├── lcd ├── 3Wire-HT1621B-GDC03849 │ ├── images │ │ ├── README.md │ │ ├── ht1621b_gdc.png │ │ └── ht1621b_gdc_en.png │ ├── DataSheet │ │ ├── README.md │ │ ├── HT1621CN.pdf │ │ ├── HT1621EN.pdf │ │ └── GDC03849C1P6.8.pdf │ ├── README_CN.md │ └── gdc03849.py ├── I2C_LCD1602 │ ├── demo.gif │ ├── test.py │ ├── README.md │ └── i2c_lcd1602.py ├── README.md └── LCD1602_BIG_DIGITS │ ├── bigdigit_test.py │ ├── README.md │ ├── mkfont.py │ └── lcd1602_bigdigit.py ├── .gitattributes ├── LED ├── TM1637 │ ├── 4-LED.jpg │ ├── test.py │ ├── README.md │ └── TM1637.py ├── TM1650 │ ├── 4-LED.jpg │ ├── test.py │ ├── README.md │ └── FourDigitDisplay.py ├── OLED_I2C_ASC │ ├── oled.jpg │ ├── demo.py │ ├── README.md │ ├── Font_6x8.py │ └── Font_8x16.py └── README.md ├── sensor ├── NTC │ ├── ntc.jpg │ ├── ntc1.jpg │ ├── ntc.py │ └── README.md ├── sht20 │ ├── sht20.jpg │ ├── README.md │ └── sht20.py ├── INA219 │ ├── ina219.jpg │ ├── README.md │ └── ina219.py ├── bme280 │ ├── bme280.jpg │ ├── test.py │ ├── README.md │ └── bme280.py ├── bmp280 │ ├── bmp280.jpg │ ├── test.py │ ├── README.md │ └── bmp280.py ├── APDS9930 │ ├── apds9930.jpg │ ├── ALS_demo.py │ ├── Proximity_demo.py │ ├── README.md │ └── APDS9930.py ├── SHT3x │ ├── I2C_16bit │ │ ├── sht30.jpg │ │ ├── sht3x_16bit.py │ │ └── README.md │ └── I2C_8bit │ │ ├── sht30.jpg │ │ ├── sht3x.py │ │ └── README.md ├── LPS22 │ ├── LPS22_demo.py │ ├── en.LPS22HB_pressure_sensor_web.jpg │ ├── LPS22_irq_demo.py │ ├── README.md │ └── LPS22.py ├── HTS221 │ ├── hts221_demo.py │ ├── hts221_irq_demo.py │ ├── README.md │ └── hts221.py ├── STTS751 │ ├── STTS751_demo.py │ ├── STTS751_irq_demo.py │ ├── README.md │ └── STTS751.py ├── LIS2MDL │ ├── LIS2MDL_demo.py │ ├── LIS2MDL_irq_demo.py │ ├── README.md │ └── LIS2MDL.py ├── LIS2DW12 │ ├── LIS2DW12_demo.py │ ├── LIS2DW12_irq_demo.py │ ├── README.md │ └── LIS2DW12.py ├── LSM6DSO │ ├── LSM6DSO_demo.py │ ├── LSM6DSO_irq_demo.py │ ├── README.md │ └── LSM6DSO.py ├── bmp180 │ ├── test.py │ ├── README.md │ └── BMP180.py ├── AHT20 │ ├── READMD.md │ └── aht20.py ├── LSM303AH │ ├── READMD.md │ └── lsm303ah.py ├── LSM6DS33 │ ├── READMD.md │ └── lsm6ds33.py ├── SC7A20 │ ├── READMD.md │ └── SC7A20.py ├── MMC5603 │ ├── READMD.md │ └── MMC5603.py ├── README.md └── si7051 │ └── si7051.py ├── misc ├── AT24XX │ ├── ds1307.jpg │ ├── test.py │ ├── README.md │ └── AT24XX.py ├── DS1302 │ ├── ds1302.jpg │ ├── test.py │ ├── README.md │ └── DS1302.py ├── DS1307 │ ├── ds1307.jpg │ ├── test.py │ ├── README.md │ └── DS1307.py ├── DS3231 │ ├── ds3231.jpg │ ├── test.py │ ├── README.md │ └── DS3231.py ├── irqUART │ ├── demo.jpg │ ├── irqUART_pyb_demo.py │ ├── irqUART_esp32_demo.py │ ├── README.md │ └── irqUART.py ├── MCP401x │ ├── README.md │ └── mcp401x.py ├── README.md └── pcf8563 │ └── pcf8563.py ├── neopixel ├── neo_16x16 │ ├── 16x16.gif │ ├── test.py │ ├── neo16x16.py │ └── README.md ├── neo_16x16_img │ ├── demo.bmp │ ├── 16x16_img.gif │ ├── README.md │ ├── neo16x16_img.py │ └── test.py └── README.md ├── keyboard └── mechanical-button │ └── single-button │ ├── key.JPG │ ├── README.md │ └── keyboard.py ├── README.md ├── LICENSE └── gnss └── ugnss.py /lcd/3Wire-HT1621B-GDC03849/images/README.md: -------------------------------------------------------------------------------- 1 | Images! 2 | -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/DataSheet/README.md: -------------------------------------------------------------------------------- 1 | The DataSheet of IC. 2 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /LED/TM1637/4-LED.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/LED/TM1637/4-LED.jpg -------------------------------------------------------------------------------- /LED/TM1650/4-LED.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/LED/TM1650/4-LED.jpg -------------------------------------------------------------------------------- /sensor/NTC/ntc.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/NTC/ntc.jpg -------------------------------------------------------------------------------- /sensor/NTC/ntc1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/NTC/ntc1.jpg -------------------------------------------------------------------------------- /misc/AT24XX/ds1307.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/misc/AT24XX/ds1307.jpg -------------------------------------------------------------------------------- /misc/DS1302/ds1302.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/misc/DS1302/ds1302.jpg -------------------------------------------------------------------------------- /misc/DS1307/ds1307.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/misc/DS1307/ds1307.jpg -------------------------------------------------------------------------------- /misc/DS3231/ds3231.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/misc/DS3231/ds3231.jpg -------------------------------------------------------------------------------- /misc/irqUART/demo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/misc/irqUART/demo.jpg -------------------------------------------------------------------------------- /sensor/sht20/sht20.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/sht20/sht20.jpg -------------------------------------------------------------------------------- /LED/OLED_I2C_ASC/oled.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/LED/OLED_I2C_ASC/oled.jpg -------------------------------------------------------------------------------- /lcd/I2C_LCD1602/demo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/lcd/I2C_LCD1602/demo.gif -------------------------------------------------------------------------------- /sensor/INA219/ina219.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/INA219/ina219.jpg -------------------------------------------------------------------------------- /sensor/bme280/bme280.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/bme280/bme280.jpg -------------------------------------------------------------------------------- /sensor/bmp280/bmp280.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/bmp280/bmp280.jpg -------------------------------------------------------------------------------- /neopixel/neo_16x16/16x16.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/neopixel/neo_16x16/16x16.gif -------------------------------------------------------------------------------- /sensor/APDS9930/apds9930.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/APDS9930/apds9930.jpg -------------------------------------------------------------------------------- /neopixel/neo_16x16_img/demo.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/neopixel/neo_16x16_img/demo.bmp -------------------------------------------------------------------------------- /sensor/SHT3x/I2C_16bit/sht30.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/SHT3x/I2C_16bit/sht30.jpg -------------------------------------------------------------------------------- /sensor/SHT3x/I2C_8bit/sht30.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/SHT3x/I2C_8bit/sht30.jpg -------------------------------------------------------------------------------- /sensor/LPS22/LPS22_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import LPS22 3 | 4 | i2c = I2C(1) 5 | lps = LPS22.LPS22(i2c) 6 | lps.get() 7 | 8 | -------------------------------------------------------------------------------- /neopixel/neo_16x16_img/16x16_img.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/neopixel/neo_16x16_img/16x16_img.gif -------------------------------------------------------------------------------- /sensor/HTS221/hts221_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import HTS221 3 | 4 | i2c = I2C(1) 5 | hts = HTS221.HTS221(i2c) 6 | hts.get() 7 | 8 | -------------------------------------------------------------------------------- /sensor/STTS751/STTS751_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import STTS751 3 | 4 | i2c = I2C(1) 5 | stt = STTS751.STTS751(i2c) 6 | stt.temperature() 7 | -------------------------------------------------------------------------------- /sensor/LIS2MDL/LIS2MDL_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import LIS2MDL 3 | 4 | i2c = I2C(1) 5 | mdl = LIS2MDL.LIS2MDL(i2c) 6 | mdl.x() 7 | mdl.get() 8 | -------------------------------------------------------------------------------- /sensor/LIS2DW12/LIS2DW12_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import LIS2DW12 3 | 4 | i2c = I2C(1) 5 | lis = LIS2DW12.LIS2DW12(i2c) 6 | lis.x() 7 | lis.get() 8 | -------------------------------------------------------------------------------- /sensor/LPS22/en.LPS22HB_pressure_sensor_web.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/sensor/LPS22/en.LPS22HB_pressure_sensor_web.jpg -------------------------------------------------------------------------------- /keyboard/mechanical-button/single-button/key.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/keyboard/mechanical-button/single-button/key.JPG -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/DataSheet/HT1621CN.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/lcd/3Wire-HT1621B-GDC03849/DataSheet/HT1621CN.pdf -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/DataSheet/HT1621EN.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/lcd/3Wire-HT1621B-GDC03849/DataSheet/HT1621EN.pdf -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/images/ht1621b_gdc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/lcd/3Wire-HT1621B-GDC03849/images/ht1621b_gdc.png -------------------------------------------------------------------------------- /sensor/LSM6DSO/LSM6DSO_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import LSM6DSO 3 | 4 | i2c = I2C(1) 5 | lsm = LSM6DSO.LSM6DSO(i2c) 6 | lsm.ax() 7 | lsm.get_a() 8 | lsm.get() 9 | -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/images/ht1621b_gdc_en.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/lcd/3Wire-HT1621B-GDC03849/images/ht1621b_gdc_en.png -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/DataSheet/GDC03849C1P6.8.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/micropython-Chinese-Community/mpy-lib/HEAD/lcd/3Wire-HT1621B-GDC03849/DataSheet/GDC03849C1P6.8.pdf -------------------------------------------------------------------------------- /lcd/README.md: -------------------------------------------------------------------------------- 1 | # LCD-libs 2 | 3 | 4 | * [I2C LCD1602 drive](I2C_LCD1602) 5 | * [3Wire-HT1621B-GDC03849](3Wire-HT1621B-GDC03849) 6 | 7 | 8 | From microbit/micropython Chinese community. 9 | www.micropython.org.cn 10 | -------------------------------------------------------------------------------- /neopixel/README.md: -------------------------------------------------------------------------------- 1 | # Neopixel-libs 2 | 3 | 4 | * [ESP8266/ESP32 neopixel 16x16 display drive](neo_16x16) 5 | * [ESP8266/ESP32 neopixel 16x16 image display drive](neo_16x16_img) 6 | 7 | From microbit/micropython Chinese community. 8 | www.micropython.org.cn 9 | -------------------------------------------------------------------------------- /LED/README.md: -------------------------------------------------------------------------------- 1 | # LED-libs 2 | 3 | 4 | * [Four Digit Display (TM1650)](TM1650) 5 | * [Four Digit Display (TM1637)](TM1637) 6 | 7 | * [I2C OLED ASCII display drive](OLED_I2C_ASC) 8 | 9 | From microbit/micropython Chinese community. 10 | www.micropython.org.cn 11 | -------------------------------------------------------------------------------- /sensor/LPS22/LPS22_irq_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import LPS22 3 | from pyb import Timer 4 | 5 | i2c = I2C(1) 6 | lps = LPS22.LPS22(i2c) 7 | 8 | def tim_irq(t): 9 | print(lps.get_irq()) 10 | 11 | tim = Timer(1, freq = 1) 12 | tim.callback(tim_irq) 13 | -------------------------------------------------------------------------------- /sensor/HTS221/hts221_irq_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | import HTS221 3 | from pyb import Timer 4 | 5 | i2c = I2C(1) 6 | hts = HTS221.HTS221(i2c) 7 | 8 | def tim_irq(t): 9 | print(hts.get_irq()) 10 | 11 | tim = Timer(1, freq = 1) 12 | tim.callback(tim_irq) 13 | -------------------------------------------------------------------------------- /sensor/LIS2MDL/LIS2MDL_irq_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | from pyb import Timer 3 | import LIS2MDL 4 | 5 | i2c = I2C(1) 6 | mdl = LIS2MDL.LIS2MDL(i2c) 7 | 8 | def tim_irq(t): 9 | print(mdl.get()) 10 | 11 | tim = Timer(1, freq = 1) 12 | tim.callback(tim_irq) 13 | -------------------------------------------------------------------------------- /sensor/STTS751/STTS751_irq_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | from pyb import Timer 3 | import STTS751 4 | 5 | i2c = I2C(1) 6 | stt = STTS751.STTS751(i2c) 7 | 8 | def tim_irq(t): 9 | print(stt.temperature_irq()) 10 | 11 | tim = Timer(1, freq = 1) 12 | tim.callback(tim_irq) 13 | -------------------------------------------------------------------------------- /sensor/LIS2DW12/LIS2DW12_irq_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | from pyb import Timer 3 | import LIS2DW12 4 | 5 | i2c = I2C(1) 6 | lis = LIS2DW12.LIS2DW12(i2c) 7 | lis.x() 8 | 9 | def tim_irq(t): 10 | print(lis.get()) 11 | 12 | tim = Timer(1, freq = 1) 13 | tim.callback(tim_irq) 14 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # micropython-libs 2 | 3 | All kinds of micropython drives, examples, libraries. 4 | 5 | * [LCD](lcd) 6 | * [LED](LED) 7 | * [Sensor](sensor) 8 | * [Neopixel](neopixel) 9 | * keyboard 10 | * radio 11 | * bluetooth 12 | * [misc](misc) 13 | 14 | From microbit/micropython Chinese community. 15 | www.micropython.org.cn 16 | -------------------------------------------------------------------------------- /sensor/LSM6DSO/LSM6DSO_irq_demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | from pyb import Timer 3 | import LSM6DSO 4 | 5 | i2c = I2C(1) 6 | lsm = LSM6DSO.LSM6DSO(i2c) 7 | lsm.ax() 8 | lsm.get_a() 9 | lsm.get() 10 | 11 | def tim_irq(t): 12 | print(lsm.get(), lsm.temperature()) 13 | 14 | tim = Timer(1, freq = 1) 15 | tim.callback(tim_irq) 16 | -------------------------------------------------------------------------------- /sensor/bmp180/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | BMP180 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import I2C 11 | import time 12 | 13 | import bmp180 14 | 15 | b = bmp180.BMP180(I2C(1)) 16 | 17 | while True: 18 | time.sleep_ms(500) 19 | b.get() 20 | -------------------------------------------------------------------------------- /sensor/bmp280/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | BMP280 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import I2C 11 | import time 12 | 13 | import bmp280 14 | 15 | b = bmp280.BMP280(I2C(1)) 16 | 17 | while True: 18 | time.sleep_ms(500) 19 | b.get() 20 | -------------------------------------------------------------------------------- /sensor/bme280/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | BME280 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import I2C 11 | import time 12 | 13 | import bme280 14 | 15 | b = bme280.BME280(I2C(1)) 16 | 17 | while True: 18 | time.sleep_ms(500) 19 | print(b.get()) 20 | -------------------------------------------------------------------------------- /misc/MCP401x/README.md: -------------------------------------------------------------------------------- 1 | # MCP401x 2 | 3 | 7-Bit Digital POT 4 | 5 | ## example 6 | 7 | ```python 8 | from machine import I2C, Pin 9 | import mcp401x 10 | 11 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 12 | mcp = mcp401x.MCP401x(i2c) 13 | mcp.write(50) 14 | 15 | ``` 16 | 17 | From microbit/micropython Chinese community. 18 | www.micropython.org.cn -------------------------------------------------------------------------------- /misc/README.md: -------------------------------------------------------------------------------- 1 | # MISC 2 | 3 | * [DS1302 RTC drive](DS1302) 4 | * [DS1307 RTC drive](DS1307) 5 | * [DS3231 RTC drive](DS3231) 6 | * [AT24XX EEPROM drive](AT24XX) 7 | * [UART with rxd irq](irqUART) 8 | * [MCP401x 7-Bit Digital POT](MCP401x) 9 | * [PCF8653 RTC drive](pcf8653) 10 | 11 | From microbit/micropython Chinese community. 12 | www.micropython.org.cn 13 | -------------------------------------------------------------------------------- /sensor/sht20/README.md: -------------------------------------------------------------------------------- 1 | # SHT20 2 | 3 | Humidity and Temperature Sensor 4 | 5 | ![](sht20.jpg) 6 | 7 | 8 | 9 | ## example 10 | 11 | ```python 12 | from machine import I2C 13 | import sht20 14 | 15 | sht = sht20.SHT20(I2C(1)) 16 | print(sht.humi(sht.humi_raw())) 17 | 18 | ``` 19 | 20 | From microbit/micropython Chinese community. 21 | www.micropython.org.cn -------------------------------------------------------------------------------- /sensor/LIS2DW12/README.md: -------------------------------------------------------------------------------- 1 | # LIS2DW12 motion sensor 2 | 3 | https://www.st.com/en/mems-and-sensors/lis2dw12.html 4 | 5 | ## example 6 | 7 | ``` 8 | from machine import I2C 9 | import LIS2DW12 10 | 11 | i2c = I2C(1) 12 | lis = LIS2DW12.LIS2DW12(i2c) 13 | lis.x() 14 | lis.get() 15 | ``` 16 | 17 | From microbit/micropython Chinese community. 18 | www.micropython.org.cn 19 | -------------------------------------------------------------------------------- /sensor/LIS2MDL/README.md: -------------------------------------------------------------------------------- 1 | # LIS2MDL Magnetic sensor 2 | 3 | https://www.st.com/zh/mems-and-sensors/lis2mdl.html 4 | 5 | ## example 6 | 7 | ``` 8 | from machine import I2C 9 | import LIS2MDL 10 | 11 | i2c = I2C(1) 12 | mdl = LIS2MDL.LIS2MDL(i2c) 13 | mdl.x() 14 | mdl.get() 15 | ``` 16 | 17 | From microbit/micropython Chinese community. 18 | www.micropython.org.cn 19 | -------------------------------------------------------------------------------- /LED/OLED_I2C_ASC/demo.py: -------------------------------------------------------------------------------- 1 | from machine import I2C, Pin 2 | from oled import OLED12864_I2C 3 | 4 | i2c = I2C(-1, scl = Pin(27, pull = Pin.PULL_UP), sda = Pin(13, pull = Pin.PULL_UP)) 5 | 6 | oled = OLED12864_I2C(i2c) 7 | oled.text(0, 0, '0123456789') 8 | oled.Font('Font_8x16') 9 | oled.text(0, 1, '0123456789') 10 | oled.Font('Font_12x24') 11 | oled.text(0, 3, '0123456789') 12 | -------------------------------------------------------------------------------- /misc/DS1302/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | DS1302 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | import DS1302 11 | from machine import Pin 12 | 13 | ds = DS1302.DS1302(clk=Pin(4), dio=Pin(5), cs=Pin(2)) 14 | 15 | ds.DateTime() 16 | ds.DateTime([2018, 3, 9, 4, 23, 0, 1, 0]) 17 | 18 | ds.Hour() 19 | ds.Second(10) 20 | -------------------------------------------------------------------------------- /misc/DS1307/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | DS1307 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | import ds1307 11 | from machine import I2C, Pin 12 | 13 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 14 | ds = ds1307.DS1307(i2c) 15 | 16 | ds.datetime() 17 | ds.datetime([2018, 3, 9, 4, 23, 0, 1, 0]) 18 | 19 | ds.hour() 20 | -------------------------------------------------------------------------------- /sensor/LSM6DSO/README.md: -------------------------------------------------------------------------------- 1 | # LSM6DSO sensor 2 | 3 | https://www.st.com/zh/mems-and-sensors/lsm6dso.html 4 | 5 | ## example 6 | 7 | ``` 8 | from machine import I2C 9 | import LSM6DSO 10 | 11 | i2c = I2C(1) 12 | lsm = LSM6DSO.LSM6DSO(i2c) 13 | lsm.ax() 14 | lsm.get_a() 15 | lsm.get() 16 | ``` 17 | 18 | From microbit/micropython Chinese community. 19 | www.micropython.org.cn 20 | -------------------------------------------------------------------------------- /sensor/HTS221/README.md: -------------------------------------------------------------------------------- 1 | # HTS221 sensor 2 | 3 | https://www.st.com/content/st_com/en/products/mems-and-sensors/humidity-sensors/hts221.html 4 | 5 | ## example 6 | 7 | ``` 8 | from machine import I2C 9 | import HTS221 10 | 11 | i2c = I2C(1) 12 | hts = HTS221.HTS221(i2c) 13 | hts.get() 14 | ``` 15 | 16 | From microbit/micropython Chinese community. 17 | www.micropython.org.cn 18 | -------------------------------------------------------------------------------- /sensor/APDS9930/ALS_demo.py: -------------------------------------------------------------------------------- 1 | ''' 2 | APDS9930 ALS demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.4 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import Pin, I2C 11 | import time 12 | import APDS9930 13 | 14 | i2c=I2C(sda=Pin(5),scl=Pin(4)) 15 | 16 | apds = APDS9930.APDS9930(i2c) 17 | 18 | while True: 19 | time.sleep_ms(500) 20 | apds.getALS() 21 | -------------------------------------------------------------------------------- /lcd/LCD1602_BIG_DIGITS/bigdigit_test.py: -------------------------------------------------------------------------------- 1 | from lcd1602_bigdigit import LCD1602_BIGDIGIT 2 | from machine import I2C, Pin 3 | from time import sleep_ms 4 | 5 | #i2c = I2C(1, sda=Pin(27), scl=Pin(26)) 6 | i2c = I2C(1, sda = Pin(18), scl = Pin(16)) 7 | 8 | lcd = LCD1602_BIGDIGIT(i2c, 39) 9 | lcd.font('square_three') 10 | 11 | n = 0 12 | while 1: 13 | n+=1 14 | lcd.number(n,4) 15 | sleep_ms(1000) 16 | -------------------------------------------------------------------------------- /LED/TM1650/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Four Digit Display demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | import machine 11 | import time 12 | import FourDigitDisplay 13 | 14 | i2c = machine.I2C(1) 15 | fdd = FourDigitDisplay.FourDigitDisplay(i2c) 16 | 17 | n = 0 18 | while 1: 19 | fdd.shownum(n) 20 | n += 1 21 | time.sleep_ms(1000) 22 | -------------------------------------------------------------------------------- /sensor/STTS751/README.md: -------------------------------------------------------------------------------- 1 | # STTS751 temperature seneor 2 | 3 | * https://www.st.com/content/st_com/zh/products/mems-and-sensors/temperature-sensors/stts751.html 4 | 5 | 6 | ## example 7 | 8 | ``` 9 | from machine import I2C 10 | import STTS751 11 | 12 | i2c = I2C(1) 13 | stt = STTS751.STTS751(i2c) 14 | stt.temperature() 15 | ``` 16 | 17 | From microbit/micropython Chinese community. 18 | www.micropython.org.cn 19 | -------------------------------------------------------------------------------- /LED/TM1637/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Four Digit Display (TM1637) demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import Pin 11 | import time 12 | import TM1637 13 | 14 | dio = Pin(5, Pin.OUT) 15 | clk = Pin(4, Pin.OUT) 16 | tm=TM1637.TM1637(dio=dio,clk=clk) 17 | 18 | n = 0 19 | while 1: 20 | tm.shownum(n) 21 | n += 1 22 | time.sleep_ms(1000) 23 | -------------------------------------------------------------------------------- /sensor/NTC/ntc.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for NTC thermistor Sensor 3 | 4 | Author: shaoziyang 5 | Date: 2024.4 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | import math 11 | 12 | def NTC_GND(adc, max, B=3780): 13 | t1 = math.log(adc/(max-adc))/B + 1/298.15 14 | return 1/t1 - 273.15 15 | 16 | def NTC_VCC(adc, max, B=3780): 17 | t1 = math.log((max-adc)/adc)/B + 1/298.15 18 | return 1/t1 - 273.15 19 | -------------------------------------------------------------------------------- /sensor/APDS9930/Proximity_demo.py: -------------------------------------------------------------------------------- 1 | ''' 2 | APDS9930 Proximity demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.4 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import Pin, I2C 11 | import time 12 | import APDS9930 13 | 14 | i2c=I2C(sda=Pin(5),scl=Pin(4)) 15 | 16 | apds = APDS9930.APDS9930(i2c) 17 | apds.Proximity_Enable() 18 | 19 | while True: 20 | time.sleep_ms(500) 21 | apds.getProximity() 22 | -------------------------------------------------------------------------------- /misc/AT24XX/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | AT24C32 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import I2C, Pin 10 | import AT24XX 11 | 12 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 13 | ee = AT24XX.AT24XX(i2c) 14 | 15 | ee.write_byte(0, 12) 16 | ee.read_byte(0) 17 | 18 | ee.write_word(4, 0x1234) 19 | ee.read_word(4) 20 | 21 | ee.write_buf(800, 'Hello!') 22 | ee.read_buf(800, 8) 23 | 24 | -------------------------------------------------------------------------------- /lcd/I2C_LCD1602/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | I2C LCD1602 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import I2C, Pin 11 | from i2c_lcd1602 import I2C_LCD1602 12 | from time import sleep_ms 13 | 14 | i2c = I2C(1, sda=Pin(9), scl=Pin(10)) 15 | 16 | LCD = I2C_LCD1602(i2c) 17 | 18 | LCD.puts("I2C LCD1602") 19 | n = 0 20 | while 1: 21 | LCD.puts(n, 0, 1) 22 | n += 1 23 | sleep_ms(1000) 24 | 25 | -------------------------------------------------------------------------------- /misc/MCP401x/mcp401x.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | 3 | class MCP401x: 4 | 5 | def __init__(self, i2c, addr = 47): 6 | self.i2c = i2c 7 | self.addr = addr 8 | self.tb = bytearray(1) 9 | self.rb = bytearray(1) 10 | 11 | def write(self, dat): 12 | self.tb[0] = dat 13 | self.i2c.writeto(self.addr, self.tb) 14 | 15 | def read(self): 16 | self.i2c.readfrom_into(self.addr, self.rb) 17 | return self.rb[0] -------------------------------------------------------------------------------- /sensor/AHT20/READMD.md: -------------------------------------------------------------------------------- 1 | # [mpy-lib](https://github.com/micropython-Chinese-Community/mpy-lib) 2 | 3 | ## AHT20 SENSOR 4 | 5 | 6 | ## Example 7 | 8 | 9 | ```py 10 | from machine import I2C, Pin 11 | from aht20 import AHT20 12 | from time import sleep_ms 13 | 14 | i2c = I2C(0, sda = Pin(4), scl = Pin(5)) 15 | aht = AHT20(i2c) 16 | 17 | while 1: 18 | aht.measure() 19 | print('Humi: {:.2f} %, Temp: {:.2f} C'.format(aht.Humi(), aht.Temp())) 20 | sleep_ms(1000) 21 | ``` 22 | -------------------------------------------------------------------------------- /misc/DS3231/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | DS3231 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import I2C, Pin 10 | import DS3231 11 | 12 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 13 | ds = DS3231.DS3231(i2c) 14 | 15 | ds.Hour(12) 16 | 17 | ds.Time() 18 | ds.Time([12,10,0]) 19 | 20 | ds.DateTime([2018,3,12,1,22,10,0]) 21 | 22 | ds.ALARM(12, 20, 10, DS3231.PER_DISABLE) 23 | ds.ALARM(12, 20, 10, DS3231.PER_DAY) 24 | ds.ClearALARM() 25 | -------------------------------------------------------------------------------- /sensor/LPS22/README.md: -------------------------------------------------------------------------------- 1 | # LPS22HB/HD/HH pressure seneor 2 | 3 | * https://www.st.com/content/st_com/en/products/mems-and-sensors/pressure-sensors/lps22hb.html 4 | * https://www.st.com/content/st_com/en/products/mems-and-sensors/pressure-sensors/lps22hd.html 5 | * https://www.st.com/content/st_com/en/products/mems-and-sensors/pressure-sensors/lps22hh.html 6 | 7 | ![](en.LPS22HB_pressure_sensor_web.jpg) 8 | 9 | ## example 10 | 11 | ``` 12 | from machine import I2C 13 | import LPS22 14 | 15 | i2c = I2C(1) 16 | lps = LPS22.LPS22(i2c) 17 | lps.get() 18 | ``` 19 | 20 | From microbit/micropython Chinese community. 21 | www.micropython.org.cn 22 | -------------------------------------------------------------------------------- /neopixel/neo_16x16_img/README.md: -------------------------------------------------------------------------------- 1 | # ESP8266/ESP32 neopixel 16x16 iamge display drive 2 | 3 | ![](16x16_img.gif) 4 | 5 | 6 | ## API 7 | 8 | * **set(n, color)** 9 | set LED[n] to color 10 | n: 0-255 11 | color: LED color. if color is not given, it will using default color 12 | 13 | * **clear()** 14 | clear all LED 15 | 16 | * **show(self, dat, offset=0)** 17 | show color emijo. 18 | dat: color emijo data 19 | offset: display offset 20 | 21 | ## example 22 | 23 | see test.py 24 | 25 | **Please note neopixel display must using external power.** 26 | 27 | From microbit/micropython Chinese community 28 | www.micropython.org.cn -------------------------------------------------------------------------------- /sensor/LSM303AH/READMD.md: -------------------------------------------------------------------------------- 1 | **LSM303AH**, ST's ultra-low-power 3D accelerometer and 3D magnetometer. 2 | 3 | 4 | ## example 5 | 6 | Normal mode 7 | 8 | ```python 9 | from lsm303ah import LSM303AH 10 | from machine import Pin, I2C 11 | 12 | i2c = I2C(1, freq=400000) 13 | mag = LSM303AH(i2c) 14 | mag.m() 15 | mag.a() 16 | ``` 17 | 18 | 19 | 20 | IRQ mode 21 | 22 | ```python 23 | from lsm303ah import LSM303AH 24 | from machine import Pin, I2C 25 | 26 | i2c = I2C(1, freq=400000) 27 | mag = LSM303AH(i2c) 28 | 29 | def MAG_IRQ(t): 30 | pyb.LED(1).toggle() 31 | print('M:', mag.m()) 32 | 33 | mag.mag_irq(1, Pin('PA5'), MAG_IRQ) 34 | 35 | ``` 36 | 37 | -------------------------------------------------------------------------------- /LED/OLED_I2C_ASC/README.md: -------------------------------------------------------------------------------- 1 | # I2C OLED ASCII display drive 2 | 3 | A simple ascii display drive for I2C OLED, it may display 4 font. 4 | 5 | ![](oled.jpg) 6 | 7 | 8 | 9 | ## example 10 | 11 | 12 | ``` 13 | from machine import I2C, Pin 14 | from oled import OLED12864_I2C 15 | 16 | i2c = I2C(-1, scl = Pin(27, pull = Pin.PULL_UP), sda = Pin(13, pull = Pin.PULL_UP)) 17 | 18 | oled = OLED12864_I2C(i2c) 19 | oled.text(0, 0, '0123456789') 20 | oled.Font('Font_8x16') 21 | oled.text(0, 1, '0123456789') 22 | oled.Font('Font_12x24') 23 | oled.text(0, 3, '0123456789') 24 | ``` 25 | 26 | 27 | From microbit/micropython Chinese community. 28 | www.micropython.org.cn 29 | -------------------------------------------------------------------------------- /sensor/LSM6DS33/READMD.md: -------------------------------------------------------------------------------- 1 | **LSM6DS33**, ST's always-on 3D accelerometer and 3D gyroscope sensor. 2 | 3 | 4 | 5 | ## example 6 | 7 | Normal mode 8 | 9 | ```python 10 | from lsm6ds33 import LSM6DS33 11 | from machine import Pin, I2C 12 | 13 | i2c = I2C(1, freq=400000) 14 | gyr = LSM6DS33(i2c) 15 | gyr.a() 16 | gyr.g() 17 | ``` 18 | 19 | 20 | 21 | IRQ mode 22 | 23 | ```python 24 | from lsm6ds33 import LSM6DS33 25 | from machine import Pin, I2C 26 | 27 | i2c = I2C(1, freq=400000) 28 | gyr = LSM6DS33(i2c) 29 | 30 | def GYR_IRQ(t): 31 | pyb.LED(1).toggle() 32 | print('A:', gyr.a_raw()) 33 | 34 | gyr.wakeup_mode(True, Pin('PA6'), GYR_IRQ) 35 | 36 | ``` 37 | 38 | -------------------------------------------------------------------------------- /misc/irqUART/irqUART_pyb_demo.py: -------------------------------------------------------------------------------- 1 | ''' 2 | irqUART demo for pyboard 3 | 4 | Author: shaoziyang 5 | Date: 2020.6 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import Pin, UART 10 | from irqUART import irqUART 11 | 12 | cnt = 0 13 | def U1_RX_IRQ(t): 14 | global cnt 15 | n = 0 16 | while u1.any(): 17 | d = u1.any() 18 | cnt+=d 19 | n+=1 20 | print('[', n, ']', cnt, d, u1.read(d)) 21 | 22 | def U1_RX_FRAME_IRQ(t): 23 | global cnt 24 | print('FRAME end') 25 | cnt = 0 26 | 27 | # STM32 28 | u1=UART(1) 29 | ui = irqUART(u1, Pin('B7'), U1_RX_IRQ, U1_RX_FRAME_IRQ) 30 | ui.uart.init(115200) 31 | 32 | -------------------------------------------------------------------------------- /sensor/bmp180/README.md: -------------------------------------------------------------------------------- 1 | # BMP180 Digital pressure sensor 2 | 3 | ## I2C Address 4 | 5 | **0x77** 6 | 7 | ## API 8 | 9 | * **get()** 10 | get envirment temperature and pressure 11 | 12 | * **getTemp()** 13 | get envirment temperature 14 | 15 | * **getPress()** 16 | get Pressure 17 | 18 | * **getAltitude()** 19 | Calculating absolute altitude 20 | 21 | 22 | ## example 23 | 24 | 25 | ``` 26 | from machine import I2C 27 | import time 28 | 29 | import bmp180 30 | 31 | b = bmp180.BMP180(I2C(1)) 32 | 33 | while True: 34 | time.sleep_ms(500) 35 | b.get() 36 | 37 | ``` 38 | 39 | From microbit/micropython Chinese community. 40 | www.micropython.org.cn 41 | -------------------------------------------------------------------------------- /misc/irqUART/irqUART_esp32_demo.py: -------------------------------------------------------------------------------- 1 | ''' 2 | irqUART demo for esp32 3 | 4 | Author: shaoziyang 5 | Date: 2020.6 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import Pin, UART 10 | from irqUART import irqUART 11 | 12 | cnt = 0 13 | def U1_RX_IRQ(t): 14 | global cnt 15 | n = 0 16 | while u1.any(): 17 | d = u1.any() 18 | cnt+=d 19 | n+=1 20 | print('[', n, ']', cnt, d, u1.read(d)) 21 | 22 | def U1_RX_FRAME_IRQ(t): 23 | global cnt 24 | print('FRAME end') 25 | cnt = 0 26 | 27 | # ESP32 28 | u1=UART(2, 115200, tx=23, rx=22) 29 | ui = irqUART(u1, Pin(22), U1_RX_IRQ, U1_RX_FRAME_IRQ) 30 | ui.uart.init(115200) 31 | 32 | 33 | -------------------------------------------------------------------------------- /sensor/SC7A20/READMD.md: -------------------------------------------------------------------------------- 1 | # [mpy-lib](https://github.com/micropython-Chinese-Community/mpy-lib) 2 | 3 | ## SC7A20 3-AXIS ACCELEROMETER SENSOR 4 | 5 | 6 | 7 | - https://www.silan.com.cn/en/index.php/product/details/47.html 8 | 9 | The SC7A20 is an acceleration sensor IC, which features abundant functions, low power dissipation, small size, and precision measurement. 10 | 11 | ## Example 12 | 13 | 14 | ```py 15 | from machine import I2C, Pin 16 | from time import sleep_ms 17 | 18 | from SC7A20 import SC7A20 19 | 20 | i2c = I2C(0, sda=Pin(4), scl=Pin(16)) 21 | 22 | sc = SC7A20(i2c) 23 | 24 | while True: 25 | print(sc.x(), sc.y(), sc.z()) 26 | sleep_ms(100) 27 | ``` 28 | -------------------------------------------------------------------------------- /sensor/INA219/README.md: -------------------------------------------------------------------------------- 1 | # INA219 2 | 3 | Zerø-Drift, Bidirectional Current/Power Monitor With I2C Interface. 4 | 5 | ![](ina219.jpg) 6 | 7 | 8 | 9 | ## description 10 | 11 | Calibration Register must be written in order to read the current value. Default Calibration Register value is 4096, which has a significant error and needs to be calibrated according to the actual circuit. 12 | 13 | 14 | ## uasge 15 | 16 | ``` 17 | from machine import Pin, SoftI2C 18 | import ina219 19 | 20 | # please modify scl/sda to the actual pins. 21 | i2c = SoftI2C(scl=Pin(pins.pin_SCL), sda=Pin(pins.pin_SDA)) 22 | 23 | ina = ina219.INA219(i2c) 24 | ina.calreg(3450) 25 | 26 | v = ina.volt() 27 | c = ina.current() 28 | p = ina.power() 29 | 30 | ``` 31 | 32 | From microbit/micropython Chinese community. 33 | www.micropython.org.cn 34 | -------------------------------------------------------------------------------- /lcd/LCD1602_BIG_DIGITS/README.md: -------------------------------------------------------------------------------- 1 | # LCD1602 Big Digits 2 | 3 | Display large font numbers on LCD1602, ported from the [small display BIG DIGITS project](https://github.com/upiir/character_display_big_digits), please visit the project link to view the font image. 4 | 5 | **usage** 6 | 7 | ``` 8 | from lcd1602_bigdigit import LCD1602_BIGDIGIT 9 | from machine import I2C, Pin 10 | from time import sleep_ms 11 | 12 | i2c = I2C(1, sda = Pin(18), scl = Pin(16)) 13 | 14 | lcd = LCD1602_BIGDIGIT(i2c, 39) 15 | lcd.font('square_three') 16 | 17 | n = 0 18 | while 1: 19 | n+=1 20 | lcd.number(n) 21 | sleep_ms(1000) 22 | 23 | ``` 24 | 25 | ![](https://user-images.githubusercontent.com/117754156/230296829-0aea22ec-64da-4251-bfc0-5bbacfc92c3e.jpg) 26 | 27 | 28 | From microbit/micropython Chinese community. 29 | www.micropython.org.cn 30 | -------------------------------------------------------------------------------- /sensor/MMC5603/READMD.md: -------------------------------------------------------------------------------- 1 | # [mpy-lib](https://github.com/micropython-Chinese-Community/mpy-lib) 2 | 3 | ## MMC5603 3-axis Magnetic Sensor 4 | 5 | - [DataSheet]( 6 | https://www.memsic.com/Public/Uploads/uploadfile/files/20220119/MMC5603NJDatasheetRev.B.pdf) 7 | 8 | The MMC5603NJ is a monolithic complete 3-axis AMR magnetic sensor with on-chip signal processing and integrated digital bus (I 2 C fast mode and I3C interface), the device can be connected directly to a microprocessor, eliminating the need for A/D converters or timing resources. 9 | 10 | ## Example 11 | 12 | 13 | ```py 14 | from machine import I2C, Pin 15 | from time import sleep_ms 16 | 17 | from MMC5603 import MMC5603 18 | 19 | i2c = I2C(0, sda=Pin(4), scl=Pin(16)) 20 | 21 | m = MMC5603(i2c) 22 | 23 | while 1: 24 | sleep_ms(500) 25 | print(m.x(), m.y(), m.z()) 26 | 27 | ``` 28 | -------------------------------------------------------------------------------- /sensor/bmp280/README.md: -------------------------------------------------------------------------------- 1 | # BMP280 Digital pressure sensor 2 | 3 | ![](bmp280.jpg) 4 | 5 | ## I2C Address 6 | 7 | I2C Address depend SDO, defult address is: 8 | 9 | **0x76** 10 | 11 | When SDO is high address is: 12 | 13 | **0x77** 14 | 15 | ## API 16 | 17 | * **get()** 18 | get envirment temperature and pressure 19 | 20 | * **getTemp()** 21 | get envirment temperature 22 | 23 | * **getPress()** 24 | get Pressure 25 | 26 | * **getAltitude()** 27 | Calculating absolute altitude 28 | 29 | * **poweron()** 30 | goto normal mode 31 | 32 | * **poweroff()** 33 | goto sleep mode 34 | 35 | ## example 36 | 37 | 38 | ``` 39 | from machine import I2C 40 | import time 41 | 42 | import bmp280 43 | 44 | b = bmp280.BMP280(I2C(1)) 45 | 46 | while True: 47 | time.sleep_ms(500) 48 | b.get() 49 | 50 | ``` 51 | 52 | From microbit/micropython Chinese community. 53 | www.micropython.org.cn 54 | -------------------------------------------------------------------------------- /sensor/bme280/README.md: -------------------------------------------------------------------------------- 1 | # BME280 Digital pressure sensor 2 | 3 | ![](bme280.jpg) 4 | 5 | ## I2C Address 6 | 7 | I2C Address depend SDO, defult address is: 8 | 9 | **0x76** 10 | 11 | When SDO is high address is: 12 | 13 | **0x77** 14 | 15 | ## API 16 | 17 | * **get()** 18 | get envirment temperature, pressure and humidity 19 | 20 | * **getTemp()** 21 | get envirment temperature 22 | 23 | * **getPress()** 24 | get Pressure 25 | 26 | * **getHumi()** 27 | get Humidity 28 | 29 | * **getAltitude()** 30 | Calculating absolute altitude 31 | 32 | * **poweron()** 33 | goto normal mode 34 | 35 | * **poweroff()** 36 | goto sleep mode 37 | 38 | ## example 39 | 40 | 41 | ``` 42 | from machine import I2C 43 | import time 44 | 45 | import bme280 46 | 47 | b = bme280.BME280(I2C(1)) 48 | 49 | while True: 50 | time.sleep_ms(500) 51 | b.get() 52 | 53 | ``` 54 | 55 | From microbit/micropython Chinese community 56 | www.micropython.org.cn -------------------------------------------------------------------------------- /neopixel/neo_16x16/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | ESP8266/ESP32 neopixel 16x16 demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import Pin 11 | import time 12 | 13 | from neo16x16 import neo16x16 14 | 15 | np = neo16x16(Pin(2)) 16 | 17 | npdat=[ 18 | 0x2008,0x1FFC,0x3FF8,0x1084,0x0100,0x1084,0x3FF8,0x1FFC, 19 | 0x2008,0x0000,0x1F00,0x01FC,0x2480,0x0124,0x2480,0x01EC, 20 | 0x1700,0x0000,0x0000,0x0804,0x2010,0x1FFC,0x3FF8,0x0004, 21 | 0x2000,0x0000,0x0000,0x0000,0x2010,0x0804,0x3FF8,0x1FFC, 22 | 0x2000,0x0004,0x0000,0x0000,0x0000,0x00F8,0x3F80,0x0104, 23 | 0x2080,0x0104,0x3F80,0x00F8,0x0000,0x0080,0x0180,0x0700, 24 | 0xFFF8,0xFFFF,0x1047,0x0638,0x0F38,0xF8C2,0xC00F,0x13FF, 25 | 0x7FC8,0x1080,0x0728,0x1C78,0x1818,0x0000,0x4010,0x0846, 26 | 0x37F0,0xFFB8,0x1E1F,0x0FEE,0x61F0,0x0100,0x4082,0x4103, 27 | 0xFFE2,0x4FFE,0x009A,0x7100,0x0086,0x0100,] 28 | 29 | n = 0 30 | while 1: 31 | np.show(npdat, n) 32 | n = (n + 1)%70 33 | time.sleep_ms(200) 34 | -------------------------------------------------------------------------------- /sensor/NTC/README.md: -------------------------------------------------------------------------------- 1 | # NTC thermistor 2 | 3 | NTC thermistor Sensor. 4 | 5 | ![](ntc.jpg) 6 | 7 | 8 | There are two connection methods for NTC resistors: NTC connected to VCC or GND, as shown in the figure. 9 | 10 | ![](ntc1.jpg) 11 | 12 | 13 | ## description 14 | 15 | - NTC_GND(adc, max, B=3780) 16 | - NTC_VCC(adc, max, B=3780) 17 | 18 | Convert numerical values to Celsius temperature. 19 | 20 | - adc, NTC input value, it can be voltage or ADC value. 21 | - max, maximum value for ADC, it can be voltage (usually Vcc) or ADC value. 22 | - B, B value of NTC resistor. 23 | 24 | If using esp32 series chips, use ADC.read_uv() to get ADC value for best optimal accuracy. 25 | 26 | 27 | ## example 28 | 29 | ```python 30 | from machine import ADC, Pin 31 | 32 | ADC_T1 = ADC(Pin(34), atten=ADC.ATTN_11DB) 33 | ADC_T2 = ADC(Pin(33), atten=ADC.ATTN_11DB) 34 | 35 | T1 = NTC_VCC(ADC_T1.read_uv()/1000, 3300) 36 | T2 = NTC_GND(ADC_T2.read_uv()/1000, 3300, B=3950) 37 | ``` 38 | 39 | From microbit/micropython Chinese community. 40 | www.micropython.org.cn -------------------------------------------------------------------------------- /sensor/README.md: -------------------------------------------------------------------------------- 1 | # Sensor-libs 2 | 3 | 4 | * [APDS9930 Digital Proximity and Ambient Light Sensor](APDS9930) 5 | * [BMP180 Digital pressure sensor drive](bmp180) **(recommend replace with BMP280)** 6 | * [BMP280 Digital pressure sensor drive](bmp280) 7 | * [BME280 humidity and pressure sensor drive](bme280) 8 | * [MMC5603 3-axis Magnetic Sensor](MMC5603) 9 | * [SC7A20 3-AXIS ACCELEROMETER SENSOR](SC7A20) 10 | * [SHT20 Humidity and Temperature Sensor](sht20) 11 | * [SHT3x Humidity and Temperature Sensor](SHT3x) 12 | * [si7051 Temperature Sensor](si7051) 13 | * [ST HTS221 humidity and temperature sensor](HTS221) 14 | * [ST LPS22 pressure sensor](LPS22) 15 | * [ST STTS751 temperature sensor](STTS751) 16 | * [ST LIS2MDL magnetic sensor](LIS2MDL) 17 | * [ST LIS2DW12 motion sensor](LIS2DW12) 18 | * [ST LSM6DSO 3D accelerometer and 3D gyroscope sensor](LSM6DSO) 19 | * [ST LSM6DS33 3D accelerometer and 3D gyroscope sensor](LSM6DS33) 20 | * [ST LSM303AH ultra-low-power 3D accelerometer and 3D magnetometer](LSM303AH) 21 | * [NTC thermistor](NTC) 22 | 23 | From microbit/micropython Chinese community. 24 | www.micropython.org.cn 25 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 shaoziyang 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /misc/AT24XX/README.md: -------------------------------------------------------------------------------- 1 | # AT24XX EEPROM 2 | 3 | AT24/AT25 series electrically erasable PROM drive 4 | 5 | ![](ds1307.jpg) 6 | 7 | ## I2C Address 8 | 9 | 0x50 - 0x57 10 | 11 | ## API 12 | 13 | * **write_byte(addr, dat)** 14 | write a byte to given address. 15 | 16 | * **read_byte(addr)** 17 | read a byte from given address. 18 | 19 | * **write_word(addr, dat)** 20 | write a word to given address. 21 | 22 | * **read_word(addr)** 23 | read a word from given address. 24 | 25 | * **write_dword(addr, dat)** 26 | write a dword (double word) to given address. 27 | 28 | * **read_dword(addr)** 29 | read a dword from given address. 30 | 31 | * **write_buf(addr, dat)** 32 | write a buffer to given address, maximum buffer length is 32. 33 | 34 | * **read_buf(addr, num)** 35 | read a buffer from given address. 36 | 37 | ## example 38 | 39 | ``` 40 | from machine import I2C, Pin 41 | import AT24XX 42 | 43 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 44 | ee = AT24XX.AT24XX(i2c) 45 | 46 | ee.write_byte(0, 12) 47 | ee.read_byte(0) 48 | 49 | ee.write_word(4, 0x1234) 50 | ee.read_word(4) 51 | 52 | ee.write_buf(800, 'Hello!') 53 | ee.read_buf(800, 8) 54 | ``` 55 | 56 | From microbit/micropython Chinese community. 57 | www.micropython.org.cn 58 | -------------------------------------------------------------------------------- /sensor/INA219/ina219.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for INA219 Bidirectional Current/Power Monitor 3 | 4 | Author: shaoziyang 5 | Date: 2024.5 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from micropython import const 11 | 12 | INA219_ADDR = const(64) 13 | 14 | class INA219(): 15 | def __init__(self, i2c): 16 | self.i2c = i2c 17 | self.rb = bytearray(2) 18 | self.tb = bytearray(2) 19 | self.setreg(0, 0x8000) # reset 20 | self.setreg(0, 0x3fff) 21 | self.calreg(4096) # default Calibration Register 22 | 23 | def setreg(self, reg, dat): 24 | self.tb[0] = dat//256 25 | self.tb[1] = dat 26 | self.i2c.writeto_mem(INA219_ADDR, reg, self.tb) 27 | 28 | def getreg(self, reg): 29 | self.i2c.readfrom_mem_into(INA219_ADDR, reg, self.rb) 30 | return self.rb[0]*256+self.rb[1] 31 | 32 | def calreg(self, value=None): 33 | if value == None: 34 | return self.getreg(5) 35 | else: 36 | self.setreg(5, value) 37 | 38 | def volt(self): 39 | return self.getreg(2)/2000 40 | 41 | def current(self): 42 | return self.getreg(4)/10000 43 | 44 | def power(self): 45 | return self.getreg(3)/500 46 | 47 | -------------------------------------------------------------------------------- /sensor/APDS9930/README.md: -------------------------------------------------------------------------------- 1 | # APDS9930 Digital Proximity and Ambient Light Sensor drive for microbit 2 | 3 | ![](apds9930.jpg) 4 | 5 | ## I2C Address 6 | 7 | **0x39** 8 | 9 | ## API 10 | 11 | * **AGAIN(gain=None)** 12 | get/set ALS Gain. 13 | gain is: [1, 8, 16, 120] 14 | 15 | * **PGAIN(gain=None)** 16 | get/set Proximity Gain. 17 | gain is: [1, 2, 4, 8] 18 | 19 | * **Power(on=True)** 20 | set power on/off 21 | 22 | * **poweron()** 23 | goto normal mode 24 | 25 | * **ALS_Enable(on=True)** 26 | Enable/Disable ALS feature 27 | 28 | * **Wait_Enable(on=True)** 29 | Enable/Disable Wait Timer feature 30 | 31 | * **Proximity_Enable(on=True)** 32 | Enable/Disable Proximity feature 33 | **VL** pin must connect to 3.3V before enable Proximity feature. 34 | 35 | * **getALS()** 36 | get Ambient Light (lux) 37 | 38 | * **getProximity()** 39 | get Proximity value. 40 | **VL** pin must connect to 3.3V before enable Proximity feature. 41 | 42 | 43 | 44 | ## example 45 | 46 | ``` 47 | from machine import Pin, I2C 48 | import time 49 | import APDS9930 50 | 51 | i2c=I2C(sda=Pin(5),scl=Pin(4)) 52 | 53 | apds = APDS9930.APDS9930(i2c) 54 | 55 | while True: 56 | time.sleep_ms(500) 57 | apds.getALS() 58 | 59 | ``` 60 | 61 | From microbit/micropython Chinese community. 62 | www.micropython.org.cn 63 | -------------------------------------------------------------------------------- /misc/DS1302/README.md: -------------------------------------------------------------------------------- 1 | # DS1302 2 | 3 | DS1302 is real-time clock (RTC) with serial interface, 31 * 8 data ram. 4 | 5 | ![](ds1302.jpg) 6 | 7 | 8 | ## API 9 | 10 | * **start()** 11 | start RTC. 12 | 13 | * **stop()** 14 | stop/pause RTC 15 | 16 | * **DateTime(DT = None)** 17 | get / set DateTime. If no paramter given, it will return current datetime, otherwise it will set datatime. 18 | datatime format: [Year, month, day, weekday, hour, minute, second] 19 | 20 | * **Year(year = None)** 21 | get / set year. 22 | 23 | * **Month(month = None)** 24 | get / set month. 25 | 26 | * **Day(day = None)** 27 | get / set day. 28 | 29 | * **Weekday(weekday = None)** 30 | get / set month. 31 | 32 | * **Hour(hour = None)** 33 | get / set hour. 34 | 35 | * **Minute(minute = None)** 36 | get / set minute. 37 | 38 | * **Second(second = None)** 39 | get / set second. 40 | 41 | * **ram(reg, dat = None)** 42 | get / set ram data (31 bytes). 43 | 44 | 45 | ## example 46 | 47 | ``` 48 | import DS1302 49 | from machine import Pin 50 | 51 | ds = DS1302.DS1302(clk=Pin(4), dio=Pin(5), cs=Pin(2)) 52 | 53 | ds.DateTime() 54 | ds.DateTime([2018, 3, 22, 4, 23, 40, 1, 0]) 55 | 56 | ds.Hour() 57 | ds.Second(10) 58 | ``` 59 | 60 | From microbit/micropython Chinese community. 61 | www.micropython.org.cn 62 | -------------------------------------------------------------------------------- /misc/DS1307/README.md: -------------------------------------------------------------------------------- 1 | # DS1307 2 | 3 | DS1307 real-time clock (RTC) is a low power, full binary-coded decimal (BCD) clock/calendar plus 56 bytes of NV SRAM. 4 | 5 | ![](ds1307.jpg) 6 | 7 | ## I2C Address 8 | 9 | 0x68 10 | 11 | ## API 12 | 13 | * **start()** 14 | start RTC. 15 | 16 | * **stop()** 17 | stop/pause RTC 18 | 19 | * **datetime(DT = None)** 20 | get / set DateTime. If no paramter given, it will return current datetime, otherwise it will set datatime. 21 | datatime format: [year, month, day, weekday, hour, minute, second] 22 | 23 | * **year(year = None)** 24 | get / set year. 25 | 26 | * **month(month = None)** 27 | get / set month. 28 | 29 | * **day(day = None)** 30 | get / set day. 31 | 32 | * **weekday(weekday = None)** 33 | get / set month. 34 | 35 | * **hour(hour = None)** 36 | get / set hour. 37 | 38 | * **minute(minute = None)** 39 | get / set minute. 40 | 41 | * **second(second = None)** 42 | get / set second. 43 | 44 | * **ram(reg, dat = None)** 45 | get / set ram data (56 bytes). 46 | 47 | 48 | ## example 49 | 50 | ``` 51 | import ds1307 52 | from machine import I2C, Pin 53 | 54 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 55 | ds = ds1307.DS1307(i2c) 56 | 57 | ds.datetime() 58 | ds.datetime([2018, 3, 9, 4, 23, 0, 1, 0]) 59 | 60 | ds.hour() 61 | ``` 62 | 63 | From microbit/micropython Chinese community. 64 | www.micropython.org.cn 65 | -------------------------------------------------------------------------------- /neopixel/neo_16x16/neo16x16.py: -------------------------------------------------------------------------------- 1 | """ 2 | ESP8266/ESP32 neopixel 16x16 display drive 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | """ 10 | from machine import Pin 11 | import neopixel 12 | 13 | class neo16x16: 14 | def __init__(self, pin): 15 | self.np = neopixel.NeoPixel(pin, 256) 16 | self.color = (0,0,8) 17 | 18 | def clear(self): 19 | self.np.fill((0,0,0)) 20 | self.np.write() 21 | 22 | def set(self, n, color=''): 23 | if color!='': 24 | self.np[n] = color 25 | else: 26 | self.np[n] = self.color 27 | self.np.write() 28 | 29 | def setcolor(self, color): 30 | self.color = color 31 | 32 | def show(self, dat, offset=0, clear = True, color=''): 33 | if color != '': 34 | self.color = color 35 | if clear: 36 | self.np.fill((0,0,0)) 37 | for x in range(16): 38 | for y in range(16): 39 | if (x+offset)>=len(dat): 40 | self.np[x*16+y]=(0,0,0) 41 | else: 42 | if (1<> 8 32 | self.tb[2] = dat 33 | self.i2c.writeto_mem(self.addr, cmd, self.tb) 34 | 35 | def get(self): 36 | self.i2c.readfrom_into(self.addr, self.rb) 37 | 38 | def init(self): 39 | self.set(CMD_INIT, 0x0800) 40 | 41 | def reset(self): 42 | self.set(CMD_RESET, 0) 43 | 44 | def measure(self): 45 | self.set(CMD_MEASURE, 0x3300) 46 | sleep_ms(75) 47 | self.get() 48 | self._H = (self.rb[1]<<12)+(self.rb[2]<<4)+(self.rb[3]>>4) 49 | self._T = ((self.rb[3]%16)<<16)+(self.rb[4]<<8)+self.rb[5] 50 | 51 | def Humi(self): 52 | return (self._H*100)/(1<<20) 53 | 54 | def Temp(self): 55 | return (self._T*200)/(1<<20)-50 56 | 57 | 58 | -------------------------------------------------------------------------------- /LED/TM1650/README.md: -------------------------------------------------------------------------------- 1 | # Four Digit Display TM1650/HBS650 drive 2 | 3 | Four Digit Display is a Module with four 7-segment LED, it can show number. It has TM1650 chip inside, control with a I2C bus. 4 | 5 | ![](4-LED.jpg) 6 | 7 | ## I2C Address 8 | 9 | | command | Display | 10 | | --- | --- | 11 | | 0x24 | 0x34 - 0x37 | 12 | 13 | 14 | ## API 15 | 16 | * **intensity(dat = -1)** 17 | set display intensity. 18 | **dat** is intensity will be set, it can be [0 - 8]. if dat is zero, display will be turn off. 19 | if not dat given, or dat > 8, or dat < 0, it will return current intensity. 20 | 21 | * **on()** 22 | turn on display 23 | 24 | * **off()** 25 | turn off display 26 | 27 | * **clear（）** 28 | clear content of the display 29 | 30 | * **shownum(num)** 31 | show a interger number in display. 32 | 33 | * **showhex(num)** 34 | show a hex number. 35 | 36 | * **showDP(bit = 1, show = True)** 37 | show or hide dot piont in give bit 38 | bit is dot piont position, [0 - 3] 39 | show, True will show DP, other will hide it 40 | 41 | ## example 42 | 43 | 44 | ``` 45 | import machine 46 | import time 47 | import FourDigitDisplay 48 | 49 | i2c = machine.I2C(1) 50 | fdd = FourDigitDisplay.FourDigitDisplay(i2c) 51 | 52 | n = 0 53 | while 1: 54 | fdd.shownum(n) 55 | n += 1 56 | time.sleep_ms(1000) 57 | ``` 58 | 59 | From microbit/micropython Chinese community. 60 | www.micropython.org.cn 61 | -------------------------------------------------------------------------------- /neopixel/neo_16x16_img/neo16x16_img.py: -------------------------------------------------------------------------------- 1 | """ 2 | ESP8266/ESP32 neopixel 16x16 image display drive 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | """ 10 | from machine import Pin 11 | import neopixel 12 | 13 | class neo16x16_img: 14 | def __init__(self, pin): 15 | self.np = neopixel.NeoPixel(pin, 256) 16 | 17 | def clear(self): 18 | self.np.fill((0,0,0)) 19 | self.np.write() 20 | 21 | def set(self, n, color): 22 | self.np[n] = color 23 | self.np.write() 24 | 25 | def show(self,dat,pos=0): 26 | for x in range(16): 27 | for y in range(8): 28 | if ((x+pos)*8)>=len(dat): 29 | self.np[x*16+y*2]=(0,0,0) 30 | self.np[x*16+y*2+1]=(0,0,0) 31 | else: 32 | t=dat[(x+pos)*8+y] 33 | r=t%16 34 | g=(t>>4)%16 35 | b=(t>>8)%16 36 | if pos%2: 37 | self.np[x*16+y*2]=(r,g,b) 38 | else: 39 | self.np[x*16+15-y*2]=(r,g,b) 40 | r=(t>>12)%16 41 | g=(t>>16)%16 42 | b=(t>>20)%16 43 | if pos%2: 44 | self.np[x*16+y*2+1]=(r,g,b) 45 | else: 46 | self.np[x*16+14-y*2]=(r,g,b) 47 | self.np.write() 48 | 49 | -------------------------------------------------------------------------------- /sensor/sht20/sht20.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for SHT20 Humidity and Temperature Sensor 3 | 4 | Author: shaoziyang 5 | Date: 2020.12 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from micropython import const 11 | from time import sleep_ms 12 | 13 | SHT20_I2C_ADDR = const(0x40) 14 | 15 | class SHT20(): 16 | 17 | def __init__(self, i2c): 18 | self.i2c = i2c 19 | self.tb = bytearray(1) 20 | self.rb = bytearray(1) 21 | self.ht = bytearray(3) 22 | self.reset() 23 | 24 | def setreg(self, reg, dat): 25 | self.tb[0] = dat 26 | self.i2c.writeto_mem(SHT20_I2C_ADDR, reg, self.tb) 27 | 28 | def getreg(self, reg): 29 | self.i2c.readfrom_mem_into(SHT20_I2C_ADDR, reg, self.rb) 30 | return self.rb[0] 31 | 32 | def write(self, cmd): 33 | self.tb[0] = cmd 34 | self.i2c.writeto(SHT20_I2C_ADDR, self.tb) 35 | 36 | def reset(self): 37 | self.write(0xfe) 38 | 39 | def measure(self, cmd, delay): 40 | self.write(cmd) 41 | sleep_ms(delay) 42 | self.i2c.readfrom_into(SHT20_I2C_ADDR, self.ht) 43 | 44 | def humi_raw(self): 45 | self.measure(0xf5, 30) 46 | return self.ht[0]*256+self.ht[1] 47 | 48 | def temperature_raw(self): 49 | self.measure(0xf3, 85) 50 | return self.ht[0]*256+self.ht[1] 51 | 52 | def humi(self): 53 | return (125*self.humi_raw()//65536) -6 54 | 55 | def temperature(self): 56 | return 175.72*self.temperature_raw()/65536 - 46.85 57 | -------------------------------------------------------------------------------- /neopixel/neo_16x16/README.md: -------------------------------------------------------------------------------- 1 | # ESP8266/ESP32 neopixel 16x16 display drive 2 | 3 | ![](16x16.gif) 4 | 5 | 6 | ## API 7 | 8 | * **set(n, color='')** 9 | set LED[n] to color 10 | n: 0-255 11 | color: LED color. if color is not given, it will using default color 12 | 13 | * **clear()** 14 | clear all LED 15 | 16 | * **setcolor(color)** 17 | set display color 18 | 19 | * **show(self, dat, offset=0, clear = True, color='')** 20 | show text or emijo. 21 | dat: text or emijo data 22 | offset: display offset 23 | clear: clear the display before show 24 | color: new color 25 | 26 | ## example 27 | 28 | 29 | ``` 30 | from machine import Pin 31 | import time 32 | 33 | from neo16x16 import neo16x16 34 | 35 | np = neo16x16(Pin(2)) 36 | 37 | npdat=[ 38 | 0x2008,0x1FFC,0x3FF8,0x1084,0x0100,0x1084,0x3FF8,0x1FFC, 39 | 0x2008,0x0000,0x1F00,0x01FC,0x2480,0x0124,0x2480,0x01EC, 40 | 0x1700,0x0000,0x0000,0x0804,0x2010,0x1FFC,0x3FF8,0x0004, 41 | 0x2000,0x0000,0x0000,0x0000,0x2010,0x0804,0x3FF8,0x1FFC, 42 | 0x2000,0x0004,0x0000,0x0000,0x0000,0x00F8,0x3F80,0x0104, 43 | 0x2080,0x0104,0x3F80,0x00F8,0x0000,0x0080,0x0180,0x0700, 44 | 0xFFF8,0xFFFF,0x1047,0x0638,0x0F38,0xF8C2,0xC00F,0x13FF, 45 | 0x7FC8,0x1080,0x0728,0x1C78,0x1818,0x0000,0x4010,0x0846, 46 | 0x37F0,0xFFB8,0x1E1F,0x0FEE,0x61F0,0x0100,0x4082,0x4103, 47 | 0xFFE2,0x4FFE,0x009A,0x7100,0x0086,0x0100,] 48 | 49 | n = 0 50 | while 1: 51 | np.show(npdat, n) 52 | n = (n + 1)%70 53 | time.sleep_ms(200) 54 | 55 | ``` 56 | 57 | From microbit/micropython Chinese community 58 | www.micropython.org.cn -------------------------------------------------------------------------------- /lcd/LCD1602_BIG_DIGITS/mkfont.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | make big digit font from "small_16x2_display_big_digits__upir.ino". 4 | 5 | ''' 6 | 7 | print('Make fonts from "small_16x2_display_big_digits__upir.ino"') 8 | 9 | f = open('small_16x2_display_big_digits__upir.ino', 'rt') 10 | buf = f.readlines() 11 | f.close() 12 | 13 | linecnt = len(buf) 14 | 15 | fontname = '' 16 | 17 | BIGFONT = {} 18 | 19 | def mt(n): 20 | return (int(n)+2)%256 21 | 22 | for i in range(linecnt): 23 | p = buf[i].find('_00[8] PROGMEM') 24 | if p>10: 25 | fontname = buf[i][11:p] 26 | fontdat = bytearray(64) 27 | fontdig = bytearray(20) 28 | for n in range(8): 29 | x = p 30 | for m in range(8): 31 | x = buf[i+n].find('B' ,x+6) 32 | s = '0'+buf[i+n][x:x+6] 33 | fontdat[n*8+m]=int(s, 2) 34 | 35 | p = buf[i].find('_digits[10][4] = ') 36 | if p>4: 37 | if buf[i][5:p] == fontname: 38 | s = buf[i][p+len('_digits[10][4] = '):] 39 | s = s.replace('{','').replace('}','').replace(';','') 40 | d=s.split(',') 41 | for n in range(20): 42 | fontdig[n] = mt(d[n*2])*16+mt(d[n*2+1]) 43 | BIGFONT[fontname] = [fontdat, fontdig] 44 | 45 | fontname = '' 46 | 47 | print('FONT number:', len(BIGFONT)) 48 | print('BIGFONTS = {') 49 | x = list(BIGFONT.keys()) 50 | for i in range(len(x)): 51 | print(" '{}':[{},{}],".format(x[i],bytes(BIGFONT[x[i]][0]),bytes(BIGFONT[x[i]][1]))) 52 | print('}') 53 | 54 | -------------------------------------------------------------------------------- /lcd/I2C_LCD1602/README.md: -------------------------------------------------------------------------------- 1 | # I2C LCD1602 MicroPython drive 2 | 3 | ## main feathur 4 | - display text in I2C LCD1602 5 | - LCD display on/off 6 | - LCD backlight on/off 7 | - LCD display shfit left/right 8 | 9 | ## ChangeLog 10 | 11 | 2020.2 ver 2.0 12 | - add autoaddress() function 13 | - add print() function 14 | - show object in puts() function 15 | 16 | 2018.2 ver 1.0 17 | - Initial version 18 | 19 | 20 | ![](demo.gif) 21 | 22 | 23 | ## internal signal 24 | 25 | |LCD1602 | PCF8574A | 26 | |--|--| 27 | |RS |P0 | 28 | |RW |P1 | 29 | |E |P2 | 30 | |BackLight |P3 | 31 | |Dat |P4-P7 | 32 | 33 | ## I2C Address 34 | 35 | | PCF8574 | PCF8574A | 36 | |--|--| 37 | | 0x27 | 0x3F | 38 | 39 | 40 | ## API 41 | 42 | * **on()** 43 | turn on LCD 44 | 45 | * **off()** 46 | turn off LCD 47 | 48 | * **clear()** 49 | clear display 50 | 51 | * **backlight(on)** 52 | 0 turn of backlight 53 | 1 turn on backlight 54 | 55 | * **char(ch, x, y)** 56 | I2show a character in given position 57 | x, 0-15 58 | y, 0-1 59 | 60 | * **puts(s, x, y)** 61 | show string/object in given position 62 | x, 0-15 63 | y, 0-1 64 | 65 | * **print(s)** 66 | print to LCD, auto wrap and scroll in line end. 67 | 68 | ## example 69 | 70 | copy mp_i2c_lcd1602.py to pyboard first. 71 | 72 | ``` 73 | from machine import I2C, Pin 74 | from mp_i2c_lcd1602 import LCD1602 75 | from time import sleep_ms 76 | 77 | i2c = I2C(1, sda=Pin(9), scl=Pin(10)) 78 | 79 | LCD = LCD1602(i2c) 80 | 81 | LCD.puts("I2C LCD1602") 82 | ``` 83 | 84 | From microbit/micropython Chinese community. 85 | www.micropython.org.cn 86 | -------------------------------------------------------------------------------- /LED/TM1637/README.md: -------------------------------------------------------------------------------- 1 | # Four Digit Display TM1637 drive 2 | 3 | Four Digit Display is a Module with four 7-segment LED, it can show number. It has TM1637 chip inside, control with a two line interface. 4 | 5 | This drive base on mcauser's TM1637 LED driver: 6 | https://github.com/mcauser/micropython-tm1637 7 | 8 | ![](4-LED.jpg) 9 | 10 | 11 | ## API 12 | 13 | * **TM1637(clk, dio, intensity=7, number = 4)** 14 | initial TM1637 display. 15 | clk, clock singal. 16 | dio, data input/output signal. 17 | intensity, display intensity. 18 | number, LED number. 19 | 20 | * **intensity(val=None)** 21 | set display intensity. 22 | **val** is intensity will be set, it can be [0 - 8]. if dat is zero, display will be turn off. 23 | if not dat given, it will return current intensity. 24 | 25 | * **on()** 26 | turn on display 27 | 28 | * **off()** 29 | turn off display 30 | 31 | * **clear（）** 32 | clear content of the display 33 | 34 | * **shownum(num)** 35 | show a interger number in display. 36 | 37 | * **showhex(num)** 38 | show a hex number. 39 | 40 | * **showDP(bit = 1, show = True)** 41 | show or hide dot piont in give bit 42 | bit is dot piont position, [0 - 3] 43 | show, True will show DP, other will hide it 44 | 45 | ## example 46 | 47 | 48 | ``` 49 | from machine import Pin 50 | import time 51 | import TM1637 52 | 53 | dio = Pin(5, Pin.OUT) 54 | clk = Pin(4, Pin.OUT) 55 | tm=TM1637.TM1637(dio=dio,clk=clk) 56 | 57 | n = 0 58 | while 1: 59 | tm.shownum(n) 60 | n += 1 61 | time.sleep_ms(1000) 62 | ``` 63 | 64 | From microbit/micropython Chinese community. 65 | www.micropython.org.cn 66 | -------------------------------------------------------------------------------- /sensor/si7051/si7051.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | from time import sleep_ms 3 | 4 | SI7051_I2C_ADDR = 0x40 5 | SI7051_CMD_HOLD_MODE = b'\xE3' 6 | SI7051_CMD_NO_HOLD_MODE = b'\xF3' 7 | SI7051_CMD_RESET = b'\xFE' 8 | SI7051_CMD_WRITE_USER_REG1 = b'\xE6' 9 | SI7051_CMD_READ_USER_REG1 = b'\xE7' 10 | SI7051_CMD_READ_ID1 = b'\xFA\x0F' 11 | SI7051_CMD_READ_ID2 = b'\xFC\xC9' 12 | SI7051_CMD_READ_REV = b'\x84\xB8' 13 | 14 | class si7051(): 15 | def __init__(self, i2c): 16 | self.i2c = i2c 17 | 18 | # get reg 19 | def getReg(self, buf, n=1): 20 | self.i2c.writeto(SI7051_I2C_ADDR, buf) 21 | t = self.i2c.readfrom(SI7051_I2C_ADDR, n) 22 | return t 23 | 24 | def ID(self): 25 | a = self.getReg(SI7051_CMD_READ_ID1, 4) 26 | b = self.getReg(SI7051_CMD_READ_ID2, 4) 27 | return hex(int.from_bytes(a+b,''))[2:] 28 | 29 | def REV(self): 30 | a = self.getReg(SI7051_CMD_READ_REV) 31 | return a[0] 32 | 33 | def UserReg(self, reg=''): 34 | if reg == '': 35 | return self.getReg(SI7051_CMD_READ_USER_REG1)[0] 36 | else: 37 | self.i2c.writeto(SI7051_I2C_ADDR, bytearray(SI7051_CMD_WRITE_USER_REG1) + bytearray([reg])) 38 | 39 | def name(self): 40 | a = self.getReg(SI7051_CMD_READ_ID2, 4)[0] 41 | return 'si70'+str(a) 42 | 43 | def Temperature(self, digital=2, delay=10): 44 | self.i2c.writeto(SI7051_I2C_ADDR, SI7051_CMD_NO_HOLD_MODE) 45 | sleep_ms(delay) 46 | a = self.i2c.readfrom(SI7051_I2C_ADDR, 2) 47 | b = a[0]*256 + a[1] 48 | return round(b*175.72/65536 - 46.85, digital) 49 | 50 | -------------------------------------------------------------------------------- /misc/irqUART/README.md: -------------------------------------------------------------------------------- 1 | # irqUART 2 | 3 | machine.UART is not support RXD irq feature, it will brings some difficulties to uart programming in some cases. 4 | 5 | irqUART give a alternative solutionuse, it use pin irq instead of uart irq. irqUART is simple, small and fast. 6 | 7 | irqUART may wakeup mcu from sleep mode. 8 | 9 | 10 | ![](demo.jpg) 11 | 12 | ## Usage 13 | 14 | 1. define user RXD irq, frame irq (when needed). 15 | 2. define a uart object. 16 | 3. define irqUART object with uart, rxd pin, RXD irq, etc. 17 | 4. init uart. 18 | 19 | ## Parameters 20 | 21 | * **uart**: uart object 22 | * **rx_pin**: uart rxd pin 23 | * **rx_irq**: user rxd irq, it can be None when not use rxd irq 24 | * **frame_irq**: user frame irq. Frame irq will be trigger when no new data and exceeding the specified time. It can be None if not use it 25 | * **CHR_TMO**: rxd irq delay (ms) after rx_pin irq, it depond on baudrate, rxbuf etc. 26 | * **FRAME_TMO**: frame irq delay (ms) after last char 27 | 28 | ## Example 29 | 30 | ``` 31 | from machine import Pin, UART 32 | from irqUART import irqUART 33 | 34 | cnt = 0 35 | def U1_RX_IRQ(t): 36 | global cnt 37 | n = 0 38 | while u1.any(): 39 | d = u1.any() 40 | cnt+=d 41 | n+=1 42 | print('[', n, ']', cnt, d, u1.read(d)) 43 | 44 | def U1_RX_FRAME_IRQ(t): 45 | global cnt 46 | print('FRAME end') 47 | cnt = 0 48 | 49 | u1=UART(1) 50 | ui = irqUART(u1, Pin('B7'), U1_RX_IRQ, U1_RX_FRAME_IRQ) 51 | ui.uart.init(115200) 52 | ``` 53 | 54 | ## Note 55 | 56 | If you use uart transmit mass data, you may need to increase uart rxbuf size to avoid data loss. 57 | 58 | From microbit/micropython Chinese community. 59 | www.micropython.org.cn 60 | -------------------------------------------------------------------------------- /misc/AT24XX/AT24XX.py: -------------------------------------------------------------------------------- 1 | ''' 2 | AT24C32 EEPROM drive 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import I2C 10 | 11 | AT24CXX_I2C_ADDRESS = (80) 12 | 13 | class AT24XX(): 14 | def __init__(self, i2c): 15 | self.i2c = i2c 16 | 17 | def write_byte(self, addr, dat): 18 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr, dat])) 19 | 20 | def read_byte(self, addr): 21 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr])) 22 | t = self.i2c.readfrom(AT24CXX_I2C_ADDRESS, 1) 23 | return t[0] 24 | 25 | def write_word(self, addr, dat): 26 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr, dat//256, dat])) 27 | 28 | def read_word(self, addr): 29 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr])) 30 | t = self.i2c.readfrom(AT24CXX_I2C_ADDRESS, 2) 31 | return t[0]*256 + t[1] 32 | 33 | def write_dword(self, addr, dat): 34 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr, dat>>24, dat>>16, dat>>8, dat])) 35 | 36 | def read_dword(self, addr): 37 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr])) 38 | t = self.i2c.readfrom(AT24CXX_I2C_ADDRESS, 4) 39 | return (t[0]<<24) + (t[1]<<16) + (t[2]<<8) + t[3] 40 | 41 | def write_buf(self, addr, buf): 42 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr]) + buf) 43 | 44 | def read_buf(self, addr, num): 45 | self.i2c.writeto(AT24CXX_I2C_ADDRESS, bytearray([addr//256, addr])) 46 | return self.i2c.readfrom(AT24CXX_I2C_ADDRESS, num) 47 | 48 | -------------------------------------------------------------------------------- /sensor/MMC5603/MMC5603.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | from micropython import const 3 | 4 | MMC5603ADDR = const(48) 5 | 6 | class MMC5603: 7 | 8 | def __init__(self, i2c): 9 | self.i2c = i2c 10 | self.tb = bytearray(1) 11 | self.rb = bytearray(1) 12 | self._rawx = 0 13 | self._rawy = 0 14 | self._rawz = 0 15 | if self.reg_get(0x39) != 0x10: 16 | raise Exception('MMC5603 ID error!') 17 | self.on() 18 | 19 | def on(self): 20 | # ODR = 10 21 | self.reg_set(0x1A, 10) 22 | self.reg_set(0x1C, 0x03) 23 | # set CONTINUOUS mode 24 | self.reg_set(0x1B, 0xA0) 25 | self.reg_set(0x1D, 0x1B) 26 | 27 | def off(self): 28 | # soft reset 29 | self.reg_set(0x1C, 0x80) 30 | 31 | def reg_set(self, reg, val): 32 | self.tb[0] = val 33 | self.i2c.writeto_mem(MMC5603ADDR, reg, self.tb) 34 | 35 | def reg_get(self, reg): 36 | self.i2c.readfrom_mem_into(MMC5603ADDR, reg, self.rb) 37 | return self.rb[0] 38 | 39 | def rawx(self): 40 | self._rawx = self.reg_get(0)*256+self.reg_get(1)-32768 41 | return self._rawx 42 | 43 | def rawy(self): 44 | self._rawy = self.reg_get(2)*256+self.reg_get(3)-32768 45 | return self._rawy 46 | 47 | def rawz(self): 48 | self._rawz = self.reg_get(4)*256+self.reg_get(5)-32768 49 | return self._rawz 50 | 51 | def x(self): 52 | return self.rawx() // 10 53 | 54 | def y(self): 55 | return self.rawy() // 10 56 | 57 | def z(self): 58 | return self.rawz() // 10 59 | 60 | def T(self): 61 | self.reg_set(0x1B, 0xA3) 62 | return self.reg_get(9)*0.8-75 63 | 64 | -------------------------------------------------------------------------------- /misc/irqUART/irqUART.py: -------------------------------------------------------------------------------- 1 | ''' 2 | UART with rx irq 3 | 4 | Author: shaoziyang 5 | Date: 2020.6 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import Pin, UART, Timer 10 | import sys 11 | 12 | class irqUART(): 13 | # uart: uart object 14 | # rx_pin: uart rxd pin 15 | # rx_irq: user rxd irq 16 | # frame_irq: user frame irq 17 | # CHR_TMO: rxd irq delay (ms) after rx_pin irq 18 | # FRAME_TMO: frame irq delay (ms) after last char 19 | def __init__(self, uart, rx_pin, rx_irq=None, frame_irq=None, CHR_TMO=3, FRAME_TMO=100): 20 | self._rxpin = rx_pin 21 | self._rxirq = rx_irq 22 | self._frameirq = frame_irq 23 | self._CHR_TMO = CHR_TMO 24 | self._FRAME_TMO = FRAME_TMO 25 | self._rxpin.init(Pin.IN) 26 | self._rxpin.irq(trigger = Pin.IRQ_FALLING, handler = self._RXPIN_IRQ) 27 | self._TMRX = Timer(-1) 28 | self._TMRX_sta = 0 29 | self._mode = Timer.ONE_SHOT if sys.platform == 'pyboard' else Timer.PERIODIC 30 | self.uart = uart 31 | 32 | def _RXPIN_IRQ(self, t): 33 | if self._TMRX_sta == 0: 34 | self._TMRX_sta = 1 35 | self._TMRX.deinit() 36 | self._TMRX.init(period = self._CHR_TMO, mode = self._mode, callback = self._TMRX_IRQ) 37 | 38 | def _TMRX_IRQ(self, t): 39 | if self._TMRX_sta != 0: 40 | if self._frameirq != None and self._FRAME_TMO > 0: 41 | self._TMRX.deinit() 42 | self._TMRX.init(period = self._FRAME_TMO, mode = Timer.ONE_SHOT, callback = self._TMRX_IRQ) 43 | if self._rxirq != None: 44 | self._rxirq(0) 45 | else: 46 | if self._frameirq != None: 47 | self._frameirq(0) 48 | self._TMRX_sta = 0 49 | 50 | -------------------------------------------------------------------------------- /keyboard/mechanical-button/single-button/README.md: -------------------------------------------------------------------------------- 1 | ### 单个机械按键驱动模块 2 | --- 3 | 4 | ![轻触按键](./key.JPG) 5 | 6 | ---- 7 | **简介** 8 | 9 | > 单个机械按键的操作，通常分为两种模式，即长按和短按。其中，长按又可分为定时长按与计时长按，定时长按即按下按键并保持按下状态达到设定时间后触发事件，且只触发一次，常用于设备复位。而计时长按则为在保持按下状态的情况下，达到设定时间（长度）值便触发一次事件，直到松开按键为止，此种方式常用于长按自动累加调整数值。短按则又可以分为单次点击和连续多次点击两种，单次点击就是按一下按键然后就松开，常用于普通的按键控制等；多次点击就是在设定的时间内连续按下、松开、再按下、再松开，来回多次，常用于一些设备的快速控制，如静电放电枪的扳机（开关），在停止状态下，扣动一次，则会切换电压极性，在停止状态下，连续扣动2次则会增加实验电压值，连续扣动3次则会减少实验电压值，连续扣动4次则会开始实验。 10 | 11 | #### 模块 12 | 13 | KEYBOARD *（\_btnKey, \_tmBtn, \_btnDef = 1, even_djlong = None, even_lj = None, \_pull = None）* 14 | 15 | ###### 参数说明 16 | ------ 17 | **\_btnKey** 18 | > 按钮引脚，按键所对应的IO引脚 19 | 20 | **\_tmBtn** 21 | > 定时器，用于定时扫描按键对应的IO状态。 22 | 23 | **\_btnDef** 24 | > 按键初始状态，若为1，则为高电平，低电平闭合。 25 | 26 | * 取值范围：`0` 或 `1` 27 | * 默认值：`1` 28 | 29 | 30 | **even_djlong** 31 | > 长按事件，若为None则为不启用，否则将调用指定的函数。 32 | 33 | * 取值范围：`None` 或 `其它` 34 | * 默认值：`None`（即不启用） 35 | 36 | **even_lj** 37 | > 连续点击事件，若为None则为不启用，否则将调用指定的函数。 38 | 39 | * 取值范围：`None` 或 `其它` 40 | * 默认值：`None`（即不启用） 41 | 42 | **\_pull** 43 | > 触发方式，按键弹起后触发或按下后触发。 44 | 45 | * 取值范围：`UP`、`DOWN`、`None` 46 | * 默认值：`UP` 47 | 48 | 49 | ###### 事件说明 50 | ------ 51 | **even_djlong(con)** 52 | > * 按键长按事件，若不带参数，则表示触发了一次固定时长的长按事件，若带参数，则会返回当前按下并保持按钮状态的时长； 53 | > * con为返回的连续有效的计时次数，时间间隔与定时器的设置有关。统计时间时可以使用 （con×时间间隔）÷1000； 54 | > * 事件名称可在引用时自定义； 55 | > * 长按计时与长按事件不可同时触发，两者二选一。 56 | 57 | 58 | **even_lj(con)** 59 | > * 按键连续点击事件，在规定的时间间隔内连续按下并松开按键的次数； 60 | > * con 为事件返回的按键点击次数，若为`1`则表示为单击。 61 | 62 | 63 | #### 用法举例： 64 | 65 | ```python 66 | from keyboard import KEYBOARD 67 | 68 | # 按键引脚 69 | p = Pin('B3') 70 | 71 | # 定时器,按键时钟使用 72 | s = Timer(1) 73 | 74 | # 长按事件 75 | def evn_long(con): 76 | print("您按下按键已保持 ", (con*10)/1000," 秒的时间了") 77 | 78 | # 连续点击事件 79 | def evn_con(con): 80 | print("您已连续点击了：", con, " 次") 81 | 82 | # 声明按键对象，并设置事件 83 | sw = KEYBOARD(p, s, 0, evn_long, evn_con, "UP") 84 | 85 | 86 | 87 | ``` 88 | -------------------------------------------------------------------------------- /sensor/SHT3x/I2C_16bit/sht3x_16bit.py: -------------------------------------------------------------------------------- 1 | # mpy-lib 2 | # SHT3x humidity and temperature sensor 16bit I2C micropython drive 3 | # ver: 1.0 4 | # License: MIT 5 | # Author: shaoziyang 6 | # https://github.com/micropython-Chinese-Community/mpy-lib 7 | 8 | from time import sleep_ms 9 | 10 | class SHT3x(): 11 | 12 | def __init__(self, i2c, addr = 68): 13 | self.i2c = i2c 14 | self._addr = addr 15 | self.ver = '1.0' 16 | self.info = 'SHT3x 16bit I2C drive for micropython' 17 | self._mode = 1 18 | self._cmd = 0x240b 19 | self._delay = 6 20 | self._decimal = 1 21 | self._rb = bytearray(3) 22 | self._ht = bytearray(6) 23 | self._T = 0 24 | self._H = 0 25 | self.reset() 26 | 27 | def status(self): 28 | self.i2c.readfrom_mem_into(self._addr, 0xf32d, self._rb, addrsize=16) 29 | return self._rb[0]*256 + self._rb[1] 30 | 31 | def write(self, cmd): 32 | self.i2c.writeto_mem(self._addr, cmd, b'', addrsize=16) 33 | 34 | def reset(self): 35 | self.write(0x30a2) 36 | 37 | def heater(self, on=0): 38 | if on: self.write(0x306d) 39 | else: self.write(0x3066) 40 | 41 | def config(self, mode = 0x240b, delay = 6, decimal = 1): 42 | t = mode >> 8 43 | self._mode = 1 if t == 0x24 or t == 0x2C else 0 44 | self._cmd = mode 45 | self._delay = delay 46 | self.write(mode) 47 | 48 | def measure(self): 49 | if self._mode: 50 | self.write(self._cmd) 51 | sleep_ms(self._delay) 52 | self.i2c.readfrom_mem_into(self._addr, 0xe000, self._ht, addrsize=16) 53 | self._T = self._ht[0]*256+self._ht[1] 54 | self._H = self._ht[3]*256+self._ht[4] 55 | 56 | def humidity(self): 57 | return round(100*self._H/65535, self._decimal) 58 | 59 | def temperature(self): 60 | return round(175*self._T/65535 - 45, self._decimal) 61 | 62 | def ht(self): 63 | return self.humidity(), self.temperature() 64 | -------------------------------------------------------------------------------- /misc/DS3231/README.md: -------------------------------------------------------------------------------- 1 | # DS3231 2 | 3 | DS3231 real-time clock (RTC) is a low power, full binary-coded decimal (BCD) clock/calendar, with alarm output. 4 | 5 | ![](ds3231.jpg) 6 | 7 | ## I2C Address 8 | 9 | 0x68 10 | 11 | ## API 12 | 13 | * **Year(year = None)** 14 | get / set year. 15 | 16 | * **Month(month = None)** 17 | get / set month. 18 | 19 | * **Day(day = None)** 20 | get / set day. 21 | 22 | * **Weekday(weekday = None)** 23 | get / set month. 24 | 25 | * **Hour(hour = None)** 26 | get / set hour. 27 | 28 | * **Minute(minute = None)** 29 | get / set minute. 30 | 31 | * **Second(second = None)** 32 | get / set second. 33 | 34 | * **DateTime(dat = None)** 35 | get / set DateTime. If no paramter given, it will return current datetime, otherwise it will set datatime. 36 | datatime format: [Year, month, day, weekday, hour, minute, second] 37 | 38 | * **Time(dat = None)** 39 | get / set Time. 40 | Time format: [hour, minute, second] 41 | 42 | * **Date(dat = None)** 43 | get / set Date. 44 | Date format: [Year, month, day] 45 | 46 | * **Temperature()** 47 | get ambient temperature. 48 | 49 | * **ClearALARM()** 50 | Clear alarm flag. It must be call to clear SQW output manual. 51 | 52 | * **ALARM(day, hour, minute, repeat)** 53 | set ALARM time and repeat. 54 | repeat: ALARM repeat mode 55 | - PER_MINUTE, alarm every minute, when second become zero. 56 | - PER_HOUR, alarm every hour, when minute equal with RTC's minute. 57 | - PER_DAY, alarm ervry day, when hour and minute equal with RTC's hour and minute. 58 | - PER_WEEKDAY, alarm every week, when day equal with RTC's weekday. 59 | - PER_MONTH, alarm every month, when day and hour and minute equal with RTC. 60 | - PER_DISABLE, disable alarm. 61 | 62 | ## example 63 | 64 | ``` 65 | from machine import I2C, Pin 66 | import DS3231 67 | 68 | i2c = I2C(sda = Pin(5), scl=Pin(4)) 69 | ds = DS3231.DS3231(i2c) 70 | 71 | ds.Hour(12) 72 | 73 | ds.Time() 74 | ds.Time([12,10,0]) 75 | 76 | ds.DateTime([2018,3,12,1,22,10,0]) 77 | 78 | ds.ALARM(12, 20, 10, ds.PER_DISABLE) 79 | ds.ALARM(12, 20, 10, ds.PER_DAY) 80 | ds.ClearALARM() 81 | ``` 82 | 83 | From microbit/micropython Chinese community. 84 | www.micropython.org.cn 85 | -------------------------------------------------------------------------------- /sensor/SHT3x/I2C_8bit/sht3x.py: -------------------------------------------------------------------------------- 1 | # mpy-lib 2 | # SHT3x humidity and temperature sensor 8bit I2C micropython drive 3 | # ver: 1.0 4 | # License: MIT 5 | # Author: shaoziyang 6 | # https://github.com/micropython-Chinese-Community/mpy-lib 7 | 8 | from time import sleep_ms 9 | 10 | class SHT3x(): 11 | 12 | def __init__(self, i2c, addr = 68): 13 | self.i2c = i2c 14 | self._addr = addr 15 | self.ver = '1.0' 16 | self.info = 'SHT3x I2C drive for micropython' 17 | self._mode = 1 18 | self._cmd = 0x240b 19 | self._delay = 6 20 | self._decimal = 1 21 | self._tb = bytearray(2) 22 | self._rb = bytearray(3) 23 | self._ht = bytearray(6) 24 | self._T = 0 25 | self._H = 0 26 | self.reset() 27 | 28 | def status(self): 29 | self.write(0xf32d) 30 | self.i2c.readfrom_into(self._addr, self._rb) 31 | return self._rb[0]*256 + self._rb[1] 32 | 33 | def clear_status(self): 34 | self.write(0x3041) 35 | 36 | def write(self, cmd): 37 | self._tb[0] = cmd>>8 38 | self._tb[1] = cmd 39 | self.i2c.writeto(self._addr, self._tb) 40 | 41 | def reset(self): 42 | self.write(0x30a2) 43 | 44 | def heater(self, on=0): 45 | if on: self.write(0x306d) 46 | else: self.write(0x3066) 47 | 48 | def config(self, mode = 0x240b, delay = 6, decimal = 1): 49 | t = mode >> 8 50 | self._mode = 1 if t == 0x24 or t == 0x2C else 0 51 | self._cmd = mode 52 | self._delay = delay 53 | self._decimal = decimal 54 | self.write(mode) 55 | 56 | def measure(self): 57 | if self._mode: 58 | self.write(self._cmd) 59 | sleep_ms(self._delay) 60 | self.write(0xe000) 61 | self.i2c.readfrom_into(self._addr, self._ht) 62 | self._T = self._ht[0]*256+self._ht[1] 63 | self._H = self._ht[3]*256+self._ht[4] 64 | 65 | def humidity(self): 66 | return round(100*self._H/65535, self._decimal) 67 | 68 | def temperature(self): 69 | return round(175*self._T/65535 - 45, self._decimal) 70 | 71 | def ht(self): 72 | return self.humidity(), self.temperature() 73 | -------------------------------------------------------------------------------- /LED/TM1650/FourDigitDisplay.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for Four Digit LED Display (TM1650) 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from micropython import const 11 | from machine import I2C 12 | 13 | COMMAND_I2C_ADDRESS = const(0x24) 14 | DISPLAY_I2C_ADDRESS = const(0x34) 15 | 16 | buf = (0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71) 17 | 18 | class FourDigitDisplay(): 19 | def __init__(self, i2c): 20 | self.i2c = i2c 21 | self._intensity = 3 22 | self.dbuf = [0, 0, 0, 0] 23 | self.tbuf = bytearray(1) 24 | self.on() 25 | 26 | def intensity(self, dat = -1): 27 | if dat < 0 or dat > 8: 28 | return self._intensity 29 | if dat == 0: 30 | self.off() 31 | else: 32 | self._intensity = dat 33 | self.cmd((dat<<4)|0x01) 34 | 35 | def cmd(self, c): 36 | self.tbuf[0] = c 37 | self.i2c.writeto(COMMAND_I2C_ADDRESS, self.tbuf) 38 | 39 | def dat(self, bit, d): 40 | self.tbuf[0] = d 41 | self.i2c.writeto(DISPLAY_I2C_ADDRESS + bit%4, self.tbuf) 42 | 43 | def on(self): 44 | self.cmd((self._intensity<<4)|0x01) 45 | 46 | def off(self): 47 | self._intensity = 0 48 | self.cmd(0) 49 | 50 | def clear(self): 51 | self.dat(0, 0) 52 | self.dat(1, 0) 53 | self.dat(2, 0) 54 | self.dat(3, 0) 55 | self.dbuf = [0, 0, 0, 0] 56 | 57 | def showbit(self, num, bit = 0): 58 | self.dbuf[bit%4] = buf[num%16] 59 | self.dat(bit, buf[num%16]) 60 | 61 | def shownum(self, num): 62 | if num < 0: 63 | self.dat(0, 0x40) # '-' 64 | num = -num 65 | else: 66 | self.showbit((num // 1000) % 10) 67 | self.showbit(num % 10, 3) 68 | self.showbit((num // 10) % 10, 2) 69 | self.showbit((num // 100) % 10, 1) 70 | 71 | def showhex(self, num): 72 | if num < 0: 73 | self.dat(0, 0x40) # '-' 74 | num = -num 75 | else: 76 | self.showbit((num >> 12) % 16) 77 | self.showbit(num % 16, 3) 78 | self.showbit((num >> 4) % 16, 2) 79 | self.showbit((num >> 8) % 16, 1) 80 | 81 | def showDP(self, bit = 1, show = True): 82 | if show: 83 | self.dat(bit, self.dbuf[bit] | 0x80) 84 | else: 85 | self.dat(bit, self.dbuf[bit] & 0x7F) 86 | -------------------------------------------------------------------------------- /sensor/SHT3x/I2C_8bit/README.md: -------------------------------------------------------------------------------- 1 | # [mpy-lib](https://github.com/micropython-Chinese-Community/mpy-lib) 2 | 3 | ## SHT3x 4 | 5 | Humidity and Temperature Sensor micropython driver, **8bit** I2C address mode. 6 | 7 | ![](sht30.jpg) 8 | 9 | 10 | ## ESP32 example 11 | 12 | ```python 13 | from machine import I2C, Pin 14 | from time import sleep_ms 15 | from sht3x import SHT3x 16 | 17 | i2c = I2C(0, sda=Pin(21), scl = Pin(22)) 18 | 19 | sht30 = SHT3x(i2c) 20 | 21 | while True: 22 | sht30.measure() 23 | print(sht30.ht()) 24 | sleep_ms(1000) 25 | ``` 26 | 27 | ## API 28 | 29 | - SHT3x.**measure()** 30 | Starting measurement. 31 | 32 | - SHT3x.**humidity()** 33 | get humidity. 34 | 35 | - SHT3x.**temperature()** 36 | get temperature. 37 | 38 | - SHT3x.**ht()** 39 | get humidity and temperature. 40 | 41 | - SHT3x.**config(mode = 0x240b, delay = 6, decimal = 1)** 42 | - mode, measurement command. Please see [mode table](#mode) below. 43 | - delay, measurement duration time 44 | - low repeatability, 4ms 45 | - Medium repeatability, 6ms (default) 46 | - High repeatability, 15ms 47 | - decimal, number of digits after decimal point 48 | 49 | - SHT3x.**heater(on=0)** 50 | Turn on/off internal heater. 51 | - on=1, turn internal heater 52 | - on=0, turn off internal heater 53 | 54 | - SHT3x.**status()** 55 | Read **Status Register** 56 | 57 | - SHT3x.**clear_status()** 58 | Clear **Status Register** 59 | 60 | - SHT3x.**reset()** 61 | Soft Reset 62 | 63 | ### mode table 64 | | mode | Repeatability | Measurement | mps | 65 | |-|-|-|:-:| 66 | | 0x2c06 | High | Single Shot| - | 67 | | 0x2c0D | Medium | Single Shot | -| 68 | | 0x2c10 | Low | Single Shot | -| 69 | | 0x2400 | High | Single Shot|- | 70 | | 0x240b (default)| Medium | Single Shot |-| 71 | | 0x2416 | Low | Single Shot | -| 72 | | 0x2032 | High | Periodic mode | 0.5| 73 | | 0x2024 | Medium | Periodic mode | 0.5| 74 | | 0x202F | Low | Periodic mode | 0.5| 75 | | 0x2130 | High | Periodic mode | 1| 76 | | 0x2126 | Medium | Periodic mode | 1| 77 | | 0x212d | Low | Periodic mode | 1| 78 | | 0x2236 | High | Periodic mode | 2| 79 | | 0x2220 | Medium | Periodic mode | 2| 80 | | 0x222b | Low | Periodic mode | 2| 81 | | 0x2334 | High | Periodic mode | 4| 82 | | 0x2322 | Medium | Periodic mode | 4| 83 | | 0x2329 | Low | Periodic mode | 4| 84 | | 0x2737 | High | Periodic mode | 10| 85 | | 0x2721 | Medium | Periodic mode | 10| 86 | | 0x272a | Low | Periodic mode | 10| 87 | 88 | 89 | please note, In order to simplify the code, crc8 checksum is ignored. 90 | 91 | From [microbit/micropython Chinese community](https://www.micropython.org.cn). 92 | -------------------------------------------------------------------------------- /sensor/SHT3x/I2C_16bit/README.md: -------------------------------------------------------------------------------- 1 | # [mpy-lib](https://github.com/micropython-Chinese-Community/mpy-lib) 2 | 3 | ## SHT3x 4 | 5 | Humidity and Temperature Sensor micropython driver, **16bit** I2C address mode. 6 | 7 | ![](sht30.jpg) 8 | 9 | 10 | 11 | ## ESP32 example 12 | 13 | ```python 14 | from machine import I2C, Pin 15 | from time import sleep_ms 16 | from sht3x_16bit import SHT3x 17 | 18 | i2c = I2C(0, sda=Pin(21), scl = Pin(22)) 19 | 20 | sht30 = SHT3x(i2c) 21 | 22 | while True: 23 | sht30.measure() 24 | print(sht30.ht()) 25 | sleep_ms(1000) 26 | ``` 27 | 28 | ## API 29 | 30 | - SHT3x.**measure()** 31 | Starting measurement. 32 | 33 | - SHT3x.**humidity()** 34 | get humidity. 35 | 36 | - SHT3x.**temperature()** 37 | get temperature. 38 | 39 | - SHT3x.**ht()** 40 | get humidity and temperature. 41 | 42 | - SHT3x.**config(mode = 0x240b, delay = 6, decimal = 1)** 43 | - mode, measurement command. Please see [mode table](#mode) below. 44 | - delay, measurement duration time 45 | - low repeatability, 4ms 46 | - Medium repeatability, 6ms (default) 47 | - High repeatability, 15ms 48 | - decimal, number of digits after decimal point 49 | 50 | - SHT3x.**heater(on=0)** 51 | Turn on/off internal heater. 52 | - on=1, turn internal heater 53 | - on=0, turn off internal heater 54 | 55 | - SHT3x.**status()** 56 | Read **Status Register** 57 | 58 | - SHT3x.**clear_status()** 59 | Clear **Status Register** 60 | 61 | - SHT3x.**reset()** 62 | Soft Reset 63 | 64 | mode table 65 | | mode | Repeatability | Measurement | mps | 66 | |-|-|-|-| 67 | | 0x2c06 | High | Single Shot| - | 68 | | 0x2c0D | Medium | Single Shot | -| 69 | | 0x2c10 | Low | Single Shot | -| 70 | | 0x2400 | High | Single Shot|- | 71 | | 0x240b (default)| Medium | Single Shot |-| 72 | | 0x2416 | Low | Single Shot | -| 73 | | 0x2032 | High | Periodic mode | 0.5| 74 | | 0x2024 | Medium | Periodic mode | 0.5| 75 | | 0x202F | Low | Periodic mode | 0.5| 76 | | 0x2130 | High | Periodic mode | 1| 77 | | 0x2126 | Medium | Periodic mode | 1| 78 | | 0x212d | Low | Periodic mode | 1| 79 | | 0x2236 | High | Periodic mode | 2| 80 | | 0x2220 | Medium | Periodic mode | 2| 81 | | 0x222b | Low | Periodic mode | 2| 82 | | 0x2334 | High | Periodic mode | 4| 83 | | 0x2322 | Medium | Periodic mode | 4| 84 | | 0x2329 | Low | Periodic mode | 4| 85 | | 0x2737 | High | Periodic mode | 10| 86 | | 0x2721 | Medium | Periodic mode | 10| 87 | | 0x272a | Low | Periodic mode | 10| 88 | 89 | 90 | please note, In order to simplify the code, crc8 checksum is ignored. 91 | 92 | From [microbit/micropython Chinese community](https://www.micropython.org.cn). 93 | -------------------------------------------------------------------------------- /LED/OLED_I2C_ASC/Font_6x8.py: -------------------------------------------------------------------------------- 1 | ''' 2 | FONT 6x8 for OLED 3 | ''' 4 | # ' ' - '~' 0x20 - 0x7E 5 | Font_6x8 = bytes(b'\ 6 | \x00\x00\x00\x00\x00\ 7 | \x00\x00\x5F\x00\x00\ 8 | \x00\x07\x00\x07\x00\ 9 | \x14\x7F\x14\x7F\x14\ 10 | \x24\x2A\x07\x2A\x12\ 11 | \x23\x13\x08\x64\x62\ 12 | \x37\x49\x55\x22\x50\ 13 | \x00\x05\x03\x00\x00\ 14 | \x00\x1C\x22\x41\x00\ 15 | \x00\x41\x22\x1C\x00\ 16 | \x08\x2A\x1C\x2A\x08\ 17 | \x08\x08\x3E\x08\x08\ 18 | \x00\x50\x30\x00\x00\ 19 | \x08\x08\x08\x08\x08\ 20 | \x00\x60\x60\x00\x00\ 21 | \x20\x10\x08\x04\x02\ 22 | \x3E\x51\x49\x45\x3E\ 23 | \x00\x42\x7F\x40\x00\ 24 | \x42\x61\x51\x49\x46\ 25 | \x21\x41\x45\x4B\x31\ 26 | \x18\x14\x12\x7F\x10\ 27 | \x27\x45\x45\x45\x39\ 28 | \x3C\x4A\x49\x49\x30\ 29 | \x01\x71\x09\x05\x03\ 30 | \x36\x49\x49\x49\x36\ 31 | \x06\x49\x49\x29\x1E\ 32 | \x00\x36\x36\x00\x00\ 33 | \x00\x56\x36\x00\x00\ 34 | \x00\x08\x14\x22\x41\ 35 | \x14\x14\x14\x14\x14\ 36 | \x41\x22\x14\x08\x00\ 37 | \x02\x01\x51\x09\x06\ 38 | \x32\x49\x79\x41\x3E\ 39 | \x7E\x11\x11\x11\x7E\ 40 | \x7F\x49\x49\x49\x36\ 41 | \x3E\x41\x41\x41\x22\ 42 | \x7F\x41\x41\x22\x1C\ 43 | \x7F\x49\x49\x49\x41\ 44 | \x7F\x09\x09\x01\x01\ 45 | \x3E\x41\x41\x51\x32\ 46 | \x7F\x08\x08\x08\x7F\ 47 | \x00\x41\x7F\x41\x00\ 48 | \x20\x40\x41\x3F\x01\ 49 | \x7F\x08\x14\x22\x41\ 50 | \x7F\x40\x40\x40\x40\ 51 | \x7F\x02\x04\x02\x7F\ 52 | \x7F\x04\x08\x10\x7F\ 53 | \x3E\x41\x41\x41\x3E\ 54 | \x7F\x09\x09\x09\x06\ 55 | \x3E\x41\x51\x21\x5E\ 56 | \x7F\x09\x19\x29\x46\ 57 | \x46\x49\x49\x49\x31\ 58 | \x01\x01\x7F\x01\x01\ 59 | \x3F\x40\x40\x40\x3F\ 60 | \x1F\x20\x40\x20\x1F\ 61 | \x7F\x20\x18\x20\x7F\ 62 | \x63\x14\x08\x14\x63\ 63 | \x03\x04\x78\x04\x03\ 64 | \x61\x51\x49\x45\x43\ 65 | \x00\x00\x7F\x41\x41\ 66 | \x02\x04\x08\x10\x20\ 67 | \x41\x41\x7F\x00\x00\ 68 | \x04\x02\x01\x02\x04\ 69 | \x40\x40\x40\x40\x40\ 70 | \x00\x01\x02\x04\x00\ 71 | \x20\x54\x54\x54\x78\ 72 | \x7F\x48\x44\x44\x38\ 73 | \x38\x44\x44\x44\x20\ 74 | \x38\x44\x44\x48\x7F\ 75 | \x38\x54\x54\x54\x18\ 76 | \x08\x7E\x09\x01\x02\ 77 | \x08\x14\x54\x54\x3C\ 78 | \x7F\x08\x04\x04\x78\ 79 | \x00\x44\x7D\x40\x00\ 80 | \x20\x40\x44\x3D\x00\ 81 | \x00\x7F\x10\x28\x44\ 82 | \x00\x41\x7F\x40\x00\ 83 | \x7C\x04\x18\x04\x78\ 84 | \x7C\x08\x04\x04\x78\ 85 | \x38\x44\x44\x44\x38\ 86 | \x7C\x14\x14\x14\x08\ 87 | \x08\x14\x14\x18\x7C\ 88 | \x7C\x08\x04\x04\x08\ 89 | \x48\x54\x54\x54\x20\ 90 | \x04\x3F\x44\x40\x20\ 91 | \x3C\x40\x40\x20\x7C\ 92 | \x1C\x20\x40\x20\x1C\ 93 | \x3C\x40\x30\x40\x3C\ 94 | \x44\x28\x10\x28\x44\ 95 | \x0C\x50\x50\x50\x3C\ 96 | \x44\x64\x54\x4C\x44\ 97 | \x00\x08\x36\x41\x00\ 98 | \x00\x00\x7F\x00\x00\ 99 | \x00\x41\x36\x08\x00\ 100 | \x02\x01\x02\x04\x02\ 101 | ') 102 | -------------------------------------------------------------------------------- /sensor/STTS751/STTS751.py: -------------------------------------------------------------------------------- 1 | # STTS751 temperature seneor micropython drive 2 | # ver: 1.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@micropython.org.cn) 5 | # v1.0 2019.7 6 | 7 | STTS751_RESOLUTION = (8, 0, 4, 12, 10, 11, 9, 12) 8 | STTS751_REG_STATUS = const(1) 9 | STTS751_REG_CONFIG = const(3) 10 | STTS751_REG_CONRAT = const(4) 11 | STTS751_REG_TEMPVH = const(0) 12 | STTS751_REG_TEMPVL = const(2) 13 | STTS751_REG_TEMPHH = const(5) 14 | STTS751_REG_TEMPHL = const(6) 15 | STTS751_REG_TEMPLH = const(7) 16 | STTS751_REG_TEMPLL = const(8) 17 | STTS751_REG_ONESHOT = const(15) 18 | STTS751_REG_THERM = const(32) 19 | STTS751_REG_THERMHYS = const(33) 20 | 21 | class STTS751(): 22 | def __init__(self, i2c): 23 | self.i2c = i2c 24 | self.addr = 0x4A 25 | self.tb = bytearray(1) 26 | self.rb = bytearray(1) 27 | self.oneshot = False 28 | self.oneshot_mode(False) 29 | 30 | def int16(self, d): 31 | return d if d < 0x8000 else d - 0x10000 32 | 33 | def setreg(self, reg, dat): 34 | self.tb[0] = dat 35 | self.i2c.writeto_mem(self.addr, reg, self.tb) 36 | 37 | def getreg(self, reg): 38 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 39 | return self.rb[0] 40 | 41 | def get2reg(self, reg): 42 | return self.getreg(reg) + self.getreg(reg+1) * 256 43 | 44 | def resolution(self, res = None): 45 | self.getreg(STTS751_REG_CONFIG) 46 | if res is None: 47 | return STTS751_RESOLUTION[(self.rb[0] & 0x0C)//4 + 4] 48 | else: 49 | if res > 12 or res < 9: return 50 | self.rb[0] = (self.rb[0] & 0xF3) | STTS751_RESOLUTION[res-9] 51 | self.setreg(STTS751_REG_CONFIG, self.rb[0]) 52 | 53 | def oneshot_mode(self, oneshot=None): 54 | if oneshot is None: 55 | return self.oneshot 56 | else: 57 | self.getreg(STTS751_REG_CONFIG) 58 | self.oneshot = oneshot 59 | if oneshot: self.rb[0] |= 0x40 60 | else: self.rb[0] &= 0xBF 61 | self.setreg(STTS751_REG_CONFIG, self.rb[0]) 62 | 63 | def ONE_SHOT(self): 64 | if self.oneshot: 65 | self.setreg(STTS751_REG_ONESHOT, 1) 66 | while 1: 67 | if self.getreg(STTS751_REG_STATUS) < 0x80: 68 | return 69 | 70 | def temperature(self): 71 | try: 72 | self.ONE_SHOT() 73 | return self.int16((self.getreg(STTS751_REG_TEMPVH)<<8) + self.getreg(STTS751_REG_TEMPVL))/256 74 | except MemoryError: 75 | return self.temperature_irq() 76 | 77 | def temperature_irq(self): 78 | self.ONE_SHOT() 79 | self.getreg(STTS751_REG_TEMPVH) 80 | return self.rb[0] if self.rb[0] < 128 else self.rb[0] - 256 81 | 82 | 83 | -------------------------------------------------------------------------------- /sensor/SC7A20/SC7A20.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | 3 | class SC7A20: 4 | 5 | def __init__(self, i2c, SDO = 1): 6 | self.i2c = i2c 7 | self.ADDR = 0x19 if SDO == 1 else 0x18 8 | self._ODR = 4 9 | self._LPen = 1 10 | self._FS = 0 11 | self._HR = 1 12 | self.tb = bytearray(1) 13 | self.rb = bytearray(1) 14 | self.init() 15 | 16 | def reg_set(self, reg, val): 17 | self.tb[0] = val 18 | self.i2c.writeto_mem(self.ADDR, reg, self.tb) 19 | 20 | def reg_get(self, reg): 21 | self.i2c.readfrom_mem_into(self.ADDR, reg, self.rb) 22 | return self.rb[0] 23 | 24 | def rw_reg(self, reg, dat, mask): 25 | self.reg_get(reg) 26 | self.rb[0] = (self.rb[0] & mask) | dat 27 | self.reg_set(reg, self.rb[0]) 28 | 29 | def ODR(self, odr = None): 30 | if odr != None: 31 | self._ODR = odr 32 | self.rw_reg(0x20, odr<<4, 0x0F) 33 | else: 34 | return self._ODR 35 | 36 | def LP(self, lp = None): 37 | if lp != None: 38 | self._LPen = lp 39 | self.rw_reg(0x20, lp<<3, 0x08) 40 | else: 41 | return self._LPen 42 | 43 | def FS(self, fs = None): 44 | if fs != None: 45 | self._FS = fs 46 | self.rw_reg(0x23, fs<<4, 0xCF) 47 | else: 48 | return self._FS 49 | 50 | def HR(self, hr = None): 51 | if hr != None: 52 | self._HR = hr 53 | self.rw_reg(0x23, hr<<3, 0x08) 54 | else: 55 | return self._HR 56 | 57 | def on(self): 58 | self.ODR(self._ODR) 59 | 60 | def off(self): 61 | self.ODR(0) 62 | 63 | def init(self): 64 | # enable TEMP 65 | self.reg_set(0x1F, 255) 66 | # ODR 4 (50Hz), LPEN = 1, XYZen = 1 67 | self.LP(1) 68 | # BDU = BLE = 0, FS = 0 (2G), HR = 1 69 | self.FS(0) 70 | self.HR(1) 71 | self.on() 72 | # int lock 73 | self.reg_set(0x24, 0x0F) 74 | 75 | def int16(self, d): 76 | return d if d < 0x8000 else d - 0x10000 77 | 78 | def T(self): 79 | return self.reg_get(0x0D) 80 | 81 | def rawx(self): 82 | return self.reg_get(0x28) + self.reg_get(0x29)*256 83 | 84 | def rawy(self): 85 | return self.reg_get(0x2A) + self.reg_get(0x2B)*256 86 | 87 | def rawz(self): 88 | return self.reg_get(0x2C) + self.reg_get(0x2D)*256 89 | 90 | def x(self): 91 | return self.int16(self.rawx())>>(4-self._FS) 92 | 93 | def y(self): 94 | return self.int16(self.rawy())>>(4-self._FS) 95 | 96 | def z(self): 97 | return self.int16(self.rawz())>>(4-self._FS) 98 | 99 | 100 | 101 | -------------------------------------------------------------------------------- /sensor/LPS22/LPS22.py: -------------------------------------------------------------------------------- 1 | # LPS22HB/HH pressure seneor micropython drive 2 | # ver: 2.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@micropython.org.cn) 5 | # v1.0 2016.4 6 | # v2.0 2019.7 7 | 8 | LPS22_CTRL_REG1 = const(0x10) 9 | LPS22_CTRL_REG2 = const(0x11) 10 | LPS22_STATUS = const(0x27) 11 | LPS22_TEMP_OUT_L = const(0x2B) 12 | LPS22_PRESS_OUT_XL = const(0x28) 13 | LPS22_PRESS_OUT_L = const(0x29) 14 | 15 | class LPS22(): 16 | def __init__(self, i2c, addr = 0x5D): 17 | self.i2c = i2c 18 | self.addr = addr 19 | self.tb = bytearray(1) 20 | self.rb = bytearray(1) 21 | self.oneshot = False 22 | self.irq_v = [0, 0] 23 | # ODR=1 EN_LPFP=1 BDU=1 24 | self.setreg(LPS22_CTRL_REG1, 0x1A) 25 | self.oneshot_mode(False) 26 | 27 | def oneshot_mode(self, oneshot=None): 28 | if oneshot is None: 29 | return self.oneshot 30 | else: 31 | self.getreg(LPS22_CTRL_REG1) 32 | self.oneshot = oneshot 33 | if oneshot: self.rb[0] &= 0x0F 34 | else: self.rb[0] |= 0x10 35 | self.setreg(LPS22_CTRL_REG1, self.rb[0]) 36 | 37 | def int16(self, d): 38 | return d if d < 0x8000 else d - 0x10000 39 | 40 | def setreg(self, reg, dat): 41 | self.tb[0] = dat 42 | self.i2c.writeto_mem(self.addr, reg, self.tb) 43 | 44 | def getreg(self, reg): 45 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 46 | return self.rb[0] 47 | 48 | def get2reg(self, reg): 49 | return self.getreg(reg) + self.getreg(reg+1) * 256 50 | 51 | def ONE_SHOT(self, b): 52 | if self.oneshot: 53 | self.setreg(LPS22_CTRL_REG2, self.getreg(LPS22_CTRL_REG2) | 0x01) 54 | self.getreg(0x28 + b*2) 55 | while 1: 56 | if self.getreg(LPS22_STATUS) & b: 57 | return 58 | 59 | def temperature(self): 60 | self.ONE_SHOT(2) 61 | try: 62 | return self.int16(self.get2reg(LPS22_TEMP_OUT_L))/100 63 | except MemoryError: 64 | return self.temperature_irq() 65 | 66 | def pressure(self): 67 | self.ONE_SHOT(1) 68 | try: 69 | return (self.getreg(LPS22_PRESS_OUT_XL) + self.get2reg(LPS22_PRESS_OUT_L) * 256)/4096 70 | except MemoryError: 71 | return self.pressure_irq() 72 | 73 | def get(self): 74 | try: 75 | return self.temperature(), self.pressure() 76 | except MemoryError: 77 | return self.get_irq() 78 | 79 | def altitude(self): 80 | return (((1013.25 / self.pressure())**(1/5.257)) - 1.0) * (self.temperature() + 273.15) / 0.0065 81 | 82 | def temperature_irq(self): 83 | self.ONE_SHOT(2) 84 | return self.int16(self.get2reg(LPS22_TEMP_OUT_L))//100 85 | 86 | def pressure_irq(self): 87 | self.ONE_SHOT(1) 88 | return self.get2reg(LPS22_PRESS_OUT_L) >> 4 89 | 90 | def get_irq(self): 91 | self.irq_v[0] = self.temperature_irq() 92 | self.irq_v[1] = self.pressure_irq() 93 | return self.irq_v 94 | -------------------------------------------------------------------------------- /sensor/LIS2MDL/LIS2MDL.py: -------------------------------------------------------------------------------- 1 | # LIS2MDL magnetic seneor micropython drive 2 | # ver: 1.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@micropython.org.cn) 5 | # v1.0 2019.7 6 | 7 | LIS2MDL_CFG_REG_A = const(0x60) 8 | LIS2MDL_CFG_REG_C = const(0x62) 9 | LIS2MDL_STATUS_REG = const(0x67) 10 | LIS2MDL_OUTX_L_REG = const(0x68) 11 | LIS2MDL_OUTY_L_REG = const(0x6A) 12 | LIS2MDL_OUTZ_L_REG = const(0x6C) 13 | 14 | class LIS2MDL(): 15 | def __init__(self, i2c): 16 | self.i2c = i2c 17 | self.addr = 0x1E 18 | self.tb = bytearray(1) 19 | self.rb = bytearray(1) 20 | # TEMP_EN=1 LP=0 ODR=0 MD=0 21 | self.setreg(LIS2MDL_CFG_REG_A, 0x80) 22 | # BDU=1 23 | self.setreg(LIS2MDL_CFG_REG_C, 0x10) 24 | self.oneshot = False 25 | self.irq_v = [0, 0, 0] 26 | 27 | def int16(self, d): 28 | return d if d < 0x8000 else d - 0x10000 29 | 30 | def setreg(self, reg, dat): 31 | self.tb[0] = dat 32 | self.i2c.writeto_mem(self.addr, reg, self.tb) 33 | 34 | def getreg(self, reg): 35 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 36 | return self.rb[0] 37 | 38 | def get2reg(self, reg): 39 | return self.getreg(reg) + self.getreg(reg+1) * 256 40 | 41 | def oneshot_mode(self, oneshot=None): 42 | if oneshot is None: 43 | return self.oneshot 44 | else: 45 | self.get2reg(LIS2MDL_OUTX_L_REG) 46 | self.get2reg(LIS2MDL_OUTY_L_REG) 47 | self.get2reg(LIS2MDL_OUTZ_L_REG) 48 | self.getreg(LIS2MDL_CFG_REG_A) 49 | self.oneshot = oneshot 50 | self.rb[0] &= 0xFC 51 | if oneshot: 52 | self.rb[0] |= 0x01 53 | self.setreg(LIS2MDL_CFG_REG_A, self.rb[0]) 54 | 55 | def ONE_SHOT(self): 56 | if self.oneshot: 57 | self.oneshot_mode(1) 58 | while 1: 59 | if self.getreg(LIS2MDL_STATUS_REG) & 0x08: 60 | return 61 | 62 | def x_raw(self): 63 | self.ONE_SHOT() 64 | return self.int16(self.get2reg(LIS2MDL_OUTX_L_REG)) 65 | 66 | def y_raw(self): 67 | self.ONE_SHOT() 68 | return self.int16(self.get2reg(LIS2MDL_OUTY_L_REG)) 69 | 70 | def z_raw(self): 71 | self.ONE_SHOT() 72 | return self.int16(self.get2reg(LIS2MDL_OUTZ_L_REG)) 73 | 74 | def get_raw(self): 75 | self.ONE_SHOT() 76 | self.irq_v[0] = self.int16(self.get2reg(LIS2MDL_OUTX_L_REG)) 77 | self.irq_v[1] = self.int16(self.get2reg(LIS2MDL_OUTY_L_REG)) 78 | self.irq_v[2] = self.int16(self.get2reg(LIS2MDL_OUTZ_L_REG)) 79 | return self.irq_v 80 | 81 | // unit uT 82 | def x(self): 83 | return self.x_raw()*3//20 84 | 85 | // unit uT 86 | def y(self): 87 | return self.y_raw()*3//20 88 | 89 | // unit uT 90 | def z(self): 91 | return self.z_raw()*3//20 92 | 93 | // uint uT 94 | def get(self): 95 | self.ONE_SHOT() 96 | self.irq_v[0] = self.int16(self.get2reg(LIS2MDL_OUTX_L_REG))*3//20 97 | self.irq_v[1] = self.int16(self.get2reg(LIS2MDL_OUTY_L_REG))*3//20 98 | self.irq_v[2] = self.int16(self.get2reg(LIS2MDL_OUTZ_L_REG))*3//20 99 | return self.irq_v 100 | -------------------------------------------------------------------------------- /sensor/bmp180/BMP180.py: -------------------------------------------------------------------------------- 1 | """ 2 | mpy drive for BMP180 Digital Pressure Sensor 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | """ 10 | import utime 11 | from machine import I2C 12 | from micropython import const 13 | 14 | BMP180_I2C_ADDR = const(0x77) 15 | 16 | class BMP180(): 17 | def __init__(self, i2c): 18 | self.i2c = i2c 19 | self.tb = bytearray(1) 20 | self.rb = bytearray(1) 21 | self.AC1 = self.short(self.get2Reg(0xAA)) 22 | self.AC2 = self.short(self.get2Reg(0xAC)) 23 | self.AC3 = self.short(self.get2Reg(0xAE)) 24 | self.AC4 = self.get2Reg(0xB0) 25 | self.AC5 = self.get2Reg(0xB2) 26 | self.AC6 = self.get2Reg(0xB4) 27 | self.B1 = self.short(self.get2Reg(0xB6)) 28 | self.B2 = self.short(self.get2Reg(0xB8)) 29 | self.MB = self.short(self.get2Reg(0xBA)) 30 | self.MC = self.short(self.get2Reg(0xBC)) 31 | self.MD = self.short(self.get2Reg(0xBE)) 32 | self.UT = 0 33 | self.UP = 0 34 | self.T = 0 35 | self.P = 0 36 | self.version = '2.0' 37 | 38 | def short(self, dat): 39 | if dat > 32767: 40 | return dat - 65536 41 | else: 42 | return dat 43 | 44 | # set reg 45 | def setReg(self, reg, dat): 46 | self.tb[0] = dat 47 | self.i2c.writeto_mem(BMP180_I2C_ADDR, reg, self.tb) 48 | 49 | # get reg 50 | def getReg(self, reg): 51 | self.i2c.readfrom_mem_into(BMP180_I2C_ADDR, reg, self.rb) 52 | return self.rb[0] 53 | 54 | # get two reg 55 | def get2Reg(self, reg): 56 | return self.getReg(reg+1) + self.getReg(reg) * 256 57 | 58 | # start measure 59 | def measure(self): 60 | self.setReg(0xF4, 0x2E) 61 | utime.sleep_ms(5) 62 | self.UT = self.get2Reg(0xF6) 63 | self.setReg(0xF4, 0x34) 64 | utime.sleep_ms(5) 65 | self.UP = self.get2Reg(0xF6) 66 | 67 | # get Temperature and Pressure 68 | def get(self): 69 | self.measure() 70 | X1 = (self.UT - self.AC6) * self.AC5/(1<<15) 71 | X2 = self.MC * (1<<11) / (X1 + self.MD) 72 | B5 = X1 + X2 73 | self.T = (B5 + 8)/160 74 | B6 = B5 - 4000 75 | X1 = (self.B2 * (B6*B6/(1<<12))) / (1<<11) 76 | X2 = (self.AC2 * B6)/(1<<11) 77 | X3 = X1 + X2 78 | B3 = ((self.AC1*4+X3) + 2)/4 79 | X1 = self.AC3 * B6 / (1<<13) 80 | X2 = (self.B1 * (B6*B6/(1<<12))) / (1<<16) 81 | X3 = (X1 + X2 + 2)/4 82 | B4 = self.AC4 * (X3 + 32768)/(1<<15) 83 | B7 = (self.UP-B3) * 50000 84 | if B7 < 0x80000000: 85 | p = (B7*2)/B4 86 | else: 87 | p = (B7/B4) * 2 88 | X1 = (p/(1<<8))*(p/(1<<8)) 89 | X1 = (X1 * 3038)/(1<<16) 90 | X2 = (-7357*p)/(1<<16) 91 | self.P = p + (X1 + X2 + 3791)/16 92 | return [self.T, self.P] 93 | 94 | # get Temperature in Celsius 95 | def getTemp(self): 96 | self.get() 97 | return self.T 98 | 99 | # get Pressure in Pa 100 | def getPress(self): 101 | self.get() 102 | return self.P 103 | 104 | # Calculating absolute altitude 105 | def getAltitude(self): 106 | return 44330*(1-(self.getPress()/101325)**(1/5.255)) 107 | 108 | -------------------------------------------------------------------------------- /lcd/I2C_LCD1602/i2c_lcd1602.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for I2C LCD1602 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | https://www.micropython.org.cn 8 | 9 | ''' 10 | from time import sleep_ms 11 | 12 | LCD_I2C_ADDR=const(63) 13 | 14 | class I2C_LCD1602(): 15 | def __init__(self, i2c, addr = 0): 16 | self.i2c=i2c 17 | self.buf = bytearray(1) 18 | self.BK, self.RS, self.E = 0x08, 0x00, 0x04 19 | self.ADDR = addr if addr else self.autoaddr() 20 | self.setcmd(0x33) 21 | sleep_ms(5) 22 | self.send(0x30) 23 | sleep_ms(5) 24 | self.send(0x20) 25 | sleep_ms(5) 26 | for i in [0x28, 0x0C, 0x06, 0x01]: 27 | self.setcmd(i) 28 | self.px, self.py = 0, 0 29 | self.pb = bytearray(16) 30 | self.version='2.1' 31 | 32 | def setReg(self, dat): 33 | self.buf[0] = dat 34 | self.i2c.writeto(self.ADDR, self.buf) 35 | sleep_ms(1) 36 | 37 | def send(self, dat): 38 | d=(dat&0xF0)|self.BK|self.RS 39 | self.setReg(d) 40 | self.setReg(d|0x04) 41 | self.setReg(d) 42 | 43 | def setcmd(self, cmd): 44 | self.RS=0 45 | self.send(cmd) 46 | self.send(cmd<<4) 47 | 48 | def setdat(self, dat): 49 | self.RS=1 50 | self.send(dat) 51 | self.send(dat<<4) 52 | 53 | def autoaddr(self): 54 | for i in range(32, 63): 55 | try: 56 | if self.i2c.readfrom(i, 1): 57 | return i 58 | except: 59 | pass 60 | raise Exception('I2C address detect error!') 61 | 62 | def write_cgram(self, buf, reg=0): 63 | n = len(buf) 64 | self.setcmd(0x40 + (reg%8)*8) 65 | for i in range(n): 66 | self.setdat(buf[i]) 67 | 68 | def clear(self): 69 | self.setcmd(1) 70 | 71 | def backlight(self, on): 72 | if on: 73 | self.BK=0x08 74 | else: 75 | self.BK=0 76 | self.setcmd(0) 77 | 78 | def on(self): 79 | self.setcmd(0x0C) 80 | 81 | def off(self): 82 | self.setcmd(0x08) 83 | 84 | def shl(self): 85 | self.setcmd(0x18) 86 | 87 | def shr(self): 88 | self.setcmd(0x1C) 89 | 90 | def char(self, ch, x=-1, y=0): 91 | if x>=0: 92 | a=0x80 93 | if y>0: 94 | a=0xC0 95 | self.setcmd(a+x) 96 | self.setdat(ch) 97 | 98 | def puts(self, s, x=0, y=0): 99 | if type(s) is not str: 100 | s = str(s) 101 | if len(s)>0: 102 | self.char(ord(s[0]),x,y) 103 | for i in range(1, len(s)): 104 | self.char(ord(s[i])) 105 | 106 | def newline(self): 107 | self.px = 0 108 | if self.py < 1: 109 | self.py += 1 110 | else: 111 | for i in range(16): 112 | self.char(self.pb[i], i) 113 | self.char(32, i, 1) 114 | self.pb[i] = 32 115 | 116 | def print(self, s): 117 | if type(s) is not str: 118 | s = str(s) 119 | for i in range(len(s)): 120 | d = ord(s[i]) 121 | if d == ord('\n'): 122 | self.newline() 123 | else: 124 | self.char(d, self.px, self.py) 125 | if self.py: 126 | self.pb[self.px] = d 127 | self.px += 1 128 | if self.px > 15: 129 | self.newline() 130 | -------------------------------------------------------------------------------- /sensor/bmp280/bmp280.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for BMP280 Digital Pressure Sensor 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import I2C 11 | 12 | class BMP280(): 13 | def __init__(self, i2c, addr = 0x76, SDO = None): 14 | self.i2c = i2c 15 | if SDO == None: 16 | self.addr = addr 17 | elif SDO: 18 | self.addr = 0x77 19 | else: 20 | self.addr = 0x76 21 | self.tb = bytearray(1) 22 | self.rb = bytearray(1) 23 | self.dig_T1 = self.get2Reg(0x88) 24 | self.dig_T2 = self.short(self.get2Reg(0x8A)) 25 | self.dig_T3 = self.short(self.get2Reg(0x8C)) 26 | self.dig_P1 = self.get2Reg(0x8E) 27 | self.dig_P2 = self.short(self.get2Reg(0x90)) 28 | self.dig_P3 = self.short(self.get2Reg(0x92)) 29 | self.dig_P4 = self.short(self.get2Reg(0x94)) 30 | self.dig_P5 = self.short(self.get2Reg(0x96)) 31 | self.dig_P6 = self.short(self.get2Reg(0x98)) 32 | self.dig_P7 = self.short(self.get2Reg(0x9A)) 33 | self.dig_P8 = self.short(self.get2Reg(0x9C)) 34 | self.dig_P9 = self.short(self.get2Reg(0x9E)) 35 | self.mode = 3 36 | self.osrs_p = 3 37 | self.osrs_t = 1 38 | self.setReg(0xF4, 0x2F) 39 | self.setReg(0xF5, 0x0C) 40 | self.filter = 3 41 | self.T = 0 42 | self.P = 0 43 | self.version = '1.0' 44 | 45 | def short(self, dat): 46 | if dat > 32767: 47 | return dat - 65536 48 | else: 49 | return dat 50 | 51 | # set reg 52 | def setReg(self, reg, dat): 53 | self.tb[0] = dat 54 | self.i2c.writeto_mem(self.addr, reg, self.tb) 55 | 56 | # get reg 57 | def getReg(self, reg): 58 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 59 | return self.rb[0] 60 | 61 | # get two reg 62 | def get2Reg(self, reg): 63 | return self.getReg(reg) + self.getReg(reg+1) * 256 64 | 65 | def get(self): 66 | adc_T = (self.getReg(0xFA)<<12) + (self.getReg(0xFB)<<4) + (self.getReg(0xFC)>>4) 67 | var1 = (((adc_T>>3)-(self.dig_T1<<1))*self.dig_T2)>>11 68 | var2 = (((((adc_T>>4)-self.dig_T1)*((adc_T>>4) - self.dig_T1))>>12)*self.dig_T3)>>14 69 | t = var1+var2 70 | self.T = ((t * 5 + 128) >> 8)/100 71 | var1 = (t>>1) - 64000 72 | var2 = (((var1>>2) * (var1>>2)) >> 11 ) * self.dig_P6 73 | var2 = var2 + ((var1*self.dig_P5)<<1) 74 | var2 = (var2>>2)+(self.dig_P4<<16) 75 | var1 = (((self.dig_P3*((var1>>2)*(var1>>2))>>13)>>3) + (((self.dig_P2) * var1)>>1))>>18 76 | var1 = ((32768+var1)*self.dig_P1)>>15 77 | if var1 == 0: 78 | return # avoid exception caused by division by zero 79 | adc_P = (self.getReg(0xF7)<<12) + (self.getReg(0xF8)<<4) + (self.getReg(0xF9)>>4) 80 | p=((1048576-adc_P)-(var2>>12))*3125 81 | if p < 0x80000000: 82 | p = (p << 1) // var1 83 | else: 84 | p = (p // var1) * 2 85 | var1 = (self.dig_P9 * (((p>>3)*(p>>3))>>13))>>12 86 | var2 = (((p>>2)) * self.dig_P8)>>13 87 | self.P = p + ((var1 + var2 + self.dig_P7) >> 4) 88 | return [self.T, self.P] 89 | 90 | # get Temperature in Celsius 91 | def getTemp(self): 92 | self.get() 93 | return self.T 94 | 95 | # get Pressure in Pa 96 | def getPress(self): 97 | self.get() 98 | return self.P 99 | 100 | # Calculating absolute altitude 101 | def getAltitude(self): 102 | return 44330*(1-(self.getPress()/101325)**(1/5.255)) 103 | 104 | # sleep mode 105 | def poweroff(self): 106 | self.setReg(0xF4, 0) 107 | 108 | # normal mode 109 | def poweron(self): 110 | self.setReg(0xF4, 0x2F) -------------------------------------------------------------------------------- /sensor/HTS221/hts221.py: -------------------------------------------------------------------------------- 1 | # HTS221 Humidity and temperature micropython drive 2 | # ver: 2.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@micropython.org.cn) 5 | # v1.0 2016.4 6 | # v2.0 2019.7 7 | 8 | from machine import I2C 9 | 10 | class HTS221(object): 11 | def __init__(self, i2c): 12 | self.i2c = i2c 13 | self.addr = 0x5F 14 | # data buffer 15 | self.tb = bytearray(1) 16 | self.rb = bytearray(1) 17 | self.oneshot = False 18 | self.irq_v = [0, 0] 19 | # HTS221 Temp Calibration registers 20 | self.T0_OUT = self.int16(self.get2reg(0x3C)) 21 | self.T1_OUT = self.int16(self.get2reg(0x3E)) 22 | t = self.getreg(0x35) % 16 23 | self.T0_degC = self.getreg(0x32) + (t%4) * 256 24 | self.T1_degC = self.getreg(0x33) + (t//4) * 256 25 | # HTS221 Humi Calibration registers 26 | self.H0_OUT = self.int16(self.get2reg(0x36)) 27 | self.H1_OUT = self.int16(self.get2reg(0x3A)) 28 | self.H0_rH = self.getreg(0x30) * 5 29 | self.H1_rH = self.getreg(0x31) * 5 30 | self.K1 = (self.T1_degC - self.T0_degC) / (self.T1_OUT - self.T0_OUT) 31 | self.K2 = (self.H1_rH - self.H0_rH) / (self.H1_OUT - self.H0_OUT) 32 | # set av conf: T=4 H=8 33 | self.setreg(0x10, 0x26) 34 | # set CTRL_REG1: PD=1 BDU=1 ODR=1 35 | self.setreg(0x20, 0x85) 36 | self.oneshot_mode(0) 37 | 38 | def oneshot_mode(self, oneshot = None): 39 | if oneshot is None: 40 | return self.oneshot 41 | else: 42 | self.getreg(0x20) 43 | self.oneshot = oneshot 44 | if oneshot: self.rb[0] &= 0xFC 45 | else: self.rb[0] |= 0x01 46 | self.setreg(0x20, self.rb[0]) 47 | 48 | def ONE_SHOT(self, b): 49 | if self.oneshot: 50 | self.setreg(0x21, self.getreg(0x21) | 0x01) 51 | self.getreg(0x2d - b*2) 52 | while 1: 53 | if self.getreg(0x27) & b: 54 | return 55 | 56 | def int16(self, d): 57 | return d if d < 0x8000 else d - 0x10000 58 | 59 | def setreg(self, reg, dat): 60 | self.tb[0] = dat 61 | self.i2c.writeto_mem(self.addr, reg, self.tb) 62 | 63 | def getreg(self, reg): 64 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 65 | return self.rb[0] 66 | 67 | def get2reg(self, reg): 68 | return self.getreg(reg) + self.getreg(reg+1) * 256 69 | 70 | # calculate Temperature 71 | def temperature(self): 72 | try: 73 | self.ONE_SHOT(1) 74 | return round((self.T0_degC + (self.int16(self.get2reg(0x2A)) - self.T0_OUT) * self.K1)/8, 1) 75 | except MemoryError: 76 | return self.temperature_irq() 77 | 78 | # calculate Humidity 79 | def humidity(self): 80 | try: 81 | self.ONE_SHOT(2) 82 | return round((self.H0_rH + (self.int16(self.get2reg(0x28)) - self.H0_OUT) * self.K2)/10, 1) 83 | except MemoryError: 84 | return self.humidity_irq() 85 | 86 | def get(self): 87 | try: 88 | return self.temperature(), self.humidity() 89 | except MemoryError: 90 | return self.get_irq() 91 | 92 | def temperature_irq(self): 93 | self.ONE_SHOT(1) 94 | return (self.T0_degC + (self.int16(self.get2reg(0x2A)) - self.T0_OUT) * (self.T1_degC - self.T0_degC) // (self.T1_OUT - self.T0_OUT)) >> 3 95 | 96 | def humidity_irq(self): 97 | self.ONE_SHOT(2) 98 | return (self.H0_rH + (self.int16(self.get2reg(0x28)) - self.H0_OUT) * (self.H1_rH - self.H0_rH) // (self.H1_OUT - self.H0_OUT))//10 99 | 100 | def get_irq(self): 101 | self.irq_v[0] = self.temperature_irq() 102 | self.irq_v[1] = self.humidity_irq() 103 | return tuple(self.irq_v) 104 | 105 | def power(self, on=None): 106 | self.getreg(0x20) 107 | if on is None: return self.rb[0] & 0x80 > 0 108 | elif on: self.rb[0] |= 0x80 109 | else: self.rb[0] &= 0x7F 110 | self.setreg(0x20, self.rb[0]) 111 | -------------------------------------------------------------------------------- /misc/pcf8563/pcf8563.py: -------------------------------------------------------------------------------- 1 | ''' 2 | PCF8563 RTC drive 3 | 4 | Author: shaoziyang 5 | Date: 2021.1 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from micropython import const 10 | 11 | PCF8563_I2C_ADDRESS = const(81) 12 | PCF8563_REG_CTRL1 = const(0) 13 | PCF8563_REG_CTRL2 = const(1) 14 | PCF8563_REG_SECOND = const(2) 15 | PCF8563_REG_MINUTE = const(3) 16 | PCF8563_REG_HOUR = const(4) 17 | PCF8563_REG_WEEKDAY = const(6) 18 | PCF8563_REG_DAY = const(5) 19 | PCF8563_REG_MONTH = const(7) 20 | PCF8563_REG_YEAR = const(8) 21 | 22 | class PCF8563(): 23 | def __init__(self, i2c): 24 | self.i2c = i2c 25 | self.tb = bytearray(1) 26 | self.rb = bytearray(1) 27 | self.buf = bytearray(7) 28 | self.DT = [0] * 8 29 | 30 | # set reg 31 | def setReg(self, reg, dat): 32 | self.tb[0] = dat 33 | self.i2c.writeto_mem(PCF8563_I2C_ADDRESS, reg, self.tb) 34 | 35 | # get reg 36 | def getReg(self, reg): 37 | self.i2c.readfrom_mem_into(PCF8563_I2C_ADDRESS, reg, self.rb) 38 | return self.rb[0] 39 | 40 | def DecToHex(self, dat): 41 | return (dat//10) * 16 + (dat%10) 42 | 43 | def HexToDec(self, dat): 44 | return (dat//16) * 10 + (dat%16) 45 | 46 | def year(self, year = None): 47 | if year == None: 48 | return self.HexToDec(self.getReg(PCF8563_REG_YEAR)) + 2000 49 | else: 50 | self.setReg(PCF8563_REG_YEAR, self.DecToHex(year%100)) 51 | 52 | def month(self, month = None): 53 | if month == None: 54 | return self.HexToDec(self.getReg(PCF8563_REG_MONTH)%32) 55 | else: 56 | self.setReg(PCF8563_REG_MONTH, self.DecToHex(month%13)) 57 | 58 | def day(self, day = None): 59 | if day == None: 60 | return self.HexToDec(self.getReg(PCF8563_REG_DAY)%64) 61 | else: 62 | self.setReg(PCF8563_REG_DAY, self.DecToHex(day%32)) 63 | 64 | def weekday(self, weekday = None): 65 | if weekday == None: 66 | return self.HexToDec(self.getReg(PCF8563_REG_WEEKDAY)%8) 67 | else: 68 | self.setReg(PCF8563_REG_WEEKDAY, self.DecToHex(weekday%8)) 69 | 70 | def hour(self, hour = None): 71 | if hour == None: 72 | return self.HexToDec(self.getReg(PCF8563_REG_HOUR)%64) 73 | else: 74 | self.setReg(PCF8563_REG_HOUR, self.DecToHex(hour%24)) 75 | 76 | def minute(self, minute = None): 77 | if minute == None: 78 | return self.HexToDec(self.getReg(PCF8563_REG_MINUTE)%128) 79 | else: 80 | self.setReg(PCF8563_REG_MINUTE, self.DecToHex(minute%60)) 81 | 82 | def second(self, second = None): 83 | if second == None: 84 | return self.HexToDec(self.getReg(PCF8563_REG_SECOND)%128) 85 | else: 86 | self.setReg(PCF8563_REG_SECOND, self.DecToHex(second%60)) 87 | 88 | def datetime(self, DT=None): 89 | if DT == None: 90 | self.i2c.readfrom_mem_into(PCF8563_I2C_ADDRESS, PCF8563_REG_SECOND, self.buf) 91 | self.DT[0] = self.HexToDec(self.buf[6]) + 2000 92 | self.DT[1] = self.HexToDec(self.buf[5]%32) 93 | self.DT[2] = self.HexToDec(self.buf[3]%64) 94 | self.DT[3] = self.HexToDec(self.buf[4]%8) 95 | self.DT[4] = self.HexToDec(self.buf[2]%64) 96 | self.DT[5] = self.HexToDec(self.buf[1]%128) 97 | self.DT[6] = self.HexToDec(self.buf[0]%128) 98 | self.DT[7] = 0 99 | return self.DT 100 | else: 101 | self.buf[0] = self.DecToHex(DT[6]%60) # second 102 | self.buf[1] = self.DecToHex(DT[5]%60) # minute 103 | self.buf[2] = self.DecToHex(DT[4]%24) # hour 104 | self.buf[3] = self.DecToHex(DT[2]%32) # date 105 | self.buf[4] = self.DecToHex(DT[3]%8) # week day 106 | self.buf[5] = self.DecToHex(DT[1]%13) # month 107 | self.buf[6] = self.DecToHex(DT[0]%100) # year 108 | self.i2c.writeto_mem(PCF8563_I2C_ADDRESS, PCF8563_REG_SECOND, self.buf) 109 | -------------------------------------------------------------------------------- /misc/DS1302/DS1302.py: -------------------------------------------------------------------------------- 1 | ''' 2 | DS1302 RTC drive 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import Pin 10 | 11 | DS1302_REG_SECOND = (0x80) 12 | DS1302_REG_MINUTE = (0x82) 13 | DS1302_REG_HOUR = (0x84) 14 | DS1302_REG_DAY = (0x86) 15 | DS1302_REG_MONTH = (0x88) 16 | DS1302_REG_WEEKDAY= (0x8A) 17 | DS1302_REG_YEAR = (0x8C) 18 | DS1302_REG_WP = (0x8E) 19 | DS1302_REG_CTRL = (0x90) 20 | DS1302_REG_RAM = (0xC0) 21 | 22 | class DS1302: 23 | def __init__(self, clk, dio, cs): 24 | self.clk = clk 25 | self.clk.init(mode=Pin.OUT, value=0) 26 | self.dio = dio 27 | self.cs = cs 28 | self.cs.init(mode=Pin.OUT, value=0) 29 | 30 | def DecToHex(self, dat): 31 | return (dat//10) * 16 + (dat%10) 32 | 33 | def HexToDec(self, dat): 34 | return (dat//16) * 10 + (dat%16) 35 | 36 | def write_byte(self, dat): 37 | self.dio.init(mode=Pin.OUT, value=0) 38 | for i in range(8): 39 | self.dio((dat >> i) & 1) 40 | self.clk(1) 41 | self.clk(0) 42 | 43 | def read_byte(self): 44 | self.dio.init(mode=Pin.IN) 45 | d = 0 46 | for i in range(8): 47 | d = d | (self.dio()<>2] 107 | else: 108 | t &= 0xF3 109 | t |= APDS9930_PGAIN.index(gain)<<2 110 | self.setReg(APDS9930_CONTROL, t) 111 | 112 | def Power(self, on=True): 113 | t = self.getReg(APDS9930_ENABLE) 114 | t &= 0xFE 115 | if on: 116 | t |= 1 117 | self.setReg(APDS9930_ENABLE, t) 118 | time.sleep_ms(3) 119 | 120 | def ALS_Enable(self, on=True): 121 | t = self.getReg(APDS9930_ENABLE) 122 | t &= 0xFD 123 | if on: 124 | t |= 2 125 | self.setReg(APDS9930_ENABLE, t) 126 | 127 | def Proximity_Enable(self, on=True): 128 | t = self.getReg(APDS9930_ENABLE) 129 | t &= 0xFB 130 | if on: 131 | t |= 4 132 | self.setReg(APDS9930_ENABLE, t) 133 | 134 | def Wait_Enable(self, on=True): 135 | t = self.getReg(APDS9930_ENABLE) 136 | t &= 0xF7 137 | if on: 138 | t |= 8 139 | self.setReg(APDS9930_ENABLE, t) 140 | 141 | def getALS(self): 142 | Ch0 = self.getCH0() 143 | Ch1 = self.getCH1() 144 | ALSIT = 2.72 * (256 - self.ATIME()) 145 | IAC = max(Ch0 - B * Ch1, C * Ch0 - D * Ch1, 0) 146 | LPC = GA * DF / (ALSIT * self.AGAIN()) 147 | return IAC * LPC 148 | 149 | def getProximity(self): 150 | return self.get2Reg(APDS9930_PDATAL)/self.PGAIN() 151 | -------------------------------------------------------------------------------- /keyboard/mechanical-button/single-button/keyboard.py: -------------------------------------------------------------------------------- 1 | # -*- coding:UTF-8 -*- 2 | 3 | ''' 4 | MIT License 5 | Copyright (c) 2018 Robin Chen 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 20 | SOFTWARE. 21 | ''' 22 | 23 | ''' 24 | ****************************************************************************** 25 | * 文 件：keyboard.py 26 | * 概 述：识别单个机械按键的单击、连击（暂未限制连击次数）、长按、短按动作，并返回事件。 27 | * 版 本：V0.10 28 | * 作 者：Robin Chen 29 | * 日 期：2018年7月26日 30 | * 历 史： 日期 编辑 版本 记录 31 | 2018年7月26日 Robin Chen V0.10 创建文件 32 | ` 33 | ******************************************************************************''' 34 | class KEYBOARD: 35 | cont = 0 36 | def __init__(self, _btnKey, _tmBtn, _btnDef = 1, even_djlong = None, even_lj = None, _pull = None): 37 | self.btn = _btnKey 38 | if _pull == "UP": 39 | self.btn.init(_btnKey.IN, _btnKey.PULL_UP) 40 | elif _pull == "DOWN": 41 | self.btn.init(_btnKey.IN, _btnKey.PULL_DOWN) 42 | else: 43 | self.btn.init(_btnKey.IN) 44 | self.btnDef = _btnDef 45 | self.eve_btnLon = even_djlong 46 | self.evn_Continuous_Clicks = even_lj 47 | self.btnLabDown = 0 # 按钮扫描记次,按下状态 48 | self.btnLabUp = 0 # 按钮扫描记次,弹起状态 49 | self.Continuous_Clicks = 0 # 连续点击次数 50 | self.clock = 10 # 定时器时钟，单位毫秒 51 | _tmBtn.init(freq = (1000 / self.clock)) 52 | _tmBtn.callback(self.doBtnScan) 53 | self.staLon = 1 # 长按标志字，1：长按计时，0:长按计次 54 | self.tLon = 3000 # 计时或计次延时，单位毫秒 55 | self.TIME_CONT_CLICKS = 50 # 连击时间间隔，按下和松开的状态保持时间长度，单位，次 56 | 57 | '''************************************************************************* 58 | * 功 能：按键扫描 59 | * 说 明：定时器回调函数，用于识别当前按键是否动作，并判断其动作形式。 60 | * 输入参数： 61 | t : 定时器无参回调函数必备，否则调用不成功。 62 | * 输出参数：None 63 | * 返 回 值：True 64 | **************************************************************************''' 65 | # 扫描按键，定时中断调用函数 66 | def doBtnScan(self, t): 67 | global cont 68 | self.btnLabUp = (self.btnLabUp * int(not(self.btn.value() ^ int(not(self.btnDef))))) + int(not(self.btn.value() ^ int(not(self.btnDef)))) 69 | btdown = self.btnLabDown 70 | self.btnLabDown = (self.btnLabDown * int(not(self.btn.value() ^ self.btnDef))) + int(not(self.btn.value() ^ self.btnDef)) 71 | 72 | # 长按计时/计次 73 | # t1:按键保持按下的时长 74 | if (self.btnLabDown * self.clock) == self.tLon: 75 | if self.staLon == 1: 76 | if self.eve_btnLon != None: 77 | self.eve_btnLon() # 按键长按事件，请勿在事件中执行过长时间的程序，否则会报定时器错误。 78 | elif self.staLon == 0: 79 | if self.eve_btnLon != None: 80 | cont += 1 81 | self.eve_btnLon(cont) # 按键长按事件，请勿在事件中执行过长时间的程序，否则会报定时器错误。 82 | self.btnLabDown = 0 83 | if self.btnLabUp > 5: 84 | cont = 0 85 | 86 | # 连续点击 87 | if (btdown > 5 and btdown < self.TIME_CONT_CLICKS) and self.btnLabUp > 0: 88 | self.Continuous_Clicks += 1 89 | 90 | if (self.btnLabUp > self.TIME_CONT_CLICKS) and (self.Continuous_Clicks > 0) or (self.btnLabDown > self.TIME_CONT_CLICKS) and (self.Continuous_Clicks > 0): 91 | if self.evn_Continuous_Clicks != None: 92 | self.evn_Continuous_Clicks(self.Continuous_Clicks) # 连续点击事件，次数为1时为单击，请勿在事件中执行过长时间的程序，否则会报定时器错误。 93 | self.Continuous_Clicks = 0 94 | -------------------------------------------------------------------------------- /sensor/LIS2DW12/LIS2DW12.py: -------------------------------------------------------------------------------- 1 | # LIS2DW12 3-axis motion seneor micropython drive 2 | # ver: 1.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@micropython.org.cn) 5 | # v1.0 2019.7 6 | 7 | LIS2DW12_CTRL1 = const(0x20) 8 | LIS2DW12_CTRL2 = const(0x21) 9 | LIS2DW12_CTRL3 = const(0x22) 10 | LIS2DW12_CTRL6 = const(0x25) 11 | LIS2DW12_STATUS = const(0x27) 12 | LIS2DW12_OUT_T_L = const(0x0D) 13 | LIS2DW12_OUT_X_L = const(0x28) 14 | LIS2DW12_OUT_Y_L = const(0x2A) 15 | LIS2DW12_OUT_Z_L = const(0x2C) 16 | 17 | LIS2DW12_SCALE = ('2g', '4g', '8g', '16g') 18 | 19 | class LIS2DW12(): 20 | def __init__(self, i2c, addr = 0x19): 21 | self.i2c = i2c 22 | self.addr = addr 23 | self.tb = bytearray(1) 24 | self.rb = bytearray(1) 25 | self.oneshot = False 26 | self.irq_v = [0, 0, 0] 27 | self._power = 0x20 28 | # ODR=5 MODE=0 LP=1 29 | self.setreg(LIS2DW12_CTRL1, 0x51) 30 | # BDU=1 31 | self.setreg(LIS2DW12_CTRL2, 0x0C) 32 | # SLP_MODE_SEL=1 33 | self.setreg(LIS2DW12_CTRL3, 0x02) 34 | # scale=2G 35 | self._scale = 0 36 | self.scale(self._scale) 37 | self.oneshot_mode(False) 38 | 39 | def int16(self, d): 40 | return d if d < 0x8000 else d - 0x10000 41 | 42 | def setreg(self, reg, dat): 43 | self.tb[0] = dat 44 | self.i2c.writeto_mem(self.addr, reg, self.tb) 45 | 46 | def getreg(self, reg): 47 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 48 | return self.rb[0] 49 | 50 | def get2reg(self, reg): 51 | return self.getreg(reg) + self.getreg(reg+1) * 256 52 | 53 | def r_w_reg(self, reg, dat, mask): 54 | self.getreg(reg) 55 | self.rb[0] = (self.rb[0] & mask) | dat 56 | self.setreg(reg, self.rb[0]) 57 | 58 | def oneshot_mode(self, oneshot=None): 59 | if oneshot is None: 60 | return self.oneshot 61 | else: 62 | self.oneshot = oneshot 63 | d = 8 if oneshot else 0 64 | self.r_w_reg(LIS2DW12_CTRL1, d, 0xF3) 65 | 66 | def ONE_SHOT(self): 67 | if self.oneshot: 68 | self.r_w_reg(LIS2DW12_CTRL3, 1, 0xFE) 69 | while 1: 70 | if (self.getreg(LIS2DW12_CTRL3) & 0x01) == 0: 71 | return 72 | 73 | def x_raw(self): 74 | self.ONE_SHOT() 75 | return self.int16(self.get2reg(LIS2DW12_OUT_X_L))>>2 76 | 77 | def y_raw(self): 78 | self.ONE_SHOT() 79 | return self.int16(self.get2reg(LIS2DW12_OUT_Y_L))>>2 80 | 81 | def z_raw(self): 82 | self.ONE_SHOT() 83 | return self.int16(self.get2reg(LIS2DW12_OUT_Z_L))>>2 84 | 85 | def get_raw(self): 86 | self.ONE_SHOT() 87 | self.irq_v[0] = self.int16(self.get2reg(LIS2DW12_OUT_X_L))>>2 88 | self.irq_v[1] = self.int16(self.get2reg(LIS2DW12_OUT_Y_L))>>2 89 | self.irq_v[2] = self.int16(self.get2reg(LIS2DW12_OUT_Z_L))>>2 90 | return self.irq_v 91 | 92 | def mg(self, reg): 93 | return round(self.int16(self.get2reg(reg)) * 0.061 * (1 << self._scale)) 94 | 95 | def x(self): 96 | self.ONE_SHOT() 97 | return self.mg(LIS2DW12_OUT_X_L) 98 | 99 | def y(self): 100 | self.ONE_SHOT() 101 | return self.mg(LIS2DW12_OUT_Y_L) 102 | 103 | def z(self): 104 | self.ONE_SHOT() 105 | return self.mg(LIS2DW12_OUT_Z_L) 106 | 107 | def get(self): 108 | self.ONE_SHOT() 109 | self.irq_v[0] = self.mg(LIS2DW12_OUT_X_L) 110 | self.irq_v[1] = self.mg(LIS2DW12_OUT_Y_L) 111 | self.irq_v[2] = self.mg(LIS2DW12_OUT_Z_L) 112 | return self.irq_v 113 | 114 | def temperature(self): 115 | try: 116 | return self.int16(self.get2reg(LIS2DW12_OUT_T_L))/256 + 25 117 | except MemoryError: 118 | return self.temperature_irq() 119 | 120 | def temperature_irq(self): 121 | self.getreg(LIS2DW12_OUT_T_L+1) 122 | if self.rb[0] & 0x80: self.rb[0] -= 256 123 | return self.rb[0] + 25 124 | 125 | def scale(self, dat=None): 126 | if dat is None: 127 | return LIS2DW12_SCALE[self._scale] 128 | else: 129 | if type(dat) is str: 130 | if not dat in LIS2DW12_SCALE: return 131 | self._scale = LIS2DW12_SCALE.index(dat) 132 | else: return 133 | self.r_w_reg(LIS2DW12_CTRL6, self._scale<<4, 0xCF) 134 | 135 | def power(self, on=None): 136 | if on is None: 137 | return self._power > 0 138 | else: 139 | if on: 140 | self.r_w_reg(LIS2DW12_CTRL1, self._power, 0x0F) 141 | self._power = 0 142 | else: 143 | self._power = self.getreg(LIS2DW12_CTRL1) & 0xF0 144 | self.r_w_reg(LIS2DW12_CTRL1, 0, 0x0F) 145 | -------------------------------------------------------------------------------- /sensor/bme280/bme280.py: -------------------------------------------------------------------------------- 1 | """ 2 | mpy drive for BME280 humidity and pressure sensor 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | """ 10 | from machine import I2C 11 | 12 | BME280_I2C_ADDR = const(0x76) 13 | 14 | class BME280(): 15 | def __init__(self, i2c, addr = BME280_I2C_ADDR): 16 | self.i2c = i2c 17 | self.addr = addr 18 | self.tb = bytearray(1) 19 | self.rb = bytearray(1) 20 | self.dig_T1 = self.get2Reg(0x88) 21 | self.dig_T2 = self.short(self.get2Reg(0x8A)) 22 | self.dig_T3 = self.short(self.get2Reg(0x8C)) 23 | self.dig_P1 = self.get2Reg(0x8E) 24 | self.dig_P2 = self.short(self.get2Reg(0x90)) 25 | self.dig_P3 = self.short(self.get2Reg(0x92)) 26 | self.dig_P4 = self.short(self.get2Reg(0x94)) 27 | self.dig_P5 = self.short(self.get2Reg(0x96)) 28 | self.dig_P6 = self.short(self.get2Reg(0x98)) 29 | self.dig_P7 = self.short(self.get2Reg(0x9A)) 30 | self.dig_P8 = self.short(self.get2Reg(0x9C)) 31 | self.dig_P9 = self.short(self.get2Reg(0x9E)) 32 | self.dig_H1 = self.getReg(0xA1) 33 | self.dig_H2 = self.short(self.get2Reg(0xE1)) 34 | self.dig_H3 = self.getReg(0xE3) 35 | a = self.getReg(0xE5) 36 | self.dig_H4 = (self.getReg(0xE4)<<4)+(a%16) 37 | self.dig_H5 = (self.getReg(0xE6)<<4)+(a>>4) 38 | self.dig_H6 = self.getReg(0xE7) 39 | if self.dig_H6>127: 40 | self.dig_H6 -= 256 41 | self.mode = 3 42 | self.osrs_p = 3 43 | self.osrs_t = 1 44 | self.osrs_h = 4 45 | self.filter = 3 46 | self.setReg(0xF2, 0x04) 47 | self.setReg(0xF4, 0x2F) 48 | self.setReg(0xF5, 0x0C) 49 | self.T = 0 50 | self.P = 0 51 | self.H = 0 52 | self.version = '1.0' 53 | 54 | def short(self, dat): 55 | if dat > 32767: 56 | return dat - 65536 57 | else: 58 | return dat 59 | 60 | # set reg 61 | def setReg(self, reg, dat): 62 | self.tb[0] = dat 63 | self.i2c.writeto_mem(self.addr, reg, self.tb) 64 | 65 | # get reg 66 | def getReg(self, reg): 67 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 68 | return self.rb[0] 69 | 70 | # get two reg 71 | def get2Reg(self, reg): 72 | return self.getReg(reg) + self.getReg(reg+1) * 256 73 | 74 | def get(self): 75 | adc_T = (self.getReg(0xFA)<<12) + (self.getReg(0xFB)<<4) + (self.getReg(0xFC)>>4) 76 | var1 = (((adc_T>>3)-(self.dig_T1<<1))*self.dig_T2)>>11 77 | var2 = (((((adc_T>>4)-self.dig_T1)*((adc_T>>4) - self.dig_T1))>>12)*self.dig_T3)>>14 78 | t = var1+var2 79 | self.T = ((t * 5 + 128) >> 8)/100 80 | var1 = (t>>1) - 64000 81 | var2 = (((var1>>2) * (var1>>2)) >> 11 ) * self.dig_P6 82 | var2 = var2 + ((var1*self.dig_P5)<<1) 83 | var2 = (var2>>2)+(self.dig_P4<<16) 84 | var1 = (((self.dig_P3*((var1>>2)*(var1>>2))>>13)>>3) + (((self.dig_P2) * var1)>>1))>>18 85 | var1 = ((32768+var1)*self.dig_P1)>>15 86 | if var1 == 0: 87 | return # avoid exception caused by division by zero 88 | adc_P = (self.getReg(0xF7)<<12) + (self.getReg(0xF8)<<4) + (self.getReg(0xF9)>>4) 89 | p=((1048576-adc_P)-(var2>>12))*3125 90 | if p < 0x80000000: 91 | p = (p << 1) // var1 92 | else: 93 | p = (p // var1) *2 94 | var1 = (self.dig_P9 * (((p>>3)*(p>>3))>>13))>>12 95 | var2 = (((p>>2)) * self.dig_P8)>>13 96 | self.P = p + ((var1 + var2 + self.dig_P7) >> 4) 97 | adc_H = (self.getReg(0xFD)<<8) + self.getReg(0xFE) 98 | var1 = t - 76800 99 | var2 = (((adc_H<<14)-(self.dig_H4<<20)-(self.dig_H5*var1))+16384)>>15 100 | var1 = var2*(((((((var1*self.dig_H6)>>10)*(((var1*self.dig_H3)>>11)+32768))>>10)+2097152)*self.dig_H2+8192)>>14) 101 | var2 = var1-(((((var1>>15)*(var1>>15))>>7)*self.dig_H1)>>4) 102 | if var2 < 0: 103 | var2 = 0 104 | if var2 > 419430400: 105 | var2 = 419430400 106 | self.H = (var2>>12)/1024 107 | return [self.T, self.P, self.H] 108 | 109 | # get Temperature in Celsius 110 | def getTemp(self): 111 | self.get() 112 | return self.T 113 | 114 | # get Pressure in Pa 115 | def getPress(self): 116 | self.get() 117 | return self.P 118 | 119 | # get Humidity in %RH 120 | def getHumi(self): 121 | self.get() 122 | return self.H 123 | 124 | # Calculating absolute altitude 125 | def getAltitude(self): 126 | return 44330*(1-(self.getPress()/101325)**(1/5.255)) 127 | 128 | # sleep mode 129 | def poweroff(self): 130 | self.setReg(0xF4, 0) 131 | 132 | # normal mode 133 | def poweron(self): 134 | self.setReg(0xF4, 0x2F) 135 | -------------------------------------------------------------------------------- /LED/TM1637/TM1637.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for Four Digit LED Display (TM1637) 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import Pin 11 | from time import sleep_us 12 | 13 | TM1637_CMD1 = (64) # 0x40 data command 14 | TM1637_CMD2 = (192) # 0xC0 address command 15 | TM1637_CMD3 = (128) # 0x80 display control command 16 | TM1637_DELAY = (10) # 10us delay between clk/dio pulses 17 | 18 | 19 | ''' 20 | 0x00-0x0F 21 | 0x10-0x1F 22 | 0x20-0x2F 23 | 0x30-0x39 0 ~ 9 24 | 0x3A-0x40 25 | 0x41-0x5A A - Z 26 | 0x5B-0x60 27 | ''' 28 | _FONT1 = b'\ 29 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 30 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 31 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\ 32 | \x3F\x06\x5B\x4F\x66\x6D\x7D\x07\x7F\x6F\ 33 | \x00\x00\x00\x00\x00\x00\x00\ 34 | \x77\x7C\x39\x5E\x79\x71\x3D\x76\x00\x0E\x00\x38\x00\x54\x5C\x73\x67\x00\x00\x78\x3E\x1C\x00\x00\x00\x00\x00\ 35 | \x00\x00\x00\x00\x08\x00\ 36 | ' 37 | _FONT2 = b'\ 38 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 39 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 40 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\ 41 | \x3F\x30\x5B\x79\x74\x6D\x6F\x38\x7F\x7D\ 42 | \x00\x00\x00\x00\x00\x00\x00\ 43 | \x7E\x67\x0F\x73\x4F\x4E\x2F\x76\x00\x31\x00\x07\x00\x62\x63\x5E\x7C\x00\x00\x47\x37\x23\x00\x00\x00\x00\x00\ 44 | \x00\x00\x00\x00\x01\x00\ 45 | ' 46 | 47 | class TM1637(): 48 | def __init__(self, clk, dio, intensity=7, number = 4): 49 | self.clk = clk 50 | self.dio = dio 51 | 52 | self._intensity = intensity%8 53 | self._LEDS = number 54 | self._ON = 8 55 | self.dbuf = [0]*number 56 | self._reverse = False 57 | self.FONT = _FONT1 58 | 59 | self.clk.init(Pin.OUT, value=0) 60 | self.dio.init(Pin.OUT, value=0) 61 | sleep_us(TM1637_DELAY) 62 | 63 | self.clear() 64 | 65 | def _start(self): 66 | self.dio(0) 67 | sleep_us(TM1637_DELAY) 68 | self.clk(0) 69 | sleep_us(TM1637_DELAY) 70 | 71 | def _stop(self): 72 | self.dio(0) 73 | sleep_us(TM1637_DELAY) 74 | self.clk(1) 75 | sleep_us(TM1637_DELAY) 76 | self.dio(1) 77 | 78 | def _write_data_cmd(self): 79 | # automatic address increment, normal mode 80 | self._start() 81 | self._write_byte(TM1637_CMD1) 82 | self._stop() 83 | 84 | def _write_dsp_ctrl(self): 85 | # display on, set brightness 86 | self._start() 87 | self._write_byte(TM1637_CMD3 | self._ON | self._intensity) 88 | self._stop() 89 | 90 | def _write_byte(self, b): 91 | for i in range(8): 92 | self.dio((b >> i) & 1) 93 | sleep_us(TM1637_DELAY) 94 | self.clk(1) 95 | sleep_us(TM1637_DELAY) 96 | self.clk(0) 97 | sleep_us(TM1637_DELAY) 98 | self.clk(1) 99 | sleep_us(TM1637_DELAY) 100 | self.clk(0) 101 | sleep_us(TM1637_DELAY) 102 | 103 | def on(self): 104 | self._ON = 8 105 | self._write_data_cmd() 106 | self._write_dsp_ctrl() 107 | 108 | def off(self): 109 | self._ON = 0 110 | self._write_data_cmd() 111 | self._write_dsp_ctrl() 112 | 113 | def intensity(self, val=None): 114 | if val is None: 115 | return self._intensity 116 | val = max(0, min(val, 8)) 117 | if val == 0: 118 | self.off() 119 | else: 120 | self._ON = 8 121 | self._intensity = val-1 122 | self._write_data_cmd() 123 | self._write_dsp_ctrl() 124 | 125 | def reverse(self, reverse=False): 126 | self._reverse = reverse 127 | if reverse: 128 | self.FONT = _FONT2 129 | else: 130 | self.FONT = _FONT1 131 | 132 | def dat(self, dat, bit=0): 133 | if self._reverse: 134 | bit = self._LEDS - bit - 1 135 | self._write_data_cmd() 136 | self._start() 137 | self._write_byte(TM1637_CMD2 | (bit%self._LEDS)) 138 | self._write_byte(dat) 139 | self._stop() 140 | self._write_dsp_ctrl() 141 | 142 | def clear(self): 143 | for i in range(self._LEDS): 144 | self.dat(0, i) 145 | self.dbuf[i] = 0 146 | 147 | def showDP(self, show = True, bit = 1): 148 | bit = bit%self._LEDS 149 | if show: 150 | self.dat(self.dbuf[bit] | 0x80, bit) 151 | else: 152 | self.dat(self.dbuf[bit] & 0x7F, bit) 153 | 154 | def show(self, s): 155 | _s = s.upper() 156 | for i in range(self._LEDS): 157 | if i < len(_s): 158 | self.dbuf[i] = self.FONT[min(0x60, ord(_s[i]))] 159 | else: 160 | self.dbuf[i] = 0 161 | self.dat(self.dbuf[i], i) 162 | 163 | def shownum(self, num): 164 | self.show(str(num)) 165 | 166 | 167 | -------------------------------------------------------------------------------- /misc/DS3231/DS3231.py: -------------------------------------------------------------------------------- 1 | ''' 2 | DS3231 RTC drive 3 | 4 | Author: shaoziyang 5 | Date: 2018.3 6 | 7 | http://www.micropython.org.cn 8 | ''' 9 | from machine import I2C, Pin 10 | 11 | DS3231_I2C_ADDR = (0x68) 12 | DS3231_REG_SEC = (0x00) 13 | DS3231_REG_MIN = (0x01) 14 | DS3231_REG_HOUR = (0x02) 15 | DS3231_REG_WEEKDAY= (0x03) 16 | DS3231_REG_DAY = (0x04) 17 | DS3231_REG_MONTH = (0x05) 18 | DS3231_REG_YEAR = (0x06) 19 | DS3231_REG_A1SEC = (0x07) 20 | DS3231_REG_A1MIN = (0x08) 21 | DS3231_REG_A1HOUR = (0x09) 22 | DS3231_REG_A1DAY = (0x0A) 23 | DS3231_REG_A2MIN = (0x0B) 24 | DS3231_REG_A2HOUR = (0x0C) 25 | DS3231_REG_A2DAY = (0x0D) 26 | DS3231_REG_CTRL = (0x0E) 27 | DS3231_REG_STA = (0x0F) 28 | DS3231_REG_AGOFF = (0x10) 29 | DS3231_REG_TEMP = (0x11) 30 | 31 | PER_DISABLE = (0) 32 | PER_MINUTE = (1) 33 | PER_HOUR = (2) 34 | PER_DAY = (3) 35 | PER_WEEKDAY = (4) 36 | PER_MONTH = (5) 37 | 38 | class DS3231(): 39 | def __init__(self, i2c): 40 | self.i2c = i2c 41 | self.setReg(DS3231_REG_CTRL, 0x4C) 42 | 43 | def DecToHex(self, dat): 44 | return (dat//10) * 16 + (dat%10) 45 | 46 | def HexToDec(self, dat): 47 | return (dat//16) * 10 + (dat%16) 48 | 49 | def setReg(self, reg, dat): 50 | self.i2c.writeto(DS3231_I2C_ADDR, bytearray([reg, dat])) 51 | 52 | def getReg(self, reg): 53 | self.i2c.writeto(DS3231_I2C_ADDR, bytearray([reg])) 54 | return self.i2c.readfrom(DS3231_I2C_ADDR, 1)[0] 55 | 56 | def Second(self, second = None): 57 | if second == None: 58 | return self.HexToDec(self.getReg(DS3231_REG_SEC)) 59 | else: 60 | self.setReg(DS3231_REG_SEC, self.DecToHex(second%60)) 61 | 62 | def Minute(self, minute = None): 63 | if minute == None: 64 | return self.HexToDec(self.getReg(DS3231_REG_MIN)) 65 | else: 66 | self.setReg(DS3231_REG_MIN, self.DecToHex(minute%60)) 67 | 68 | def Hour(self, hour = None): 69 | if hour == None: 70 | return self.HexToDec(self.getReg(DS3231_REG_HOUR)) 71 | else: 72 | self.setReg(DS3231_REG_HOUR, self.DecToHex(hour%24)) 73 | 74 | def Weekday(self, weekday = None): 75 | if weekday == None: 76 | return self.HexToDec(self.getReg(DS3231_REG_WEEKDAY)) 77 | else: 78 | self.setReg(DS3231_REG_WEEKDAY, self.DecToHex(weekday%8)) 79 | 80 | def Day(self, day = None): 81 | if day == None: 82 | return self.HexToDec(self.getReg(DS3231_REG_DAY)) 83 | else: 84 | self.setReg(DS3231_REG_DAY, self.DecToHex(day%32)) 85 | 86 | def Month(self, month = None): 87 | if month == None: 88 | return self.HexToDec(self.getReg(DS3231_REG_MONTH)) 89 | else: 90 | self.setReg(DS3231_REG_MONTH, self.DecToHex(month%13)) 91 | 92 | def Year(self, year = None): 93 | if year == None: 94 | return self.HexToDec(self.getReg(DS3231_REG_YEAR)) + 2000 95 | else: 96 | self.setReg(DS3231_REG_YEAR, self.DecToHex(year%100)) 97 | 98 | def Date(self, dat = None): 99 | if dat == None: 100 | return [self.Year(), self.Month(), self.Day()] 101 | else: 102 | self.Year(dat[0]%100) 103 | self.Month(dat[1]%13) 104 | self.Day(dat[2]%32) 105 | 106 | def Time(self, dat = None): 107 | if dat == None: 108 | return [self.Hour(), self.Minute(), self.Second()] 109 | else: 110 | self.Hour(dat[0]%24) 111 | self.Minute(dat[1]%60) 112 | self.Second(dat[2]%60) 113 | 114 | def DateTime(self, dat = None): 115 | if dat == None: 116 | return self.Date() + [self.Weekday()] + self.Time() 117 | else: 118 | self.Year(dat[0]) 119 | self.Month(dat[1]) 120 | self.Day(dat[2]) 121 | self.Weekday(dat[3]) 122 | self.Hour(dat[4]) 123 | self.Minute(dat[5]) 124 | self.Second(dat[6]) 125 | 126 | def ALARM(self, day, hour, minute, repeat): 127 | IE = self.getReg(DS3231_REG_CTRL) 128 | if repeat == PER_DISABLE: 129 | self.setReg(DS3231_REG_CTRL, IE & 0xFC) # disable ALARM OUT 130 | return 131 | IE |= 0x46 132 | self.setReg(DS3231_REG_CTRL, IE) 133 | M2 = M3 = M4 = 0x80 134 | DT = 0 135 | if repeat == PER_MINUTE: 136 | pass 137 | elif repeat == PER_HOUR: 138 | M2 = 0 139 | elif repeat == PER_DAY: 140 | M2 = M3 = 0 141 | else: 142 | M2 = M3 = M4 = 0 143 | if repeat == PER_WEEKDAY: 144 | DT = 0x40 145 | self.setReg(DS3231_REG_A2MIN, self.DecToHex(minute%60)|M2) 146 | self.setReg(DS3231_REG_A2HOUR, self.DecToHex(hour%24)|M3) 147 | self.setReg(DS3231_REG_A2DAY, self.DecToHex(day%32)|M4|DT) 148 | 149 | def ClearALARM(self): 150 | self.setReg(DS3231_REG_STA, 0) 151 | 152 | def Temperature(self): 153 | t1 = self.getReg(DS3231_REG_TEMP) 154 | t2 = self.getReg(DS3231_REG_TEMP + 1) 155 | if t1>0x7F: 156 | return t1 - t2/256 -256 157 | else: 158 | return t1 + t2/256 159 | -------------------------------------------------------------------------------- /LED/OLED_I2C_ASC/Font_8x16.py: -------------------------------------------------------------------------------- 1 | ''' 2 | FONT 8x16 for OLED 3 | ''' 4 | # ' ' - '~' 0x20 - 0x7E 5 | Font_8x16 = bytes(b'\ 6 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 7 | \x00\x00\x38\xFC\xFC\x38\x00\x00\x00\x00\x0D\x0D\x00\x00\ 8 | \x00\x0E\x1E\x00\x00\x1E\x0E\x00\x00\x00\x00\x00\x00\x00\ 9 | \x20\xF8\xF8\x20\xF8\xF8\x20\x02\x0F\x0F\x02\x0F\x0F\x02\ 10 | \x38\x7C\x44\x47\x47\xCC\x98\x06\x0C\x08\x38\x38\x0F\x07\ 11 | \x30\x30\x00\x80\xC0\x60\x30\x0C\x06\x03\x01\x00\x0C\x0C\ 12 | \x80\xD8\x7C\xE4\xBC\xD8\x40\x07\x0F\x08\x08\x07\x0F\x08\ 13 | \x00\x10\x1E\x0E\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 14 | \x00\x00\xF0\xF8\x0C\x04\x00\x00\x00\x03\x07\x0C\x08\x00\ 15 | \x00\x00\x04\x0C\xF8\xF0\x00\x00\x00\x08\x0C\x07\x03\x00\ 16 | \x80\xA0\xE0\xC0\xC0\xE0\xA0\x00\x02\x03\x01\x01\x03\x02\ 17 | \x00\x80\x80\xE0\xE0\x80\x80\x00\x00\x00\x03\x03\x00\x00\ 18 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x1E\x0E\x00\x00\ 19 | \x80\x80\x80\x80\x80\x80\x80\x00\x00\x00\x00\x00\x00\x00\ 20 | \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0C\x0C\x00\x00\ 21 | \x00\x00\x00\x80\xC0\x60\x30\x0C\x06\x03\x01\x00\x00\x00\ 22 | \xF0\xF8\x0C\xC4\x0C\xF8\xF0\x03\x07\x0C\x08\x0C\x07\x03\ 23 | \x00\x10\x18\xFC\xFC\x00\x00\x00\x08\x08\x0F\x0F\x08\x08\ 24 | \x08\x0C\x84\xC4\x64\x3C\x18\x0E\x0F\x09\x08\x08\x0C\x0C\ 25 | \x08\x0C\x44\x44\x44\xFC\xB8\x04\x0C\x08\x08\x08\x0F\x07\ 26 | \xC0\xE0\xB0\x98\xFC\xFC\x80\x00\x00\x00\x08\x0F\x0F\x08\ 27 | \x7C\x7C\x44\x44\x44\xC4\x84\x04\x0C\x08\x08\x08\x0F\x07\ 28 | \xF0\xF8\x4C\x44\x44\xC0\x80\x07\x0F\x08\x08\x08\x0F\x07\ 29 | \x0C\x0C\x04\x84\xC4\x7C\x3C\x00\x00\x0F\x0F\x00\x00\x00\ 30 | \xB8\xFC\x44\x44\x44\xFC\xB8\x07\x0F\x08\x08\x08\x0F\x07\ 31 | \x38\x7C\x44\x44\x44\xFC\xF8\x00\x08\x08\x08\x0C\x07\x03\ 32 | \x00\x00\x00\x30\x30\x00\x00\x00\x00\x00\x06\x06\x00\x00\ 33 | \x00\x00\x00\x30\x30\x00\x00\x00\x00\x08\x0E\x06\x00\x00\ 34 | \x00\x80\xC0\x60\x30\x18\x08\x00\x00\x01\x03\x06\x0C\x08\ 35 | \x00\x20\x20\x20\x20\x20\x20\x00\x01\x01\x01\x01\x01\x01\ 36 | \x00\x08\x18\x30\x60\xC0\x80\x00\x08\x0C\x06\x03\x01\x00\ 37 | \x18\x1C\x04\xC4\xE4\x3C\x18\x00\x00\x00\x0D\x0D\x00\x00\ 38 | \xF0\xF8\x08\xC8\xC8\xF8\xF0\x07\x0F\x08\x0B\x0B\x0B\x01\ 39 | \xE0\xF0\x98\x8C\x98\xF0\xE0\x0F\x0F\x00\x00\x00\x0F\x0F\ 40 | \x04\xFC\xFC\x44\x44\xFC\xB8\x08\x0F\x0F\x08\x08\x0F\x07\ 41 | \xF0\xF8\x0C\x04\x04\x0C\x18\x03\x07\x0C\x08\x08\x0C\x06\ 42 | \x04\xFC\xFC\x04\x0C\xF8\xF0\x08\x0F\x0F\x08\x0C\x07\x03\ 43 | \x04\xFC\xFC\x44\xE4\x0C\x1C\x08\x0F\x0F\x08\x08\x0C\x0E\ 44 | \x04\xFC\xFC\x44\xE4\x0C\x1C\x08\x0F\x0F\x08\x00\x00\x00\ 45 | \xF0\xF8\x0C\x84\x84\x8C\x98\x03\x07\x0C\x08\x08\x07\x0F\ 46 | \xFC\xFC\x40\x40\x40\xFC\xFC\x0F\x0F\x00\x00\x00\x0F\x0F\ 47 | \x00\x00\x04\xFC\xFC\x04\x00\x00\x00\x08\x0F\x0F\x08\x00\ 48 | \x00\x00\x00\x04\xFC\xFC\x04\x07\x0F\x08\x08\x0F\x07\x00\ 49 | \x04\xFC\xFC\xC0\xE0\x3C\x1C\x08\x0F\x0F\x00\x01\x0F\x0E\ 50 | \x04\xFC\xFC\x04\x00\x00\x00\x08\x0F\x0F\x08\x08\x0C\x0E\ 51 | \xFC\xFC\x38\x70\x38\xFC\xFC\x0F\x0F\x00\x00\x00\x0F\x0F\ 52 | \xFC\xFC\x38\x70\xE0\xFC\xFC\x0F\x0F\x00\x00\x00\x0F\x0F\ 53 | \xF8\xFC\x04\x04\x04\xFC\xF8\x07\x0F\x08\x08\x08\x0F\x07\ 54 | \x04\xFC\xFC\x44\x44\x7C\x38\x08\x0F\x0F\x08\x00\x00\x00\ 55 | \xF8\xFC\x04\x04\x04\xFC\xF8\x07\x0F\x08\x0E\x3C\x3F\x27\ 56 | \x04\xFC\xFC\x44\xC4\xFC\x38\x08\x0F\x0F\x00\x00\x0F\x0F\ 57 | \x18\x3C\x64\x44\xC4\x9C\x18\x06\x0E\x08\x08\x08\x0F\x07\ 58 | \x00\x1C\x0C\xFC\xFC\x0C\x1C\x00\x00\x08\x0F\x0F\x08\x00\ 59 | \xFC\xFC\x00\x00\x00\xFC\xFC\x07\x0F\x08\x08\x08\x0F\x07\ 60 | \xFC\xFC\x00\x00\x00\xFC\xFC\x01\x03\x06\x0C\x06\x03\x01\ 61 | \xFC\xFC\x00\xC0\x00\xFC\xFC\x07\x0F\x0E\x03\x0E\x0F\x07\ 62 | \x0C\x3C\xF0\xE0\xF0\x3C\x0C\x0C\x0F\x03\x01\x03\x0F\x0C\ 63 | \x00\x3C\x7C\xC0\xC0\x7C\x3C\x00\x00\x08\x0F\x0F\x08\x00\ 64 | \x1C\x0C\x84\xC4\x64\x3C\x1C\x0E\x0F\x09\x08\x08\x0C\x0E\ 65 | \x00\x00\xFC\xFC\x04\x04\x00\x00\x00\x0F\x0F\x08\x08\x00\ 66 | \x38\x70\xE0\xC0\x80\x00\x00\x00\x00\x00\x01\x03\x07\x0E\ 67 | \x00\x00\x04\x04\xFC\xFC\x00\x00\x00\x08\x08\x0F\x0F\x00\ 68 | \x08\x0C\x06\x03\x06\x0C\x08\x00\x00\x00\x00\x00\x00\x00\ 69 | \x00\x00\x00\x00\x00\x00\x00\x20\x20\x20\x20\x20\x20\x20\ 70 | \x00\x00\x03\x07\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\ 71 | \x00\xA0\xA0\xA0\xE0\xC0\x00\x07\x0F\x08\x08\x07\x0F\x08\ 72 | \x04\xFC\xFC\x20\x60\xC0\x80\x00\x0F\x0F\x08\x08\x0F\x07\ 73 | \xC0\xE0\x20\x20\x20\x60\x40\x07\x0F\x08\x08\x08\x0C\x04\ 74 | \x80\xC0\x60\x24\xFC\xFC\x00\x07\x0F\x08\x08\x07\x0F\x08\ 75 | \xC0\xE0\xA0\xA0\xA0\xE0\xC0\x07\x0F\x08\x08\x08\x0C\x04\ 76 | \x40\xF8\xFC\x44\x0C\x18\x00\x08\x0F\x0F\x08\x00\x00\x00\ 77 | \xC0\xE0\x20\x20\xC0\xE0\x20\x27\x6F\x48\x48\x7F\x3F\x00\ 78 | \x04\xFC\xFC\x40\x20\xE0\xC0\x08\x0F\x0F\x00\x00\x0F\x0F\ 79 | \x00\x00\x20\xEC\xEC\x00\x00\x00\x00\x08\x0F\x0F\x08\x00\ 80 | \x00\x00\x00\x00\x20\xEC\xEC\x00\x30\x70\x40\x40\x7F\x3F\ 81 | \x04\xFC\xFC\x80\xC0\x60\x20\x08\x0F\x0F\x01\x03\x0E\x0C\ 82 | \x00\x00\x04\xFC\xFC\x00\x00\x00\x00\x08\x0F\x0F\x08\x00\ 83 | \xE0\xE0\x60\xC0\x60\xE0\xC0\x0F\x0F\x00\x07\x00\x0F\x0F\ 84 | \x20\xE0\xC0\x20\x20\xE0\xC0\x00\x0F\x0F\x00\x00\x0F\x0F\ 85 | \xC0\xE0\x20\x20\x20\xE0\xC0\x07\x0F\x08\x08\x08\x0F\x07\ 86 | \x20\xE0\xC0\x20\x20\xE0\xC0\x40\x7F\x7F\x48\x08\x0F\x07\ 87 | \xC0\xE0\x20\x20\xC0\xE0\x20\x07\x0F\x08\x48\x7F\x7F\x40\ 88 | \x20\xE0\xC0\x60\x20\xE0\xC0\x08\x0F\x0F\x08\x00\x00\x00\ 89 | \x40\xE0\xA0\x20\x20\x60\x40\x04\x0C\x09\x09\x0B\x0E\x04\ 90 | \x20\x20\xF8\xFC\x20\x20\x00\x00\x00\x07\x0F\x08\x0C\x04\ 91 | \xE0\xE0\x00\x00\xE0\xE0\x00\x07\x0F\x08\x08\x07\x0F\x08\ 92 | \x00\xE0\xE0\x00\x00\xE0\xE0\x00\x03\x07\x0C\x0C\x07\x03\ 93 | \xE0\xE0\x00\x80\x00\xE0\xE0\x07\x0F\x0C\x07\x0C\x0F\x07\ 94 | \x20\x60\xC0\x80\xC0\x60\x20\x08\x0C\x07\x03\x07\x0C\x08\ 95 | \xE0\xE0\x00\x00\x00\xE0\xE0\x47\x4F\x48\x48\x68\x3F\x1F\ 96 | \x60\x60\x20\xA0\xE0\x60\x20\x0C\x0E\x0B\x09\x08\x0C\x0C\ 97 | \x00\x40\x40\xF8\xBC\x04\x04\x00\x00\x00\x07\x0F\x08\x08\ 98 | \x00\x00\x00\xBC\xBC\x00\x00\x00\x00\x00\x0F\x0F\x00\x00\ 99 | \x00\x04\x04\xBC\xF8\x40\x40\x00\x08\x08\x0F\x07\x00\x00\ 100 | \x08\x0C\x04\x0C\x08\x0C\x04\x00\x00\x00\x00\x00\x00\x00\ 101 | ') 102 | -------------------------------------------------------------------------------- /gnss/ugnss.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mini GNSS Data analysis 3 | 4 | ''' 5 | 6 | class uGNSS(): 7 | 8 | GNSS_DIR = ('N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 9 | 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW') 10 | GNSS_VALID = (b'1', b'2') 11 | 12 | def __init__(self, bufsize = 2048): 13 | 14 | self.latitude = 0.0 15 | self.longitude = 0.0 16 | self.latitude_dir = 'N' 17 | self.longitude_dir = 'E' 18 | self.speed = 0.0 19 | self.course = 0.0 20 | self.altitude = 0.0 21 | self.geoid_height = 0.0 22 | self.date = [0, 0, 0] 23 | self.time = [0, 0, 0] 24 | self.datetime = [0, 0, 0, 0, 0, 0, 0, 0] 25 | self.valid = False 26 | self.satellites_in_view = 0 27 | self.satellites_in_use = 0 28 | self.satellites_used = [] 29 | self.hdop = 0.0 30 | self.pdop = 0.0 31 | self.vdop = 0.0 32 | self._crc = bytearray(1) 33 | self._buf = bytearray(256) 34 | self._pos = 0 35 | self._seg = [] 36 | 37 | def DM2DMS(dm): 38 | return 39 | 40 | def checksum(self, buf, length): 41 | self._crc[0] = 0 42 | for i in range(1, length): 43 | self._crc[0] ^= buf[i] 44 | try: 45 | d = int(b'0x'+buf[length+1:length+3]) 46 | except: 47 | return False 48 | return self._crc[0] == d 49 | 50 | def parse(self): 51 | try: 52 | if not self.checksum(self._buf, self._pos-4): 53 | return False 54 | 55 | self._seg = bytes(self._buf[1:self._pos-4]).split(b',') 56 | if self._seg[0] in self.GNSS_CMD: 57 | try: 58 | self.GNSS_CMD[self._seg[0]](self) 59 | return True 60 | except: 61 | return False 62 | 63 | return False 64 | finally: 65 | self._pos = 0 66 | 67 | def update_char(self, c): 68 | if self._pos: 69 | if self._pos > 250: 70 | self._pos = 0 71 | return False 72 | else: 73 | if type(c) is int: 74 | self._buf[self._pos] = c 75 | elif type(c) is str: 76 | self._buf[self._pos] = ord(c) 77 | else: 78 | self._pos = 0 79 | return False 80 | 81 | if self._buf[self._pos] == ord('\n'): 82 | return self.parse() 83 | else: 84 | self._pos += 1 85 | else: 86 | if c == '$' or c == ord(b'$'): 87 | self._buf[0] = 36 88 | self._pos = 1 89 | 90 | def update(self, dat): 91 | if not dat: 92 | return False 93 | 94 | for i in range(len(dat)): 95 | self.update_char(dat[i]) 96 | return self.valid 97 | 98 | def _time(self, dat): 99 | h, m, s = dat[0:2], dat[2:4], dat[4:6] 100 | self.time = [int(h), int(m), int(s)] 101 | self.datetime[4:7] = self.time 102 | 103 | def _date(self, dat): 104 | d, m, y = dat[0:2], dat[2:4], dat[4:6] 105 | self.date = [int(y), int(m), int(d)] 106 | self.datetime[0:3] = self.date 107 | 108 | def _latlon(self, dat): 109 | t = float(dat) 110 | d, m = divmod(t, 100) 111 | return d + m/60 112 | 113 | def _GNGGA(self): 114 | self._time(self._seg[1]) 115 | self.latitude = self._latlon(self._seg[2]) 116 | self.latitude_dir = self._seg[3].decode() 117 | self.longitude = self._latlon(self._seg[4]) 118 | self.longitude_dir = self._seg[5].decode() 119 | self.valid = self._seg[6] in self.GNSS_VALID 120 | self.satellites_in_use = int(self._seg[7]) 121 | self.hdop = float(self._seg[8]) 122 | self.altitude = float(self._seg[9]) 123 | self.geoid_height = float(self._seg[11]) 124 | 125 | def _GNRMC(self): 126 | self._time(self._seg[1]) 127 | self._date(self._seg[9]) 128 | self.valid = (self._seg[2] == b'A') 129 | self.latitude = self._latlon(self._seg[3]) 130 | self.latitude_dir = self._seg[4].decode() 131 | self.longitude = self._latlon(self._seg[5]) 132 | self.longitude_dir = self._seg[6].decode() 133 | self.speed = float(self._seg[7]) 134 | self.course = float(self._seg[8]) 135 | 136 | def _GNVTG(self): 137 | self.course = float(self._seg[1]) 138 | self.speed = float(self._seg[7]) 139 | 140 | def _GNGLL(self): 141 | self.latitude = self._latlon(self._seg[1]) 142 | self.latitude_dir = self._seg[2] 143 | self.longitude = self._latlon(self._seg[3]) 144 | self.longitude_dir = self._seg[4] 145 | self._time(self._seg[5]) 146 | self.valid = (self._seg[6] == b'A') 147 | 148 | def _GNGSA(self): 149 | self.pdop = float(self._seg[15]) 150 | self.hdop = float(self._seg[16]) 151 | self.vdop = float(self._seg[17]) 152 | 153 | def _GPGSV(self): 154 | self.satellites_in_view = int(self._seg[3]) 155 | 156 | GNSS_CMD = { 157 | b'GNGGA': _GNGGA, 158 | b'GNRMC': _GNRMC, 159 | b'GNVTG': _GNVTG, 160 | b'GNGLL': _GNGLL, 161 | b'GPGSV': _GPGSV, 162 | b'GNGSA': _GNGSA 163 | } 164 | 165 | def print(self): 166 | print('GNSS valid:', self.valid) 167 | print('lat:', self.latitude, self.latitude_dir) 168 | print('lon:', self.longitude, self.longitude_dir) 169 | print('speed:', self.speed) 170 | print('altitude:', self.altitude, self.geoid_height) 171 | print('hdop:', self.hdop) 172 | print('pdop:', self.pdop) 173 | print('vdop:', self.vdop) 174 | print('UTC:', self.datetime, self.date, self.time) 175 | print('satellites') 176 | print(' in view:', self.satellites_in_view) 177 | print(' in use: ', self.satellites_in_use) 178 | print(' list: ', self.satellites_used) 179 | 180 | -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/README_CN.md: -------------------------------------------------------------------------------- 1 | [:uk:English][EN] 2 | 3 | 3Wire-HT1621B-GDC03849 4 | ==== 5 | ![Frame diagram](./images/ht1621b_gdc.png) 6 | > 3Wire-HT1621B-GDC03849 为ht1621b作为驱动芯片的GDC03849液晶驱动模块。驱动芯片与主CPU为3+CS总线通讯方式进行数据交换。 7 | 8 | 9 | HT1621B 10 | ---- 11 | > HT1621是由[台湾合泰半导体公司][HT]生产的一款128点内存映象和多功能的LCD驱动器，HT1621 的软件配置特性使它适用于多种LCD应用场合包括LCD模块和显示子系统用于连接主控制器和HT1621的管脚只有4或5条，HT1621 还有一个节电命令用于降低系统功耗。详细资料请阅读 [HT1621B数据手册][1] 12 | 13 | 14 | #### 接口 15 | 16 | * **init(_timer = CMD_TIMER_DIS, _wdt = CMD_WDT_DIS, _scs = CMD_RC256K, _bias = CMD_B3C4, _tone = CMD_TONE4K, _irq = CMD_IRQ_DIS, _twc = CMD_F128, _mod = CMD_NORMAL)**
17 | *芯片功能与参数初始化* 18 | _timer: 时基输出设置
19 | _wdt: WDT溢出标志输出设置
20 | _scs: 系统时钟源设置
21 | _bias: 偏压和公共端设置
22 | _tone: 声音设置
23 | _irq: IRQ设置（生效/失效）
24 | _twc: 时基/WDT时钟输出设置（F1～F128）
25 | _mod: 模式设置（测试模式和普通模式）
26 | 27 | * **HT1621xWrCmd(_cmd)**
28 | *发送单个命令。*
29 | _cmd: 命令。（16进制）
30 | ```python 31 | # 向ht1621b发送打开LCD偏置电压（即打开LCD电源）的命令 32 | HT1621xWrCmd(0x006) # 在这里已经设置了常量（LCDON）来代替命令值（0x006)。 33 | ``` 34 | * **HT1621xWrOneData(_addr, _htdata)**
35 | *指定地址发送单个数据。*
36 | _addr: 地址（16进制）
37 | _htdata:数据，通常为1个字节。（16进制）
38 | ```python 39 | # 将温度最左侧(1号位)的数字显示为2 40 | HT1621xWrOneData(0x13, ((0x0B, 0x06))) 41 | ``` 42 | 43 | * **HT1621xWrAllData(_addr, _htdata)**
44 | *指定起始地址，连续发送多个数据。*
45 | _addr：起始地址（16进制）
46 | _htdata：连续的数据（16进制列表）
47 | ```python 48 | # 将温度值区全部显示为2。 49 | ALLSHOW(0x00, ((0x0B, 0x06), (0x0B, 0x06), (0x0B, 0x06), (0x0B, 0x06), (0x0B, 0x06), (0x0B, 0x06))) 50 | ``` 51 | 52 | * **ALLSHOW(_addr, _nbit)**
53 | *指定起始地址连续发送指定个数的 1。*
54 | _addr:起始地址（16进制）
55 | _nbit:数据SEG位数(1-32)。
56 | ```python 57 | # 清除内存中所有内容，即全部置1 58 | ALLSHOW(0x00, 32) 59 | ``` 60 | 61 | * **ALLCLEAR(_addr, _nbit)**
62 | *指定起始地址连续发送指定个数的 0。*
63 | _addr: 起始地址。（0x00-0x)
64 | _nbit: RAM区（SEG）个数（1-32）。
65 | ```python 66 | # 清除内存中所有内容，即全部置0 67 | ALLCLEAR(0x00, 32) 68 | ``` 69 | * **LCDON()**
70 | *打开LCD偏压发生器。* 71 | 72 | * **LCDOFF()**
73 | *关闭LCD偏压发生器。* 74 | 75 | * **HTBEEP(_t)**
76 | *使蜂鸣器一直响指定的时间后不响。*
77 | _t:保持时间，单位：毫秒
78 | ```python 79 | # 蜂鸣器持续响500毫秒 80 | HTBEEP(500) 81 | ``` 82 | 83 | #### 常量 84 | 85 | * 功能符号(标志字) 86 | 87 | 名称 | 描述 88 | --- | --- 89 | FLAG_CMD | 命令 90 | FLAG_READ | 只读RAM 91 | FLAG_WRITE | 只写RAM 92 | FLAG_MODIFY | 读和写RAM(即修改RAM)READ-MODIFY-WRITE 93 | 94 | * 液晶控制 95 | 96 | 名称 | 描述 97 | --- | --- 98 | CMD_LCDON | 打开LCD偏压发生器 99 | CMD_LCDOFF | 关闭LCD偏压发生器（上电时默认设置） 100 | 101 | * 系统控制 102 | 103 | 名称 | 描述 104 | --- | --- 105 | CMD_SYSEN | 打开系统振荡器 106 | CMD_SYSDIS | 关半系统振荡器和LCD偏压发生器 （上电时默认设置） 107 | 108 | * Bias与COM设置，即偏置电压与COM端,当前参数根据液晶的资料文件进行选择，比如1/4DUTY,1/3BIAL，则选择"B3C4" 109 | * 1/2偏压设置 110 | 111 | 名称 | 描述 112 | --- | --- 113 | CMD_B2C2 | 2COM,1/2 bias 114 | CMD_B2C3 | 001001000 3COM,1/2 bias 115 | CMD_B2C4 | 4COM,1/2 bias 116 | 117 | * 1/3偏压设置 118 | 119 | 名称 | 描述 120 | --- | --- 121 | CMD_B3C2 | 2COM,1/3 bias 122 | CMD_B3C3 | 3COM,1/3 bias 123 | CMD_B3C4 | 4COM,1/3 bias 124 | 125 | * 时钟设置 126 | 127 | 名称 | 描述 128 | --- | --- 129 | CMD_RC256K | 系统时钟源，片内RC振荡器 （上电时默认设置） 130 | CMD_EXT256K | 系统时钟源，外部时钟 131 | CMD_XTAL32K | 系统时钟源（晶振） 132 | 133 | * 时基设置 134 | 135 | 名称 | 描述 136 | --- | --- 137 | CMD_TIMER_EN | 时基输出使能 138 | CMD_TIMER_DIS | 时基输出失效 139 | CMD_CLR_TIMER | 时基发生器清零 140 | 141 | * WDT设置 142 | 143 | 名称 | 描述 144 | --- | --- 145 | CMD_WDT_DIS | WDT溢出标志输出失效，禁用看门狗 146 | CMD_WDT_EN | WDT溢出标志输出有效，启用看门狗 147 | CMD_CLR_WDT | 清除WDT状态 148 | 149 | * 声音输出设置 150 | 151 | 名称 | 描述 152 | --- | --- 153 | CMD_TONE2K | 设置声音频率输出为2KHz 154 | CMD_TONE4K | 设置声音频率输出为4KHz 155 | CMD_TONEON | 打开声音输出 156 | CMD_TONEOFF | 关闭声音输出（上电时默认设置） 157 | 158 | * 时基/WDT输出设置 159 | 160 | 名称 | 描述 161 | --- | --- 162 | CMD_F1 | 时基/WDT时钟输出:1Hz
WDT超时标志后: 4s 163 | CMD_F2 | 时基/WDT时钟输出:2Hz
WDT超时标志后: 2s 164 | CMD_F4 | 时基/WDT时钟输出:4Hz
WDT超时标志后: 1s 165 | CMD_F8 | 时基/WDT时钟输出:8Hz
WDT超时标志后: 1/2s 166 | CMD_F16 | 时基/WDT时钟输出:16Hz
WDT超时标志后: 1/4s 167 | CMD_F32 | 时基/WDT时钟输出:32Hz
WDT超时标志后: 1/8s 168 | CMD_F64 | 时基/WDT时钟输出:64Hz
WDT超时标志后: 1/16s 169 | CMD_F128 | 时基/WDT时钟输出:128Hz
WDT超时标志后: 1/32s（上电时默认设置） 170 | 171 | * IRQ设置 172 | 173 | 名称 | 描述 174 | --- | --- 175 | CMD_IRQ_DIS | 使IRQ输出失效（上电时默认设置） 176 | CMD_IRQ_EN | 使IRQ输出有效 177 | 178 | * 工作模式设置 179 | 180 | 名称 | 描述 181 | --- | --- 182 | CMD_TEST | 测试模式 183 | CMD_NORMAL | 普通模式（上电时默认设置） 184 | 185 |

186 | 187 | 188 | 189 | GDC03849 190 | ---- 191 | > GDC03849 是一款由[大连佳显][DL]公司生产的液晶屏幕,仅用于显示3位整数与2位小数的温度与温度值。详细信息请阅读 [GDC03849数据手册][2]。 192 | 193 | #### 接口 194 | 195 | * **viewTemp(_gdcdata)**
196 | *在温度区显示温度值*
197 | _gdcdata: 温度值（浮点数）
198 | ```python 199 | # 显示温度值为 25.34。 200 | viewTemp(25.34) 201 | ``` 202 | 203 | * **viewRH(_gdcdata)**
204 | *在湿度区显示湿度值*
205 | _gdcdata: 温度值（浮点数）
206 | ```python 207 | # 显示湿度值为 93.43。 208 | viewRH(93.45) 209 | ``` 210 | 211 | * **LCDALLSHOW()**
212 | *显示整片LCD所有字段*
213 | 214 | * **LCDALLCLEAR()**
215 | *清除整片LCD所有字段*
216 | 217 | * **TEMPCLEAR()**
218 | *清除温度区域（整行）所有字段显示*
219 | 220 | * **RHCLEAR()**
221 | *清除湿度区域（整行）所有字段显示*
222 | 223 | #### 常量 224 | 225 | 名称 | 描述 226 | --- | --- 227 | NUMCODE_RH_HEX | 以元组方式存储的湿度区单个字符的段码编码（16进制） 228 | NUMCODE_TEMP_HEX | 以元组方式存储的温度区单个字符的段码编码（16进制） 229 | 230 | 231 | #### 综合示例 232 | 233 | * 温度区显示为：温度 33.05 摄氏度，湿度 98.34% 234 | 235 | ```python 236 | # 当前实验板PYB Nano 237 | from ht1621x import HT1621B 238 | from gdc03849 import GDC03849 239 | 240 | from machine import Pin 241 | 242 | CS = Pin("A0") 243 | RD = Pin("A1") 244 | WR = Pin("B0") 245 | DA = Pin("B1") 246 | 247 | ht = HT1621B(CS, RD, WR, DA) 248 | gdc = GDC03849(ht) 249 | 250 | gdc.viewTemp(33.05) 251 | gdc.viewRH(98.34) 252 | 253 | ``` 254 | 255 | 256 | [HT]:http://www.holtek.com.cn 257 | [DL]:http://www.good-display.cn 258 | [1]:./DataSheet/HT1621CN.pdf 259 | [2]:./DataSheet/GDC03849C1P6.8.pdf 260 | [EN]:./README.md 261 | -------------------------------------------------------------------------------- /neopixel/neo_16x16_img/test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | ESP8266/ESP32 neopixel 16x16 image display demo 3 | 4 | Author: shaoziyang 5 | Date: 2018.2 6 | 7 | http://www.micropython.org.cn 8 | 9 | ''' 10 | from machine import Pin 11 | import time 12 | 13 | from neo16x16_img import neo16x16_img 14 | 15 | np = neo16x16_img(Pin(2)) 16 | 17 | npdat=[ 18 | 0x2AF3AF, 0x000000, 0x000000, 0x000000, 19 | 0x000000, 0x000000, 0x000000, 0x000000, 20 | 0x000000, 0x000000, 0x000000, 0x000000, 21 | 0x000000, 0x000000, 0x6CF000, 0x39F19F, 22 | 0x06F000, 0x5CF29F, 0x000000, 0x000000, 23 | 0x000000, 0x000000, 0x000000, 0x000000, 24 | 0x000000, 0x000000, 0x000000, 0x000000, 25 | 0x000000, 0x5CF000, 0x07F2AF, 0x00014E, 26 | 0x000000, 0x06F16E, 0x6CF2AF, 0x000000, 27 | 0x000000, 0x000000, 0x000000, 0x000000, 28 | 0x000000, 0x000000, 0x000000, 0x000000, 29 | 0x6DF000, 0x06F29F, 0x00004E, 0x000000, 30 | 0x000000, 0x36E000, 0x07F05F, 0x5DF2AF, 31 | 0x0005EF, 0x000000, 0x000000, 0x000000, 32 | 0x000000, 0x000000, 0x000000, 0x5CF000, 33 | 0x08F29F, 0x14A06F, 0x000000, 0x000000, 34 | 0x000000, 0x000000, 0x26E000, 0x08F05F, 35 | 0x6CF19F, 0x000000, 0x000000, 0x000000, 36 | 0x000000, 0x5B76CA, 0x000000, 0x08F4BC, 37 | 0x25D05F, 0x000000, 0x000000, 0x000000, 38 | 0x000000, 0x000000, 0x000000, 0x26F000, 39 | 0x4B839F, 0x5A45A3, 0x0007C8, 0x000000, 40 | 0x8A7000, 0x5C85A6, 0x7B75B5, 0x000000, 41 | 0x000000, 0x000000, 0x000000, 0x000000, 42 | 0x000000, 0x000000, 0x000000, 0x000000, 43 | 0x000000, 0x6A76B8, 0x6A75B7, 0x8A6695, 44 | 0x000000, 0x5A76C9, 0x8B8594, 0x000000, 45 | 0x000000, 0x000000, 0x000000, 0x000000, 46 | 0x000000, 0x000000, 0x000000, 0x000000, 47 | 0x000000, 0x000000, 0x6DA8CA, 0x000000, 48 | 0x000000, 0x000000, 0x000000, 0x000000, 49 | 0x000000, 0x000000, 0x000000, 0x000000, 50 | 0x000000, 0x000000, 0x000000, 0x000000, 51 | 0x121145, 0x000000, 0x000000, 0x000000, 52 | 0x000000, 0x000000, 0x000000, 0x169156, 53 | 0x000000, 0x000000, 0x000000, 0x000000, 54 | 0x000000, 0x000000, 0x000000, 0x234000, 55 | 0x15818B, 0x000217, 0x000000, 0x000000, 56 | 0x000000, 0x000000, 0x129000, 0x0AE17B, 57 | 0x000169, 0x000000, 0x000000, 0x000000, 58 | 0x000000, 0x000000, 0x000000, 0x19C301, 59 | 0x24709C, 0x00013A, 0x000000, 0x000000, 60 | 0x000000, 0x000000, 0x116000, 0x169237, 61 | 0x24718B, 0x245169, 0x000000, 0x000000, 62 | 0x000000, 0x235000, 0x0CF09D, 0x1590AE, 63 | 0x159159, 0x000000, 0x000000, 0x000000, 64 | 0x000000, 0x000000, 0x000000, 0x17C149, 65 | 0x09D18C, 0x0BF0BE, 0x23519C, 0x000234, 66 | 0x000000, 0x17B000, 0x16B15C, 0x14817C, 67 | 0x000024, 0x000000, 0x000000, 0x000000, 68 | 0x000000, 0x000000, 0x000000, 0x002013, 69 | 0x012000, 0x11A126, 0x000116, 0x000000, 70 | 0x000000, 0x000000, 0x000000, 0x048012, 71 | 0x16B149, 0x12716A, 0x000000, 0x000000, 72 | 0x000000, 0x12811B, 0x147247, 0x09E16A, 73 | 0x15B09D, 0x00010A, 0x000000, 0x000000, 74 | 0x000000, 0x000000, 0x16C127, 0x0BE08D, 75 | 0x17A0BF, 0x18B09C, 0x13A17A, 0x000227, 76 | 0x214000, 0x0AE17A, 0x1680AE, 0x0AD235, 77 | 0x0BE0BF, 0x00009C, 0x000000, 0x000000, 78 | 0x000000, 0x000000, 0x236235, 0x158246, 79 | 0x000245, 0x246312, 0x18B168, 0x200145, 80 | 0x122FFF, 0x000123, 0x000000, 0x000000, 81 | 0x000000, 0x235000, 0x000000, 0x000000, 82 | 0x000000, 0x000000, 0x000000, 0x9FF9FF, 83 | 0x9FF9FF, 0x0009FF, 0x000000, 0x000000, 84 | 0x000000, 0x9FF000, 0x0CF9FF, 0x0CF0CF, 85 | 0x0CF0CF, 0x9FF9FF, 0x000000, 0x000000, 86 | 0x000000, 0x9FF000, 0x0CF0CF, 0x0CF0CF, 87 | 0x0CF0CF, 0x0CF0CF, 0x9FF0CF, 0x000000, 88 | 0x9FF000, 0x0CF0CF, 0x0CF0CF, 0x0CF0CF, 89 | 0x0CF0CF, 0x0CF0CF, 0x9FF0CF, 0x000000, 90 | 0x000000, 0x0CF9FF, 0x0CF0CF, 0x0CF0CF, 91 | 0x0CF0CF, 0x0CF0CF, 0x0CF0CF, 0x0009FF, 92 | 0x0CF9FF, 0x0CF0CF, 0x0CF0CF, 0x0CF0CF, 93 | 0x0CF0CF, 0x0CF0CF, 0x0CF0CF, 0x0009FF, 94 | 0x9FF000, 0x0CF0CF, 0x0CF0CF, 0x0CF0CF, 95 | 0x0CF0CF, 0x0CF0CF, 0x0CF0CF, 0x9FF0CF, 96 | 0x0CF9FF, 0x0CF0CF, 0x0CF0CF, 0x0000FF, 97 | 0x0CF0FF, 0x0CF0CF, 0x0CF0CF, 0x0009FF, 98 | 0x9FF000, 0x0CF0CF, 0x0CF0CF, 0x0FF0CF, 99 | 0x0FF000, 0x0CF0CF, 0x0CF0CF, 0x9FF0CF, 100 | 0x0CF9FF, 0x0CF0CF, 0x0FF0CF, 0x000000, 101 | 0x0FF000, 0x0CF0CF, 0x0CF0CF, 0x0009FF, 102 | 0x000000, 0x0CF9FF, 0x0CF0CF, 0x0000FF, 103 | 0x000000, 0x0CF0FF, 0x0CF000, 0x0009FF, 104 | 0x9FF000, 0x0CF0CF, 0x0FF0CF, 0x000000, 105 | 0x0FF000, 0x0CF0CF, 0x9FF0CF, 0x000000, 106 | 0x000000, 0x9FF000, 0x0CF0CF, 0x0000FF, 107 | 0x000000, 0x0CF0FF, 0x9FF0CF, 0x000000, 108 | 0x000000, 0x9FF000, 0x0009FF, 0x000000, 109 | 0x000000, 0x9FF9FF, 0x000000, 0x000000, 110 | 0x000000, 0x000000, 0x000000, 0x000000, 111 | 0x000000, 0x000000, 0x000000, 0x000000, 112 | 0x000000, 0x000000, 0x000000, 0x000000, 113 | 0x000000, 0x000000, 0x000000, 0x000000, 114 | 0x000000, 0x000000, 0x000000, 0x000000, 115 | 0x000000, 0x000000, 0x000000, 0x000000, 116 | 0x000000, 0x000000, 0xEEE000, 0xFC9FC9, 117 | 0xFC9FC9, 0x000000, 0x000000, 0x000000, 118 | 0x000000, 0x000000, 0xFC9000, 0xFC9FC9, 119 | 0xFC9FC9, 0xEEEFC9, 0x000000, 0x000000, 120 | 0x000000, 0xAAA000, 0x555FC9, 0x000000, 121 | 0x333000, 0xEEEFC9, 0x000000, 0x000000, 122 | 0x000000, 0x000000, 0xFC9FC9, 0x000000, 123 | 0x000F90, 0xFC9000, 0x000FC9, 0x000000, 124 | 0x000000, 0xFC9000, 0x000FC9, 0xF99000, 125 | 0x000000, 0xFC9FC9, 0x000000, 0x000000, 126 | 0x000000, 0x000000, 0xFC9FC9, 0x000000, 127 | 0x000000, 0xFC9000, 0x000FC9, 0x000000, 128 | 0x000000, 0xFC9000, 0x000FC9, 0x000000, 129 | 0x000000, 0xFC9FC9, 0x000000, 0x000000, 130 | 0x000000, 0x000000, 0xFC9FC9, 0x000000, 131 | 0x000000, 0xFC9000, 0x000FC9, 0x000000, 132 | 0x000000, 0xFC9000, 0x000FC9, 0x000000, 133 | 0x000000, 0xFC9FC9, 0x000000, 0x000000, 134 | 0x000000, 0x000000, 0xFC9FC9, 0x000000, 135 | 0x000000, 0xFC9000, 0x000FC9, 0x000000, 136 | 0x000000, 0xFC9000, 0x000FC9, 0xF99000, 137 | 0x000000, 0xFC9FC9, 0x000000, 0x000000, 138 | 0x000000, 0x000000, 0xFC9FC9, 0x000000, 139 | 0x000F90, 0xFC9000, 0x000FC9, 0x000000, 140 | 0x000000, 0xBBB000, 0x333FC9, 0x000000, 141 | 0x111000, 0xEEEFC9, 0x000000, 0x000000, 142 | 0x000000, 0x000000, 0xFC9000, 0xFC9FC9, 143 | 0xFC9FC9, 0xFC9FC9, 0x000000, 0x000000, 144 | 0x000000, 0x000000, 0xFC9000, 0xFC9FC9, 145 | 0xFC9FC9, 0x000000, 0x000000, 0x000000, 146 | ] 147 | 148 | n = 0 149 | while 1: 150 | np.show(npdat, n) 151 | n = (n+16)%64 152 | time.sleep_ms(1000) 153 | 154 | -------------------------------------------------------------------------------- /sensor/LSM6DSO/LSM6DSO.py: -------------------------------------------------------------------------------- 1 | # LSM6DSO 3D accelerometer and 3D gyroscope seneor micropython drive 2 | # ver: 1.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@micropython.org.cn) 5 | # v1.0 2019.7 6 | 7 | LSM6DSO_CTRL1_XL = const(0x10) 8 | LSM6DSO_CTRL2_G = const(0x11) 9 | LSM6DSO_CTRL3_C = const(0x12) 10 | LSM6DSO_CTRL6_C = const(0x15) 11 | LSM6DSO_CTRL8_XL = const(0x17) 12 | LSM6DSO_STATUS = const(0x1E) 13 | LSM6DSO_OUT_TEMP_L = const(0x20) 14 | LSM6DSO_OUTX_L_G = const(0x22) 15 | LSM6DSO_OUTY_L_G = const(0x24) 16 | LSM6DSO_OUTZ_L_G = const(0x26) 17 | LSM6DSO_OUTX_L_A = const(0x28) 18 | LSM6DSO_OUTY_L_A = const(0x2A) 19 | LSM6DSO_OUTZ_L_A = const(0x2C) 20 | 21 | LSM6DSO_SCALEA = ('2g', '16g', '4g', '8g') 22 | LSM6DSO_SCALEG = ('250', '125', '500', '', '1000', '', '2000') 23 | 24 | class LSM6DSO(): 25 | def __init__(self, i2c, addr = 0x6B): 26 | self.i2c = i2c 27 | self.addr = addr 28 | self.tb = bytearray(1) 29 | self.rb = bytearray(1) 30 | self.oneshot = False 31 | self.irq_v = [[0, 0, 0], [0, 0, 0]] 32 | self._power = True 33 | self._power_a = 0x10 34 | self._power_g = 0x10 35 | # ODR_XL=1 FS_XL=0 36 | self.setreg(LSM6DSO_CTRL1_XL, 0x10) 37 | # ODR_G=1 FS_125=1 38 | self.setreg(LSM6DSO_CTRL2_G, 0x12) 39 | # BDU=1 IF_INC=1 40 | self.setreg(LSM6DSO_CTRL3_C, 0x44) 41 | self.setreg(LSM6DSO_CTRL8_XL, 0) 42 | # scale=2G 43 | self._scale_a = 0 44 | self._scale_g = 0 45 | self._scale_a_c = 1 46 | self._scale_g_c = 1 47 | self.scale_a('2g') 48 | self.scale_g('125') 49 | 50 | def int16(self, d): 51 | return d if d < 0x8000 else d - 0x10000 52 | 53 | def setreg(self, reg, dat): 54 | self.tb[0] = dat 55 | self.i2c.writeto_mem(self.addr, reg, self.tb) 56 | 57 | def getreg(self, reg): 58 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 59 | return self.rb[0] 60 | 61 | def get2reg(self, reg): 62 | return self.getreg(reg) + self.getreg(reg+1) * 256 63 | 64 | def r_w_reg(self, reg, dat, mask): 65 | self.getreg(reg) 66 | self.rb[0] = (self.rb[0] & mask) | dat 67 | self.setreg(reg, self.rb[0]) 68 | 69 | def ax_raw(self): 70 | return self.int16(self.get2reg(LSM6DSO_OUTX_L_A)) 71 | 72 | def ay_raw(self): 73 | return self.int16(self.get2reg(LSM6DSO_OUTY_L_A)) 74 | 75 | def az_raw(self): 76 | return self.int16(self.get2reg(LSM6DSO_OUTZ_L_A)) 77 | 78 | def gx_raw(self): 79 | return self.int16(self.get2reg(LSM6DSO_OUTX_L_G)) 80 | 81 | def gy_raw(self): 82 | return self.int16(self.get2reg(LSM6DSO_OUTY_L_G)) 83 | 84 | def gz_raw(self): 85 | return self.int16(self.get2reg(LSM6DSO_OUTZ_L_G)) 86 | 87 | def mg(self, reg): 88 | return round(self.int16(self.get2reg(reg)) * 0.061 * self._scale_a_c) 89 | 90 | def mdps(self, reg): 91 | return round(self.int16(self.get2reg(reg)) * 4.375 * self._scale_g_c) 92 | 93 | def ax(self): 94 | return self.mg(LSM6DSO_OUTX_L_A) 95 | 96 | def ay(self): 97 | return self.mg(LSM6DSO_OUTY_L_A) 98 | 99 | def az(self): 100 | return self.mg(LSM6DSO_OUTZ_L_A) 101 | 102 | def gx(self): 103 | return self.mdps(LSM6DSO_OUTX_L_G) 104 | 105 | def gy(self): 106 | return self.mdps(LSM6DSO_OUTY_L_G) 107 | 108 | def gz(self): 109 | return self.mdps(LSM6DSO_OUTZ_L_G) 110 | 111 | def get_a(self): 112 | self.irq_v[0][0] = self.ax() 113 | self.irq_v[0][1] = self.ay() 114 | self.irq_v[0][2] = self.az() 115 | return self.irq_v[0] 116 | 117 | def get_g(self): 118 | self.irq_v[1][0] = self.gx() 119 | self.irq_v[1][1] = self.gy() 120 | self.irq_v[1][2] = self.gz() 121 | return self.irq_v[1] 122 | 123 | def get(self): 124 | self.get_a() 125 | self.get_g() 126 | return self.irq_v 127 | 128 | def get_a_raw(self): 129 | self.irq_v[0][0] = self.ax_raw() 130 | self.irq_v[0][1] = self.ay_raw() 131 | self.irq_v[0][2] = self.az_raw() 132 | return self.irq_v[0] 133 | 134 | def get_g(self): 135 | self.irq_v[1][0] = self.gx_raw() 136 | self.irq_v[1][1] = self.gy_raw() 137 | self.irq_v[1][2] = self.gz_raw() 138 | return self.irq_v[1] 139 | 140 | def get(self): 141 | self.get_a_raw() 142 | self.get_g_raw() 143 | return self.irq_v 144 | 145 | def temperature(self): 146 | try: 147 | return self.int16(self.get2reg(LSM6DSO_OUT_TEMP_L))/256 + 25 148 | except MemoryError: 149 | return self.temperature_irq() 150 | 151 | def temperature_irq(self): 152 | self.getreg(LSM6DSO_OUT_TEMP_L+1) 153 | if self.rb[0] & 0x80: self.rb[0] -= 256 154 | return self.rb[0] + 25 155 | 156 | def scale_a(self, dat=None): 157 | if dat is None: 158 | return LSM6DSO_SCALEA[self._scale_a] 159 | else: 160 | if type(dat) is str: 161 | if not dat in LSM6DSO_SCALEA: return 162 | self._scale_a = LSM6DSO_SCALEA.index(dat) 163 | self._scale_a_c = int(dat.rstrip('g'))//2 164 | else: return 165 | self.r_w_reg(LSM6DSO_CTRL1_XL, self._scale_a<<2, 0xF3) 166 | 167 | def scale_g(self, dat=None): 168 | if (dat is None) or (dat == ''): 169 | return LSM6DSO_SCALEG[self._scale_g] 170 | else: 171 | if type(dat) is str: 172 | if not dat in LSM6DSO_SCALEG: return 173 | self._scale_g = LSM6DSO_SCALEG.index(dat) 174 | self._scale_g_c = int(dat)//125 175 | else: return 176 | self.r_w_reg(LSM6DSO_CTRL2_G, self._scale_g<<1, 0xF1) 177 | 178 | def power(self, on=None): 179 | if on is None: 180 | return self._power 181 | else: 182 | self._power = on 183 | if on: 184 | self.r_w_reg(LSM6DSO_CTRL1_XL, self._power_a, 0x0F) 185 | self.r_w_reg(LSM6DSO_CTRL2_G, self._power_g, 0x0F) 186 | else: 187 | self._power_a = self.getreg(LSM6DSO_CTRL1_XL) & 0xF0 188 | self._power_g = self.getreg(LSM6DSO_CTRL2_G) & 0xF0 189 | self.r_w_reg(LSM6DSO_CTRL1_XL, 0, 0x0F) 190 | self.r_w_reg(LSM6DSO_CTRL2_G, 0, 0x0F) 191 | -------------------------------------------------------------------------------- /sensor/LSM303AH/lsm303ah.py: -------------------------------------------------------------------------------- 1 | # LSM303AH: ST's ultra-low-power 3D accelerometer and 3D magnetometer micropython drive 2 | # ver: 1.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@mail.micropython.org.cn) 5 | # v1.0 2019.5 6 | 7 | LSM303AH_ADDR_A = const(0x1D) 8 | LSM303AH_ADDR_M = const(0x1E) 9 | 10 | LSM303AH_SCALEA = ('2g', '16g', '4g', '8g') 11 | LSM303AH_COEA = (1, 8, 2, 4) 12 | 13 | LSM303AH_WHO_AM_I_A = const(0x0F) 14 | LSM303AH_CTRL1_A = const(0x20) 15 | LSM303AH_CTRL2_A = const(0x21) 16 | LSM303AH_CTRL3_A = const(0x22) 17 | LSM303AH_CTRL4_A = const(0x23) 18 | LSM303AH_CTRL5_A = const(0x24) 19 | LSM303AH_FIFO_CTRL_A = const(0x25) 20 | LSM303AH_OUT_T_A = const(0x26) 21 | LSM303AH_STATUS_A = const(0x27) 22 | LSM303AH_OUT_X_L_A = const(0x28) 23 | LSM303AH_OUT_Y_L_A = const(0x2A) 24 | LSM303AH_OUT_Z_L_A = const(0x2C) 25 | 26 | LSM303AH_WHO_AM_I_M = const(0x4F) 27 | LSM303AH_CFG_REG_A_M = const(0x60) 28 | LSM303AH_CFG_REG_B_M = const(0x61) 29 | LSM303AH_CFG_REG_C_M = const(0x62) 30 | LSM303AH_INT_CTRL_REG_M = const(0x63) 31 | LSM303AH_INT_SOURCE_REG_M = const(0x64) 32 | LSM303AH_INT_THS_L_REG_M = const(0x65) 33 | LSM303AH_INT_THS_H_REG_M = const(0x66) 34 | 35 | LSM303AH_OUTX_L_REG_M = const(0x68) 36 | LSM303AH_OUTY_L_REG_M = const(0x6A) 37 | LSM303AH_OUTZ_L_REG_M = const(0x6C) 38 | 39 | 40 | class LSM303AH(): 41 | def __init__(self, i2c): 42 | self.i2c = i2c 43 | self.tb = bytearray(1) 44 | self.rb = bytearray(1) 45 | if self.getreg(LSM303AH_ADDR_A, 15) != 0x43 and self.getreg(LSM303AH_ADDR_M, 79) != 0x40: 46 | raise Exception('sensor ID error') 47 | self.irq_v = [[0, 0, 0], [0, 0, 0]] 48 | self._power = True 49 | self._power_a = 0x10 50 | self._power_m = 0x10 51 | self._scale_a = 0 52 | self._scale_m = 0 53 | self._mag_irq = 0 54 | # soft reset 55 | self.setreg(LSM303AH_ADDR_A, LSM303AH_CTRL2_A, 0x40) 56 | self.setreg(LSM303AH_ADDR_M, LSM303AH_CFG_REG_A_M, 0x20) 57 | # ODR_A=6 FS=0 58 | self.setreg(LSM303AH_ADDR_A, LSM303AH_CTRL1_A, 0x60) 59 | # ODR_M=0 MD=0 60 | self.setreg(LSM303AH_ADDR_M, LSM303AH_CFG_REG_A_M, 0x80) 61 | 62 | def int16(self, d): 63 | return d if d < 0x8000 else d - 0x10000 64 | 65 | def setreg(self, addr, reg, dat): 66 | self.tb[0] = dat 67 | self.i2c.writeto_mem(addr, reg, self.tb) 68 | 69 | def getreg(self, addr, reg): 70 | self.i2c.readfrom_mem_into(addr, reg, self.rb) 71 | return self.rb[0] 72 | 73 | def get2reg(self, addr, reg): 74 | return self.getreg(addr, reg) + self.getreg(addr, reg+1) * 256 75 | 76 | def r_w_reg(self, addr, reg, dat, mask): 77 | self.getreg(addr, reg) 78 | self.rb[0] = (self.rb[0] & mask) | dat 79 | self.setreg(addr, reg, self.rb[0]) 80 | 81 | def ax_raw(self): 82 | return self.int16(self.get2reg(LSM303AH_ADDR_A, LSM303AH_OUT_X_L_A)) 83 | 84 | def ay_raw(self): 85 | return self.int16(self.get2reg(LSM303AH_ADDR_A, LSM303AH_OUT_Y_L_A)) 86 | 87 | def az_raw(self): 88 | return self.int16(self.get2reg(LSM303AH_ADDR_A, LSM303AH_OUT_Z_L_A)) 89 | 90 | def a_raw(self): 91 | self.irq_v[0][0] = self.ax_raw() 92 | self.irq_v[0][1] = self.ay_raw() 93 | self.irq_v[0][2] = self.az_raw() 94 | return self.irq_v[0] 95 | 96 | def convert_a(self, a): 97 | return LSM303AH_COEA[self._scale_a]*0.061*a 98 | 99 | def ax(self): 100 | self.convert_a(self.ax_raw()) 101 | 102 | def ay(self): 103 | self.convert_a(self.ay_raw()) 104 | 105 | def az(self): 106 | self.convert_a(self.az_raw()) 107 | 108 | def a(self): 109 | self.irq_v[0][0] = self.ax() 110 | self.irq_v[0][1] = self.ay() 111 | self.irq_v[0][2] = self.az() 112 | return self.irq_v[0] 113 | 114 | def scale_a(self, dat=None): 115 | if dat is None: 116 | return LSM303AH_SCALEA[self._scale_a] 117 | else: 118 | if type(dat) is str: 119 | if not dat in LSM303AH_SCALEA: return 120 | self._scale_a = LSM303AH_SCALEA.index(dat) 121 | else: return 122 | self.r_w_reg(LSM303AH_ADDR_A, LSM303AH_CTRL1_A, self._scale_a<<2, 0xF3) 123 | 124 | def mx_raw(self): 125 | return self.int16(self.get2reg(LSM303AH_ADDR_M, LSM303AH_OUTX_L_REG_M)) 126 | 127 | def my_raw(self): 128 | return self.int16(self.get2reg(LSM303AH_ADDR_M, LSM303AH_OUTY_L_REG_M)) 129 | 130 | def mz_raw(self): 131 | return self.int16(self.get2reg(LSM303AH_ADDR_M, LSM303AH_OUTZ_L_REG_M)) 132 | 133 | def m_raw(self): 134 | self.irq_v[1][0] = self.mx_raw() 135 | self.irq_v[1][1] = self.my_raw() 136 | self.irq_v[1][2] = self.mz_raw() 137 | return self.irq_v[1] 138 | 139 | def mx(self): 140 | return self.mx_raw()*3//2 141 | 142 | def my(self): 143 | return self.my_raw()*3//2 144 | 145 | def mz(self): 146 | return self.mz_raw()*3//2 147 | 148 | def m(self): 149 | self.irq_v[1][0] = self.mx() 150 | self.irq_v[1][1] = self.my() 151 | self.irq_v[1][2] = self.mz() 152 | return self.irq_v[1] 153 | 154 | def mag_irq(self, on = None, pin = None, callback = None, ths = 0xC0): 155 | if on == None: 156 | return self._mag_irq 157 | elif on == True: 158 | self._mag_irq = 1 159 | self.setreg(LSM303AH_ADDR_M, LSM303AH_INT_THS_L_REG_M, ths) 160 | self.setreg(LSM303AH_ADDR_M, LSM303AH_INT_THS_H_REG_M, ths>>8) 161 | self.r_w_reg(LSM303AH_ADDR_M, LSM303AH_CFG_REG_C_M, 0x40, 0x3B) 162 | self.setreg(LSM303AH_ADDR_M, LSM303AH_INT_CTRL_REG_M, 0xE5) 163 | if pin != None and callback != None: 164 | pin.init(Pin.IN) 165 | pin.irq(handler=callback, trigger=Pin.IRQ_RISING) 166 | else: 167 | self._mag_irq = 0 168 | self.setreg(LSM303AH_ADDR_M, LSM303AH_INT_CTRL_REG_M, 0x00) 169 | 170 | def temperature(self): 171 | self.getreg(LSM303AH_ADDR_A, LSM303AH_OUT_T_A) 172 | if self.rb[0] > 127: self.rb[0] -= 256 173 | return self.rb[0] + 25 174 | 175 | def power(self, on=None): 176 | if on is None: 177 | return self._power 178 | else: 179 | self._power = on 180 | if on: 181 | self.r_w_reg(LSM303AH_ADDR_A, LSM303AH_CTRL1_A, self._power_a, 0x0F) 182 | self.r_w_reg(LSM303AH_ADDR_M, LSM303AH_CFG_REG_A_M, self._power_m, 0xFC) 183 | else: 184 | self._power_a = self.getreg(LSM303AH_CTRL1_A) & 0xF0 185 | self._power_m = self.getreg(LSM303AH_CFG_REG_A_M) & 0x03 186 | self.r_w_reg(LSM303AH_ADDR_A, LSM303AH_CTRL1_A, 0, 0x0F) 187 | self.r_w_reg(LSM303AH_ADDR_M, LSM303AH_CFG_REG_A_M, 3, 0x03) 188 | 189 | -------------------------------------------------------------------------------- /sensor/LSM6DS33/lsm6ds33.py: -------------------------------------------------------------------------------- 1 | # LSM6DS33: ST's always-on 3D accelerometer and 3D gyroscope micropython drive 2 | # ver: 1.0 3 | # License: MIT 4 | # Author: shaoziyang (shaoziyang@mail.micropython.org.cn) 5 | # v1.0 2019.5 6 | 7 | LSM6DS33_ORIENT_CFG_G = const(0x0B) 8 | LSM6DS33_INT1_CTRL = const(0x0D) 9 | LSM6DS33_INT2_CTRL = const(0x0E) 10 | LSM6DS33_CTRL1_XL = const(0x10) 11 | LSM6DS33_CTRL2_G = const(0x11) 12 | LSM6DS33_CTRL3_C = const(0x12) 13 | LSM6DS33_CTRL4_C = const(0x13) 14 | LSM6DS33_CTRL5_C = const(0x14) 15 | LSM6DS33_CTRL6_C = const(0x15) 16 | LSM6DS33_CTRL7_G = const(0x16) 17 | LSM6DS33_CTRL8_XL = const(0x17) 18 | LSM6DS33_CTRL9_XL = const(0x18) 19 | LSM6DS33_CTRL10_C = const(0x19) 20 | LSM6DS33_WAKE_UP_SRC = const(0x1B) 21 | LSM6DS33_STATUS = const(0x1E) 22 | LSM6DS33_OUT_TEMP_L = const(0x20) 23 | LSM6DS33_OUTX_L_G = const(0x22) 24 | LSM6DS33_OUTY_L_G = const(0x24) 25 | LSM6DS33_OUTZ_L_G = const(0x26) 26 | LSM6DS33_OUTX_L_XL = const(0x28) 27 | LSM6DS33_OUTY_L_XL = const(0x2A) 28 | LSM6DS33_OUTZ_L_XL = const(0x2C) 29 | LSM6DS33_TAP_CFG = const(0x58) 30 | LSM6DS33_WAKE_UP_THS = const(0x5B) 31 | LSM6DS33_WAKE_UP_DUR = const(0x5C) 32 | LSM6DS33_MD1_CFG = const(0x5E) 33 | LSM6DS33_MD2_CFG = const(0x5F) 34 | 35 | LSM6DS33_SCALEA = ('2g', '16g', '4g', '8g') 36 | LSM6DS33_COEA = (1, 8, 2, 4) 37 | LSM6DS33_SCALEG = ('250', '125', '500', '', '1000', '', '2000') 38 | LSM6DS33_COEG = (2, 1, 4, 0, 8, 0, 16) 39 | 40 | class LSM6DS33(): 41 | def __init__(self, i2c, addr = 0x6B): 42 | self.i2c = i2c 43 | self.addr = addr 44 | self.tb = bytearray(1) 45 | self.rb = bytearray(1) 46 | self.irq_v = [[0, 0, 0], [0, 0, 0]] 47 | self._power = True 48 | self._power_a = 0x10 49 | self._power_g = 0x10 50 | self._wakeup_mode = 0 51 | if self.getreg(15) != 0x69: 52 | raise Exception('sensor ID error') 53 | # RESET 54 | self.setreg(LSM6DS33_CTRL3_C, 1) 55 | # ODR_XL=6 FS_XL=0 56 | self.setreg(LSM6DS33_CTRL1_XL, 0x60) 57 | # ODR_G=4 FS=250 58 | self.setreg(LSM6DS33_CTRL2_G, 0x40) 59 | # BDU=1 IF_INC=1 60 | self.setreg(LSM6DS33_CTRL3_C, 0x44) 61 | self.setreg(LSM6DS33_CTRL8_XL, 0) 62 | # scale=2G 125dps 63 | self._scale_a = 0 64 | self._scale_g = 0 65 | 66 | def int16(self, d): 67 | return d if d < 0x8000 else d - 0x10000 68 | 69 | def setreg(self, reg, dat): 70 | self.tb[0] = dat 71 | self.i2c.writeto_mem(self.addr, reg, self.tb) 72 | 73 | def getreg(self, reg): 74 | self.i2c.readfrom_mem_into(self.addr, reg, self.rb) 75 | return self.rb[0] 76 | 77 | def get2reg(self, reg): 78 | return self.getreg(reg) + self.getreg(reg+1) * 256 79 | 80 | def r_w_reg(self, reg, dat, mask): 81 | self.getreg(reg) 82 | self.rb[0] = (self.rb[0] & mask) | dat 83 | self.setreg(reg, self.rb[0]) 84 | 85 | def ax_raw(self): 86 | return self.int16(self.get2reg(LSM6DS33_OUTX_L_XL)) 87 | 88 | def ay_raw(self): 89 | return self.int16(self.get2reg(LSM6DS33_OUTY_L_XL)) 90 | 91 | def az_raw(self): 92 | return self.int16(self.get2reg(LSM6DS33_OUTZ_L_XL)) 93 | 94 | def gx_raw(self): 95 | return self.int16(self.get2reg(LSM6DS33_OUTX_L_G)) 96 | 97 | def gy_raw(self): 98 | return self.int16(self.get2reg(LSM6DS33_OUTY_L_G)) 99 | 100 | def gz_raw(self): 101 | return self.int16(self.get2reg(LSM6DS33_OUTZ_L_G)) 102 | 103 | def a_raw(self): 104 | self.irq_v[0][0] = self.ax_raw() 105 | self.irq_v[0][1] = self.ay_raw() 106 | self.irq_v[0][2] = self.az_raw() 107 | return self.irq_v[0] 108 | 109 | def g_raw(self): 110 | self.irq_v[1][0] = self.gx_raw() 111 | self.irq_v[1][1] = self.gy_raw() 112 | self.irq_v[1][2] = self.gz_raw() 113 | return self.irq_v[1] 114 | 115 | def t_raw(self): 116 | return self.get2reg(LSM6DS33_OUT_TEMP_L) 117 | 118 | def temperature(self): 119 | try: 120 | return self.int16(self.t_raw())/16 + 25 121 | except MemoryError: 122 | return self.int16(self.t_raw())//16 + 25 123 | 124 | def scale_a(self, dat=None): 125 | if dat is None: 126 | return LSM6DS33_SCALEA[self._scale_a] 127 | else: 128 | if type(dat) is str: 129 | if not dat in LSM6DS33_SCALEA: return 130 | self._scale_a = LSM6DS33_SCALEA.index(dat) 131 | else: return 132 | self.r_w_reg(LSM6DS33_CTRL1_XL, self._scale_a<<2, 0xF3) 133 | 134 | def scale_g(self, dat=None): 135 | if (dat is None) or (dat == ''): 136 | return LSM6DS33_SCALEG[self._scale_g] 137 | else: 138 | if type(dat) is str: 139 | if not dat in LSM6DS33_SCALEG: return 140 | self._scale_g = LSM6DS33_SCALEG.index(dat) 141 | else: return 142 | self.r_w_reg(LSM6DS33_CTRL2_G, self._scale_g<<1, 0xF1) 143 | 144 | def wakeup_mode(self, on = None, pin = None, callback = None, ths = 0x20): 145 | if on == None: 146 | return self._wakeup_mode 147 | if on == True: 148 | self._wakeup_mode = 1 149 | # ENABLE SLOPE_FDS 150 | self.r_w_reg(LSM6DS33_TAP_CFG, 0x10, 0xEF) 151 | # WAKE_UP_THS = 20 152 | self.setreg(LSM6DS33_WAKE_UP_THS, ths) 153 | # INT1_WU=1 154 | self.r_w_reg(LSM6DS33_MD1_CFG, 0x20, 0xDF) 155 | if pin != None and callback != None: 156 | pin.init(Pin.IN) 157 | pin.irq(handler=callback, trigger=Pin.IRQ_RISING) 158 | else: 159 | self._wakeup_mode = 0 160 | self.r_w_reg(LSM6DS33_TAP_CFG, 0x00, 0xEF) 161 | self.r_w_reg(LSM6DS33_MD1_CFG, 0x00, 0xDF) 162 | 163 | def power(self, on=None): 164 | if on is None: 165 | return self._power 166 | else: 167 | self._power = on 168 | if on: 169 | self.r_w_reg(LSM6DS33_CTRL1_XL, self._power_a, 0x0F) 170 | self.r_w_reg(LSM6DS33_CTRL2_G, self._power_g, 0x0F) 171 | else: 172 | self._power_a = self.getreg(LSM6DS33_CTRL1_XL) & 0xF0 173 | self._power_g = self.getreg(LSM6DS33_CTRL2_G) & 0xF0 174 | self.r_w_reg(LSM6DS33_CTRL1_XL, 0, 0x0F) 175 | self.r_w_reg(LSM6DS33_CTRL2_G, 0, 0x0F) 176 | 177 | def convert_a(self, a): 178 | return LSM6DS33_COEA[self._scale_a]*0.061*a 179 | 180 | def convert_g(self, g): 181 | return LSM6DS33_COEG[self._scale_g]*4.375*g 182 | 183 | def ax(self): 184 | self.convert_a(self.ax_raw()) 185 | 186 | def ay(self): 187 | self.convert_a(self.ay_raw()) 188 | 189 | def az(self): 190 | self.convert_a(self.az_raw()) 191 | 192 | def gx(self): 193 | self.convert_g(self.gx_raw()) 194 | 195 | def gy(self): 196 | self.convert_g(self.gy_raw()) 197 | 198 | def gz(self): 199 | self.convert_g(self.gz_raw()) 200 | 201 | def a(self): 202 | self.irq_v[0][0] = self.ax() 203 | self.irq_v[0][1] = self.ay() 204 | self.irq_v[0][2] = self.az() 205 | return self.irq_v[0] 206 | 207 | def g(self): 208 | self.irq_v[1][0] = self.gx() 209 | self.irq_v[1][1] = self.gy() 210 | self.irq_v[1][2] = self.gz() 211 | return self.irq_v[1] 212 | -------------------------------------------------------------------------------- /lcd/3Wire-HT1621B-GDC03849/gdc03849.py: -------------------------------------------------------------------------------- 1 | # -*- coding:UTF-8 -*- 2 | 3 | ''' 4 | MIT License 5 | 6 | Copyright (c) 2018 Robin Chen 7 | 8 | Permission is hereby granted, free of charge, to any person obtaining a copy 9 | of this software and associated documentation files (the "Software"), to deal 10 | in the Software without restriction, including without limitation the rights 11 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 | copies of the Software, and to permit persons to whom the Software is 13 | furnished to do so, subject to the following conditions: 14 | 15 | The above copyright notice and this permission notice shall be included in all 16 | copies or substantial portions of the Software. 17 | 18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 21 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 24 | SOFTWARE. 25 | ''' 26 | 27 | '''/****************************************************************************** 28 | * File : gdc03849.py 29 | * Function : LCD Drive 30 | * Description: To be done. 31 | * Version : V1.00 32 | * Author : Robin Chen 33 | * Date : 9th May 2018 34 | * History : No. When Who What 35 | * 1 9/May/2018 Robin Chen Create 36 | * 2 30/May/2018 Robin Chen Complete package 37 | ******************************************************************************/''' 38 | 39 | class GDC03849: 40 | '''/****************************************************************************** 41 | * Name : __init__(self, _ht1621x) 42 | * Function : Init 43 | * Input : _ht1621x: object. 44 | * Output: : None. 45 | * Return : None. 46 | * Description: To be done. 47 | * Version : V1.00 48 | * Author : Robin Chen 49 | * Date : 9th May 2018 50 | ******************************************************************************/''' 51 | def __init__(self, _ht1621x): 52 | self.ht = _ht1621x 53 | self.ht.init() # Here you can add parameters as needed, currently using default parameters 54 | self.ht.LCDON() 55 | self.LCDALLSHOW() 56 | self.ht.HTBEEP(1) # Buzzer sounds for 1 second 57 | self.LCDALLCLEAR() 58 | 59 | # the hex list for (0-9、.) 60 | self.NUMCODE_RH_HEX = ((0x0D, 0x0F), # 0 61 | (0x08, 0x06), 62 | (0x0B, 0x0D), 63 | (0x0A, 0x0F), 64 | (0x0E, 0x06), 65 | (0x0E, 0x0B), 66 | (0x0F, 0x0B), 67 | (0x08, 0x0E), 68 | (0x0F, 0x0F), 69 | (0x0E, 0x0F)) # 9 70 | 71 | # the hex list for (0-9、.) 72 | self.NUMCODE_TEMP_HEX = ((0x0F, 0x0D), # 0 73 | (0x06, 0x08), 74 | (0x0B, 0x0E), 75 | (0x0F, 0x0A), 76 | (0x06, 0x0B), 77 | (0x0D, 0x0B), 78 | (0x0D, 0x0F), 79 | (0x07, 0x08), 80 | (0x0F, 0x0F), 81 | (0x0F, 0x0B)) # 9 82 | 83 | '''/****************************************************************************** 84 | * Name : viewTemp(self, _gdcdata) 85 | * Function : Init 86 | * Input : _gdcdata: value. 87 | * Output: : None. 88 | * Return : None. 89 | * Description: To be done. 90 | * Version : V1.00 91 | * Author : Robin Chen 92 | * Date : 9th May 2018 93 | ******************************************************************************/''' 94 | def viewTemp(self, _gdcdata): 95 | val = () 96 | stda = ('00000' + str(int(_gdcdata * 100)))[-5::] 97 | stda = list(stda)[::-1] 98 | for i in stda: 99 | val = val + self.NUMCODE_TEMP_HEX[int(i)] 100 | self.ht.HT1621xWrAllData(0x0A, val) 101 | return True 102 | 103 | '''/****************************************************************************** 104 | * Name : viewRH(self, _gdcdata) 105 | * Function : Value Show 106 | * Input : _gdcdata: value. 107 | * Output: : None. 108 | * Return : None. 109 | * Description: To be done. 110 | * Version : V1.00 111 | * Author : Robin Chen 112 | * Date : 9th May 2018 113 | ******************************************************************************/''' 114 | def viewRH(self, _gdcdata): 115 | val = () 116 | stda = ('00000' + str(int(_gdcdata * 100)))[-5::] 117 | for i in stda: 118 | val = val + self.NUMCODE_RH_HEX[int(i)] 119 | self.ht.HT1621xWrAllData(0x00, val) 120 | return True 121 | 122 | '''/****************************************************************************** 123 | * Name : LCDALLSHOW(self) 124 | * Function : LCD ALL Value Show 125 | * Input : None. 126 | * Output: : None. 127 | * Return : None. 128 | * Description: To be done. 129 | * Version : V1.00 130 | * Author : Robin Chen 131 | * Date : 9th May 2018 132 | ******************************************************************************/''' 133 | def LCDALLSHOW(self): 134 | self.ht.ALLSHOW(0x00, 20) 135 | return True 136 | 137 | '''/****************************************************************************** 138 | * Name : LCDALLCLEAR(self) 139 | * Function : LCD ALL Clear 140 | * Input : None. 141 | * Output: : None. 142 | * Return : None. 143 | * Description: To be done. 144 | * Version : V1.00 145 | * Author : Robin Chen 146 | * Date : 9th May 2018 147 | ******************************************************************************/''' 148 | def LCDALLCLEAR(self): 149 | self.ht.ALLCLEAR(0x00, 20) 150 | return True 151 | 152 | 153 | '''/****************************************************************************** 154 | * Name : TEMPCLEAR(self) 155 | * Function : Temp ALL Clear 156 | * Input : None. 157 | * Output: : None. 158 | * Return : None. 159 | * Description: To be done. 160 | * Version : V1.00 161 | * Author : Robin Chen 162 | * Date : 9th May 2018 163 | ******************************************************************************/''' 164 | def TEMPCLEAR(self): 165 | self.ht.ALLCLEAR(0x0A, 10) 166 | return True 167 | 168 | 169 | '''/****************************************************************************** 170 | * Name : RHCLEAR(self) 171 | * Function : RH ALL Clear 172 | * Input : None. 173 | * Output: : None. 174 | * Return : None. 175 | * Description: To be done. 176 | * Version : V1.00 177 | * Author : Robin Chen 178 | * Date : 9th May 2018 179 | ******************************************************************************/''' 180 | def RHCLEAR(self): 181 | self.ht.ALLCLEAR(0x00, 10) 182 | return True 183 | -------------------------------------------------------------------------------- /lcd/LCD1602_BIG_DIGITS/lcd1602_bigdigit.py: -------------------------------------------------------------------------------- 1 | ''' 2 | mpy drive for I2C LCD1602 Big Digits 3 | 4 | Author: shaoziyang 5 | Date: 2024.9 6 | 7 | https://www.micropython.org.cn 8 | 9 | ''' 10 | from i2c_lcd1602 import I2C_LCD1602 11 | 12 | BIGFONTS = { 13 | 'real':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1c\x02\x02\x01\x01\x02\x02\x1c\x07\x08\x08\x10\x10\x08\x08\x07\x1c\x04\x04\x04\x08\x08\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x08\x08\x07\x03\x04\x04\x08\x08\x10\x10\x1f',b'\x00T\x07\x07$S$4\x93\x07\x924\x92\x84&\x07TTT6'], 14 | 'real_bold':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1c\x0e\x06\x07\x07\x06\x0e\x1c\x07\x0e\x0c\x1c\x1c\x0c\x0e\x07\x1e\x06\x06\x06\x0c\x0c\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x1c\x0c\x0e\x07\x03\x06\x06\x0c\x0c\x18\x18\x1f',b'\x00T\x07\x07$S$4\x93\x07\x924\x92\x84&\x07TTT6'], 15 | 'rounded':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1c\x02\x01\x01\x01\x01\x02\x1c\x07\x08\x10\x10\x10\x10\x08\x07\x00\x00\x00\x10\x10\x10\x10\x1f\x10\x10\x10\x10\x10\x10\x10\x10\x01\x02\x04\x08\x00\x00\x00\x00\x10\x10\x10\x10\x10\x08\x04\x03',b'\x00T\x87\x07$S$4\x96\x07R4RT$\x07TTT4'], 16 | 'rounded_bold':[b'\x1f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x1c\x1e\x07\x03\x03\x07\x1e\x1c\x07\x0f\x1c\x18\x18\x1c\x0f\x07\x00\x00\x00\x18\x18\x18\x1f\x1f\x18\x18\x18\x18\x18\x18\x18\x18\x03\x07\x0e\x0c\x00\x00\x00\x00\x18\x18\x18\x18\x18\x0c\x07\x03',b'\x00T\x87\x07$S$4\x96\x07R4RT$\x07TTT4'], 17 | 'skewed':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x01\x01\x01\x02\x04\x08\x10\x01\x02\x04\x08\x10\x10\x10\x1f\x1f\x10\x10\x10\x10\x10\x10\x1f\x10\x10\x10\x10\x10\x10\x10\x10\x1f\x00\x00\x00\x00\x00\x00\x1f\x1f\x10\x10\x10\x10\x10\x10\x10',b'\x00d\x07\x07$S$4S\x07\x92\x84\x92d$\x07dd\x94$'], 18 | 'skewed_bold':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x03\x03\x03\x02\x04\x08\x10\x01\x02\x04\x08\x18\x18\x18\x1f\x1f\x18\x18\x18\x18\x18\x18\x1f\x18\x18\x18\x18\x18\x18\x18\x18\x1f\x00\x00\x00\x00\x00\x00\x1f\x1f\x18\x18\x18\x18\x18\x18\x18',b'\x00d\x07\x07$S$4S\x07\x92\x84\x92d$\x07dd\x94$'], 19 | 'dots_small':[b'\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x15\x00\x01\x00\x00\x01\x00\x15\x15\x00\x10\x00\x00\x10\x00\x15\x15\x00\x10\x00\x00\x10\x00\x10\x10\x00\x10\x00\x00\x10\x00\x10\x15\x00\x00\x00\x00\x00\x00\x15\x10\x00\x10\x00\x00\x10\x00\x15',b'g\x97\x07\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 20 | 'dots_big':[b'\x1b\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x1b\x1b\x1b\x00\x03\x03\x00\x1b\x1b\x1b\x1b\x00\x18\x18\x00\x1b\x1b\x1b\x1b\x00\x18\x18\x00\x18\x18\x18\x18\x00\x18\x18\x00\x18\x18\x1b\x1b\x00\x00\x00\x00\x1b\x1b\x18\x18\x00\x18\x18\x00\x1b\x1b',b'g\x97\x07\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 21 | 'dashed':[b'\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x1b\x01\x00\x01\x01\x00\x01\x1b\x1b\x10\x00\x10\x10\x00\x10\x1b\x1b\x10\x00\x10\x10\x00\x10\x10\x10\x10\x00\x10\x10\x00\x10\x10\x1b\x00\x00\x00\x00\x00\x00\x1b\x10\x10\x00\x10\x10\x00\x10\x1b',b'g\x97\x07\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 22 | 'dashed_bold':[b'\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x1b\x03\x00\x03\x03\x00\x03\x1b\x1b\x18\x00\x18\x18\x00\x18\x1b\x1b\x18\x00\x18\x18\x00\x18\x18\x18\x18\x00\x18\x18\x00\x18\x18\x1b\x00\x00\x00\x00\x00\x00\x1b\x18\x18\x00\x18\x18\x00\x18\x1b',b'g\x97\x07\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 23 | 'angled':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x01\x01\x01\x01\x01\x01\x1f\x1f\x10\x10\x10\x10\x10\x10\x1f\x1f\x01\x01\x01\x01\x01\x01\x01\x10\x10\x10\x10\x10\x10\x10\x10\x1f\x00\x00\x00\x00\x00\x00\x1f\x01\x01\x01\x01\x01\x01\x01\x1f',b'\x00T\x07\x07&X&4S\x07R4pT$\x07TTT\t'], 24 | 'angled_bold':[b'\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x03\x03\x03\x03\x03\x03\x1f\x1f\x18\x18\x18\x18\x18\x18\x1f\x1f\x03\x03\x03\x03\x03\x03\x03\x18\x18\x18\x18\x18\x18\x18\x18\x1f\x00\x00\x00\x00\x00\x00\x1f\x03\x03\x03\x03\x03\x03\x03\x1f',b'\x00T\x07\x07&X&4S\x07R4pT$\x07TTT\t'], 25 | 'blocks':[b'\x1f\x1f\x1f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x00\x00\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',b'\x11\x11\x01\x01!\x13!1\x13\x01\x121\x12\x11!\x01DU\x111'], 26 | 'blocks_crossed':[b'\x1f\x1f\x1f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x1f\x1f\x1e\x1d\x1b\x17\x0f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1e\x1d\x1f\x1f\x1f\x1f\x17\x0f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1e\x1d\x1b\x17\x0f\x1e\x1d\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x17\x0f',b"\x19\x81\x04\x01!C'1C\x01\x124\x12V!\x07VVV1"], 27 | 'blocks_cut':[b'\x1f\x1f\x1f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x1f\x1f\x1f\x01\x03\x07\x0f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x0f\x07\x03\x01\x10\x18\x1c\x1e\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1e\x1c\x18\x10\x00\x00\x00\x00\x00\x01\x03\x07\x1c\x18\x10\x00\x00\x00\x00\x00',b"A\x17\x04\x01'C!7C\x01\x127I\x17!\x07\x17AA\x87"], 28 | 'classic':[b'\x1f\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x1f\x1f\x03\x03\x03\x03\x03\x03\x1f\x1f\x18\x18\x18\x18\x18\x18\x1f\x01\x02\x04\x00\x00\x00\x00\x00\x18\x18\x18\x18\x18\x18\x18\x18\x1f\x00\x00\x00\x00\x00\x00\x1f\x18\x18\x18\x18\x18\x18\x18\x1f',b'\x00Tg\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 29 | 'classic_bold':[b'\x1f\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x1f\x1f\x07\x07\x07\x07\x07\x07\x1f\x1f\x1c\x1c\x1c\x1c\x1c\x1c\x1f\x01\x03\x07\x00\x00\x00\x00\x00\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1f\x00\x00\x00\x00\x00\x00\x1f\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1f',b'\x00Tg\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 30 | 'classic_serif':[b'\x1f\x1f\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x1f\x1f\x1f\x03\x03\x03\x03\x03\x03\x1f\x1f\x18\x18\x18\x18\x18\x18\x1f\x1f\x00\x00\x00\x00\x00\x1f\x1f\x18\x18\x18\x18\x18\x18\x18\x18\x1f\x1f\x00\x00\x00\x00\x00\x1f\x18\x18\x18\x18\x18\x18\x18\x1f',b'\x00T\x07\x07\x84V$4\x93\x07XdXT$\x07TTTd'], 31 | 'tron':[b'\x1f\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x1f\x1f\x03\x03\x03\x03\x03\x03\x03\x1f\x18\x18\x18\x18\x18\x18\x1f\x1f\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x18\x1f\x00\x00\x00\x00\x00\x00\x1f\x18\x18\x18\x18\x18\x18\x18\x1f',b'd\x91\x07\x07$X$1\x93\x07X1XQ$\x07TQT\x04'], 32 | 'tron_bold':[b'\x1f\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x1f\x1f\x07\x07\x07\x07\x07\x07\x07\x1f\x1c\x1c\x1c\x1c\x1c\x1c\x1f\x1f\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1f\x00\x00\x00\x00\x00\x00\x1f\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1f',b'd\x91\x07\x07$X$1\x93\x07X1XQ$\x07TQT\x04'], 33 | 'square_two':[b'\x1f\x1f\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x1f\x1f\x1f\x1f\x03\x03\x03\x03\x1f\x1f\x1f\x1f\x18\x18\x18\x18\x1f\x1f\x01\x03\x07\x00\x00\x00\x00\x00\x18\x18\x18\x18\x18\x18\x18\x18\x1f\x1f\x00\x00\x00\x00\x1f\x1f\x18\x18\x18\x18\x18\x18\x1f\x1f',b'\x00Tg\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 34 | 'square_three':[b'\x1f\x1f\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x1f\x1f\x1f\x1f\x07\x07\x07\x07\x1f\x1f\x1f\x1f\x1c\x1c\x1c\x1c\x1f\x1f\x01\x03\x07\x0f\x00\x00\x00\x00\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1c\x1f\x1f\x00\x00\x00\x00\x1f\x1f\x1c\x1c\x1c\x1c\x1c\x1c\x1f\x1f',b'\x11Tg\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 35 | 'square_four':[b'\x1f\x1f\x1c\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x1c\x1f\x1f\x1f\x1f\x0f\x0f\x0f\x0f\x1f\x1f\x1f\x1f\x1e\x1e\x1e\x1e\x1f\x1f\x01\x03\x07\x0f\x00\x00\x00\x00\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1f\x1f\x00\x00\x00\x00\x1f\x1f\x1e\x1e\x1e\x1e\x1e\x1e\x1f\x1f',b'\x11Tg\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 36 | 'square_five':[b'\x1f\x1f\x1f\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x1f\x1f\x1f\x1f\x1f\x1f\x0f\x0f\x1f\x1f\x1f\x1f\x1f\x1f\x1e\x1e\x1f\x1f\x1f\x01\x03\x07\x0f\x0f\x00\x00\x00\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1f\x1f\x1f\x00\x00\x1f\x1f\x1f\x1e\x1e\x1e\x1e\x1e\x1f\x1f\x1f',b'\x11Tg\x07\x84X$4\x93\x07X\x84XT$\x07TTT\x84'], 37 | } 38 | 39 | class LCD1602_BIGDIGIT(I2C_LCD1602): 40 | 41 | def __init__(self, i2c, addr=0): 42 | self.i2c = i2c 43 | self.addr = addr 44 | super().__init__(i2c, addr) 45 | self.fontdat = (bytearray(64), bytearray(20)) 46 | self.font('real') 47 | 48 | def font(self, fontname): 49 | try: 50 | self.fontdat = BIGFONTS[fontname] 51 | self.write_cgram(self.fontdat[0]) 52 | except: 53 | print('Load font error!') 54 | 55 | # show one digit 56 | def digit(self, n=0, pos=0): 57 | n = n%10 58 | d1 = self.fontdat[1][n*2+0] 59 | d2 = self.fontdat[1][n*2+1] 60 | self.char((d1//16-2)%256, pos, 0) 61 | self.char((d1%16-2)%256) 62 | self.char((d2//16-2)%256, pos, 1) 63 | self.char((d2%16-2)%256) 64 | 65 | # show number 66 | def number(self, num=1, bits=5): 67 | for i in range(bits): 68 | self.digit(num%10, 13-i*3) 69 | num //= 10 70 | --------------------------------------------------------------------------------