├── 8 Channel I2C POT Servo Controller ├── I2C_POT.py └── main.py ├── AK8975 Graphical Compass ├── AK8975.py ├── SSD1306_I2C.py └── main.py ├── BD Flag on 0.96 inch TFT ├── ST7735.py └── main.py ├── BME680 Environment Sensor Demo ├── BME680.py ├── ILI9341.py ├── bmp.py └── main.py ├── DHT22 and Waveshare OLED ├── SH1107.py ├── dht.py └── main.py ├── DS18B20 and Waveshare 1.8 inch TFT ├── ST7735.py └── main.py ├── DVK511 - BME280 Environment Sensor + SSD1306 ├── I2C │ ├── BME280_I2C.py │ ├── SSD1306_SPI.py │ └── main.py ├── Image │ └── art.jpg └── SPI │ ├── BME280_SPI.py │ ├── SSD1306_SPI.py │ └── main.py ├── DVK511 - MAX44009 Ambient Light Sensor (Soft I2C) ├── LCD.py ├── MAX44009.py └── main.py ├── DVK511 - MAX7219 + Dual LM35 └── main.py ├── DVK511 - PCF8563 RTCC ├── LCD.py ├── PCF8563.py └── main.py ├── DVK511 - TM1637 + MPL115A1 Barometer ├── MPL115A1.py ├── TM1637.py └── main.py ├── Digital Compass with HMC5883L and NeoPixel LEDs ├── HMC5883L.py └── main.py ├── Frequency Meter - EXTI ├── I2C_LCD.py ├── PCF8574.py └── main.py ├── GY-MCU68x Environment Sensor Demo ├── GY68x.py ├── ST7789.py └── main.py ├── Graphical Compass with HMC1022 (UART) and ST7735 TFT Display Pi HAT ├── HMC1022.py ├── ST7735.py └── main.py ├── HC-SR04 SONAR ├── SONAR.py ├── main.py └── segment_display.py ├── I2C LCD Test ├── I2C_LCD.py ├── PCF8574.py └── main.py ├── IR Range Finder with ToF050 (MODBUS) and ST7735 TFT Display Pi HAT ├── ST7735.py ├── ToF050.py └── main.py ├── IR Remote (Simplified) └── main.py ├── Internal RTCC ├── ST7735.py └── main.py ├── IoT ├── Network Clock │ ├── SH1107.py │ ├── WiFi.py │ └── main.py ├── PICO W Open Weather Map │ ├── ST7789_2in.py │ ├── main.py │ └── open_weather_map.py └── Weather Station with Weather Stack API │ ├── ST7735.py │ ├── WiFi.py │ └── main.py ├── MikroE Rotary Click + Waveshare 7 Segment Display ├── LED_circle.py ├── encoder.py ├── main.py └── segment_display.py ├── Musical Lights - LED SPL Meter (PWM) └── main.py ├── PICO UPS ├── INA219.py ├── ST7789.py └── main.py ├── PIO Codes ├── Alphanumerical LCD Driver │ ├── LCD_2x16.py │ └── main.py ├── DHT11 Sensor Demo │ ├── DHT.py │ ├── ST7789.py │ └── main.py ├── DHT22 Sensor Demo │ ├── DHT.py │ ├── ST7789.py │ └── main.py ├── Driving 7 Segment Displays with PIO - Murata Resistive Rotation Sensor │ └── main.py ├── Driving LCTech Dual 74HC164 Seven Segment Display Module with PIO (DHT11) │ ├── 74HC164 8 Digit 7 Segment Display.pdf │ └── main.py ├── Driving Waveshare 7 Segment Display with PIO and State Machine Periodic Interrupt (GP2Y3E) │ └── main.py ├── Driving Waveshare 7 Segment Display with PIO and Timer (TMP36) │ └── main.py ├── Frequency Counter │ └── main.py ├── HC-SR04 SONAR Demo │ ├── SONAR.py │ ├── ST7789.py │ └── main.py ├── Police Lights │ └── main.py ├── RGB Matrix BD Flag │ ├── RGB_Matrix.py │ └── main.py ├── RGB Matrix Random Pixels │ ├── RGB_Matrix.py │ └── main.py ├── RGB Matrix Thermometer │ ├── RGB_Matrix.py │ └── main.py ├── Rotary Encoder │ ├── SH1107.py │ └── main.py ├── TCS3200 Colour Sensor Demo │ ├── ST7789.py │ ├── TCS3200.py │ └── main.py ├── Traffic Lights │ └── main.py └── WG26 RFID Reader │ ├── SH1107.py │ └── main.py ├── Pioneer 600 - BMP280 Barometer (Weather Forecast) ├── BMP280.py ├── SSD1306_I2C.py ├── images │ ├── Cloudy.jpg │ ├── Rainy.jpg │ ├── Stormy.jpg │ └── Sunny.jpg └── main.py ├── Pioneer 600 - DS18B20 Graphical Thermometer ├── SSD1306_I2C.py ├── images │ └── img.jpg └── main.py ├── Pioneer 600 - DS3231 RTCC and PCF8574 IO Expander Demo ├── DS3231.py ├── PCF8574.py ├── SSD1306_I2C.py └── main.py ├── Pioneer 600 - NEC IR Remote Decoder ├── SSD1306_I2C.py └── main.py ├── Pioneer 600 - PCF8951 ADC-DAC + Graphical ADXL335 Accelerometer ├── SSD1306_I2C.py └── main.py ├── Police Lights - GPIO └── Police_Lights.py ├── RCWL-1605 UART SONAR Sensor Demo ├── RCWL1605.py ├── ST7735.py └── main.py ├── README.md ├── RGB Cylon └── main.py ├── SGP40 VoC Sensor and SHTC3 Temperature-Relative Humidity Sensor ├── SGP40.py ├── SHTC3.py ├── SSD1306_mini.py ├── VOC_Algorithm.py └── main.py ├── Seven Segment Thermometer - Timer ├── main.py └── segment_display.py ├── TFT Touch Colour Mixer ├── ST7789.py ├── XPT2046.py └── main.py └── Waveshare I2C RGB LCD Test ├── RGB_LCD_1602.py └── main.py /8 Channel I2C POT Servo Controller/I2C_POT.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import I2C 3 | from time import sleep_us 4 | from array import array 5 | 6 | 7 | POT_I2C_ADDRESS = const(0x20) 8 | 9 | POT_CH0_REG = const(0x50) 10 | POT_CH1_REG = const(0x52) 11 | POT_CH2_REG = const(0x54) 12 | POT_CH3_REG = const(0x56) 13 | POT_CH4_REG = const(0x58) 14 | POT_CH5_REG = const(0x5A) 15 | POT_CH6_REG = const(0x5C) 16 | POT_CH7_REG = const(0x5E) 17 | 18 | 19 | class I2C_POT(): 20 | def __init__(self, _i2c): 21 | self.i2c = _i2c 22 | self.i2c_address = POT_I2C_ADDRESS 23 | 24 | 25 | def read_channel_raw(self, ch): 26 | value = 0 27 | value = self.i2c.readfrom_mem(self.i2c_address, (POT_CH0_REG + (2 * ch)), 2) 28 | return ((value[1] << 8) | value[0]) 29 | 30 | 31 | def read_channel_avg(self, ch, avg_points = 4, sampling_delay = 100): 32 | i = 0 33 | avg = 0 34 | 35 | for i in range (0, avg_points, 1): 36 | avg += self.read_channel_raw(ch) 37 | sleep_us(sampling_delay) 38 | 39 | avg = int(avg / avg_points) 40 | return avg 41 | 42 | 43 | def read_all_channel_raw(self): 44 | i = 0 45 | raws = array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0]) 46 | 47 | for i in range (0, 8, 1): 48 | raws[i] = self.read_channel_raw(i) 49 | 50 | return raws[0], raws[1], raws[2], raws[3], raws[4], raws[5], raws[6], raws[7] 51 | 52 | 53 | def read_all_channel_avg(self, avg_points = 4, sampling_delay = 100): 54 | i = 0 55 | avgs = array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0]) 56 | 57 | for i in range (0, 8, 1): 58 | avgs[i] = self.read_channel_avg(i, avg_points, sampling_delay) 59 | 60 | return avgs[0], avgs[1], avgs[2], avgs[3], avgs[4], avgs[5], avgs[6], avgs[7] 61 | -------------------------------------------------------------------------------- /8 Channel I2C POT Servo Controller/main.py: -------------------------------------------------------------------------------- 1 | from array import array 2 | from micropython import const 3 | from machine import I2C, PWM, Pin 4 | from time import sleep_ms 5 | from I2C_POT import I2C_POT 6 | 7 | 8 | POT_MIN = const(0) 9 | POT_MAX = const(4095) 10 | 11 | SERVO_PIN_START = const(14) 12 | NO_OF_SERVOS = const(8) 13 | SERVO_PWM_FREQUENCY = const(50) 14 | 15 | SERVO_0 = const(3000) 16 | SERVO_90 = const(4915) 17 | SERVO_180 = const(7000) 18 | 19 | SERVO_ANGLE_MIN = const(0) 20 | SERVO_ANGLE_MAX = const(180) 21 | 22 | SAMPLING_TIME = const(10) 23 | 24 | 25 | i = 0 26 | pwm = 0 27 | pos = array('H', [0, 0, 0, 0, 0, 0, 0, 0]) 28 | servo = array('H', [0, 0, 0, 0, 0, 0, 0, 0]) 29 | 30 | servo = [None] * 8 31 | 32 | LED = Pin(25, Pin.OUT) 33 | 34 | i2c = I2C(0, scl = Pin(5), sda = Pin(4), freq = 100000) 35 | 36 | pot = I2C_POT(i2c) 37 | 38 | 39 | for i in range(0, NO_OF_SERVOS): 40 | servo[i] = PWM(Pin(SERVO_PIN_START + i)) 41 | servo[i].freq(SERVO_PWM_FREQUENCY) 42 | servo[i].duty_u16(SERVO_90) 43 | 44 | sleep_ms(3000) 45 | 46 | 47 | def map_value(v, x_min, x_max, y_min, y_max): 48 | value = int(y_min + (((y_max - y_min) / (x_max - x_min)) * (v - x_min))) 49 | value = constrain_value(value, y_max, y_min) 50 | return value 51 | 52 | 53 | def constrain_value(v, max_v, min_v): 54 | if(v >= max_v): 55 | v = max_v 56 | 57 | if(v <= min_v): 58 | v = min_v 59 | 60 | return v 61 | 62 | 63 | def set_servo_pos(channel, value): 64 | position = map_value(value, POT_MIN, POT_MAX, SERVO_0, SERVO_180) 65 | angle = map_value(position, SERVO_0, SERVO_180, SERVO_ANGLE_MIN, SERVO_ANGLE_MAX) 66 | servo[channel].duty_u16(position) 67 | print("CH " + str(channel) + ": " + str(angle)) 68 | 69 | 70 | def set_all_servos(): 71 | global pos 72 | pos = pot.read_all_channel_avg() 73 | for i in range(0, NO_OF_SERVOS): 74 | set_servo_pos(i, pos[i]) 75 | print("\r\n") 76 | 77 | 78 | while(True): 79 | LED.toggle() 80 | set_all_servos() 81 | sleep_ms(SAMPLING_TIME) 82 | 83 | -------------------------------------------------------------------------------- /AK8975 Graphical Compass/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import I2C, Pin 3 | from SSD1306_I2C import * 4 | from AK8975 import * 5 | from time import sleep_ms 6 | import math 7 | 8 | 9 | scale_factor = const(12) 10 | scale_factor_p = const(3) 11 | 12 | 13 | conv_factor = 0.0174532925 14 | pi_by_2 = 1.570796327 15 | 16 | 17 | state = False 18 | 19 | 20 | LED = Pin(17, Pin.OUT) 21 | Button = Pin(7, Pin.IN, Pin.PULL_UP) 22 | i2c = I2C(0, scl = Pin(9), sda = Pin(8), freq = 400000) 23 | 24 | 25 | oled = OLED1306(i2c) 26 | compass = AK8975(i2c) 27 | 28 | 29 | #compass.calibrate(); 30 | 31 | 32 | def draw_background(): 33 | oled.ellipse(32, 36, 1, 1, oled.WHITE, True) 34 | oled.ellipse(32, 36, 24, 24, oled.WHITE, False) 35 | oled.ellipse(32, 36, 26, 26, oled.WHITE, False) 36 | oled.text("RP2040 & AK8975", 1, 1, oled.WHITE) 37 | 38 | 39 | def draw_pointer(heading_in_degrees): 40 | global state 41 | 42 | heading_in_radians = (heading_in_degrees * conv_factor) 43 | 44 | h = int(scale_factor * math.sin(heading_in_radians)) 45 | v = int(scale_factor * math.cos(heading_in_radians)) 46 | 47 | if(state): 48 | if((heading > 0) and (heading <= 90)): 49 | hn = (32 + h) 50 | vn = (30 - v) 51 | hs = (26 - h) 52 | vs = (38 + v) 53 | 54 | elif((heading > 90) and (heading <= 180)): 55 | hn = (32 + h) 56 | vn = (36 - v) 57 | hs = (26 - h) 58 | vs = (30 + v) 59 | 60 | elif((heading > 180) and (heading <= 270)): 61 | hn = (26 + h) 62 | vn = (36 - v) 63 | hs = (32 - h) 64 | vs = (30 + v) 65 | 66 | else: 67 | hn = (26 + h) 68 | vn = (30 - v) 69 | hs = (32 - h) 70 | vs = (38 + v) 71 | 72 | 73 | oled.text("N", hn, vn, oled.WHITE) 74 | oled.text("S", hs, vs, oled.WHITE) 75 | 76 | else: 77 | oled.line(32, 36, (32 + h), (36 - v), oled.WHITE) 78 | 79 | vp = int(scale_factor_p * math.cos((heading_in_radians - pi_by_2))) 80 | hp = int(scale_factor_p * math.sin((heading_in_radians - pi_by_2))) 81 | oled.line(32, 36, (32 - hp), (36 + vp), oled.WHITE) 82 | oled.line(32, 36, (32 + hp), (36 - vp), oled.WHITE) 83 | 84 | oled.line((32 + h), (36 - v), (32 + hp), (36 - vp), oled.WHITE) 85 | oled.line((32 - h), (36 + v), (32 + hp), (36 - vp), oled.WHITE) 86 | oled.line((32 + h), (36 - v), (32 - hp), (36 + vp), oled.WHITE) 87 | oled.line((32 - h), (36 + v), (32 - hp), (36 + vp), oled.WHITE) 88 | 89 | oled.text(str("%3.1f N " %heading_in_degrees), 64, 32) 90 | oled.show() 91 | 92 | 93 | 94 | while(True): 95 | try: 96 | LED.on() 97 | 98 | if(Button.value() == False): 99 | while(Button.value() == False): 100 | LED.on() 101 | sleep_ms(40) 102 | LED.off() 103 | sleep_ms(40) 104 | state = not state 105 | 106 | x, y, z = compass.read_raw_magnetic_data() 107 | print(f"Raw: X = {x:04d}, Y = {y:04d}, Z = {z:04d}") 108 | 109 | x_uT, y_uT, z_uT = compass.read() 110 | print(f"Calibrated: X = {x_uT:4.2f} uT, Y = {y_uT:4.2f} uT, Z = {z_uT:4.2f} uT") 111 | 112 | heading = compass.heading(y, z) 113 | print(f"Heading: {heading:3.1f}°") 114 | 115 | directions = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'] 116 | index = round(heading / 45) % 8 117 | print(f"Direction: {directions[index]}") 118 | 119 | oled.fill(0x00) 120 | draw_background() 121 | draw_pointer(heading) 122 | sleep_ms(200) 123 | LED.off() 124 | sleep_ms(200) 125 | 126 | except Exception as e: 127 | print(f"Error: {e}") 128 | print("") 129 | sleep_ms(1000) 130 | 131 | 132 | -------------------------------------------------------------------------------- /BD Flag on 0.96 inch TFT/main.py: -------------------------------------------------------------------------------- 1 | from ST7735 import TFT096 2 | import utime 3 | import random 4 | import math 5 | 6 | 7 | lcd = TFT096() 8 | 9 | 10 | def circle(x,y,r,c): 11 | lcd.hline(x-r,y,r*2,c) 12 | for i in range(1,r): 13 | a = int(math.sqrt(r*r-i*i)) # Pythagoras! 14 | lcd.hline(x-a,y+i,a*2,c) # Lower half 15 | lcd.hline(x-a,y-i,a*2,c) # Upper half 16 | lcd.display() 17 | 18 | def ring(x,y,r,c): 19 | lcd.pixel(x-r,y,c) 20 | lcd.pixel(x+r,y,c) 21 | lcd.pixel(x,y-r,c) 22 | lcd.pixel(x,y+r,c) 23 | lcd.display() 24 | utime.sleep(0.1) 25 | for i in range(1,r): 26 | a = int(math.sqrt(r*r-i*i)) 27 | lcd.pixel(x-a,y-i,c) 28 | lcd.pixel(x+a,y-i,c) 29 | lcd.pixel(x-a,y+i,c) 30 | lcd.pixel(x+a,y+i,c) 31 | lcd.pixel(x-i,y-a,c) 32 | lcd.pixel(x+i,y-a,c) 33 | lcd.pixel(x-i,y+a,c) 34 | lcd.pixel(x+i,y+a,c) 35 | lcd.display() 36 | 37 | lcd.fill(lcd.GREEN) 38 | circle(80, 39, 20, lcd.RED) 39 | 40 | 41 | -------------------------------------------------------------------------------- /BME680 Environment Sensor Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from time import sleep_ms 3 | from ILI9341 import * 4 | from BME680 import * 5 | from bmp import image_data, image_width, image_height 6 | 7 | 8 | LED = Pin(25, Pin.OUT) 9 | i2c = I2C(id = 0, scl = Pin(21), sda = Pin(20), freq = 400000) 10 | 11 | disp = TFT_ILI9341() 12 | bme = BME680(i2c) 13 | 14 | back_colour = disp.colour_generator(90, 90, 90) 15 | 16 | 17 | def draw_icons(): 18 | idx = 0 19 | for y in range(image_height): 20 | for x in range(image_width): 21 | high = image_data[idx] 22 | low = image_data[idx + 1] 23 | color = (low << 8) | high # RGB565 24 | disp.pixel(x, y, color) 25 | idx += 2 26 | 27 | 28 | def write_text(text, x, y, size, color): 29 | background = disp.pixel(x, y) 30 | info = [] 31 | 32 | disp.text(text, x, y, color) 33 | for i in range(x, x + (8 * len(text))): 34 | for j in range(y, y + 8): 35 | px_color = disp.pixel(i, j) 36 | info.append((i, j, px_color)) if px_color == color else None 37 | 38 | disp.text(text, x, y, background) 39 | 40 | for px_info in info: 41 | disp.fill_rect(size*px_info[0] - (size-1)*x , size*px_info[1] 42 | - (size-1)*y, size, size, px_info[2]) 43 | 44 | 45 | 46 | while(True): 47 | LED.toggle() 48 | T, P, RH, G, A, Td, G_index, iaq = bme.read() 49 | 50 | disp.fill(back_colour) 51 | draw_icons() 52 | 53 | write_text("RP2350 RISC-V and BME680", 76, 2, 1, disp.WHITE) 54 | write_text(str("%2.2f deg C " %T), 72, 20, 2, disp.RED) 55 | write_text(str("%2.2f " %RH) + "% ", 72, 55, 2, disp.BLUE) 56 | write_text(str("%4.2f mBar " %P), 72, 90, 2, disp.GREEN) 57 | write_text(str("%2.2f deg C " %Td), 72, 135, 2, disp.CYAN) 58 | write_text(str("%2.2f " %iaq), 72, 175, 2, disp.MAGENTA) 59 | 60 | if((G_index <= 5)): 61 | write_text("Worst!", 72, 210, 2, disp.BLACK) 62 | elif((G_index > 5) and (G_index < 25)): 63 | write_text("Bad.", 72, 210, 2, disp.RED) 64 | elif((G_index >= 25) and (G_index < 50)): 65 | write_text("Moderate.", 72, 210, 2, disp.YELLOW) 66 | elif((G_index >= 50) and (G_index < 75)): 67 | write_text("Good.", 72, 210, 2, disp.CYAN) 68 | else: 69 | write_text("Excellent.", 72, 210, 2, disp.GREEN) 70 | 71 | disp.show() 72 | print(T, P, RH, G, A, Td, G_index, iaq) 73 | 74 | sleep_ms(1000) 75 | 76 | -------------------------------------------------------------------------------- /DHT22 and Waveshare OLED/SH1107.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SPI 3 | from utime import sleep_ms, sleep_us 4 | import framebuf 5 | 6 | 7 | DC_pin = const(8) 8 | CS_pin = const(9) 9 | SCK_pin = const(10) 10 | MOSI_pin = const(11) 11 | RST_pin = const(12) 12 | 13 | SH1107_SET_LOWER_COLUMN_ADDRESS = const(0x00) 14 | SH1107_SET_UPPER_COLUMN_ADDRESS = const(0x10) 15 | SH1107_SET_PAGE_MEMORY_ADDRESSING_MODE = const(0x20) 16 | SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE = const(0x21) 17 | SH1107_SET_CONSTRAST_CONTROL = const(0x81) 18 | SH1107_SET_DC_DC_OFF_MODE = const(0x8A) 19 | SH1107_SET_DC_DC_ON_MODE = const(0x8B) 20 | SH1107_SET_SEGMENT_REMAP_NORMAL = const(0xA0) 21 | SH1107_SET_SEGMENT_REMAP_REVERSE = const(0xA1) 22 | SH1107_SET_ENTIRE_DISPLAY_OFF = const(0xA4) 23 | SH1107_SET_ENTIRE_DISPLAY_ON = const(0xA5) 24 | SH1107_SET_NORMAL_DISPLAY = const(0xA6) 25 | SH1107_SET_REVERSE_DISPLAY = const(0xA7) 26 | SH1107_SET_MULTIPLEX_RATIO = const(0xA8) 27 | SH1107_SET_DC_DC_CONTROL_MODE = const(0xAD) 28 | SH1107_DISPLAY_OFF = const(0xAE) 29 | SH1107_DISPLAY_ON = const(0xAF) 30 | SH1107_SET_PAGE_ADDRESS = const(0xB0) 31 | SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION = const(0xC0) 32 | SH1107_SET_DISPLAY_OFFSET = const(0xD3) 33 | SH1107_SET_DISPLAY_CLOCK_FREQUENCY = const(0xD5) 34 | SH1107_SET_PRECHARGE_DISCHARGE_PERIOD = const(0xD9) 35 | SH1107_SET_VCOM_DESELECT_LEVEL = const(0xDB) 36 | SH1107_SET_DISPLAY_START_LINE = const(0xDC) 37 | 38 | CMD = False 39 | DAT = True 40 | 41 | LOW = False 42 | HIGH = True 43 | 44 | 45 | class OLED_13(framebuf.FrameBuffer): 46 | def __init__(self): 47 | self.width = 128 48 | self.height = 64 49 | 50 | self.WHITE = 1 51 | self.BLACK = 0 52 | 53 | self.cs = Pin(CS_pin, Pin.OUT) 54 | self.rst = Pin(RST_pin, Pin.OUT) 55 | self.sck = Pin(SCK_pin, Pin.OUT) 56 | self.mosi = Pin(MOSI_pin, Pin.OUT) 57 | 58 | self.cs(HIGH) 59 | 60 | self.spi = SPI(1, 20000_000, polarity = 0, phase = 0,sck = self.sck, mosi = self.mosi,miso = None) 61 | 62 | self.dc = Pin(DC_pin, Pin.OUT) 63 | self.dc(HIGH) 64 | 65 | self.buffer = bytearray(self.height * (self.width // 8)) 66 | super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HMSB) 67 | self.init_display() 68 | 69 | 70 | def write(self, value, mode): 71 | self.dc(mode) 72 | self.cs(LOW) 73 | self.spi.write(bytearray([value])) 74 | self.cs(HIGH) 75 | 76 | 77 | def init_display(self): 78 | self.rst(HIGH) 79 | sleep_ms(1) 80 | self.rst(LOW) 81 | sleep_ms(10) 82 | self.rst(HIGH) 83 | 84 | self.write(SH1107_DISPLAY_OFF, CMD) 85 | 86 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS | 0x00), CMD) 87 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS | 0x00), CMD) 88 | 89 | self.write((SH1107_SET_PAGE_ADDRESS | 0x00), CMD) 90 | 91 | self.write(SH1107_SET_DISPLAY_START_LINE, CMD) 92 | self.write(0x00, CMD) 93 | self.write(SH1107_SET_CONSTRAST_CONTROL, CMD) 94 | self.write(0x6F, CMD) 95 | self.write(SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE, CMD) 96 | 97 | self.write(SH1107_SET_SEGMENT_REMAP_NORMAL, CMD) 98 | self.write((SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION | 0x00), CMD) 99 | self.write(SH1107_SET_ENTIRE_DISPLAY_OFF, CMD) 100 | 101 | self.write(SH1107_SET_NORMAL_DISPLAY, CMD) 102 | self.write(SH1107_SET_MULTIPLEX_RATIO, CMD) 103 | self.write(0x3F, CMD) 104 | 105 | self.write(SH1107_SET_DISPLAY_OFFSET, CMD) 106 | self.write(0x60, CMD) 107 | 108 | self.write(SH1107_SET_DISPLAY_CLOCK_FREQUENCY, CMD) 109 | self.write(0x41, CMD) 110 | 111 | self.write(SH1107_SET_PRECHARGE_DISCHARGE_PERIOD, CMD) 112 | self.write(0x22, CMD) 113 | 114 | self.write(SH1107_SET_VCOM_DESELECT_LEVEL, CMD) 115 | self.write(0x35, CMD) 116 | 117 | self.write(SH1107_SET_DC_DC_CONTROL_MODE, CMD) 118 | self.write(SH1107_SET_DC_DC_OFF_MODE, CMD) 119 | self.write(SH1107_DISPLAY_ON, CMD) 120 | 121 | 122 | def show(self): 123 | self.write(SH1107_SET_PAGE_ADDRESS, CMD) 124 | for page in range(0, 64): 125 | self.column = (63 - page) 126 | 127 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS + (self.column & 0x0F)), CMD) 128 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS + (self.column >> 4)), CMD) 129 | 130 | for num in range(0, 16): 131 | self.write((self.buffer[(page * 16) + num]), DAT) 132 | 133 | -------------------------------------------------------------------------------- /DHT22 and Waveshare OLED/dht.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if sys.platform.startswith("esp"): 4 | from esp import dht_readinto 5 | elif sys.platform == "mimxrt": 6 | from mimxrt import dht_readinto 7 | elif sys.platform == "rp2": 8 | from rp2 import dht_readinto 9 | else: 10 | from pyb import dht_readinto 11 | 12 | 13 | class DHTBase: 14 | def __init__(self, pin): 15 | self.pin = pin 16 | self.buf = bytearray(5) 17 | 18 | def measure(self): 19 | buf = self.buf 20 | dht_readinto(self.pin, buf) 21 | if (buf[0] + buf[1] + buf[2] + buf[3]) & 0xFF != buf[4]: 22 | raise Exception("checksum error") 23 | 24 | 25 | class DHT11(DHTBase): 26 | def humidity(self): 27 | return self.buf[0] 28 | 29 | def temperature(self): 30 | return self.buf[2] 31 | 32 | 33 | class DHT22(DHTBase): 34 | def humidity(self): 35 | return (self.buf[0] << 8 | self.buf[1]) * 0.1 36 | 37 | def temperature(self): 38 | t = ((self.buf[2] & 0x7F) << 8 | self.buf[3]) * 0.1 39 | if self.buf[2] & 0x80: 40 | t = -t 41 | return t 42 | 43 | 44 | -------------------------------------------------------------------------------- /DHT22 and Waveshare OLED/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from SH1107 import OLED_13 3 | from utime import sleep_ms 4 | import math 5 | import dht 6 | 7 | LED = Pin(25, Pin.OUT) 8 | 9 | oled = OLED_13() 10 | RHT = dht.DHT22(Pin(28, Pin.IN)) 11 | 12 | 13 | def map_value(value, x_min, x_max, y_min, y_max): 14 | return (y_min + (((y_max - y_min)/(x_max - x_min)) * (value - x_min))) 15 | 16 | 17 | def circle(xc, yc, r, c): 18 | a = 0 19 | b = r 20 | p = (1 - b) 21 | 22 | while(a <= b): 23 | oled.pixel((xc + a), (yc + b), c) 24 | oled.pixel((xc + b), (yc + a), c) 25 | oled.pixel((xc - a), (yc + b), c) 26 | oled.pixel((xc - b), (yc + a), c) 27 | oled.pixel((xc + b), (yc - a), c) 28 | oled.pixel((xc + a), (yc - b), c) 29 | oled.pixel((xc - a), (yc - b), c) 30 | oled.pixel((xc - b), (yc - a), c) 31 | 32 | if(p < 0): 33 | p += (3 + (2 * a)) 34 | a += 1 35 | 36 | else: 37 | p += (5 + (2 * (a - b))) 38 | a += 1 39 | b -= 1 40 | 41 | 42 | while True: 43 | oled.fill(oled.BLACK) 44 | 45 | oled.text("Tmp/'C", 6, 1, oled.WHITE) 46 | oled.text("R.H./%", 73, 1, oled.WHITE) 47 | 48 | oled.text("30", 4, 35, oled.WHITE) 49 | oled.text("50", 25, 30, oled.WHITE) 50 | oled.text("70", 45, 35, oled.WHITE) 51 | 52 | oled.text("30", 65, 35, oled.WHITE) 53 | oled.text("50", 85, 30, oled.WHITE) 54 | oled.text("70", 105, 35, oled.WHITE) 55 | 56 | circle(33, 63, 25, oled.WHITE) 57 | circle(93, 63, 25, oled.WHITE) 58 | 59 | oled.hline(0, 10, 127, oled.WHITE) 60 | oled.hline(0, 28, 127, oled.WHITE) 61 | oled.vline(63, 0, 63, oled.WHITE) 62 | 63 | RHT.measure() 64 | t = RHT.temperature() 65 | rh = RHT.humidity() 66 | 67 | oled.text(str("% 2.1f" % t), 8, 16, oled.WHITE) 68 | oled.text(str("% 2.1f" % rh), 72, 16, oled.WHITE) 69 | 70 | l1 = map_value(t, 0, 100, -1.571, 1.571) 71 | l2 = map_value(rh, 0, 100, -1.571, 1.571) 72 | 73 | oled.line(33, 63, (33 + int(20 * math.sin(l1))), int(63 - (20 * math.cos(l1))), oled.WHITE) 74 | oled.line(93, 63, (93 + int(20 * math.sin(l2))), int(63 - (20 * math.cos(l2))), oled.WHITE) 75 | 76 | oled.show() 77 | 78 | LED.toggle() 79 | sleep_ms(100) 80 | 81 | 82 | 83 | -------------------------------------------------------------------------------- /DS18B20 and Waveshare 1.8 inch TFT/main.py: -------------------------------------------------------------------------------- 1 | from ST7735 import TFT18 2 | from machine import Pin 3 | from utime import sleep_ms 4 | from onewire import OneWire 5 | from ds18x20 import DS18X20 6 | import array as array 7 | 8 | 9 | LED = Pin(25, Pin.OUT) 10 | 11 | lcd = TFT18() 12 | 13 | ow = OneWire(Pin(28)) 14 | ds = DS18X20(ow) 15 | roms = ds.scan() 16 | 17 | 18 | def map_value(v, x_min, x_max, y_min, y_max): 19 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 20 | 21 | 22 | def circle(xc, yc, r, f, colour): 23 | a = 0 24 | b = r 25 | p = (1 - b) 26 | 27 | while(a <= b): 28 | if(f == True): 29 | lcd.line((xc - a), (yc + b), (xc + a), (yc + b), colour) 30 | lcd.line((xc - a), (yc - b), (xc + a), (yc - b), colour) 31 | lcd.line((xc - b), (yc + a), (xc + b), (yc + a), colour) 32 | lcd.line((xc - b), (yc - a), (xc + b), (yc - a), colour) 33 | 34 | else: 35 | lcd.pixel((xc + a), (yc + b), colour) 36 | lcd.pixel((xc + b), (yc + a), colour) 37 | lcd.pixel((xc - a), (yc + b), colour) 38 | lcd.pixel((xc - b), (yc + a), colour) 39 | lcd.pixel((xc + b), (yc - a), colour) 40 | lcd.pixel((xc + a), (yc - b), colour) 41 | lcd.pixel((xc - a), (yc - b), colour) 42 | lcd.pixel((xc - b), (yc - a), colour) 43 | 44 | if(p < 0): 45 | p += (3 + (2 * a)) 46 | a += 1 47 | 48 | else: 49 | p += (5 + (2 * (a - b))) 50 | a += 1 51 | b -= 1 52 | 53 | 54 | def draw_background(): 55 | lcd.text("Tmp 1", 15, 2, lcd.MAGENTA) 56 | lcd.text("Tmp 2", 72, 2, lcd.MAGENTA) 57 | 58 | circle(33, 145, 9 , False, lcd.WHITE) 59 | lcd.line(31, 139, 35, 139, lcd.BLACK) 60 | lcd.line(30, 137, 30, 34, lcd.WHITE) 61 | lcd.line(36, 137, 36, 34, lcd.WHITE) 62 | lcd.line(31, 33, 35, 33, lcd.WHITE) 63 | lcd.line(32, 33, 34, 33, lcd.BLACK) 64 | lcd.line(32, 32, 34, 32, lcd.WHITE) 65 | circle(33, 145, 7, True, lcd.RED) 66 | lcd.fill_rect(33, 137, 2, 1, lcd.RED) 67 | 68 | circle(93, 145, 9 , False, lcd.WHITE) 69 | lcd.line(91, 139, 95, 139, lcd.BLACK) 70 | lcd.line(90, 137, 90, 34, lcd.WHITE) 71 | lcd.line(96, 137, 96, 34, lcd.WHITE) 72 | lcd.line(91, 33, 95, 33, lcd.WHITE) 73 | lcd.line(92, 33, 94, 33, lcd.BLACK) 74 | lcd.line(92, 32, 94, 32, lcd.WHITE) 75 | circle(93, 145, 7, True, lcd.RED) 76 | lcd.fill_rect(93, 137, 2, 1, lcd.RED) 77 | 78 | for i in range (0, 100, 10): 79 | lcd.line(41, (41 + i), 43, (41 + i), lcd.YELLOW) 80 | lcd.line(83, (41 + i), 85, (41 + i), lcd.YELLOW) 81 | 82 | for i in range (0, 110, 10): 83 | lcd.line(41, (36 + i), 45, (36 + i), lcd.YELLOW) 84 | lcd.line(81, (36 + i), 85, (36 + i), lcd.YELLOW) 85 | 86 | lcd.text(str("%s" % (100 - int(1.5 * i))), 52, (36 + i), lcd.CYAN) 87 | 88 | 89 | def temp_bar(x_pos, y_pos, bar): 90 | for i in range (0, 3): 91 | lcd.line((x_pos + i), y_pos, (x_pos + i), bar, lcd.RED) 92 | 93 | 94 | while True: 95 | i = 0 96 | LED.toggle() 97 | tmp = array.array('f', [0, 0]) 98 | lcd.fill(lcd.BLACK) 99 | draw_background() 100 | 101 | ds.convert_temp() 102 | sleep_ms(750) 103 | 104 | for rom in roms: 105 | j = int.from_bytes(rom, "big") 106 | tmp[i] = ds.read_temp(rom) 107 | print("ROM Code: " + str("%08x" % j) + " - Temp/Deg. C: " + str("%2.1f" % tmp[i])) 108 | i += 1 109 | 110 | lcd.text(str("%2.1f" % tmp[0]), 18, 16, lcd.GREEN) 111 | lcd.text(str("%2.1f" % tmp[1]), 75, 16, lcd.GREEN) 112 | 113 | bar1 = map_value(tmp[0], -50, 100, 137, 36) 114 | bar2 = map_value(tmp[1], -50, 100, 137, 36) 115 | 116 | temp_bar(32, 137, bar1) 117 | temp_bar(92, 137, bar2) 118 | 119 | lcd.display() 120 | 121 | -------------------------------------------------------------------------------- /DVK511 - BME280 Environment Sensor + SSD1306/Image/art.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/DVK511 - BME280 Environment Sensor + SSD1306/Image/art.jpg -------------------------------------------------------------------------------- /DVK511 - MAX44009 Ambient Light Sensor (Soft I2C)/LCD.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms 3 | from micropython import const 4 | 5 | clear_display = const(0x01) 6 | goto_home = const(0x02) 7 | 8 | cursor_direction_inc = const(0x06) 9 | cursor_direction_dec = const(0x04) 10 | display_shift = const(0x05) 11 | display_no_shift = const(0x04) 12 | 13 | display_on = const(0x0C) 14 | display_off = const(0x0A) 15 | cursor_on = const(0x0A) 16 | cursor_off = const(0x08) 17 | blink_on = const(0x09) 18 | blink_off = const(0x08) 19 | 20 | _8_pin_interface = const(0x30) 21 | _4_pin_interface = const(0x20) 22 | _2_row_display = const(0x28) 23 | _1_row_display = const(0x20) 24 | _5x10_dots = const(0x60) 25 | _5x7_dots = const(0x20) 26 | 27 | line_1_y_pos = const(0x00) 28 | line_2_y_pos = const(0x40) 29 | line_3_y_pos = const(0x14) 30 | line_4_y_pos = const(0x54) 31 | 32 | dly = const(2) 33 | 34 | DAT = const(1) 35 | CMD = const(0) 36 | 37 | 38 | class LCD(): 39 | def __init__(self, RS, EN, D4, D5, D6, D7): 40 | self.rs = Pin(RS, Pin.OUT) 41 | self.en = Pin(EN, Pin.OUT) 42 | self.d4 = Pin(D4, Pin.OUT) 43 | self.d5 = Pin(D5, Pin.OUT) 44 | self.d6 = Pin(D6, Pin.OUT) 45 | self.d7 = Pin(D7, Pin.OUT) 46 | 47 | self.init() 48 | 49 | 50 | def write(self, value, mode): 51 | self.rs.value(mode) 52 | self.send(value) 53 | 54 | 55 | def send(self, value): 56 | self.d7.value(0x01 & (value >> 0x07)) 57 | self.d6.value(0x01 & (value >> 0x06)) 58 | self.d5.value(0x01 & (value >> 0x05)) 59 | self.d4.value(0x01 & (value >> 0x04)) 60 | self.toggle_en() 61 | self.d7.value(0x01 & (value >> 0x03)) 62 | self.d6.value(0x01 & (value >> 0x02)) 63 | self.d5.value(0x01 & (value >> 0x01)) 64 | self.d4.value(0x01 & value) 65 | self.toggle_en() 66 | 67 | 68 | def toggle_en(self): 69 | self.en.value(1) 70 | sleep_ms(dly) 71 | self.en.value(0) 72 | sleep_ms(dly) 73 | 74 | 75 | def clear_home(self): 76 | self.write(clear_display, CMD) 77 | self.write(goto_home, CMD) 78 | 79 | 80 | def goto_xy(self, x_pos, y_pos): 81 | if(y_pos == 1): 82 | self.write((0x80 | (line_2_y_pos + x_pos)), CMD) 83 | 84 | elif(y_pos == 2): 85 | self.write((0x80 | (line_3_y_pos + x_pos)), CMD) 86 | 87 | elif(y_pos == 3): 88 | self.write((0x80 | (line_4_y_pos + x_pos)), CMD) 89 | 90 | else: 91 | self.write((0x80 | (line_1_y_pos + x_pos)), CMD) 92 | 93 | 94 | def init(self): 95 | sleep_ms(dly) 96 | self.toggle_en() 97 | self.write(0x33, CMD) 98 | self.write(0x32, CMD) 99 | 100 | self.write((_4_pin_interface | _2_row_display | _5x7_dots), CMD) 101 | self.write((display_on | cursor_off | blink_off), CMD) 102 | self.write(clear_display, CMD) 103 | self.write((cursor_direction_inc | display_no_shift), CMD) 104 | 105 | 106 | def put_chr(self, ch): 107 | self.write(ord(ch), DAT) 108 | 109 | 110 | def put_str(self, ch_string): 111 | for chr in ch_string: 112 | self.put_chr(chr) 113 | 114 | -------------------------------------------------------------------------------- /DVK511 - MAX44009 Ambient Light Sensor (Soft I2C)/MAX44009.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SoftI2C 3 | from utime import sleep_ms 4 | 5 | 6 | MAX44009_address = const(0x4A) 7 | MAX44009_INTERRUPT_STATUS_REG = const(0x00) 8 | MAX44009_INTERRUPT_ENABLE_REG = const(0x01) 9 | MAX44009_CONFIGURATION_REG = const(0x02) 10 | MAX44009_LUX_HIGH_BYTE_REG = const(0x03) 11 | MAX44009_LUX_LOW_BYTE_REG = const(0x04) 12 | MAX44009_UPPER_THRESHOLD_HIGH_BYTE_REG = const(0x05) 13 | MAX44009_LOWER_THRESHOLD_HIGH_BYTE_REG = const(0x06) 14 | MAX44009_THRESHOLD_TIMER_REG = const(0x07) 15 | 16 | 17 | class MAX44009(): 18 | 19 | def __init__(self, _i2c, _i2c_address = MAX44009_address): 20 | self.I2C = _i2c 21 | self.I2C_address = _i2c_address 22 | self.init() 23 | 24 | 25 | def write(self, reg, value): 26 | if not type(value) is bytearray: 27 | value = bytearray([value]) 28 | 29 | self.I2C.writeto_mem(self.I2C_address, reg, value) 30 | 31 | 32 | def read(self, reg): 33 | return (self.I2C.readfrom_mem(self.I2C_address, reg, 1)[0]) 34 | 35 | 36 | def init(self): 37 | self.write(MAX44009_INTERRUPT_ENABLE_REG, 0x00) 38 | self.write(MAX44009_CONFIGURATION_REG, 0x03) 39 | self.write(MAX44009_THRESHOLD_TIMER_REG, 0xFF) 40 | 41 | 42 | def get_lux_value(self): 43 | HB = 0 44 | LB = 0 45 | exponent = 0 46 | mantisa = 0 47 | 48 | HB = self.read(MAX44009_LUX_HIGH_BYTE_REG) 49 | LB = self.read(MAX44009_LUX_LOW_BYTE_REG) 50 | 51 | exponent = ((HB & 0xF0) >> 4) 52 | mantisa = (((HB & 0x0F) << 4) | (LB & 0x0F)) 53 | 54 | while(exponent > -1): 55 | mantisa <<= 1 56 | exponent -= 1 57 | 58 | lx = (float(mantisa) * 0.045) 59 | return lx 60 | -------------------------------------------------------------------------------- /DVK511 - MAX44009 Ambient Light Sensor (Soft I2C)/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SoftI2C 3 | from utime import sleep_ms 4 | from MAX44009 import MAX44009 5 | from LCD import LCD 6 | 7 | 8 | LCD_RS = const(22) 9 | LCD_EN = const(10) 10 | LCD_D4 = const(18) 11 | LCD_D5 = const(11) 12 | LCD_D6 = const(12) 13 | LCD_D7 = const(28) 14 | 15 | 16 | LED = Pin(25, Pin.OUT) 17 | i2c = SoftI2C(scl=Pin(2), sda=Pin(3), freq=100000) 18 | light = MAX44009(i2c) 19 | lcd = LCD(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7) 20 | 21 | 22 | lcd.goto_xy(0, 0) 23 | lcd.put_str("MAX44009 RP2040") 24 | lcd.goto_xy(0, 1) 25 | lcd.put_str("ALS/lux:") 26 | 27 | while(True): 28 | lux = light.get_lux_value() 29 | lcd.goto_xy(9, 1) 30 | lcd.put_str(str("%5.1f " %lux)) 31 | print(str("%5.1f" %lux)) 32 | sleep_ms(400) -------------------------------------------------------------------------------- /DVK511 - MAX7219 + Dual LM35/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, ADC, SoftSPI 3 | from utime import sleep_ms 4 | from MAX72xx import MAX72xx 5 | 6 | 7 | adc0 = ADC(Pin(26)) 8 | adc1 = ADC(Pin(27)) 9 | 10 | spi = SoftSPI(baudrate=100000, polarity = 0, phase = 0, sck = Pin(10), mosi = Pin(12), miso = Pin(25)) 11 | dis = MAX72xx(spi, 11) 12 | 13 | 14 | def map_value_float(v, x_min, x_max, y_min, y_max): 15 | return (y_min + (((y_max - y_min) / (x_max - x_min)) * (v - x_min))) 16 | 17 | 18 | def constrain_value(v, max_v, min_v): 19 | if(v >= max_v): 20 | v = max_v 21 | 22 | if(v <= min_v): 23 | v = min_v 24 | 25 | return v 26 | 27 | 28 | def display_data(pos, value): 29 | dis.write((pos + 2), (value // 100)) 30 | dis.write((pos + 1), (((value // 10) % 10) | 0x80)) 31 | dis.write(pos, (value % 10)) 32 | 33 | 34 | def adc0_avg(): 35 | avg = 0 36 | for i in range (0, 64): 37 | avg += adc0.read_u16() 38 | 39 | return (avg >> 6) 40 | 41 | 42 | def adc1_avg(): 43 | avg = 0 44 | for i in range (0, 64): 45 | avg += adc1.read_u16() 46 | 47 | return (avg >> 6) 48 | 49 | 50 | while(True): 51 | T0 = adc0_avg() 52 | T0 = map_value_float(T0, 0, 65535, 0, 320) 53 | T0 = constrain_value(T0, 99.9, 0) 54 | display_data(6, int(T0 * 10)) 55 | print("LM35 T0: " + str("%2.1f" %T0)) 56 | 57 | T1 = adc1_avg() 58 | T1 = map_value_float(T1, 0, 65535, 0, 320) 59 | T1 = constrain_value(T1, 99.9, 0) 60 | display_data(1, int(T1 * 10)) 61 | print("LM35 T1: " + str("%2.1f" %T1)) 62 | 63 | print("\r\n") 64 | sleep_ms(400) -------------------------------------------------------------------------------- /DVK511 - PCF8563 RTCC/LCD.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms 3 | from micropython import const 4 | 5 | clear_display = const(0x01) 6 | goto_home = const(0x02) 7 | 8 | cursor_direction_inc = const(0x06) 9 | cursor_direction_dec = const(0x04) 10 | display_shift = const(0x05) 11 | display_no_shift = const(0x04) 12 | 13 | display_on = const(0x0C) 14 | display_off = const(0x0A) 15 | cursor_on = const(0x0A) 16 | cursor_off = const(0x08) 17 | blink_on = const(0x09) 18 | blink_off = const(0x08) 19 | 20 | _8_pin_interface = const(0x30) 21 | _4_pin_interface = const(0x20) 22 | _2_row_display = const(0x28) 23 | _1_row_display = const(0x20) 24 | _5x10_dots = const(0x60) 25 | _5x7_dots = const(0x20) 26 | 27 | line_1_y_pos = const(0x00) 28 | line_2_y_pos = const(0x40) 29 | line_3_y_pos = const(0x14) 30 | line_4_y_pos = const(0x54) 31 | 32 | dly = const(2) 33 | 34 | DAT = const(1) 35 | CMD = const(0) 36 | 37 | 38 | class LCD(): 39 | def __init__(self, RS, EN, D4, D5, D6, D7): 40 | self.rs = Pin(RS, Pin.OUT) 41 | self.en = Pin(EN, Pin.OUT) 42 | self.d4 = Pin(D4, Pin.OUT) 43 | self.d5 = Pin(D5, Pin.OUT) 44 | self.d6 = Pin(D6, Pin.OUT) 45 | self.d7 = Pin(D7, Pin.OUT) 46 | 47 | self.init() 48 | 49 | 50 | def write(self, value, mode): 51 | self.rs.value(mode) 52 | self.send(value) 53 | 54 | 55 | def send(self, value): 56 | self.d7.value(0x01 & (value >> 0x07)) 57 | self.d6.value(0x01 & (value >> 0x06)) 58 | self.d5.value(0x01 & (value >> 0x05)) 59 | self.d4.value(0x01 & (value >> 0x04)) 60 | self.toggle_en() 61 | self.d7.value(0x01 & (value >> 0x03)) 62 | self.d6.value(0x01 & (value >> 0x02)) 63 | self.d5.value(0x01 & (value >> 0x01)) 64 | self.d4.value(0x01 & value) 65 | self.toggle_en() 66 | 67 | 68 | def toggle_en(self): 69 | self.en.value(1) 70 | sleep_ms(dly) 71 | self.en.value(0) 72 | sleep_ms(dly) 73 | 74 | 75 | def clear_home(self): 76 | self.write(clear_display, CMD) 77 | self.write(goto_home, CMD) 78 | 79 | 80 | def goto_xy(self, x_pos, y_pos): 81 | if(y_pos == 1): 82 | self.write((0x80 | (line_2_y_pos + x_pos)), CMD) 83 | 84 | elif(y_pos == 2): 85 | self.write((0x80 | (line_3_y_pos + x_pos)), CMD) 86 | 87 | elif(y_pos == 3): 88 | self.write((0x80 | (line_4_y_pos + x_pos)), CMD) 89 | 90 | else: 91 | self.write((0x80 | (line_1_y_pos + x_pos)), CMD) 92 | 93 | 94 | def init(self): 95 | sleep_ms(dly) 96 | self.toggle_en() 97 | self.write(0x33, CMD) 98 | self.write(0x32, CMD) 99 | 100 | self.write((_4_pin_interface | _2_row_display | _5x7_dots), CMD) 101 | self.write((display_on | cursor_off | blink_off), CMD) 102 | self.write(clear_display, CMD) 103 | self.write((cursor_direction_inc | display_no_shift), CMD) 104 | 105 | 106 | def put_chr(self, ch): 107 | self.write(ord(ch), DAT) 108 | 109 | 110 | def put_str(self, ch_string): 111 | for chr in ch_string: 112 | self.put_chr(chr) 113 | 114 | -------------------------------------------------------------------------------- /DVK511 - PCF8563 RTCC/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, I2C 3 | from utime import sleep_ms 4 | from PCF8563 import PCF8563 5 | from LCD import LCD 6 | 7 | 8 | LCD_RS = const(22) 9 | LCD_EN = const(10) 10 | LCD_D4 = const(18) 11 | LCD_D5 = const(11) 12 | LCD_D6 = const(12) 13 | LCD_D7 = const(28) 14 | 15 | 16 | i = 0 17 | index = 0 18 | set_read = 0 19 | hour = 23 20 | minute = 59 21 | second = 45 22 | day = 1 23 | date = 31 24 | month = 12 25 | year = 21 26 | 27 | 28 | LED = Pin(25, Pin.OUT) 29 | BUZ = Pin(17, Pin.OUT) 30 | 31 | BUZ.on() 32 | 33 | A_Key = Pin(4, Pin.IN, Pin.PULL_UP) 34 | B_Key = Pin(5, Pin.IN, Pin.PULL_UP) 35 | C_Key = Pin(7, Pin.IN, Pin.PULL_UP) 36 | D_Key = Pin(8, Pin.IN, Pin.PULL_UP) 37 | 38 | lcd = LCD(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7) 39 | 40 | i2c =I2C(1, scl=Pin(3), sda=Pin(2), freq=100000) 41 | rtc = PCF8563(i2c) 42 | 43 | rtc.set(hour, minute, second, day, date, month, year) 44 | 45 | 46 | def set_parameter(value, value_max, value_min, x_pos, y_pos): 47 | if(D_Key.value() == False): 48 | BUZ.toggle() 49 | LED.toggle() 50 | sleep_ms(10) 51 | value += 1 52 | 53 | if(value > value_max): 54 | value = value_min 55 | 56 | if(A_Key.value() == False): 57 | BUZ.toggle() 58 | LED.toggle() 59 | sleep_ms(10) 60 | value -= 1 61 | 62 | if(value < value_min): 63 | value = value_max 64 | 65 | lcd.goto_xy(x_pos, y_pos) 66 | lcd.put_str(" ") 67 | sleep_ms(10) 68 | lcd.goto_xy(x_pos, y_pos) 69 | lcd.put_str(str("%02u" %value)) 70 | sleep_ms(10) 71 | BUZ.on() 72 | 73 | return value 74 | 75 | 76 | def RTC_run(): 77 | global set_read, i 78 | 79 | if(B_Key.value() == False): 80 | sleep_ms(60) 81 | if(B_Key.value() == False): 82 | BUZ.toggle() 83 | set_read = 1 84 | 85 | if(set_read == 1): 86 | set_time() 87 | elif(set_read == 0): 88 | rtc_read() 89 | rtc_display() 90 | 91 | 92 | def set_time(): 93 | global set_read, index, i, hour, minute, second, day, date, month, year 94 | 95 | lcd.goto_xy(0, 0) 96 | lcd.put_str("SET") 97 | 98 | if(C_Key.value() == False): 99 | BUZ.toggle() 100 | sleep_ms(40) 101 | index += 1 102 | 103 | if(index > 6): 104 | index = 6 105 | 106 | if(B_Key.value() == False): 107 | BUZ.toggle() 108 | sleep_ms(40) 109 | index -= 1 110 | 111 | if(index < 0): 112 | index = 0 113 | 114 | if(index == 0): 115 | lcd.goto_xy(0, 1) 116 | lcd.put_str("HR ") 117 | hour = set_parameter(hour, 23, 0, 4, 0) 118 | 119 | elif(index == 1): 120 | lcd.goto_xy(0, 1) 121 | lcd.put_str("MIN") 122 | minute = set_parameter(minute, 59, 0, 7, 0) 123 | 124 | elif(index == 2): 125 | lcd.goto_xy(0, 1) 126 | lcd.put_str("SEC") 127 | second = set_parameter(second, 59, 0, 10, 0) 128 | 129 | elif(index == 3): 130 | lcd.goto_xy(0, 1) 131 | lcd.put_str("DT ") 132 | date = set_parameter(date, 31, 1, 4, 1) 133 | 134 | elif(index == 4): 135 | lcd.goto_xy(0, 1) 136 | lcd.put_str("MTH") 137 | month = set_parameter(month, 12, 1, 7, 1) 138 | 139 | elif(index == 5): 140 | lcd.goto_xy(0, 1) 141 | lcd.put_str("YR ") 142 | year = set_parameter(year, 99, 0, 10, 1) 143 | 144 | elif(index == 6): 145 | day = 1 146 | rtc.set(hour, minute, second, day, date, month, year) 147 | lcd.goto_xy(0, 0) 148 | lcd.put_str(" ") 149 | lcd.goto_xy(0, 1) 150 | lcd.put_str(" ") 151 | BUZ.on() 152 | set_read = 0 153 | index = 0 154 | 155 | sleep_ms(100) 156 | 157 | 158 | def rtc_read(): 159 | global hour, minute, second, day, date, month, year 160 | 161 | hour, minute, second, day, date, month, year = rtc.get() 162 | 163 | 164 | def rtc_display(): 165 | global hour, minute, second, date, month, year 166 | lcd.goto_xy(4, 0) 167 | lcd.put_str(str("%02u:" %hour)) 168 | lcd.goto_xy(7, 0) 169 | lcd.put_str(str("%02u:" %minute)) 170 | lcd.goto_xy(10, 0) 171 | lcd.put_str(str("%02u" %second)) 172 | lcd.goto_xy(4, 1) 173 | lcd.put_str(str("%02u/" %date)) 174 | lcd.goto_xy(7, 1) 175 | lcd.put_str(str("%02u/" %month)) 176 | lcd.goto_xy(10, 1) 177 | lcd.put_str(str("%02u" %year)) 178 | LED.toggle() 179 | sleep_ms(990) 180 | 181 | 182 | while(True): 183 | RTC_run() 184 | 185 | 186 | 187 | 188 | -------------------------------------------------------------------------------- /DVK511 - TM1637 + MPL115A1 Barometer/MPL115A1.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | from utime import sleep_ms, sleep_us 4 | 5 | 6 | MPL115A1_PRESH = const(0x80) 7 | MPL115A1_PRESL = const(0x82) 8 | MPL115A1_TEMPH = const(0x84) 9 | MPL115A1_TEMPL = const(0x86) 10 | 11 | MPL115A1_A0_H = const(0x88) 12 | MPL115A1_A0_L = const(0x8A) 13 | MPL115A1_B1_H = const(0x8C) 14 | MPL115A1_B1_L = const(0x8E) 15 | MPL115A1_B2_H = const(0x90) 16 | MPL115A1_B2_L = const(0x92) 17 | MPL115A1_C12_H = const(0x94) 18 | MPL115A1_C12_L = const(0x96) 19 | 20 | MPL115A1_conv_cmd = const(0x24) 21 | 22 | 23 | coefficient_A0 = 0 24 | coefficient_B1 = 0 25 | coefficient_B2 = 0 26 | coefficient_C12 = 0 27 | 28 | 29 | class MPL115A1(): 30 | def __init__(self, _spi, _csn, _sdn): 31 | self.spi = _spi 32 | self.csn = Pin(_csn, Pin.OUT) 33 | self.sdn = Pin(_sdn, Pin.OUT) 34 | 35 | self.init() 36 | 37 | 38 | def init(self): 39 | self.sdn.on() 40 | self.csn.on() 41 | self.load_coefficients() 42 | 43 | 44 | def load_coefficients(self): 45 | global coefficient_A0, coefficient_B1, coefficient_B2, coefficient_C12 46 | 47 | HB = 0 48 | LB = 0 49 | 50 | HB, LB = self.read_word(MPL115A1_A0_H) 51 | coefficient_A0 = ((HB << 0x05) + (LB >> 0x03) + (float(LB & 0x07) / 8.0)) 52 | 53 | HB, LB = self.read_word(MPL115A1_B1_H) 54 | coefficient_B1 = (((float((HB & 0x1F) * 0x0100) + LB) / 8192.0) - 3.0) 55 | 56 | HB, LB = self.read_word(MPL115A1_B2_H) 57 | coefficient_B2 = ((float(((HB - 0x80) << 8) + LB) / 16384.0) - 2.0) 58 | 59 | HB, LB = self.read_word(MPL115A1_C12_H) 60 | coefficient_C12 = (float((HB * 0x100) + LB) / 16777216.0) 61 | 62 | 63 | def write(self, address, value): 64 | self.csn.off() 65 | sleep_ms(3) 66 | self.spi.write(bytearray([address & 0x7F])) 67 | self.spi.write(bytearray([value])) 68 | self.csn.on() 69 | 70 | 71 | def read_byte(self, address): 72 | value = 0 73 | self.csn.off() 74 | sleep_ms(3) 75 | self.spi.write(bytearray([address])) 76 | value = self.spi.read(0x02, address) 77 | self.csn.on() 78 | 79 | return value[0] 80 | 81 | 82 | def read_word(self, address): 83 | HB = self.read_byte(address) 84 | LB = self.read_byte(address + 0x02) 85 | 86 | return HB, LB 87 | 88 | 89 | def get_data(self): 90 | global coefficient_A0, coefficient_B1, coefficient_B2, coefficient_C12 91 | 92 | HB = 0 93 | LB = 0 94 | P_adc = 0 95 | T_adc = 0 96 | pressure = 0 97 | temperature = 0 98 | 99 | self.write(MPL115A1_conv_cmd, 0x00) 100 | 101 | HB, LB = self.read_word(MPL115A1_PRESH) 102 | P_adc = (((HB << 0x08) + LB) >> 0x06) 103 | 104 | HB, LB = self.read_word(MPL115A1_TEMPH) 105 | T_adc = (((HB << 0x08) + LB) >> 0x06) 106 | 107 | pressure = ( coefficient_A0 + (( coefficient_B1 + ( coefficient_C12 * T_adc)) * P_adc) + ( coefficient_B2 * T_adc)) 108 | pressure = (((pressure * 65.0) / 1023.0) + 50.0) 109 | 110 | temperature = (30.0 + ((T_adc - 472) / (-5.35))) 111 | 112 | return pressure, temperature 113 | -------------------------------------------------------------------------------- /DVK511 - TM1637 + MPL115A1 Barometer/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SoftSPI 3 | from utime import sleep_ms 4 | from TM1637 import TM1637 5 | from MPL115A1 import MPL115A1 6 | 7 | tm = TM1637(2, 3, 6) 8 | spi = SoftSPI(baudrate=100000, polarity = 0, phase = 0, sck = Pin(12), mosi = Pin(11), miso=Pin(10)) 9 | baro = MPL115A1(spi, 8, 7) 10 | 11 | while(True): 12 | P, T = baro.get_data() 13 | tm.put_str(0, str("%3u" %T)) 14 | tm.put_str(3, " 'C") 15 | sleep_ms(1600) 16 | tm.put_str(0, str("%3u" %P)) 17 | tm.put_str(3, "kPa") 18 | sleep_ms(1600) -------------------------------------------------------------------------------- /Digital Compass with HMC5883L and NeoPixel LEDs/HMC5883L.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from utime import sleep_ms 3 | import math 4 | 5 | 6 | HMC5883L_I2C_address = const(0x1E) 7 | 8 | HMC5883L_Config_Reg_A = const(0x00) 9 | HMC5883L_Config_Reg_B = const(0x01) 10 | HMC5883L_Mode_Reg = const(0x02) 11 | HMC5883L_X_MSB_Reg = const(0x03) 12 | HMC5883L_X_LSB_Reg = const(0x04) 13 | HMC5883L_Z_MSB_Reg = const(0x05) 14 | HMC5883L_Z_LSB_Reg = const(0x06) 15 | HMC5883L_Y_MSB_Reg = const(0x07) 16 | HMC5883L_Y_LSB_Reg = const(0x08) 17 | HMC5883L_Status_Reg = const(0x09) 18 | HMC5883L_ID_Reg_A = const(0x0A) 19 | HMC5883L_ID_Reg_B = const(0x0B) 20 | HMC5883L_ID_Reg_C = const(0x0C) 21 | 22 | HMC5883L_declination_angle = -0.5167 23 | 24 | 25 | class HMC5883L(): 26 | def __init__(self, _i2c): 27 | self.m_scale = 1.3 28 | 29 | self.i2c = _i2c 30 | 31 | self.init() 32 | 33 | 34 | def init(self): 35 | self.write(HMC5883L_Config_Reg_A, 0x70) 36 | self.write(HMC5883L_Config_Reg_B, 0xA0) 37 | self.write(HMC5883L_Mode_Reg, 0x00) 38 | self.set_scale(self.m_scale) 39 | 40 | 41 | def write(self, reg, value): 42 | if not type(value) is bytearray: 43 | value = bytearray([value]) 44 | 45 | self.i2c.writeto_mem(HMC5883L_I2C_address, reg, value) 46 | 47 | 48 | def read_byte(self, reg): 49 | retval = self.i2c.readfrom_mem(HMC5883L_I2C_address, reg, 0x01) 50 | return retval[0x00] 51 | 52 | 53 | def read_word(self, reg): 54 | value = self.i2c.readfrom_mem(HMC5883L_I2C_address, reg, 0x02) 55 | 56 | retval = value[0x00] 57 | retval <<= 0x08 58 | retval |= value[0x01] 59 | 60 | return retval 61 | 62 | 63 | def read_signed_word(self, address): 64 | retval = self.read_word(address) 65 | 66 | if(retval > 32767): 67 | retval -= 65536 68 | 69 | return retval 70 | 71 | 72 | def set_scale(self, gauss): 73 | if (gauss == 0.88): 74 | value = 0x00 75 | self.m_scale = 0.73 76 | 77 | elif (gauss == 1.3): 78 | value = 0x01 79 | self.m_scale = 0.92 80 | 81 | elif (gauss == 1.9): 82 | value = 0x02 83 | self.m_scale = 1.22 84 | 85 | elif (gauss == 2.5): 86 | value = 0x03 87 | self.m_scale = 1.52 88 | 89 | elif (gauss == 4.0): 90 | value = 0x04 91 | self.m_scale = 2.27 92 | 93 | elif (gauss == 4.7): 94 | value = 0x05 95 | self.m_scale = 2.56 96 | 97 | elif (gauss == 5.6): 98 | value = 0x06 99 | self.m_scale = 3.03 100 | 101 | elif (gauss == 8.1): 102 | value = 0x07 103 | self.m_scale = 4.35 104 | 105 | value = (value << 0x05) 106 | self.write(HMC5883L_Config_Reg_B, value) 107 | 108 | 109 | def get_raw_data(self): 110 | x_axis = (float(self.read_signed_word(HMC5883L_X_MSB_Reg)) * self.m_scale) 111 | z_axis = (float(self.read_signed_word(HMC5883L_Z_MSB_Reg)) * self.m_scale) 112 | y_axis = (float(self.read_signed_word(HMC5883L_Y_MSB_Reg)) * self.m_scale) 113 | 114 | return x_axis, y_axis, z_axis 115 | 116 | 117 | def get_heading(self): 118 | x_axis, y_axis, z_axis = self.get_raw_data() 119 | h = math.atan2(y_axis, x_axis) 120 | h += HMC5883L_declination_angle 121 | h = (h * (180.0 / math.pi)) 122 | 123 | if(h < 0.0): 124 | h += 360 125 | 126 | if(h > 360): 127 | h -= 360 128 | 129 | return h 130 | 131 | -------------------------------------------------------------------------------- /Digital Compass with HMC5883L and NeoPixel LEDs/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from utime import sleep_ms 3 | from neopixel import NeoPixel 4 | from HMC5883L import HMC5883L 5 | 6 | 7 | pin = Pin(14, Pin.OUT) 8 | np = NeoPixel(pin, 24) 9 | 10 | i2c = I2C(1, sda = Pin(2), scl = Pin(3), freq = 100000) 11 | compass = HMC5883L(i2c) 12 | 13 | 14 | while(True): 15 | 16 | h = compass.get_heading() 17 | print(h) 18 | 19 | for i in range (0, 24): 20 | np[i] = (60, 0, 0) 21 | i = (h / 15) 22 | 23 | np[int(i)] = (0, 0 , 90) 24 | np.write() 25 | 26 | sleep_ms(400) -------------------------------------------------------------------------------- /Frequency Meter - EXTI/I2C_LCD.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from PCF8574 import PCF8574_IO 3 | import utime 4 | 5 | 6 | clear_display = const(0x01) 7 | goto_home = const(0x02) 8 | 9 | cursor_direction_inc = const(0x06) 10 | cursor_direction_dec = const(0x04) 11 | display_shift = const(0x05) 12 | display_no_shift = const(0x04) 13 | 14 | display_on = const(0x0C) 15 | display_off = const(0x0A) 16 | cursor_on = const(0x0A) 17 | cursor_off = const(0x08) 18 | blink_on = const(0x09) 19 | blink_off = const(0x08) 20 | 21 | _8_pin_interface = const(0x30) 22 | _4_pin_interface = const(0x20) 23 | _2_row_display = const(0x28) 24 | _1_row_display = const(0x20) 25 | _5x10_dots = const(0x60) 26 | _5x7_dots = const(0x20) 27 | 28 | line_1_y_pos = const(0x00) 29 | line_2_y_pos = const(0x40) 30 | line_3_y_pos = const(0x14) 31 | line_4_y_pos = const(0x54) 32 | 33 | BL_ON = const(1) 34 | BL_OFF = const(0) 35 | 36 | DAT = const(1) 37 | CMD = const(0) 38 | 39 | 40 | io_ex = 0 41 | bl_state = 0 42 | data_value = 0 43 | 44 | 45 | class TWI_LCD(): 46 | 47 | def __init__(self, i2c, i2c_addr): 48 | global io_ex 49 | global data_value 50 | global bl_state 51 | 52 | self.i2c = i2c 53 | self.i2c_addr = i2c_addr 54 | io_ex = PCF8574_IO(i2c, i2c_addr) 55 | utime.sleep_ms(10) 56 | 57 | bl_state = BL_ON 58 | data_value |= 0x04 59 | io_ex.PCF8574_write_byte(data_value) 60 | utime.sleep_ms(10) 61 | self.send_data(0x33, CMD) 62 | self.send_data(0x32, CMD) 63 | self.send_data((_4_pin_interface | _2_row_display | _5x7_dots), CMD) 64 | self.send_data((display_on | cursor_off | blink_off), CMD) 65 | self.send_data(clear_display, CMD) 66 | self.send_data((cursor_direction_inc | display_no_shift), CMD) 67 | 68 | def send_data(self, send_value, mode): 69 | global data_value 70 | global bl_state 71 | global io_ex 72 | 73 | if(mode == CMD): 74 | data_value &= 0xF4 75 | else: 76 | data_value |= 0x01 77 | 78 | if(bl_state == BL_ON): 79 | data_value |= 0x08 80 | else: 81 | data_value &= 0xF7 82 | 83 | io_ex.PCF8574_write_byte(data_value) 84 | self.quad_bit_send(send_value) 85 | utime.sleep_ms(1) 86 | 87 | def toggle_EN(self): 88 | global data_value 89 | data_value |= 0x04 90 | io_ex.PCF8574_write_byte(data_value) 91 | utime.sleep_ms(1) 92 | data_value &= 0xF9 93 | io_ex.PCF8574_write_byte(data_value) 94 | utime.sleep_ms(1) 95 | 96 | def quad_bit_send(self, lcd_data): 97 | global data_value 98 | temp = (lcd_data & 0xF0) 99 | data_value &= 0x0F 100 | data_value |= temp 101 | io_ex.PCF8574_write_byte(data_value) 102 | self.toggle_EN() 103 | temp = (lcd_data & 0x0F) 104 | temp <<= 0x04 105 | data_value &= 0x0F 106 | data_value |= temp 107 | io_ex.PCF8574_write_byte(data_value) 108 | self.toggle_EN() 109 | 110 | def clr_home(self): 111 | self.send_data(clear_display, CMD) 112 | self.send_data(goto_home, CMD) 113 | 114 | def goto_pos(self, x_pos, y_pos): 115 | if(y_pos == 0): 116 | self.send_data((0x80 | x_pos), CMD) 117 | else: 118 | self.send_data((0xC0 | x_pos), CMD) 119 | 120 | def put_chr(self, ch): 121 | self.send_data(ord(ch), DAT) 122 | 123 | def put_str(self, ch_string): 124 | for chr in ch_string: 125 | self.put_chr(chr) 126 | -------------------------------------------------------------------------------- /Frequency Meter - EXTI/PCF8574.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | 3 | 4 | class PCF8574_IO(): 5 | 6 | def __init__(self, i2c, i2c_addr): 7 | self.i2c = i2c 8 | self.i2c_addr = i2c_addr 9 | 10 | def PCF8574_write_byte(self, value): 11 | self.i2c.writeto(self.i2c_addr, bytes([value])) 12 | 13 | def PCF8574_read_byte(self, mask): 14 | self.PCF8574_write_byte(mask) 15 | retval = self.i2c.readfrom(self.i2c_addr, 1) 16 | return retval[0] 17 | -------------------------------------------------------------------------------- /Frequency Meter - EXTI/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from I2C_LCD import TWI_LCD 3 | from utime import sleep_ms, ticks_diff, ticks_us 4 | 5 | 6 | lcd_port = I2C(1, scl=Pin(3), sda=Pin(2), freq=20_000) 7 | lcd = TWI_LCD(lcd_port, 0x27) 8 | 9 | 10 | f = 0 11 | trap = True 12 | t_diff = 0 13 | first_edge = 0 14 | second_edge = 0 15 | 16 | 17 | interrupt_channel = Pin(15, Pin.IN) 18 | 19 | def interrupt_handler(pin): 20 | global t_diff, trap, first_edge, second_edge 21 | 22 | interrupt_channel.irq(handler = None) 23 | 24 | if(trap == True): 25 | first_edge = ticks_us() 26 | else: 27 | second_edge = ticks_us() 28 | t_diff = ticks_diff(second_edge, first_edge) 29 | 30 | trap = not trap 31 | 32 | interrupt_channel.irq(handler = interrupt_handler) 33 | 34 | interrupt_channel.irq(trigger = Pin.IRQ_FALLING, handler = interrupt_handler) 35 | 36 | 37 | lcd.clr_home 38 | lcd.goto_pos(0, 0) 39 | lcd.put_str("Frequency/Hz:") 40 | 41 | 42 | while True: 43 | f = (500000 / (t_diff)) 44 | print('F/Hz:' + str(f)) 45 | lcd.goto_pos(0, 1) 46 | lcd.put_str(str("%4.2f " % f)) 47 | sleep_ms(100) 48 | 49 | -------------------------------------------------------------------------------- /GY-MCU68x Environment Sensor Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, UART 2 | from utime import sleep_ms, 3 | from ST7789 import TFT208 4 | from GY68x import GY68x 5 | import framebuf 6 | import math 7 | 8 | 9 | uart = UART(1, baudrate = 9600, bits = 8, parity = None, stop = 1, tx = Pin(4), rx = Pin(5)) 10 | 11 | tft = TFT208() 12 | gy = GY68x(uart) 13 | 14 | 15 | def circle(xc, yc, r, c): 16 | a = 0 17 | b = r 18 | p = (1 - b) 19 | 20 | while(a <= b): 21 | tft.pixel((xc + a), (yc + b), c) 22 | tft.pixel((xc + b), (yc + a), c) 23 | tft.pixel((xc - a), (yc + b), c) 24 | tft.pixel((xc - b), (yc + a), c) 25 | tft.pixel((xc + b), (yc - a), c) 26 | tft.pixel((xc + a), (yc - b), c) 27 | tft.pixel((xc - a), (yc - b), c) 28 | tft.pixel((xc - b), (yc - a), c) 29 | 30 | if(p < 0): 31 | p += (3 + (2 * a)) 32 | a += 1 33 | 34 | else: 35 | p += (5 + (2 * (a - b))) 36 | a += 1 37 | b -= 1 38 | 39 | 40 | def map_value(v, x_min, x_max, y_min, y_max): 41 | return (y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 42 | 43 | 44 | def constrain(value, min_value, max_value): 45 | if(value > max_value): 46 | return max_value 47 | 48 | elif(value < min_value): 49 | return min_value 50 | 51 | else: 52 | return value 53 | 54 | 55 | def draw_background_graphics(): 56 | tft.fill(0x1248) 57 | 58 | tft.text("RP2040 GY-MCU68x Environment Sensor", 20, 10, tft.WHITE) 59 | 60 | circle(40, 100, 2, tft.RED) 61 | circle(120, 100, 2, tft.GREEN) 62 | circle(200, 100, 2, tft.YELLOW) 63 | circle(280, 100, 2, tft.MAGENTA) 64 | 65 | for i in range (0, 320, 80): 66 | circle((40 + i), 100, 34, tft.WHITE) 67 | circle((40 + i), 100, 36, tft.WHITE) 68 | 69 | tft.text("T/deg C", 15, 45, tft.WHITE) 70 | tft.text("RH/%", 106, 45, tft.WHITE) 71 | tft.text("P/mbar", 175, 45, tft.WHITE) 72 | tft.text("Gas/k Ohms", 232, 45, tft.WHITE) 73 | 74 | tft.rect(8, 200, 304, 24, tft.WHITE) 75 | tft.fill_rect(10, 202, 50, 20, tft.BLUE) 76 | tft.fill_rect(60, 202, 50, 20, tft.CYAN) 77 | tft.fill_rect(110, 202, 50, 20, tft.GREEN) 78 | tft.fill_rect(160, 202, 50, 20, tft.YELLOW) 79 | tft.fill_rect(210, 202, 50, 20, tft.RED) 80 | tft.fill_rect(260, 202, 50, 20, tft.MAGENTA) 81 | 82 | tft.text("<100", 20, 208, tft.BLACK) 83 | tft.text("100", 75, 208, tft.BLACK) 84 | tft.text("200", 125, 208, tft.BLACK) 85 | tft.text("300", 175, 208, tft.BLACK) 86 | tft.text("400", 225, 208, tft.BLACK) 87 | tft.text("500", 275, 208, tft.BLACK) 88 | 89 | 90 | def draw_dial(x_pos, y_pos, value, value_min, value_max, colour): 91 | temp = constrain(value, value_min, value_max) 92 | line = map_value(temp, value_min, value_max, -2.618, 2.618) 93 | tft.line(x_pos, y_pos, (x_pos + int(30 * math.sin(line))), int(y_pos - (30 * math.cos(line))), colour) 94 | 95 | 96 | def draw_pointer(value, value_min, value_max): 97 | temp = constrain(value, value_min, value_max) 98 | temp = int(map_value(temp, value_min, value_max, 10, 310)) 99 | tft.line(temp, 194, (temp - 4), 190, tft.WHITE) 100 | tft.line(temp, 194, (temp + 4), 190, tft.WHITE) 101 | tft.line((temp - 4), 190, (temp + 4), 190, tft.WHITE) 102 | 103 | 104 | 105 | while(True): 106 | draw_background_graphics() 107 | 108 | t, rh, p, iaq, gas, alt = gy.get_data() 109 | 110 | tft.text(str("%2.1f" %t), 25, 145, tft.WHITE) 111 | tft.text(str("%2.1f" %rh), 105, 145, tft.WHITE) 112 | tft.text(str("%3.1f" %p), 185, 145, tft.WHITE) 113 | tft.text(str("%3.1f" %gas), 270, 145, tft.WHITE) 114 | tft.text(("IAQ: " + str("%3.1f" %iaq)), 130, 170, tft.WHITE) 115 | 116 | draw_dial(40, 100, t, gy.t_min, gy.t_max, tft.RED) 117 | draw_dial(120, 100, rh, gy.rh_min, gy.rh_max, tft.GREEN) 118 | draw_dial(200, 100, p, gy.p_min, gy.p_max, tft.YELLOW) 119 | draw_dial(280, 100, gas, gy.gas_min, gy.gas_max, tft.MAGENTA) 120 | draw_pointer(iaq, gy.iaq_min, gy.iaq_max) 121 | 122 | 123 | tft.show() 124 | 125 | sleep_ms(100) 126 | -------------------------------------------------------------------------------- /Graphical Compass with HMC1022 (UART) and ST7735 TFT Display Pi HAT/HMC1022.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import UART, Pin 3 | from utime import sleep_ms 4 | 5 | 6 | HMC1022_I2C_Address = const(0xE0) 7 | 8 | HMC1022_Get_Angular_Measurement = const(0x31) 9 | HMC1022_Start_Calibration = const(0xC0) 10 | HMC1022_End_Calibration = const(0xC1) 11 | HMC1022_Set_Magnetic_Declination_High_Byte = const(0x03) 12 | HMC1022_Set_Magnetic_Declination_Low_Byte = const(0x04) 13 | 14 | HMC1022_max_no_of_bytes_to_send = const(0x04) 15 | HMC1022_max_no_of_bytes_to_read = const(0x08) 16 | 17 | 18 | class HMC1022(): 19 | def __init__(self, _uart, _pin): 20 | self.tx_data = bytearray(HMC1022_max_no_of_bytes_to_send) 21 | self.rx_data = bytearray(HMC1022_max_no_of_bytes_to_read) 22 | self.calibration_LED = Pin(_pin, Pin.OUT) 23 | self.uart = _uart 24 | 25 | 26 | def get_heading(self): 27 | i = 0x00 28 | h = -1 29 | CRC = 0x00 30 | temp = bytearray(HMC1022_max_no_of_bytes_to_read) 31 | 32 | self.tx_data[0x00] = HMC1022_Get_Angular_Measurement 33 | self.tx_data[0x01] = 0x00 34 | self.tx_data[0x02] = 0x00 35 | self.tx_data[0x03] = 0x00 36 | 37 | self.uart.write(self.tx_data) 38 | 39 | if(self.uart.any() > 0x00): 40 | self.rx_data = self.uart.read(HMC1022_max_no_of_bytes_to_read) 41 | 42 | if(self.rx_data[0x00] == 0x0D): 43 | if(self.rx_data[0x01] == 0x0A): 44 | if(self.rx_data[0x05] == 0x2E): 45 | for i in range (0x00, 0x07): 46 | CRC += self.rx_data[i] 47 | 48 | if((CRC & 0xFF) == self.rx_data[0x07]): 49 | for i in range (0x02, 0x07): 50 | temp[i] = (self.rx_data[i] - 0x30) 51 | 52 | h = (float(temp[0x02]) * 100.0) 53 | h += (float(temp[0x03]) * 10.0) 54 | h += (float(temp[0x04]) * 1.0) 55 | h += (float(temp[0x06]) * 0.1) 56 | 57 | else: 58 | h = -1 59 | 60 | return h 61 | 62 | 63 | def calibrate(self): 64 | i = 0 65 | self.tx_data[0x00] = HMC1022_Start_Calibration 66 | self.tx_data[0x01] = 0x00 67 | self.tx_data[0x02] = 0x00 68 | self.tx_data[0x03] = 0x00 69 | 70 | self.uart.write(self.tx_data) 71 | 72 | for i in range (0, 60): 73 | self.calibration_LED.on() 74 | sleep_ms(100) 75 | self.calibration_LED.off() 76 | sleep_ms(990) 77 | 78 | for i in range (0, 60): 79 | self.calibration_LED.on() 80 | sleep_ms(400) 81 | self.calibration_LED.off() 82 | sleep_ms(600) 83 | 84 | self.tx_data[0x00] = HMC1022_End_Calibration 85 | self.uart.write(self.tx_data) 86 | 87 | 88 | def factory_reset(self): 89 | self.tx_data[0x00] = 0xA0 90 | self.tx_data[0x01] = 0xAA 91 | self.tx_data[0x02] = 0xA5 92 | self.tx_data[0x03] = 0xC5 93 | 94 | self.uart.write(self.tx_data) 95 | 96 | 97 | def set_I2C_address(self, new_I2C_address): 98 | self.tx_data[0x00] = 0xA0 99 | self.tx_data[0x01] = 0xAA 100 | self.tx_data[0x02] = 0xA5 101 | self.tx_data[0x03] = new_I2C_address 102 | 103 | self.uart.write(self.tx_data) 104 | 105 | 106 | def set_declination_angle(self, angle): 107 | hb = 0x00 108 | lb = 0x00 109 | 110 | lb = (angle & 0x00FF) 111 | 112 | hb = (angle & 0xFF00) 113 | hb >>= 0x08 114 | 115 | self.tx_data[0x00] = HMC1022_Set_Magnetic_Declination_High_Byte 116 | self.tx_data[0x01] = hb 117 | self.tx_data[0x02] = HMC1022_Set_Magnetic_Declination_Low_Byte 118 | self.tx_data[0x03] = lb 119 | 120 | self.uart.write(self.tx_data) 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /Graphical Compass with HMC1022 (UART) and ST7735 TFT Display Pi HAT/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import UART, Pin 3 | from utime import sleep_ms 4 | from HMC1022 import HMC1022 5 | from ST7735 import TFT_144 6 | import math 7 | 8 | 9 | scale_factor_1 = const(42) 10 | scale_factor_2 = const(6) 11 | 12 | 13 | conv_factor = 0.0174532925 14 | pi_by_2 = 1.570796327 15 | 16 | 17 | LED = Pin(25, Pin.OUT) 18 | 19 | tft = TFT_144() 20 | 21 | uart = UART(1, baudrate = 9600, tx = Pin(4), rx = Pin(5)) 22 | compass = HMC1022(uart, 18) 23 | 24 | 25 | def circle(xc, yc, r, f, colour): 26 | a = 0 27 | b = r 28 | p = (1 - b) 29 | 30 | while(a <= b): 31 | if(f == True): 32 | tft.line((xc - a), (yc + b), (xc + a), (yc + b), colour) 33 | tft.line((xc - a), (yc - b), (xc + a), (yc - b), colour) 34 | tft.line((xc - b), (yc + a), (xc + b), (yc + a), colour) 35 | tft.line((xc - b), (yc - a), (xc + b), (yc - a), colour) 36 | 37 | else: 38 | tft.pixel((xc + a), (yc + b), colour) 39 | tft.pixel((xc + b), (yc + a), colour) 40 | tft.pixel((xc - a), (yc + b), colour) 41 | tft.pixel((xc - b), (yc + a), colour) 42 | tft.pixel((xc + b), (yc - a), colour) 43 | tft.pixel((xc + a), (yc - b), colour) 44 | tft.pixel((xc - a), (yc - b), colour) 45 | tft.pixel((xc - b), (yc - a), colour) 46 | 47 | if(p < 0): 48 | p += (3 + (2 * a)) 49 | a += 1 50 | 51 | else: 52 | p += (5 + (2 * (a - b))) 53 | a += 1 54 | b -= 1 55 | 56 | 57 | def draw_background(): 58 | circle(63, 60, 48, False, tft.RED) 59 | circle(63, 60, 46, False, tft.RED) 60 | circle(63, 60, 4, True, tft.BLUE) 61 | 62 | tft.text("N", 60, 1, tft.GREEN) 63 | tft.text(" N", 80, 115, tft.WHITE) 64 | 65 | 66 | while(True): 67 | tft.fill(tft.BLACK) 68 | 69 | heading_in_degrees = compass.get_heading() 70 | tft.text(str("%03.1f" %heading_in_degrees), 40, 115, tft.WHITE) 71 | 72 | heading_in_radians = (heading_in_degrees * conv_factor) 73 | v1 = int(scale_factor_1 * math.cos(heading_in_radians)) 74 | h1 = int(scale_factor_1 * math.sin(heading_in_radians)) 75 | tft.line(63, 60, (63 + h1), (60 - v1), tft.YELLOW) 76 | 77 | v2 = int(scale_factor_2 * math.cos((heading_in_radians - pi_by_2))) 78 | h2 = int(scale_factor_2 * math.sin((heading_in_radians - pi_by_2))) 79 | tft.line(63, 60, (63 - h2), (60 + v2), tft.CYAN) 80 | tft.line(63, 60, (63 + h2), (60 - v2), tft.CYAN) 81 | 82 | tft.line((63 + h1), (60 - v1), (63 + h2), (60 - v2), tft.CYAN) 83 | tft.line((63 - h1), (60 + v1), (63 + h2), (60 - v2), tft.CYAN) 84 | tft.line((63 + h1), (60 - v1), (63 - h2), (60 + v2), tft.CYAN) 85 | tft.line((63 - h1), (60 + v1), (63 - h2), (60 + v2), tft.CYAN) 86 | 87 | draw_background() 88 | tft.show() 89 | 90 | LED.toggle() 91 | sleep_ms(600) 92 | -------------------------------------------------------------------------------- /HC-SR04 SONAR/SONAR.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_us, ticks_us 3 | 4 | 5 | class SONAR(): 6 | def __init__(self, _trigger, _echo, _pulse_time, _timeout, _scaling_factor): 7 | self.timeout = _timeout 8 | self.pulse_time = _pulse_time 9 | self.scaling_factor = _scaling_factor 10 | self.echo = Pin(_echo, Pin.IN) 11 | self.trigger = Pin(_trigger, Pin.OUT) 12 | 13 | self.trigger.low() 14 | 15 | 16 | def trigger_sensor(self): 17 | self.trigger.high() 18 | sleep_us(self.pulse_time) 19 | self.trigger.low() 20 | 21 | 22 | def get_range(self): 23 | self.trigger_sensor() 24 | 25 | cnt = 0 26 | while((cnt < self.timeout) and (self.echo.value() == False)): 27 | cnt += 1 28 | sleep_us(1) 29 | 30 | t1 = ticks_us() 31 | 32 | cnt = 0 33 | while((cnt < self.timeout) and (self.echo.value() == True)): 34 | cnt += 1 35 | sleep_us(1) 36 | 37 | t2 = ticks_us() 38 | 39 | d = (t2 - t1) 40 | if(d < 0): 41 | d = 0 42 | 43 | d = int(d / self.scaling_factor) 44 | 45 | return d 46 | 47 | -------------------------------------------------------------------------------- /HC-SR04 SONAR/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, Timer 2 | from segment_display import seg_disp 3 | from utime import sleep_ms, sleep_us, ticks_us 4 | from SONAR import SONAR 5 | 6 | 7 | seg = 0 8 | value = 0 9 | 10 | 11 | def timer_callback(t): 12 | global value, seg 13 | 14 | if(seg == 0): 15 | val = ((value % 10000) // 1000) 16 | elif(seg == 1): 17 | val = ((value % 1000) // 100) 18 | elif(seg == 2): 19 | val = ((value % 100) // 10) 20 | else: 21 | val = (value % 10) 22 | 23 | disp.send_data(val, seg, False) 24 | seg += 1 25 | 26 | if(seg > 3): 27 | seg = 0 28 | 29 | 30 | tim = Timer(mode = Timer.PERIODIC, period = 1, callback = timer_callback) 31 | disp = seg_disp() 32 | LED = Pin(25, Pin.OUT) 33 | hcsr04 = SONAR(3, 2, 10, 38000, 5.8) 34 | 35 | 36 | while(True): 37 | value = hcsr04.get_range() 38 | print(value) 39 | LED.toggle() 40 | sleep_ms(400) 41 | 42 | 43 | -------------------------------------------------------------------------------- /HC-SR04 SONAR/segment_display.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | 4 | mosi_pin = const(11) 5 | sck_pin = const(10) 6 | rclk_pin = const(9) 7 | 8 | 9 | seg_code_list = [ 10 | 0x3F, # 0 11 | 0x06, # 1 12 | 0x5B, # 2 13 | 0x4F, # 3 14 | 0x66, # 4 15 | 0x6D, # 5 16 | 0x7D, # 6 17 | 0x07, # 7 18 | 0x7F, # 8 19 | 0x6F, # 9 20 | 0x77, # A 21 | 0x7C, # b 22 | 0x39, # C 23 | 0x5E, # d 24 | 0x79, # E 25 | 0x71 # F 26 | ] 27 | 28 | seg_pos_list = [ 29 | 0xFE, # 1st 30 | 0xFD, # 2nd 31 | 0xDB, # 3rd 32 | 0xF7, # 4th 33 | ] 34 | 35 | 36 | class seg_disp(): 37 | 38 | def __init__(self): 39 | self.mosi = Pin(mosi_pin, Pin.OUT) 40 | self.sck = Pin(sck_pin, Pin.OUT) 41 | self.rclk = Pin(rclk_pin, Pin.OUT) 42 | 43 | def send_data(self, value, pos, dot): 44 | clks = 16 45 | temp = seg_pos_list[pos] 46 | temp <<= 8 47 | temp |= seg_code_list[value] 48 | 49 | if(dot == True): 50 | temp |= 0x80 51 | 52 | self.rclk.value(False) 53 | 54 | while(clks > 0): 55 | if((temp & 0x8000) != 0x0000): 56 | self.mosi.value(True) 57 | else: 58 | self.mosi.value(False) 59 | 60 | self.sck.value(True) 61 | temp <<= 1 62 | clks -= 1 63 | self.sck.value(False) 64 | 65 | self.rclk.value(True) 66 | -------------------------------------------------------------------------------- /I2C LCD Test/I2C_LCD.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from PCF8574 import PCF8574_IO 3 | import utime 4 | 5 | 6 | clear_display = const(0x01) 7 | goto_home = const(0x02) 8 | 9 | cursor_direction_inc = const(0x06) 10 | cursor_direction_dec = const(0x04) 11 | display_shift = const(0x05) 12 | display_no_shift = const(0x04) 13 | 14 | display_on = const(0x0C) 15 | display_off = const(0x0A) 16 | cursor_on = const(0x0A) 17 | cursor_off = const(0x08) 18 | blink_on = const(0x09) 19 | blink_off = const(0x08) 20 | 21 | _8_pin_interface = const(0x30) 22 | _4_pin_interface = const(0x20) 23 | _2_row_display = const(0x28) 24 | _1_row_display = const(0x20) 25 | _5x10_dots = const(0x60) 26 | _5x7_dots = const(0x20) 27 | 28 | line_1_y_pos = const(0x00) 29 | line_2_y_pos = const(0x40) 30 | line_3_y_pos = const(0x14) 31 | line_4_y_pos = const(0x54) 32 | 33 | BL_ON = const(1) 34 | BL_OFF = const(0) 35 | 36 | DAT = const(1) 37 | CMD = const(0) 38 | 39 | 40 | io_ex = 0 41 | bl_state = 0 42 | data_value = 0 43 | 44 | 45 | class TWI_LCD(): 46 | 47 | def __init__(self, i2c, i2c_addr): 48 | global io_ex 49 | global data_value 50 | global bl_state 51 | 52 | self.i2c = i2c 53 | self.i2c_addr = i2c_addr 54 | io_ex = PCF8574_IO(i2c, i2c_addr) 55 | utime.sleep_ms(10) 56 | 57 | bl_state = BL_ON 58 | data_value |= 0x04 59 | io_ex.PCF8574_write_byte(data_value) 60 | utime.sleep_ms(10) 61 | self.send_data(0x33, CMD) 62 | self.send_data(0x32, CMD) 63 | self.send_data((_4_pin_interface | _2_row_display | _5x7_dots), CMD) 64 | self.send_data((display_on | cursor_off | blink_off), CMD) 65 | self.send_data(clear_display, CMD) 66 | self.send_data((cursor_direction_inc | display_no_shift), CMD) 67 | 68 | def send_data(self, send_value, mode): 69 | global data_value 70 | global bl_state 71 | global io_ex 72 | 73 | if(mode == CMD): 74 | data_value &= 0xF4 75 | else: 76 | data_value |= 0x01 77 | 78 | if(bl_state == BL_ON): 79 | data_value |= 0x08 80 | else: 81 | data_value &= 0xF7 82 | 83 | io_ex.PCF8574_write_byte(data_value) 84 | self.quad_bit_send(send_value) 85 | utime.sleep_ms(1) 86 | 87 | def toggle_EN(self): 88 | global data_value 89 | data_value |= 0x04 90 | io_ex.PCF8574_write_byte(data_value) 91 | utime.sleep_ms(1) 92 | data_value &= 0xF9 93 | io_ex.PCF8574_write_byte(data_value) 94 | utime.sleep_ms(1) 95 | 96 | def quad_bit_send(self, lcd_data): 97 | global data_value 98 | temp = (lcd_data & 0xF0) 99 | data_value &= 0x0F 100 | data_value |= temp 101 | io_ex.PCF8574_write_byte(data_value) 102 | self.toggle_EN() 103 | temp = (lcd_data & 0x0F) 104 | temp <<= 0x04 105 | data_value &= 0x0F 106 | data_value |= temp 107 | io_ex.PCF8574_write_byte(data_value) 108 | self.toggle_EN() 109 | 110 | def clr_home(self): 111 | self.send_data(clear_display, CMD) 112 | self.send_data(goto_home, CMD) 113 | 114 | def goto_xy(self, x_pos, y_pos): 115 | if(y_pos == 0): 116 | self.send_data((0x80 | x_pos), CMD) 117 | else: 118 | self.send_data((0xC0 | x_pos), CMD) 119 | 120 | def put_chr(self, ch): 121 | self.send_data(ord(ch), DAT) 122 | 123 | def put_str(self, ch_string): 124 | for chr in ch_string: 125 | self.put_chr(chr) 126 | -------------------------------------------------------------------------------- /I2C LCD Test/PCF8574.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | 3 | 4 | class PCF8574_IO(): 5 | 6 | def __init__(self, i2c, i2c_addr): 7 | self.i2c = i2c 8 | self.i2c_addr = i2c_addr 9 | 10 | def PCF8574_write_byte(self, value): 11 | self.i2c.writeto(self.i2c_addr, bytes([value])) 12 | 13 | def PCF8574_read_byte(self, mask): 14 | self.PCF8574_write_byte(mask) 15 | retval = self.i2c.readfrom(self.i2c_addr, 1) 16 | return retval[0] 17 | -------------------------------------------------------------------------------- /I2C LCD Test/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from I2C_LCD import TWI_LCD 3 | import utime 4 | 5 | lcd_port = I2C(1, scl=Pin(3), sda=Pin(2), freq=20_000) 6 | 7 | print(lcd_port.scan()) 8 | 9 | i = -11.0 10 | 11 | lcd = TWI_LCD(lcd_port, 0x27) 12 | 13 | lcd.clr_home 14 | lcd.goto_xy(1, 0) 15 | lcd.put_str("RP2040 uPython") 16 | 17 | 18 | while True: 19 | 20 | lcd.goto_xy(7, 1) 21 | lcd.put_str(str("%2.1f " % i)) 22 | i += 0.1 23 | utime.sleep_ms(100) 24 | 25 | if(i >= 100): 26 | i = -11.0 -------------------------------------------------------------------------------- /IR Range Finder with ToF050 (MODBUS) and ST7735 TFT Display Pi HAT/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import UART, Pin 3 | from utime import sleep_ms 4 | from ToF050 import ToF050 5 | from ST7735 import TFT_144 6 | 7 | 8 | LED = Pin(25, Pin.OUT) 9 | 10 | tft = TFT_144() 11 | 12 | uart = UART(1, baudrate = 115200, tx = Pin(4), rx = Pin(5)) 13 | tof = ToF050(uart) 14 | 15 | 16 | def map_value(v, x_min, x_max, y_min, y_max): 17 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 18 | 19 | 20 | def background(): 21 | tft.text("0", 10, 62, tft.CYAN) 22 | tft.text("100", 54, 62, tft.CYAN) 23 | tft.text("200", 100, 62, tft.CYAN) 24 | 25 | for i in range(0, 100, 9): 26 | tft.vline((14 + i), 76, 10, tft.GREEN) 27 | if(i < 99): 28 | tft.vline((19+ i), 82, 4, tft.GREEN) 29 | 30 | tft.text("ToF050 RP2040", 12, 9, tft.RED) 31 | tft.text("Range/mm:", 16, 36, tft.WHITE) 32 | 33 | 34 | while(True): 35 | r = tof.get_range() 36 | 37 | if(r == -1): 38 | d = tof.max_distance 39 | r = d 40 | 41 | d = map_value(r, 0, 200, 0, 100) 42 | 43 | tft.fill(tft.BLACK) 44 | background() 45 | tft.fill_rect(14, 90, d, 16, tft.YELLOW) 46 | tft.text(str("%03s" %r), 90, 36, tft.WHITE) 47 | tft.show() 48 | LED.toggle() 49 | sleep_ms(100) 50 | -------------------------------------------------------------------------------- /IR Remote (Simplified)/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | from utime import sleep_ms, sleep_us, ticks_diff, ticks_us, ticks_ms 4 | 5 | 6 | pulse = const(1000) 7 | sync_low = const(8000) 8 | sync_high = const(16000) 9 | 10 | 11 | ir_data = 0 12 | temp = 0 13 | first_edge = 0 14 | second_edge = 0 15 | capture_done = False 16 | 17 | 18 | machine.freq(240000000) 19 | 20 | IR_RX = Pin(14, Pin.IN) 21 | 22 | LED1 = Pin(7, Pin.OUT) 23 | LED2 = Pin(8, Pin.OUT) 24 | LED3 = Pin(11, Pin.OUT) 25 | LED4 = Pin(12, Pin.OUT) 26 | LED_TGL = Pin(25, Pin.OUT) 27 | 28 | LED1.value(False) 29 | LED2.value(False) 30 | LED3.value(False) 31 | LED4.value(False) 32 | LED_TGL.value(False) 33 | 34 | 35 | while True: 36 | 37 | if(IR_RX.value() == False): 38 | ir_data = 0 39 | temp = 0 40 | first_edge = 0 41 | second_edge = 0 42 | capture_done = False 43 | while(capture_done == False): 44 | 45 | print("IR Detected!") 46 | first_edge = ticks_us() 47 | 48 | i= 0 49 | while(IR_RX.value() == False): 50 | i += 1 51 | sleep_us(1) 52 | 53 | if(i > 2600): 54 | break 55 | 56 | i = 0 57 | while(IR_RX.value() == True): 58 | i += 1 59 | sleep_us(1) 60 | 61 | if(i > 2600): 62 | break 63 | 64 | 65 | second_edge = ticks_us() 66 | temp = ticks_diff(second_edge, first_edge) 67 | 68 | if(temp in range (sync_low, sync_high)): 69 | 70 | for s in range(0, 16): 71 | LED_TGL.toggle() 72 | ir_data <<= 1 73 | first_edge = ticks_us() 74 | while(IR_RX.value() == False): 75 | continue 76 | 77 | while(IR_RX.value() == True): 78 | continue 79 | second_edge = ticks_us() 80 | temp = ticks_diff(second_edge, first_edge) 81 | 82 | if(temp >= pulse): 83 | ir_data |= 1 84 | 85 | print(str(s) + " " + str(temp)) 86 | 87 | print("IR Data: " + str("%0x" % ir_data,)) 88 | 89 | if((ir_data & 0x00FF) == 0x00EA): 90 | LED1.toggle() 91 | elif((ir_data & 0x00FF) == 0x00EE): 92 | LED2.toggle() 93 | elif((ir_data & 0x00FF) == 0x00E9): 94 | LED3.toggle() 95 | elif((ir_data & 0x00FF) == 0x00ED): 96 | LED4.toggle() 97 | elif((ir_data & 0x00FF) == 0x00E1): 98 | LED1.value(False) 99 | LED2.value(False) 100 | LED3.value(False) 101 | LED4.value(False) 102 | 103 | sleep_ms(100) 104 | capture_done = True 105 | 106 | else: 107 | print("Error!") 108 | capture_done = True 109 | 110 | -------------------------------------------------------------------------------- /IoT/Network Clock/SH1107.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SPI 3 | from utime import sleep_ms, sleep_us 4 | import framebuf 5 | 6 | 7 | DC_pin = const(8) 8 | CS_pin = const(9) 9 | SCK_pin = const(10) 10 | MOSI_pin = const(11) 11 | RST_pin = const(12) 12 | 13 | SH1107_SET_LOWER_COLUMN_ADDRESS = const(0x00) 14 | SH1107_SET_UPPER_COLUMN_ADDRESS = const(0x10) 15 | SH1107_SET_PAGE_MEMORY_ADDRESSING_MODE = const(0x20) 16 | SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE = const(0x21) 17 | SH1107_SET_CONSTRAST_CONTROL = const(0x81) 18 | SH1107_SET_DC_DC_OFF_MODE = const(0x8A) 19 | SH1107_SET_DC_DC_ON_MODE = const(0x8B) 20 | SH1107_SET_SEGMENT_REMAP_NORMAL = const(0xA0) 21 | SH1107_SET_SEGMENT_REMAP_REVERSE = const(0xA1) 22 | SH1107_SET_ENTIRE_DISPLAY_OFF = const(0xA4) 23 | SH1107_SET_ENTIRE_DISPLAY_ON = const(0xA5) 24 | SH1107_SET_NORMAL_DISPLAY = const(0xA6) 25 | SH1107_SET_REVERSE_DISPLAY = const(0xA7) 26 | SH1107_SET_MULTIPLEX_RATIO = const(0xA8) 27 | SH1107_SET_DC_DC_CONTROL_MODE = const(0xAD) 28 | SH1107_DISPLAY_OFF = const(0xAE) 29 | SH1107_DISPLAY_ON = const(0xAF) 30 | SH1107_SET_PAGE_ADDRESS = const(0xB0) 31 | SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION = const(0xC0) 32 | SH1107_SET_DISPLAY_OFFSET = const(0xD3) 33 | SH1107_SET_DISPLAY_CLOCK_FREQUENCY = const(0xD5) 34 | SH1107_SET_PRECHARGE_DISCHARGE_PERIOD = const(0xD9) 35 | SH1107_SET_VCOM_DESELECT_LEVEL = const(0xDB) 36 | SH1107_SET_DISPLAY_START_LINE = const(0xDC) 37 | 38 | CMD = False 39 | DAT = True 40 | 41 | LOW = False 42 | HIGH = True 43 | 44 | 45 | class OLED_13(framebuf.FrameBuffer): 46 | def __init__(self): 47 | self.width = 128 48 | self.height = 64 49 | 50 | self.WHITE = 1 51 | self.BLACK = 0 52 | 53 | self.cs = Pin(CS_pin, Pin.OUT) 54 | self.rst = Pin(RST_pin, Pin.OUT) 55 | self.sck = Pin(SCK_pin, Pin.OUT) 56 | self.mosi = Pin(MOSI_pin, Pin.OUT) 57 | 58 | self.cs(HIGH) 59 | 60 | self.spi = SPI(1, 20000_000, polarity = 0, phase = 0,sck = self.sck, mosi = self.mosi,miso = None) 61 | 62 | self.dc = Pin(DC_pin, Pin.OUT) 63 | self.dc(HIGH) 64 | 65 | self.buffer = bytearray(self.height * (self.width // 8)) 66 | super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HMSB) 67 | self.init_display() 68 | 69 | 70 | def write(self, value, mode): 71 | self.dc(mode) 72 | self.cs(LOW) 73 | self.spi.write(bytearray([value])) 74 | self.cs(HIGH) 75 | 76 | 77 | def init_display(self): 78 | self.rst(HIGH) 79 | sleep_ms(1) 80 | self.rst(LOW) 81 | sleep_ms(10) 82 | self.rst(HIGH) 83 | 84 | self.write(SH1107_DISPLAY_OFF, CMD) 85 | 86 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS | 0x00), CMD) 87 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS | 0x00), CMD) 88 | 89 | self.write((SH1107_SET_PAGE_ADDRESS | 0x00), CMD) 90 | 91 | self.write(SH1107_SET_DISPLAY_START_LINE, CMD) 92 | self.write(0x00, CMD) 93 | self.write(SH1107_SET_CONSTRAST_CONTROL, CMD) 94 | self.write(0x6F, CMD) 95 | self.write(SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE, CMD) 96 | 97 | self.write(SH1107_SET_SEGMENT_REMAP_NORMAL, CMD) 98 | self.write((SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION | 0x00), CMD) 99 | self.write(SH1107_SET_ENTIRE_DISPLAY_OFF, CMD) 100 | 101 | self.write(SH1107_SET_NORMAL_DISPLAY, CMD) 102 | self.write(SH1107_SET_MULTIPLEX_RATIO, CMD) 103 | self.write(0x3F, CMD) 104 | 105 | self.write(SH1107_SET_DISPLAY_OFFSET, CMD) 106 | self.write(0x60, CMD) 107 | 108 | self.write(SH1107_SET_DISPLAY_CLOCK_FREQUENCY, CMD) 109 | self.write(0x41, CMD) 110 | 111 | self.write(SH1107_SET_PRECHARGE_DISCHARGE_PERIOD, CMD) 112 | self.write(0x22, CMD) 113 | 114 | self.write(SH1107_SET_VCOM_DESELECT_LEVEL, CMD) 115 | self.write(0x35, CMD) 116 | 117 | self.write(SH1107_SET_DC_DC_CONTROL_MODE, CMD) 118 | self.write(SH1107_SET_DC_DC_OFF_MODE, CMD) 119 | self.write(SH1107_DISPLAY_ON, CMD) 120 | 121 | 122 | def show(self): 123 | self.write(SH1107_SET_PAGE_ADDRESS, CMD) 124 | for page in range(0, 64): 125 | self.column = (63 - page) 126 | 127 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS + (self.column & 0x0F)), CMD) 128 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS + (self.column >> 4)), CMD) 129 | 130 | for num in range(0, 16): 131 | self.write((self.buffer[(page * 16) + num]), DAT) 132 | 133 | -------------------------------------------------------------------------------- /IoT/PICO W Open Weather Map/open_weather_map.py: -------------------------------------------------------------------------------- 1 | import urequests 2 | import ujson as json 3 | import gc 4 | 5 | 6 | class open_weather_map(): 7 | def __init__(self, country, city, key): 8 | self.country_code = country 9 | self.city_code = city 10 | self.api_key = key 11 | gc.enable() 12 | gc.collect() 13 | 14 | 15 | def connect_url(self): 16 | gc.collect() 17 | url = 'https://api.openweathermap.org/data/2.5/weather?q=' + self.city_code + ',' + self.country_code + '&APPID=' + self.api_key + '&units=metric' 18 | return url 19 | 20 | 21 | def fetch_data(self): 22 | return_data = [] 23 | 24 | fetched_data = urequests.post(self.connect_url()) 25 | 26 | gc.collect() 27 | return_data.append(fetched_data.json().get('name')) # 0 28 | return_data.append(fetched_data.json().get('sys').get('country')) # 1 29 | return_data.append(fetched_data.json().get('coord').get('lat')) # 2 30 | return_data.append(fetched_data.json().get('coord').get('lon')) # 3 31 | 32 | return_data.append(fetched_data.json().get('dt')) # 4 33 | return_data.append(fetched_data.json().get('sys').get('sunrise')) # 5 34 | return_data.append(fetched_data.json().get('sys').get('sunset')) # 6 35 | 36 | return_data.append(fetched_data.json().get('weather')[0].get('main')) # 7 37 | return_data.append(fetched_data.json().get('weather')[0].get('description')) # 8 38 | 39 | return_data.append(fetched_data.json().get('main').get('temp')) # 9 40 | return_data.append(fetched_data.json().get('main').get('feels_like')) # 10 41 | return_data.append(fetched_data.json().get('main').get('temp_min')) # 11 42 | return_data.append(fetched_data.json().get('main').get('temp_max')) # 12 43 | 44 | return_data.append(fetched_data.json().get('main').get('humidity')) # 13 45 | 46 | return_data.append(fetched_data.json().get('main').get('pressure')) # 14 47 | 48 | return_data.append(fetched_data.json().get('wind').get('speed')) # 15 49 | return_data.append(fetched_data.json().get('wind').get('deg')) # 16 50 | return_data.append(fetched_data.json().get('wind').get('gust')) # 17 51 | 52 | return_data.append(fetched_data.json().get('visibility')) # 18 53 | 54 | return_data.append(fetched_data.json().get('clouds').get('all')) # 19 55 | 56 | return_data.append(fetched_data.json().get('main').get('sea_level')) # 20 57 | return_data.append(fetched_data.json().get('main').get('grnd_level')) # 21 58 | 59 | return_data.append(fetched_data.json().get('weather')[0].get('icon')) # 22 60 | 61 | return return_data 62 | -------------------------------------------------------------------------------- /MikroE Rotary Click + Waveshare 7 Segment Display/LED_circle.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_us 3 | 4 | 5 | leds = [ 6 | 0x0000, 7 | 0x0001, 8 | 0x0002, 9 | 0x0004, 10 | 0x0008, 11 | 0x0010, 12 | 0x0020, 13 | 0x0040, 14 | 0x0080, 15 | 0x0100, 16 | 0x0200, 17 | 0x0400, 18 | 0x0800, 19 | 0x1000, 20 | 0x2000, 21 | 0x4000, 22 | 0x8000 23 | ] 24 | 25 | 26 | class LED_circle(): 27 | def __init__(self, _sdi, _sck, _cs, _mr): 28 | self.mr = Pin(_mr, Pin.OUT) 29 | self.cs = Pin(_cs, Pin.OUT) 30 | self.sck = Pin(_sck, Pin.OUT) 31 | self.sdi = Pin(_sdi, Pin.OUT) 32 | 33 | self.mr.high() 34 | self.cs.low() 35 | self.sck.low() 36 | self.sdi.low() 37 | 38 | 39 | def update(self): 40 | self.cs.high() 41 | sleep_us(100) 42 | self.cs.low() 43 | 44 | 45 | def write(self, value): 46 | for i in range(0, 8): 47 | self.sck.low() 48 | 49 | if((value & 0x80) != 0x00): 50 | self.sdi.high() 51 | else: 52 | self.sdi.low() 53 | 54 | self.sck.high() 55 | value <<= 0x01 56 | 57 | 58 | def send(self, value, disp_type): 59 | if(value > 16): 60 | value = 16 61 | 62 | if(value < 0): 63 | value = 0 64 | 65 | temp = leds[value] 66 | 67 | if(disp_type == True): 68 | temp = ~temp 69 | 70 | lb = (temp & 0x00FF) 71 | hb = ((temp & 0xFF00) >> 0x08) 72 | 73 | self.write(lb) 74 | self.write(hb) 75 | 76 | self.update() 77 | -------------------------------------------------------------------------------- /MikroE Rotary Click + Waveshare 7 Segment Display/encoder.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | 3 | 4 | class encoder(): 5 | 6 | def __init__(self, enc_A, enc_B, _sw, _min_cnt, _max_cnt, _step_size): 7 | self.sw = Pin(_sw, Pin.IN) 8 | self.enc_a = Pin(enc_A, Pin.IN) 9 | self.enc_b = Pin(enc_B, Pin.IN) 10 | self.max_cnt = _max_cnt 11 | self.min_cnt = _min_cnt 12 | self.step_size = _step_size 13 | self.cnt = self.min_cnt 14 | 15 | 16 | def check_count(self): 17 | if self.enc_a.value(): 18 | self.cnt += self.step_size 19 | 20 | if(self.cnt > self.max_cnt): 21 | self.cnt = self.min_cnt 22 | 23 | else: 24 | self.cnt -= self.step_size 25 | 26 | if(self.cnt < self.min_cnt): 27 | self.cnt = self.max_cnt 28 | 29 | 30 | def irq_handler_1(self, p): 31 | self.check_count() 32 | 33 | 34 | def irq_handler_2(self, p): 35 | self.check_count() 36 | 37 | 38 | def decode(self): 39 | if ((self.enc_a.value() == True) and (self.enc_b.value() == True)): 40 | self.enc_b.irq(self.irq_handler_1, Pin.IRQ_FALLING) 41 | 42 | if ((self.enc_a.value() == False) and (self.enc_b.value() == False)): 43 | self.enc_b.irq(self.irq_handler_2, Pin.IRQ_RISING) 44 | 45 | return self.cnt 46 | 47 | -------------------------------------------------------------------------------- /MikroE Rotary Click + Waveshare 7 Segment Display/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, Timer 2 | from utime import sleep_ms 3 | from encoder import encoder 4 | from LED_circle import LED_circle 5 | from segment_display import seg_disp 6 | 7 | 8 | seg = 0 9 | value = 0 10 | invert = 0 11 | counter = 1 12 | past_value = 0 13 | present_value = 0 14 | 15 | 16 | def timer_callback(t): 17 | global value, seg 18 | 19 | if(seg == 0): 20 | val = ((value % 10000) // 1000) 21 | elif(seg == 1): 22 | val = ((value % 1000) // 100) 23 | elif(seg == 2): 24 | val = ((value % 100) // 10) 25 | else: 26 | val = (value % 10) 27 | 28 | disp.send_data(val, seg, False) 29 | seg += 1 30 | 31 | if(seg > 3): 32 | seg = 0 33 | 34 | 35 | tim = Timer(mode = Timer.PERIODIC, period = 1, callback = timer_callback) 36 | disp = seg_disp() 37 | led = LED_circle(21, 20, 7, 8) 38 | enc = encoder(2, 3, 14, 0, 1000, 10) 39 | 40 | led.send(0, 0) 41 | sleep_ms(400) 42 | led.send(0, 1) 43 | sleep_ms(400) 44 | 45 | 46 | 47 | while(True): 48 | if(enc.sw.value() == True): 49 | sleep_ms(40) 50 | if(enc.sw.value() == True): 51 | invert ^= 0x01 52 | 53 | value = enc. decode() 54 | 55 | present_value = value 56 | 57 | if(present_value > past_value): 58 | counter += 1 59 | 60 | if(counter > 16): 61 | counter = 1 62 | 63 | if(present_value < past_value): 64 | counter -= 1 65 | 66 | if(counter < 1): 67 | counter = 16 68 | 69 | past_value = present_value 70 | 71 | led.send(counter, invert) 72 | print(value) 73 | sleep_ms(100) 74 | 75 | 76 | 77 | 78 | 79 | -------------------------------------------------------------------------------- /MikroE Rotary Click + Waveshare 7 Segment Display/segment_display.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | 4 | mosi_pin = const(11) 5 | sck_pin = const(10) 6 | rclk_pin = const(9) 7 | 8 | 9 | seg_code_list = [ 10 | 0x3F, # 0 11 | 0x06, # 1 12 | 0x5B, # 2 13 | 0x4F, # 3 14 | 0x66, # 4 15 | 0x6D, # 5 16 | 0x7D, # 6 17 | 0x07, # 7 18 | 0x7F, # 8 19 | 0x6F, # 9 20 | 0x77, # A 21 | 0x7C, # b 22 | 0x39, # C 23 | 0x5E, # d 24 | 0x79, # E 25 | 0x71 # F 26 | ] 27 | 28 | seg_pos_list = [ 29 | 0xFE, # 1st 30 | 0xFD, # 2nd 31 | 0xFB, # 3rd 32 | 0xF7, # 4th 33 | ] 34 | 35 | 36 | class seg_disp(): 37 | 38 | def __init__(self): 39 | self.mosi = Pin(mosi_pin, Pin.OUT) 40 | self.sck = Pin(sck_pin, Pin.OUT) 41 | self.rclk = Pin(rclk_pin, Pin.OUT) 42 | 43 | def send_data(self, value, pos, dot): 44 | clks = 16 45 | temp = seg_pos_list[pos] 46 | temp <<= 8 47 | temp |= seg_code_list[value] 48 | 49 | if(dot == True): 50 | temp |= 0x80 51 | 52 | self.rclk.value(False) 53 | 54 | while(clks > 0): 55 | if((temp & 0x8000) != 0x0000): 56 | self.mosi.value(True) 57 | else: 58 | self.mosi.value(False) 59 | 60 | self.sck.value(True) 61 | temp <<= 1 62 | clks -= 1 63 | self.sck.value(False) 64 | 65 | self.rclk.value(True) 66 | -------------------------------------------------------------------------------- /Musical Lights - LED SPL Meter (PWM)/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, PWM, ADC 2 | from utime import sleep_ms, sleep_us 3 | import math 4 | 5 | 6 | adc = ADC(Pin(26)) 7 | 8 | D0 = Pin(1, Pin.OUT) 9 | D1 = Pin(3, Pin.OUT) 10 | D2 = Pin(5, Pin.OUT) 11 | D3 = Pin(6, Pin.OUT) 12 | D4 = Pin(7, Pin.OUT) 13 | D5 = Pin(8, Pin.OUT) 14 | D6 = Pin(9, Pin.OUT) 15 | D7 = Pin(10, Pin.OUT) 16 | 17 | pwm1 = PWM(Pin(0)) 18 | pwm1.freq(6000) 19 | pwm1.duty_u16(65536) 20 | 21 | pwm2 = PWM(Pin(2)) 22 | pwm2.freq(6000) 23 | pwm2.duty_u16(65536) 24 | 25 | pwm3 = PWM(Pin(4)) 26 | pwm3.freq(6000) 27 | pwm3.duty_u16(0) 28 | 29 | 30 | def map_value(v, x_min, x_max, y_min, y_max): 31 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 32 | 33 | 34 | def level(value): 35 | if(value == 8): 36 | D0.low() 37 | D1.low() 38 | D2.low() 39 | D3.low() 40 | D4.low() 41 | D5.low() 42 | D6.low() 43 | D7.low() 44 | 45 | elif(value == 7): 46 | D0.high() 47 | D1.low() 48 | D2.low() 49 | D3.low() 50 | D4.low() 51 | D5.low() 52 | D6.low() 53 | D7.low() 54 | 55 | elif(value == 6): 56 | D0.high() 57 | D1.high() 58 | D2.low() 59 | D3.low() 60 | D4.low() 61 | D5.low() 62 | D6.low() 63 | D7.low() 64 | 65 | elif(value == 5): 66 | D0.high() 67 | D1.high() 68 | D2.high() 69 | D3.low() 70 | D4.low() 71 | D5.low() 72 | D6.low() 73 | D7.low() 74 | 75 | elif(value == 4): 76 | D0.high() 77 | D1.high() 78 | D2.high() 79 | D3.high() 80 | D4.low() 81 | D5.low() 82 | D6.low() 83 | D7.low() 84 | 85 | elif(value == 3): 86 | D0.high() 87 | D1.high() 88 | D2.high() 89 | D3.high() 90 | D4.high() 91 | D5.low() 92 | D6.low() 93 | D7.low() 94 | 95 | elif(value == 2): 96 | D0.high() 97 | D1.high() 98 | D2.high() 99 | D3.high() 100 | D4.high() 101 | D5.high() 102 | D6.low() 103 | D7.low() 104 | 105 | elif(value == 1): 106 | D0.high() 107 | D1.high() 108 | D2.high() 109 | D3.high() 110 | D4.high() 111 | D5.high() 112 | D6.high() 113 | D7.low() 114 | 115 | else: 116 | D0.high() 117 | D1.high() 118 | D2.high() 119 | D3.high() 120 | D4.high() 121 | D5.high() 122 | D6.high() 123 | D7.high() 124 | 125 | 126 | def ADC_rms(): 127 | rms = 0 128 | tmp = 0 129 | sample = 0 130 | 131 | for i in range(0, 16): 132 | sample = adc.read_u16() 133 | tmp += (sample * sample) 134 | 135 | tmp >>= 4 136 | rms = math.sqrt(tmp) 137 | rms *= 0.000050354 138 | 139 | if(rms <= 0): 140 | rms = 0.000050354 141 | 142 | return rms 143 | 144 | 145 | def get_dB(): 146 | dB = ADC_rms() 147 | dB = 94 + (20 * math.log10(dB / 3.16)) 148 | return dB 149 | 150 | 151 | while(True): 152 | db = get_dB() 153 | print(db) 154 | 155 | if((db >= 30) and (db <= 55)): 156 | pwm1.duty_u16(64000) 157 | pwm2.duty_u16(40) 158 | pwm3.duty_u16(64000) 159 | 160 | elif((db >55) and (db <= 75)): 161 | pwm1.duty_u16(64000) 162 | pwm2.duty_u16(40) 163 | pwm3.duty_u16(64000) 164 | 165 | else: 166 | pwm1.duty_u16(40) 167 | pwm2.duty_u16(64000) 168 | pwm3.duty_u16(64000) 169 | 170 | i = map_value(db, 40, 90, 1, 8) 171 | level(i) 172 | sleep_ms(40) 173 | 174 | 175 | 176 | -------------------------------------------------------------------------------- /PICO UPS/INA219.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import I2C 3 | 4 | 5 | CONFIG_REG = const(0x00) 6 | SHUNT_VOLTAGE_REG = const(0x01) 7 | BUS_VOLTAGE_REG = const(0x02) 8 | POWER_REG = const(0x03) 9 | CURRENT_REG = const(0x04) 10 | CALIBRATION_REG = const(0x05) 11 | 12 | 13 | bus_voltage_range_16V = const(0x00) 14 | bus_voltage_range_32V = const(0x01) 15 | 16 | gain_div_1_40mV = const(0x00) 17 | gain_div_2_80mV = const(0x01) 18 | gain_div_4_160mV = const(0x02) 19 | gain_div_8_320mV = const(0x03) 20 | 21 | ADC_9_bit_1_sample = const(0x00) 22 | ADC_10_bit_1_sample = const(0x01) 23 | ADC_11_bit_1_sample = const(0x02) 24 | ADC_12_bit_1_sample = const(0x03) 25 | ADC_12_bit_2_samples = const(0x09) 26 | ADC_12_bit_4_samples = const(0x0A) 27 | ADC_12_bit_8_samples = const(0x0B) 28 | ADC_12_bit_16_samples = const(0x0C) 29 | ADC_12_bit_32_samples = const(0x0D) 30 | ADC_12_bit_64_samples = const(0x0E) 31 | ADC_12_bit_128_samples = const(0x0F) 32 | 33 | power_down_mode = const(0x00) 34 | shunt_voltage_triggered_mode = const(0x01) 35 | bus_voltage_triggered_mode = const(0x02) 36 | shunt_and_bus_voltage_triggered_mode = const(0x03) 37 | adc_off_mode = const(0x04) 38 | shunt_voltage_continuous_mode = const(0x05) 39 | bus_voltage_continuous_mode = const(0x06) 40 | shunt_and_bus_voltage_continuous_mode = const(0x07) 41 | 42 | 43 | class INA219(): 44 | 45 | def __init__(self, _i2c, _i2c_addr, _shunt, _batt_low, _batt_full): 46 | self.i2c = _i2c 47 | self.i2c_addr = _i2c_addr 48 | self.batt_low = _batt_low 49 | self.batt_full = _batt_full 50 | self.current_lsb = 0 51 | self.calibration_value = 0 52 | self.power_lsb = 0 53 | self.shunt_resistor_ohms = _shunt 54 | self.calibrate_for_32V_2A() 55 | 56 | 57 | def read(self, reg): 58 | value = self.i2c.readfrom_mem(self.i2c_addr, reg, 0x02) 59 | retval = ((value[0x00] << 0x08) + value[0x01]) 60 | return retval 61 | 62 | 63 | def write(self, reg, value): 64 | if not type(value) is bytearray: 65 | value = bytearray([value]) 66 | 67 | self.i2c.writeto_mem(self.i2c_addr, reg, value) 68 | 69 | 70 | def calibrate_for_32V_2A(self): 71 | self.current_lsb = 1.0 72 | self.power_lsb = 0.002 73 | self.calibration_value = 4096 74 | 75 | configuration = (bus_voltage_range_32V << 13) | \ 76 | (gain_div_8_320mV << 11) | \ 77 | (ADC_12_bit_32_samples << 7) | \ 78 | (ADC_12_bit_32_samples << 3) | \ 79 | (shunt_and_bus_voltage_continuous_mode) 80 | 81 | self.write(CALIBRATION_REG, self.calibration_value) 82 | self.write(CONFIG_REG, configuration) 83 | 84 | 85 | def get_shunt_voltage_in_mV(self): 86 | value = self.read(SHUNT_VOLTAGE_REG) 87 | 88 | if(value > 32767): 89 | value -= 65535 90 | 91 | return (value * 0.01) 92 | 93 | 94 | def get_bus_voltage_in_mV(self): 95 | self.read(BUS_VOLTAGE_REG) 96 | 97 | return ((self.read(BUS_VOLTAGE_REG) >> 3) * 0.004 * 1000.0) 98 | 99 | 100 | def get_current_mA(self): 101 | value = self.read(CURRENT_REG) 102 | 103 | if(value > 32767): 104 | value -= 65535 105 | 106 | return (value * self.current_lsb) 107 | 108 | 109 | def get_current_from_shunt(self): 110 | value = (self.get_shunt_voltage_in_mV() * 10) 111 | 112 | return (value / self.shunt_resistor_ohms) 113 | 114 | 115 | def get_power(self): 116 | value = self.read(POWER_REG) 117 | 118 | if(value > 32767): 119 | value -= 65535 120 | 121 | return (value * self.power_lsb * 10.0) 122 | 123 | 124 | def calculate_power(self): 125 | value = (self.get_current_from_shunt() * self.get_bus_voltage_in_mV()) 126 | 127 | return (value / 1000000.0) 128 | 129 | 130 | def get_battery_capacity(self): 131 | capacity = ((((self.get_bus_voltage_in_mV() / 1000.0) - self.batt_low) / (self.batt_full - self.batt_low)) * 100.0) 132 | 133 | if(capacity >= 100): 134 | capacity = 100 135 | 136 | if(capacity <= 0): 137 | capacity = 0 138 | 139 | return capacity 140 | -------------------------------------------------------------------------------- /PICO UPS/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from utime import sleep_ms 3 | from ST7789 import TFT2 4 | from INA219 import INA219 5 | 6 | 7 | key1 = Pin(15, Pin.IN, Pin.PULL_UP) 8 | key2 = Pin(17, Pin.IN, Pin.PULL_UP) 9 | LED = Pin(25, Pin.OUT) 10 | i2c = I2C(1, scl = Pin(7), sda = Pin(6), freq = 100000) 11 | ina = INA219(i2c, 0x43, 0.1, 2.95 , 4.2) 12 | tft = TFT2() 13 | 14 | 15 | state_1 = False 16 | state_2 = False 17 | 18 | 19 | def map_value(v, x_min, x_max, y_min, y_max): 20 | return int(y_min + (((y_max - y_min) / (x_max - x_min)) * (v - x_min))) 21 | 22 | 23 | def constrain_value(v, max_v, min_v): 24 | if(v >= max_v): 25 | v = max_v 26 | 27 | if(v <= min_v): 28 | v = min_v 29 | 30 | return v 31 | 32 | 33 | def back_art(value): 34 | tft.fill(tft.BLACK) 35 | tft.text("Raspberry Pi PICO RP2040 UPS" , 40, 20, tft.WHITE) 36 | 37 | tft.fill_rect(20, 50, 30, 10, tft.WHITE) 38 | tft.rect(10, 60, 50, 170, tft.WHITE) 39 | tft.rect(12, 62, 46, 166, tft.WHITE) 40 | 41 | h1 = map_value(value, 0, 100, 225, 65) 42 | h2 = map_value(value, 0, 100, 0, 160) 43 | 44 | h1 = constrain_value(h1, 225, 65) 45 | h2 = constrain_value(h2, 160, 0) 46 | 47 | if(0 < value <= 30): 48 | colour = tft.RED 49 | elif(30 < value <= 60): 50 | colour = tft.YELLOW 51 | else: 52 | colour = tft.GREEN 53 | 54 | tft.fill_rect(15, h1, 40, h2, colour) 55 | 56 | 57 | for i in range(0, 100, 5): 58 | back_art(i) 59 | tft.show() 60 | 61 | 62 | for i in range(100, 0, -5): 63 | back_art(i) 64 | tft.show() 65 | 66 | 67 | while (True): 68 | 69 | if(key1.value() == False): 70 | LED.on() 71 | while(key1.value() == False): 72 | pass 73 | state_1 ^= 1 74 | LED.off() 75 | 76 | if(key2.value() == False): 77 | LED.on() 78 | while(key2.value() == False): 79 | pass 80 | state_2 ^= 1 81 | LED.off() 82 | 83 | 84 | bv = (ina.get_bus_voltage_in_mV() / 1000.0) 85 | c = ina.get_battery_capacity() 86 | 87 | if(state_1): 88 | i = ina.get_current_mA() 89 | else: 90 | i = ina.get_current_from_shunt() 91 | 92 | 93 | if(state_2): 94 | p = ina.get_power() 95 | else: 96 | p = ina.calculate_power() 97 | 98 | back_art(c) 99 | 100 | tft.text("Battery Parameters" , 110, 55, tft.MAGENTA) 101 | tft.text(("Voltage : " + str("%1.3f" %bv) + " V"), 110, 80, tft.CYAN) 102 | tft.text(("Current : " + str("%4.1f" %i) + " mA"), 110, 110, tft.GREEN) 103 | tft.text(("Power : " + str("%3.2f" %p) + " W"), 110, 140, tft.RED) 104 | tft.text(("Capacity: " + str("%3.1f" %c) + " %"), 110, 170, tft.YELLOW) 105 | 106 | tft.show() 107 | 108 | print("Voltage : {:1.3f} V".format(bv)) 109 | print("Current : {:4.1f} mA".format(i)) 110 | print("Power : {:3.2f} W".format(p)) 111 | print("Capacity: {:3.1f} %".format(c)) 112 | print("\r\n") 113 | 114 | sleep_ms(100) 115 | -------------------------------------------------------------------------------- /PIO Codes/Alphanumerical LCD Driver/LCD_2x16.py: -------------------------------------------------------------------------------- 1 | #Pin Connections 2 | 3 | # RW = GND 4 | # RS = base_pin + 5 5 | # EN = base_pin + 4 6 | # D7 = base_pin + 3 7 | # D6 = base_pin + 2 8 | # D5 = base_pin + 1 9 | # D4 = base_pin + 0 10 | 11 | 12 | from machine import Pin 13 | from utime import sleep_ms 14 | from rp2 import asm_pio, StateMachine, PIO 15 | from micropython import const 16 | 17 | 18 | clear_display = const(0x01) 19 | goto_home = const(0x02) 20 | 21 | cursor_direction_inc = const(0x06) 22 | cursor_direction_dec = const(0x04) 23 | display_shift = const(0x05) 24 | display_no_shift = const(0x04) 25 | 26 | display_on = const(0x0C) 27 | display_off = const(0x0A) 28 | cursor_on = const(0x0A) 29 | cursor_off = const(0x08) 30 | blink_on = const(0x09) 31 | blink_off = const(0x08) 32 | 33 | _8_pin_interface = const(0x30) 34 | _4_pin_interface = const(0x20) 35 | _2_row_display = const(0x28) 36 | _1_row_display = const(0x20) 37 | _5x10_dots = const(0x60) 38 | _5x7_dots = const(0x20) 39 | 40 | line_1_y_pos = const(0x00) 41 | line_2_y_pos = const(0x40) 42 | line_3_y_pos = const(0x14) 43 | line_4_y_pos = const(0x54) 44 | 45 | dly = const(2) 46 | 47 | DAT = const(1) 48 | CMD = const(0) 49 | 50 | 51 | lcd_value = 0 52 | 53 | 54 | class LCD(): 55 | 56 | @asm_pio(out_shiftdir = PIO.SHIFT_RIGHT, 57 | autopull = True, 58 | pull_thresh = 6, 59 | out_init = ((PIO.OUT_HIGH, ) * 6)) 60 | 61 | def lcd_write(): 62 | pull(ifempty) # Pull data from TX_FIFO if empty 63 | out(pins, 6) # write lcd info 64 | 65 | 66 | def toggle_en(self): 67 | global lcd_value 68 | 69 | lcd_value |= 0x10 70 | sleep_ms(dly) 71 | self.sm.put(lcd_value) 72 | 73 | lcd_value &= 0x2F 74 | sleep_ms(dly) 75 | self.sm.put(lcd_value) 76 | 77 | 78 | def write(self, value, mode): 79 | global lcd_value 80 | 81 | if(mode == DAT): 82 | lcd_value |= 0x20 83 | else: 84 | lcd_value &= 0x1F 85 | 86 | self.send(value) 87 | 88 | 89 | def send(self, value): 90 | global lcd_value 91 | 92 | temp = ((value & 0xF0) >> 4) 93 | lcd_value &= 0x30 94 | lcd_value |= (temp & 0x0F) 95 | self.toggle_en() 96 | 97 | temp = (value & 0x0F) 98 | lcd_value &= 0x30 99 | lcd_value |= (temp & 0x0F) 100 | self.toggle_en() 101 | 102 | 103 | def clear_home(self): 104 | self.write(clear_display, CMD) 105 | self.write(goto_home, CMD) 106 | 107 | 108 | def goto_xy(self, x_pos, y_pos): 109 | if(y_pos == 1): 110 | self.write((0x80 | (line_2_y_pos + x_pos)), CMD) 111 | 112 | elif(y_pos == 2): 113 | self.write((0x80 | (line_3_y_pos + x_pos)), CMD) 114 | 115 | elif(y_pos == 3): 116 | self.write((0x80 | (line_4_y_pos + x_pos)), CMD) 117 | 118 | else: 119 | self.write((0x80 | (line_1_y_pos + x_pos)), CMD) 120 | 121 | 122 | def init(self): 123 | sleep_ms(dly) 124 | self.toggle_en() 125 | self.write(0x33, CMD) 126 | self.write(0x32, CMD) 127 | 128 | self.write((_4_pin_interface | _2_row_display | _5x7_dots), CMD) 129 | self.write((display_on | cursor_off | blink_off), CMD) 130 | self.write(clear_display, CMD) 131 | self.write((cursor_direction_inc | display_no_shift), CMD) 132 | 133 | 134 | def put_chr(self, ch): 135 | self.write(ord(ch), DAT) 136 | 137 | 138 | def put_str(self, ch_string): 139 | for chr in ch_string: 140 | self.put_chr(chr) 141 | 142 | 143 | def __init__(self, base_pin): 144 | self.out_pin = Pin(base_pin, Pin.OUT) 145 | self.sm = StateMachine(0, LCD.lcd_write, out_base = self.out_pin, freq = 250000) 146 | self.sm.active(1) 147 | self.init() 148 | 149 | -------------------------------------------------------------------------------- /PIO Codes/Alphanumerical LCD Driver/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms, 3 | from LCD_2x16 import LCD 4 | 5 | 6 | i = -11.0 7 | 8 | 9 | lcd = LCD(0) 10 | 11 | 12 | lcd.clear_home() 13 | lcd.goto_xy(1, 0) 14 | lcd.put_str("RP2040 PIO LCD") 15 | 16 | 17 | while(True): 18 | lcd.goto_xy(6, 1) 19 | lcd.put_str(str("%2.1f " % i)) 20 | i += 0.1 21 | sleep_ms(100) 22 | 23 | if(i >= 100): 24 | i = -11.0 25 | 26 | 27 | -------------------------------------------------------------------------------- /PIO Codes/DHT11 Sensor Demo/DHT.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | from utime import sleep_ms 4 | from rp2 import PIO, asm_pio, StateMachine 5 | 6 | 7 | DHT11_sensor = const(0) 8 | DHT2x_sensor = const(1) 9 | 10 | 11 | class DHT(): 12 | 13 | @asm_pio(set_init = PIO.OUT_HIGH, 14 | in_shiftdir = PIO.SHIFT_LEFT, 15 | autopush = True) 16 | 17 | def io_ops(): 18 | set(pindirs, 1) # Set the sensor pin as an output 19 | set(pins, 1) # Set the pin high 20 | nop() [2] # Wait a bit 21 | set(pins, 0) # Set the pin low 22 | set(x, 20) # Create a delay of approximately 12000 cycles or 12000 / 500000 = 24ms 23 | label('loop1') # while holding the pin low 24 | set(y, 20) 25 | label('loop2') 26 | nop() [26] 27 | jmp(y_dec, 'loop2') 28 | jmp(x_dec, 'loop1') 29 | 30 | set(pindirs, 0) # Set sensor pin as an input 31 | wait(1, pin, 0) # Wait for a high level response from the sensor 32 | wait(0, pin, 0) # Wait for a low level response from the sensor 33 | wait(1, pin, 0) # Wait for a high level response from the sensor 34 | wait(0, pin, 0) # Wait for a low level response from the sensor 35 | 36 | set(x, 4) # Start recording 5 bytes of sensor data output 37 | label('bytes') 38 | set(y, 7) # Each byte contains 8 bits 39 | label('bits') 40 | wait(1, pin, 0) [25] # Wait for a high level response from the sensor and the wait for 25 / 500000 = 50us 41 | in_(pins, 1) # After 50us if the sensor is sending high out put then fill ISR with 1 or else fill with 0 and shift by 1 bit 42 | wait(0, pin, 0) # Wait for a low level response from the sensor 43 | jmp(y_dec, 'bits') 44 | jmp(x_dec, 'bytes') 45 | 46 | push(block) # Finally push data out of RX_FIFO 47 | 48 | 49 | def __init__(self, _pin, _sensor, _sm = 0): 50 | self.pin = Pin(_pin, Pin.IN, Pin.PULL_UP) 51 | self.rh = 0 52 | self.t = 0 53 | self.checksum = 0 54 | self.sensor = _sensor 55 | self.sm = StateMachine(_sm, DHT.io_ops, 56 | freq = 500000, 57 | in_base = self.pin, 58 | set_base = self.pin) 59 | self.sm.active(1) 60 | 61 | 62 | def get_reading(self): 63 | self.sm.restart() 64 | value = self.sm.get() 65 | CRC = (self.sm.get() & 0xFF) 66 | 67 | byte_1 = ((value >> 24) & 0xFF) 68 | byte_2 = ((value >> 16) & 0xFF) 69 | byte_3 = ((value >> 8) & 0xFF) 70 | byte_4 = (value & 0xFF) 71 | 72 | self.checksum = (byte_1 + byte_2 + byte_3 + byte_4) 73 | 74 | if(self.checksum == CRC): 75 | sleep_ms(800) 76 | if(self.sensor == DHT2x_sensor): 77 | sign = 0 78 | 79 | if(byte_3 & 0x80): 80 | sign = -1 81 | 82 | else: 83 | sign = 1 84 | 85 | self.rh = (((byte_1 << 8) + byte_2) / 10) 86 | self.t = (((((byte_3 & 0x7F) << 8) + byte_4) * sign) / 10) 87 | 88 | else: 89 | self.rh = (byte_1 + (byte_2 / 100)) 90 | self.t = (byte_3 + (byte_4 / 100)) 91 | 92 | 93 | 94 | 95 | class DHT11(DHT): 96 | def __init__(self, pin, sm = 0): 97 | super().__init__(pin, DHT11_sensor, sm) 98 | 99 | 100 | class DHT2x(DHT): 101 | def __init__(self, pin, sm = 0): 102 | super().__init__(pin, DHT2x_sensor, sm) 103 | 104 | 105 | 106 | -------------------------------------------------------------------------------- /PIO Codes/DHT11 Sensor Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from DHT import DHT11 3 | from ST7789 import TFT114 4 | from utime import sleep_ms 5 | 6 | 7 | LED = Pin(25, Pin.OUT) 8 | dht = DHT11(0) 9 | tft = TFT114() 10 | 11 | 12 | 13 | def write_text(text, x, y, size, color): 14 | background = tft.pixel(x, y) 15 | info = [] 16 | 17 | tft.text(text, x, y, color) 18 | for i in range(x, x + (8 * len(text))): 19 | for j in range(y, y + 8): 20 | px_color = tft.pixel(i, j) 21 | info.append((i, j, px_color)) if px_color == color else None 22 | 23 | tft.text(text, x, y, background) 24 | 25 | for px_info in info: 26 | tft.fill_rect(size*px_info[0] - (size-1)*x , size*px_info[1] - (size-1)*y, size, size, px_info[2]) 27 | 28 | 29 | while(True): 30 | LED.toggle() 31 | dht.get_reading() 32 | tft.fill(tft.BLACK) 33 | write_text("DHT11 PIO", 10, 4, 3, tft.CYAN) 34 | write_text(("RH/%: " + str("%2.1f" %dht.rh)), 0, 56, 3, tft.GREEN) 35 | write_text(("T/'C: " + str("%2.1f" %dht.t)), 0, 96, 3, tft.RED) 36 | tft.show() 37 | sleep_ms(400) 38 | -------------------------------------------------------------------------------- /PIO Codes/DHT22 Sensor Demo/DHT.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | from utime import sleep_ms 4 | from rp2 import PIO, asm_pio, StateMachine 5 | 6 | 7 | DHT11_sensor = const(0) 8 | DHT2x_sensor = const(1) 9 | 10 | 11 | class DHT(): 12 | 13 | @asm_pio(set_init = PIO.OUT_HIGH, 14 | in_shiftdir = PIO.SHIFT_LEFT, 15 | push_thresh = 8, 16 | autopush = True) 17 | 18 | def io_ops(): 19 | set(pindirs, 1) # Set the sensor pin as an output 20 | set(pins, 0) # Set the pin low 21 | set(x, 20) # Create a delay of approximately 10000 cycles or 10000 / 500000 = 20ms 22 | label('loop1') # while holding the pin low 23 | set(y, 20) 24 | label('loop2') 25 | nop() [22] 26 | jmp(y_dec, 'loop2') 27 | jmp(x_dec, 'loop1') 28 | 29 | set(pindirs, 0) 30 | wait(1, pin, 0) 31 | wait(0, pin, 0) 32 | wait(1, pin, 0) 33 | 34 | set(x, 4) 35 | label('bytes') 36 | set(y, 7) 37 | label('bits') 38 | wait(0, pin, 0) 39 | wait(1, pin, 0) [24] 40 | in_(pins, 1) 41 | jmp(y_dec, 'bits') 42 | jmp(x_dec, 'bytes') 43 | 44 | 45 | 46 | def __init__(self, _pin, _sensor, _sm = 0): 47 | self.pin = Pin(_pin, Pin.IN, Pin.PULL_UP) 48 | self.rh = 0 49 | self.t = 0 50 | self.checksum = 0 51 | self.sensor = _sensor 52 | self.sm = StateMachine(_sm, DHT.io_ops, 53 | freq = 500000, 54 | in_base = self.pin, 55 | set_base = self.pin) 56 | self.sm.active(1) 57 | 58 | 59 | def get_reading(self): 60 | data = [] 61 | 62 | self.sm.restart() 63 | 64 | for i in range(0, 5): 65 | data.append(self.sm.get()) 66 | 67 | self.checksum = ((data[0] + data[1] + data[2] + data[3]) & 0xFF) 68 | 69 | if(data[4] == self.checksum): 70 | if(self.sensor == DHT2x_sensor): 71 | sign = 0 72 | 73 | if(data[2] & 0x80): 74 | sign = -1 75 | 76 | else: 77 | sign = 1 78 | 79 | self.rh = (((data[0] << 8) + data[1]) / 10) 80 | self.t = (((((data[2] & 0x7F) << 8) + data[3]) * sign) / 10) 81 | 82 | else: 83 | self.rh = (data[0] + (data[1] / 100)) 84 | self.t = (data[2] + (data[3] / 100)) 85 | 86 | 87 | 88 | 89 | class DHT11(DHT): 90 | def __init__(self, pin, sm = 0): 91 | super().__init__(pin, DHT11_sensor, sm) 92 | 93 | 94 | class DHT2x(DHT): 95 | def __init__(self, pin, sm = 0): 96 | super().__init__(pin, DHT2x_sensor, sm) 97 | 98 | 99 | 100 | 101 | -------------------------------------------------------------------------------- /PIO Codes/DHT22 Sensor Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from DHT import DHT2x 3 | from ST7789 import TFT114 4 | from utime import sleep_ms 5 | 6 | 7 | LED = Pin(25, Pin.OUT) 8 | dht = DHT2x(0) 9 | tft = TFT114() 10 | 11 | 12 | 13 | def write_text(text, x, y, size, color): 14 | background = tft.pixel(x, y) 15 | info = [] 16 | 17 | tft.text(text, x, y, color) 18 | for i in range(x, x + (8 * len(text))): 19 | for j in range(y, y + 8): 20 | px_color = tft.pixel(i, j) 21 | info.append((i, j, px_color)) if px_color == color else None 22 | 23 | tft.text(text, x, y, background) 24 | 25 | for px_info in info: 26 | tft.fill_rect(size*px_info[0] - (size-1)*x , size*px_info[1] - (size-1)*y, size, size, px_info[2]) 27 | 28 | 29 | while(True): 30 | LED.toggle() 31 | dht.get_reading() 32 | tft.fill(tft.BLACK) 33 | write_text("DHT11 PIO", 10, 4, 3, tft.CYAN) 34 | write_text(("RH/%: " + str("%2.1f" %dht.rh)), 0, 56, 3, tft.GREEN) 35 | write_text(("T/'C: " + str("%2.1f" %dht.t)), 0, 96, 3, tft.RED) 36 | tft.show() 37 | sleep_ms(400) 38 | -------------------------------------------------------------------------------- /PIO Codes/Driving 7 Segment Displays with PIO - Murata Resistive Rotation Sensor/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, ADC 2 | from utime import sleep_ms 3 | from rp2 import PIO, asm_pio, StateMachine 4 | 5 | 6 | seg = 0 7 | value = 0 8 | 9 | 10 | seg_code_list = [ 11 | 0xC0, # 0 12 | 0xF9, # 1 13 | 0xA4, # 2 14 | 0xB0, # 3 15 | 0x99, # 4 16 | 0x92, # 5 17 | 0x82, # 6 18 | 0xF8, # 7 19 | 0x80, # 8 20 | 0x90, # 9 21 | 0x9C, # Degree Symbol 22 | ] 23 | 24 | seg_pos_list = [ 25 | 0x0E, # 1st 26 | 0x0D, # 2nd 27 | 0x0B, # 3rd 28 | 0x07, # 4th 29 | ] 30 | 31 | 32 | @asm_pio(out_shiftdir = PIO.SHIFT_RIGHT, 33 | autopull = True, 34 | pull_thresh = 12, 35 | out_init = ((PIO.OUT_HIGH, ) * 12)) 36 | 37 | def drive_display(): 38 | pull(ifempty) # Pull data from TX_FIFO if empty 39 | out(pins, 12) 40 | 41 | 42 | sm1 = StateMachine(0, drive_display, freq = 1000000, out_base = Pin(2)) 43 | sm1.active(1) 44 | 45 | 46 | def send_data(value, pos): 47 | temp = seg_pos_list[pos] 48 | temp <<= 8 49 | temp |= seg_code_list[value] 50 | sm1.put(temp) 51 | 52 | 53 | @asm_pio() 54 | 55 | def periodic_irq(): 56 | wrap_target() 57 | 58 | set(y, 6) # Use y scratch register for loop count 59 | 60 | label('loop') # delay loop 61 | nop() [12] # 1 + 12 = 13 cycle delay 62 | jmp(y_dec, 'loop') # decrement y scratch register and loopback 63 | 64 | irq(rel(0)) # if y scratch register is 0 then trigger interrupt 65 | wrap() 66 | 67 | 68 | def periodic_irq_callback(sm): 69 | global seg 70 | 71 | point = False 72 | 73 | if(seg == 0): 74 | val = (value // 100) 75 | elif(seg == 1): 76 | val = ((value % 100) // 10) 77 | point = True 78 | elif(seg == 2): 79 | val = (value % 10) 80 | else: 81 | val = 10 82 | 83 | send_data(val, seg) 84 | 85 | seg += 1 86 | 87 | if(seg > 3): 88 | seg = 0 89 | 90 | 91 | sm2 = StateMachine(1, periodic_irq, freq = 100000) 92 | sm2.irq(periodic_irq_callback) 93 | sm2.active(1) 94 | 95 | angle_sensor = ADC(Pin(28)) 96 | 97 | 98 | while(True): 99 | angle_sensor_value = 0 100 | avg = 0 101 | 102 | for i in range (0, 16): 103 | avg += angle_sensor.read_u16() 104 | sleep_ms(10) 105 | 106 | avg >>= 4 107 | 108 | angle_sensor_value = ((avg * 360) / 65536) 109 | 110 | value = int(angle_sensor_value) 111 | sleep_ms(600) 112 | 113 | -------------------------------------------------------------------------------- /PIO Codes/Driving LCTech Dual 74HC164 Seven Segment Display Module with PIO (DHT11)/74HC164 8 Digit 7 Segment Display.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/PIO Codes/Driving LCTech Dual 74HC164 Seven Segment Display Module with PIO (DHT11)/74HC164 8 Digit 7 Segment Display.pdf -------------------------------------------------------------------------------- /PIO Codes/Driving LCTech Dual 74HC164 Seven Segment Display Module with PIO (DHT11)/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, ADC 3 | from utime import sleep_ms 4 | from rp2 import PIO, asm_pio, StateMachine 5 | import dht 6 | 7 | 8 | DAT_pin = const(16) 9 | CLK_pin = const(17) 10 | 11 | 12 | seg = 0 13 | value_1 = 1234 14 | value_2 = 5678 15 | 16 | 17 | seg_code_list = [ 18 | 0x03, # 0 19 | 0x9F, # 1 20 | 0x25, # 2 21 | 0x0D, # 3 22 | 0x99, # 4 23 | 0x49, # 5 24 | 0x41, # 6 25 | 0x1F, # 7 26 | 0x01, # 8 27 | 0x09, # 9 28 | ] 29 | 30 | seg_pos_list = [ 31 | #Segment locations from top to bottom 32 | 0x80, 33 | 0x40, 34 | 0x20, 35 | 0x10, 36 | 0x08, 37 | 0x04, 38 | 0x02, 39 | 0x01, 40 | ] 41 | 42 | 43 | @asm_pio(out_shiftdir = PIO.SHIFT_RIGHT, 44 | autopull = True, 45 | pull_thresh = 16, 46 | out_init = PIO.OUT_LOW, 47 | sideset_init = PIO.OUT_HIGH) 48 | 49 | def drive_display(): 50 | 51 | wrap_target() 52 | set(y, 15) # use y scratch register as a bit counter 53 | label('loop') # data sending loop 54 | out(pins, 1) # Toggle the state of DAT pin according to the bit value of LSB 55 | nop() .side(1) # Wait a bit and set CLK pin high 56 | jmp(y_dec, 'loop') .side(0) # Decrement y register value and set CLK pin low 57 | pull(ifempty) # Pull data from TX_FIFO if empty and load new data to 74HC164 ICs 58 | wrap() 59 | 60 | 61 | sm1 = StateMachine(0, drive_display, freq = 10000000, out_base = Pin(DAT_pin), sideset_base = Pin(CLK_pin)) 62 | sm1.active(1) 63 | 64 | 65 | def send_data(value, pos, point): 66 | temp = seg_pos_list[pos] 67 | temp <<= 8 68 | temp |= seg_code_list[value] 69 | 70 | if(point == True): 71 | temp &= 0xFFFE 72 | 73 | sm1.put(temp) 74 | 75 | 76 | @asm_pio() 77 | 78 | def periodic_irq(): 79 | 80 | """ 81 | Total Delay = (1 + (6 + 1) * (12 + 1 + 1) + 1) = 100 cycles 82 | Interrupt Frequency = 100000 / 100 = 1000 Hz 83 | 84 | """ 85 | wrap_target() 86 | 87 | set(x, 6) # Use x scratch register for loop count 88 | 89 | label('loop') # delay loop 90 | nop() [12] # 1 + 12 = 13 cycle delay 91 | jmp(x_dec, 'loop') # decrement x scratch register and loopback 92 | 93 | irq(rel(0)) # if x scratch register is 0 then trigger interrupt 94 | wrap() 95 | 96 | 97 | def periodic_irq_callback(sm): 98 | global seg 99 | 100 | point = False 101 | 102 | if(seg == 0): 103 | send_data((value_1 // 1000), 0, False) 104 | elif(seg == 1): 105 | send_data(((value_1 % 1000) // 100), 1, True) 106 | elif(seg == 2): 107 | send_data(((value_1 % 100) // 10), 2, False) 108 | elif(seg == 3): 109 | send_data((value_1 % 10), 3, False) 110 | elif(seg == 4): 111 | send_data((value_2 // 1000), 4, False) 112 | elif(seg == 5): 113 | send_data(((value_2 % 1000) // 100), 5, True) 114 | elif(seg == 6): 115 | send_data(((value_2 % 100) // 10), 6, False) 116 | else: 117 | send_data((value_2 % 10), 7, False) 118 | 119 | seg += 1 120 | 121 | if(seg > 7): 122 | seg = 0 123 | 124 | 125 | sm2 = StateMachine(1, periodic_irq, freq = 100000) 126 | sm2.irq(periodic_irq_callback) 127 | sm2.active(1) 128 | 129 | 130 | DHT = dht.DHT11(Pin(0, Pin.IN)) 131 | 132 | 133 | while(True): 134 | DHT.measure() 135 | t = DHT.temperature() 136 | rh = DHT.humidity() 137 | 138 | value_1 = int(t * 100) 139 | value_2 = int(rh * 100) 140 | 141 | sleep_ms(400) 142 | 143 | 144 | -------------------------------------------------------------------------------- /PIO Codes/Driving Waveshare 7 Segment Display with PIO and State Machine Periodic Interrupt (GP2Y3E)/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, ADC 3 | from utime import sleep_ms 4 | from rp2 import PIO, asm_pio, StateMachine 5 | 6 | 7 | mosi_pin = const(11) 8 | sck_pin = const(10) 9 | rclk_pin = const(9) 10 | 11 | 12 | seg = 0 13 | value = 0 14 | 15 | 16 | seg_code_list = [ 17 | 0x3F, # 0 18 | 0x06, # 1 19 | 0x5B, # 2 20 | 0x4F, # 3 21 | 0x66, # 4 22 | 0x6D, # 5 23 | 0x7D, # 6 24 | 0x07, # 7 25 | 0x7F, # 8 26 | 0x6F, # 9 27 | 0x77, # A 28 | 0x7C, # b 29 | 0x39, # C 30 | 0x5E, # d 31 | 0x79, # E 32 | 0x71 # F 33 | ] 34 | 35 | seg_pos_list = [ 36 | 0xFE, # 1st 37 | 0xFD, # 2nd 38 | 0xFB, # 3rd 39 | 0xF7, # 4th 40 | ] 41 | 42 | 43 | @asm_pio(out_shiftdir = PIO.SHIFT_LEFT, 44 | autopull = True, 45 | pull_thresh = 16, 46 | out_init = PIO.OUT_LOW, 47 | sideset_init = (PIO.OUT_LOW, PIO.OUT_LOW)) 48 | 49 | def drive_display(): 50 | 51 | wrap_target() 52 | set(x, 15) .side(0b00) # use x scratch register as a bit counter and clear RCLK and SCLK 53 | label('loop') # data sending loop 54 | out(pins, 1) .side(0b00) # Toggle MOSI pin according to the bit value of MSB while holding SCLK and RCLK low 55 | jmp(x_dec, 'loop') .side(0b10) # Decrement x register value and set SCLK 56 | pull(ifempty) .side(0b01) # Pull data from TX_FIFO if empty and load new data to 74HC595s by setting RCLK high 57 | wrap() 58 | 59 | 60 | sm1 = StateMachine(0, drive_display, freq = 1000000, out_base = Pin(mosi_pin), sideset_base = Pin(rclk_pin)) 61 | sm1.active(1) 62 | 63 | 64 | def send_data(value, pos): 65 | temp = seg_pos_list[pos] 66 | temp <<= 8 67 | temp |= seg_code_list[value] 68 | 69 | sm1.put(temp << 16) 70 | 71 | 72 | @asm_pio() 73 | 74 | def periodic_irq(): 75 | 76 | """ 77 | Total Delay = (1 + (6 + 1) * (12 + 1 + 1) + 1) = 100 cycles 78 | Interrupt Frequency = 100000 / 100 = 1000 Hz 79 | 80 | """ 81 | wrap_target() 82 | 83 | set(y, 6) # Use y scratch register for loop count 84 | 85 | label('loop') # delay loop 86 | nop() [12] # 1 + 12 = 13 cycle delay 87 | jmp(y_dec, 'loop') # decrement y scratch register and loopback 88 | 89 | irq(rel(0)) # if y scratch register is 0 then trigger interrupt 90 | wrap() 91 | 92 | 93 | def periodic_irq_callback(sm): 94 | global seg 95 | 96 | point = False 97 | 98 | if(seg == 0): 99 | val = (value // 1000) 100 | elif(seg == 1): 101 | val = ((value % 1000) // 100) 102 | point = True 103 | elif(seg == 2): 104 | val = ((value % 100) // 10) 105 | else: 106 | val = (value % 10) 107 | 108 | send_data(val, seg) 109 | 110 | seg += 1 111 | 112 | if(seg > 3): 113 | seg = 0 114 | 115 | 116 | sm2 = StateMachine(1, periodic_irq, freq = 100000) 117 | sm2.irq(periodic_irq_callback) 118 | sm2.active(1) 119 | 120 | 121 | d_sensor = ADC(Pin(27)) 122 | state_pin = Pin(16, Pin.OUT) 123 | 124 | 125 | 126 | while(True): 127 | d = 0 128 | avg = 0 129 | state_pin.on() 130 | 131 | for i in range (0, 8): 132 | avg += d_sensor.read_u16() 133 | sleep_ms(10) 134 | 135 | avg >>= 3 136 | 137 | state_pin.off() 138 | 139 | d = ((avg * 3300.0) / 65536.0) 140 | value = int(3140.25 - (d * 2.158)) 141 | sleep_ms(400) 142 | 143 | -------------------------------------------------------------------------------- /PIO Codes/Driving Waveshare 7 Segment Display with PIO and Timer (TMP36)/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, ADC, Timer 3 | from utime import sleep_ms 4 | from rp2 import PIO, asm_pio, StateMachine 5 | 6 | 7 | mosi_pin = const(11) 8 | sck_pin = const(10) 9 | rclk_pin = const(9) 10 | 11 | 12 | conversion_factor = 3300 / 65535 13 | 14 | 15 | seg = 0 16 | value = 0 17 | 18 | 19 | seg_code_list = [ 20 | 0x3F, # 0 21 | 0x06, # 1 22 | 0x5B, # 2 23 | 0x4F, # 3 24 | 0x66, # 4 25 | 0x6D, # 5 26 | 0x7D, # 6 27 | 0x07, # 7 28 | 0x7F, # 8 29 | 0x6F, # 9 30 | 0x77, # A 31 | 0x7C, # b 32 | 0x39, # C 33 | 0x5E, # d 34 | 0x79, # E 35 | 0x71 # F 36 | ] 37 | 38 | seg_pos_list = [ 39 | 0xFE, # 1st 40 | 0xFD, # 2nd 41 | 0xFB, # 3rd 42 | 0xF7, # 4th 43 | ] 44 | 45 | 46 | @asm_pio(out_shiftdir = PIO.SHIFT_LEFT, 47 | autopull = True, 48 | pull_thresh = 16, 49 | out_init = PIO.OUT_LOW, 50 | sideset_init = (PIO.OUT_LOW, PIO.OUT_LOW)) 51 | 52 | def drive_display(): 53 | 54 | wrap_target() 55 | set(y, 15) .side(0b00) # use y scratch register as a bit counter and clear RCLK and SCLK 56 | label('loop') # data sending loop 57 | out(pins, 1) .side(0b00) # Toggle MOSI pin according to the bit value of MSB while holding SCLK and RCLK low 58 | jmp(y_dec, 'loop') .side(0b10) # Decrement y register value and set SCLK 59 | pull(ifempty) .side(0b01) # Pull data from TX_FIFO if empty and load new data to 74HC595s by setting RCLK high 60 | wrap() 61 | 62 | 63 | sm = StateMachine(0, drive_display, freq = 1000000, out_base = Pin(mosi_pin), sideset_base = Pin(rclk_pin)) 64 | 65 | sm.active(1) 66 | 67 | 68 | def send_data(value, pos, dot): 69 | temp = seg_pos_list[pos] 70 | temp <<= 8 71 | temp |= seg_code_list[value] 72 | 73 | if(dot == True): 74 | temp |= 0x80 75 | 76 | sm.put(temp << 16) 77 | 78 | 79 | def timer_callback(t): 80 | global seg 81 | 82 | point = False 83 | 84 | if(seg == 0): 85 | val = int(value / 100) 86 | elif(seg == 1): 87 | val = int((value % 100) / 10) 88 | point = True 89 | elif(seg == 2): 90 | val = int(value % 10) 91 | else: 92 | val = 12 93 | 94 | send_data(val, seg, point) 95 | seg += 1 96 | 97 | if(seg > 3): 98 | seg = 0 99 | 100 | 101 | tim = Timer(mode = Timer.PERIODIC, period = 1, callback = timer_callback) 102 | t_sensor = ADC(Pin(26)) 103 | 104 | 105 | while(True): 106 | avg = 0 107 | for i in range (0, 64): 108 | avg += t_sensor.read_u16() 109 | sleep_ms(4) 110 | avg >>= 6 111 | 112 | t_reading = avg * conversion_factor 113 | value = (t_reading / 3) 114 | sleep_ms(250) 115 | 116 | -------------------------------------------------------------------------------- /PIO Codes/Frequency Counter/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from time import sleep_ms, ticks_us 3 | from rp2 import asm_pio, StateMachine, PIO 4 | from ST7789 import TFT114 5 | 6 | t1 = 0 7 | t2 = 0 8 | t_diff = 0 9 | 10 | 11 | @asm_pio() 12 | def IO_ops(): 13 | irq(clear, 0) # clear irq 0 14 | wait(1, pin, 0) # wait for high logic on pin index 0, i.e sense pin 15 | irq(rel(0)) # raise IRQ 0 16 | wait(0, pin, 0) # wait for logic low on pin index 0, i.e sense pin 17 | 18 | 19 | def irq_0_handler(sm): 20 | global t1, t2, t_diff 21 | t2 = ticks_us() 22 | t_diff = (t2 - t1) 23 | t1 = t2 24 | 25 | 26 | sense_pin = Pin(0, Pin.IN) 27 | tft = TFT114() 28 | 29 | sm = StateMachine(0, IO_ops, in_base = sense_pin) 30 | sm.irq(irq_0_handler) 31 | sm.active(1) 32 | 33 | 34 | def write_text(text, x, y, size, color): 35 | background = tft.pixel(x, y) 36 | info = [] 37 | 38 | tft.text(text, x, y, color) 39 | for i in range(x, x + (8 * len(text))): 40 | for j in range(y, y + 8): 41 | px_color = tft.pixel(i, j) 42 | info.append((i, j, px_color)) if px_color == color else None 43 | 44 | tft.text(text, x, y, background) 45 | 46 | for px_info in info: 47 | tft.fill_rect(size*px_info[0] - (size-1)*x , size*px_info[1] - (size-1)*y, size, size, px_info[2]) 48 | 49 | 50 | while(True): 51 | period = t_diff 52 | tft.fill(tft.BLACK) 53 | write_text("RP2040 PICO PIO", 0, 6, 2, tft.WHITE) 54 | write_text("Frequency Meter", 0, 30, 2, tft.WHITE) 55 | 56 | if(period > 999): 57 | f = 1000000 / (period + 1) 58 | write_text("f/ Hz: " + str("%2.2f" %f), 2, 65, 2, tft.MAGENTA) 59 | else: 60 | f = 1000 / (period + 1) 61 | write_text("f/kHz: " + str("%2.2f" %f), 2, 65, 2, tft.MAGENTA) 62 | 63 | 64 | write_text("T/us : " + str("%4u" %period), 2, 105, 2, tft.CYAN) 65 | 66 | tft.show() 67 | 68 | sleep_ms(600) 69 | 70 | 71 | -------------------------------------------------------------------------------- /PIO Codes/HC-SR04 SONAR Demo/SONAR.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from rp2 import asm_pio, StateMachine, PIO 3 | from utime import sleep_ms, sleep_us, ticks_us, ticks_diff 4 | 5 | 6 | t1 = 0 7 | t2 = 0 8 | t_diff = 0 9 | 10 | 11 | class SONAR(): 12 | 13 | @asm_pio(sideset_init = PIO.OUT_LOW) 14 | def IO_ops(): 15 | irq(clear, 0) # clear irq 0 16 | irq(clear, 1) # clear irq 1 17 | set(x, 9) # set x scratch register to count 10 (approximately 10 / 1000000 = 10us high time is needed for HC-SR04 to be triggred) 18 | nop() .side(1) # wait one cycle and set the trigger pin high 19 | label("trigger") # trigger delay start 20 | jmp(x_dec, "trigger") # decement x scratch register value and loopback until x scratch register is zero 21 | nop() .side(0) # wait one cycle and set the trigger pin low 22 | 23 | wait(1, pin, 0) # wait for high logic on pin index 0, i.e echo pin 24 | irq(0) # set IRQ index 0 and wait for IRQ ack 25 | wait(0, pin, 0) # wait for logic low on pin index 0, i.e echo pin 26 | irq(1) # set IRQ index 1 and wait for IRQ ack 27 | 28 | 29 | def irq_0_handler(sm): 30 | global t1, t2, t_diff 31 | t1 = 0 32 | 33 | 34 | def irq_1_handler(sm): 35 | global t1, t2, t_diff 36 | t2 = ticks_us() 37 | t_diff = ticks_diff(t2, t1) 38 | t1 = t2 39 | 40 | 41 | def get_reading_in_cm(self): 42 | global t_diff 43 | return (t_diff // 58) 44 | 45 | 46 | def get_reading_in_in(self): 47 | global t_diff 48 | return (t_diff // 148) 49 | 50 | 51 | def get_reading_us(self): 52 | global t_diff 53 | return (t_diff) 54 | 55 | 56 | def __init__(self, _trigger_pin, _echo_pin, _sm = 0): 57 | self.sm = _sm 58 | 59 | self.ECHO_pin = Pin(_echo_pin, Pin.IN) 60 | self.TRIGGER_pin = Pin(_trigger_pin, Pin.OUT) 61 | 62 | self.sm = StateMachine(0, SONAR.IO_ops, in_base = self.ECHO_pin, sideset_base = self.TRIGGER_pin, freq = 1000000) 63 | 64 | self.sm.irq(SONAR.irq_0_handler) 65 | self.sm.irq(SONAR.irq_1_handler) 66 | 67 | self.sm.active(1) 68 | 69 | 70 | -------------------------------------------------------------------------------- /PIO Codes/HC-SR04 SONAR Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms 3 | from rp2 import asm_pio, StateMachine, PIO 4 | from SONAR import SONAR 5 | from ST7789 import TFT114 6 | 7 | 8 | bar = 0 9 | distance = 0 10 | 11 | sonar = SONAR(15, 14) 12 | tft = TFT114() 13 | 14 | 15 | def map_value(v, x_min, x_max, y_min, y_max): 16 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 17 | 18 | 19 | def constrain(value, min_value, max_value): 20 | if(value > max_value): 21 | return max_value 22 | 23 | elif(value < min_value): 24 | return min_value 25 | 26 | else: 27 | return value 28 | 29 | 30 | 31 | def write_text(text, x, y, size, color): 32 | background = tft.pixel(x, y) 33 | info = [] 34 | 35 | tft.text(text, x, y, color) 36 | for i in range(x, x + (8 * len(text))): 37 | for j in range(y, y + 8): 38 | px_color = tft.pixel(i, j) 39 | info.append((i, j, px_color)) if px_color == color else None 40 | 41 | tft.text(text, x, y, background) 42 | 43 | for px_info in info: 44 | tft.fill_rect(size*px_info[0] - (size-1)*x , size*px_info[1] - (size-1)*y, size, size, px_info[2]) 45 | 46 | 47 | while(True): 48 | 49 | distance = sonar.get_reading_in_cm() 50 | distance = constrain(distance, 0, 500) 51 | bar = map_value(distance, 0, 500, 0, 219) 52 | bar = constrain(bar, 0, 219) 53 | tft.fill(tft.BLACK) 54 | 55 | write_text("HC-SR04 PIO", 25, 4, 2, tft.WHITE) 56 | write_text("D/cm: " + str("%3u" %distance), 6, 45, 3, tft.YELLOW) 57 | tft.rect(9, 90, 222, 15, tft.RED) 58 | tft.fill_rect(10, 92, bar, 13, tft.GREEN) 59 | 60 | for i in range(0, 230, 20): 61 | tft.vline((10 + i), 112, 10, tft.BLUE) 62 | tft.vline((20 + i), 112, 5, tft.MAGENTA) 63 | 64 | tft.show() 65 | 66 | sleep_ms(600) 67 | 68 | -------------------------------------------------------------------------------- /PIO Codes/Police Lights/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms 3 | from rp2 import PIO, asm_pio, StateMachine 4 | 5 | 6 | @asm_pio(set_init = PIO.OUT_LOW, sideset_init = PIO.OUT_HIGH) 7 | def police_lights(): 8 | """ 9 | Total no. of cycles = (1 + 1 + (29 + 1) * (6 + 1) + 1) * 2 = 426 cycles 10 | Flash frequency = 2000 / 426 = 4.69Hz 11 | """ 12 | 13 | wrap_target() 14 | 15 | set(pins, 0) .side(1) 16 | 17 | set(x, 29) 18 | label("delay_1") 19 | nop() [6] 20 | jmp(x_dec, "delay_1") 21 | 22 | set(pins, 1) .side(0) 23 | 24 | set(y, 29) 25 | label("delay_2") 26 | nop() [6] 27 | jmp(y_dec, "delay_2") 28 | 29 | wrap() 30 | 31 | 32 | sm = StateMachine(0, police_lights, freq = 2000, set_base = Pin(2), sideset_base = Pin(3)) 33 | 34 | sm.active(1) -------------------------------------------------------------------------------- /PIO Codes/RGB Matrix BD Flag/main.py: -------------------------------------------------------------------------------- 1 | from RGB_Matrix import RGB_Matrix 2 | from utime import sleep_ms 3 | from random import randint 4 | 5 | 6 | tgl = 0 7 | ws = RGB_Matrix(6) 8 | 9 | while(True): 10 | ws.pixels_fill(ws.YELLOW) 11 | tgl = tgl ^ 1 12 | for i in range(0, 2): 13 | for k in range(0, 16, 2): 14 | if(tgl): 15 | ws.draw_V_line(k, (1 - i), (8 + i), ws.GREEN) 16 | ws.draw_V_line((k + 1), (2 - i), (7 + i), ws.GREEN) 17 | else: 18 | ws.draw_V_line((k + 1), (1 - i), (8 + i), ws.GREEN) 19 | ws.draw_V_line(k, (2 - i), (7 + i), ws.GREEN) 20 | 21 | 22 | ws.draw_circle((8 + i), (tgl + 4), 2, True, ws.RED) 23 | ws.pixels_show(15) 24 | sleep_ms(randint(50, 300)) -------------------------------------------------------------------------------- /PIO Codes/RGB Matrix Random Pixels/main.py: -------------------------------------------------------------------------------- 1 | from RGB_Matrix import RGB_Matrix 2 | from utime import sleep_ms 3 | from random import randint, randrange 4 | 5 | 6 | ws = RGB_Matrix(6) 7 | 8 | while(True): 9 | #ws.pixels_fill(ws.BLACK) 10 | x_pos = randrange(0, 16) 11 | y_pos = randrange(0, 10) 12 | ws.draw_pixel(x_pos, y_pos, (randint(0, 16), randint(0, 16), randint(0, 16))) 13 | ws.pixels_show(randint(10, 25)) 14 | sleep_ms(40) -------------------------------------------------------------------------------- /PIO Codes/RGB Matrix Thermometer/main.py: -------------------------------------------------------------------------------- 1 | from machine import ADC 2 | from RGB_Matrix import RGB_Matrix 3 | from utime import sleep_ms 4 | 5 | 6 | conversion_factor = 3300.0 / 65535.0 7 | 8 | 9 | t = 0 10 | tgl = 0 11 | ws = RGB_Matrix(6) 12 | TMP36 = ADC(1) 13 | 14 | 15 | def map_value(v, x_min, x_max, y_min, y_max): 16 | return int(y_min + (((y_max - y_min) / (x_max - x_min)) * (v - x_min))) 17 | 18 | 19 | def constrain_value(v, max_v, min_v): 20 | if(v >= max_v): 21 | v = max_v 22 | 23 | if(v <= min_v): 24 | v = min_v 25 | 26 | return v 27 | 28 | 29 | def adc_avg(): 30 | avg = 0 31 | for i in range (0, 16): 32 | avg += TMP36.read_u16() 33 | 34 | return (avg >> 4) 35 | 36 | 37 | def graphical_thermometer(value): 38 | ws.pixels_fill(ws.BLACK) 39 | 40 | ws.draw_V_line(0, 3, 5, ws.WHITE) 41 | ws.draw_V_line(1, 2, 6, ws.WHITE) 42 | ws.draw_V_line(2, 1, 7, ws.WHITE) 43 | ws.draw_V_line(3, 1, 7, ws.WHITE) 44 | ws.draw_V_line(4, 2, 6, ws.WHITE) 45 | ws.draw_H_line(5, 14, 3, ws.WHITE) 46 | ws.draw_H_line(5, 14, 5, ws.WHITE) 47 | ws.draw_pixel(15, 4, ws.WHITE) 48 | 49 | for i in range(5, 15, 2): 50 | ws.draw_V_line((i + 1), 7, 8, ws.BLUE) 51 | ws.draw_V_line(i, 7, 7, ws.GREEN) 52 | 53 | 54 | ws.draw_V_line(1, 3, 5, ws.RED) 55 | ws.draw_V_line(1, 3, 5, ws.RED) 56 | ws.draw_V_line(1, 3, 5, ws.RED) 57 | ws.draw_V_line(2, 2, 6, ws.RED) 58 | ws.draw_V_line(3, 2, 6, ws.RED) 59 | ws.draw_V_line(4, 3, 5, ws.RED) 60 | 61 | bar = map_value(value, 0, 50, 5, 14) 62 | bar = constrain_value(bar, 14, 5) 63 | 64 | ws.draw_H_line(5, bar, 4, ws.RED) 65 | 66 | 67 | def numerical_thermometer(value): 68 | ws.pixels_fill(ws.BLACK) 69 | ws.print_str(0, 2, (str("%s" %value) + "C"), (24, 9, 36), ws.BLACK) 70 | 71 | 72 | while(True): 73 | tmp = conversion_factor * adc_avg() 74 | t = int(tmp / 28.0) 75 | 76 | tgl = (tgl ^ 1) 77 | 78 | if(tgl == 0): 79 | numerical_thermometer(t) 80 | else: 81 | graphical_thermometer(t) 82 | 83 | ws.pixels_show(25) 84 | sleep_ms(3000) 85 | -------------------------------------------------------------------------------- /PIO Codes/Rotary Encoder/SH1107.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SPI 3 | from utime import sleep_ms, sleep_us 4 | import framebuf 5 | 6 | 7 | DC_pin = const(8) 8 | CS_pin = const(9) 9 | SCK_pin = const(10) 10 | MOSI_pin = const(11) 11 | RST_pin = const(12) 12 | 13 | SH1107_SET_LOWER_COLUMN_ADDRESS = const(0x00) 14 | SH1107_SET_UPPER_COLUMN_ADDRESS = const(0x10) 15 | SH1107_SET_PAGE_MEMORY_ADDRESSING_MODE = const(0x20) 16 | SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE = const(0x21) 17 | SH1107_SET_CONSTRAST_CONTROL = const(0x81) 18 | SH1107_SET_DC_DC_OFF_MODE = const(0x8A) 19 | SH1107_SET_DC_DC_ON_MODE = const(0x8B) 20 | SH1107_SET_SEGMENT_REMAP_NORMAL = const(0xA0) 21 | SH1107_SET_SEGMENT_REMAP_REVERSE = const(0xA1) 22 | SH1107_SET_ENTIRE_DISPLAY_OFF = const(0xA4) 23 | SH1107_SET_ENTIRE_DISPLAY_ON = const(0xA5) 24 | SH1107_SET_NORMAL_DISPLAY = const(0xA6) 25 | SH1107_SET_REVERSE_DISPLAY = const(0xA7) 26 | SH1107_SET_MULTIPLEX_RATIO = const(0xA8) 27 | SH1107_SET_DC_DC_CONTROL_MODE = const(0xAD) 28 | SH1107_DISPLAY_OFF = const(0xAE) 29 | SH1107_DISPLAY_ON = const(0xAF) 30 | SH1107_SET_PAGE_ADDRESS = const(0xB0) 31 | SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION = const(0xC0) 32 | SH1107_SET_DISPLAY_OFFSET = const(0xD3) 33 | SH1107_SET_DISPLAY_CLOCK_FREQUENCY = const(0xD5) 34 | SH1107_SET_PRECHARGE_DISCHARGE_PERIOD = const(0xD9) 35 | SH1107_SET_VCOM_DESELECT_LEVEL = const(0xDB) 36 | SH1107_SET_DISPLAY_START_LINE = const(0xDC) 37 | 38 | CMD = False 39 | DAT = True 40 | 41 | LOW = False 42 | HIGH = True 43 | 44 | 45 | class OLED_13(framebuf.FrameBuffer): 46 | def __init__(self): 47 | self.width = 128 48 | self.height = 64 49 | 50 | self.WHITE = 1 51 | self.BLACK = 0 52 | 53 | self.cs = Pin(CS_pin, Pin.OUT) 54 | self.rst = Pin(RST_pin, Pin.OUT) 55 | self.sck = Pin(SCK_pin, Pin.OUT) 56 | self.mosi = Pin(MOSI_pin, Pin.OUT) 57 | 58 | self.cs(HIGH) 59 | 60 | self.spi = SPI(1, 20000_000, polarity = 0, phase = 0,sck = self.sck, mosi = self.mosi,miso = None) 61 | 62 | self.dc = Pin(DC_pin, Pin.OUT) 63 | self.dc(HIGH) 64 | 65 | self.buffer = bytearray(self.height * (self.width // 8)) 66 | super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HMSB) 67 | self.init_display() 68 | 69 | 70 | def write(self, value, mode): 71 | self.dc(mode) 72 | self.cs(LOW) 73 | self.spi.write(bytearray([value])) 74 | self.cs(HIGH) 75 | 76 | 77 | def init_display(self): 78 | self.rst(HIGH) 79 | sleep_ms(1) 80 | self.rst(LOW) 81 | sleep_ms(10) 82 | self.rst(HIGH) 83 | 84 | self.write(SH1107_DISPLAY_OFF, CMD) 85 | 86 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS | 0x00), CMD) 87 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS | 0x00), CMD) 88 | 89 | self.write((SH1107_SET_PAGE_ADDRESS | 0x00), CMD) 90 | 91 | self.write(SH1107_SET_DISPLAY_START_LINE, CMD) 92 | self.write(0x00, CMD) 93 | self.write(SH1107_SET_CONSTRAST_CONTROL, CMD) 94 | self.write(0x6F, CMD) 95 | self.write(SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE, CMD) 96 | 97 | self.write(SH1107_SET_SEGMENT_REMAP_NORMAL, CMD) 98 | self.write((SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION | 0x00), CMD) 99 | self.write(SH1107_SET_ENTIRE_DISPLAY_OFF, CMD) 100 | 101 | self.write(SH1107_SET_NORMAL_DISPLAY, CMD) 102 | self.write(SH1107_SET_MULTIPLEX_RATIO, CMD) 103 | self.write(0x3F, CMD) 104 | 105 | self.write(SH1107_SET_DISPLAY_OFFSET, CMD) 106 | self.write(0x60, CMD) 107 | 108 | self.write(SH1107_SET_DISPLAY_CLOCK_FREQUENCY, CMD) 109 | self.write(0x41, CMD) 110 | 111 | self.write(SH1107_SET_PRECHARGE_DISCHARGE_PERIOD, CMD) 112 | self.write(0x22, CMD) 113 | 114 | self.write(SH1107_SET_VCOM_DESELECT_LEVEL, CMD) 115 | self.write(0x35, CMD) 116 | 117 | self.write(SH1107_SET_DC_DC_CONTROL_MODE, CMD) 118 | self.write(SH1107_SET_DC_DC_OFF_MODE, CMD) 119 | self.write(SH1107_DISPLAY_ON, CMD) 120 | 121 | 122 | def show(self): 123 | self.write(SH1107_SET_PAGE_ADDRESS, CMD) 124 | for page in range(0, 64): 125 | self.column = (63 - page) 126 | 127 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS + (self.column & 0x0F)), CMD) 128 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS + (self.column >> 4)), CMD) 129 | 130 | for num in range(0, 16): 131 | self.write((self.buffer[(page * 16) + num]), DAT) 132 | 133 | -------------------------------------------------------------------------------- /PIO Codes/Rotary Encoder/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from SH1107 import OLED_13 3 | from utime import sleep_ms 4 | from rp2 import asm_pio, StateMachine, PIO 5 | 6 | 7 | count = 0 8 | direction = 0 9 | 10 | 11 | @asm_pio(set_init = (PIO.IN_HIGH, PIO.IN_HIGH)) 12 | def rotary_encoder(): 13 | irq(clear, 0) # clear IRQ 0 14 | wrap_target() 15 | wait(0, pin, 1) # wait input_pins(1) goes LOW 16 | in_(pins, 2) # read input_pins into ISR 17 | push(block) # push ISR to RX FIFO 18 | irq(0) # raise IRQ 0 19 | wait(1, pin, 1) # wait input_pins(1) goes HIGH 20 | wrap() 21 | 22 | 23 | def irq_callback(sm): 24 | global count, direction 25 | 26 | if (sm.irq().flags() > 0): # check if there is an interrupt flag 27 | 28 | direction = sm.get() # get input states 29 | 30 | LED.toggle() 31 | 32 | if(direction == 0): 33 | count += 1 34 | else: 35 | count -= 1 36 | 37 | 38 | LED = Pin(25, Pin.OUT) 39 | 40 | oled = OLED_13() 41 | 42 | sm = StateMachine(0, rotary_encoder, in_base = Pin(18), freq = 25000) 43 | sm.irq(irq_callback) 44 | sm.active(1) 45 | 46 | 47 | while(True): 48 | oled.fill(oled.BLACK) 49 | 50 | oled.text("Count:", 6, 10, oled.WHITE) 51 | oled.text("Direction:", 6, 25, oled.WHITE) 52 | 53 | if(count > 9999): 54 | count = 0 55 | elif(count < 0): 56 | count = 9999 57 | 58 | oled.text(str("% 4u" % count), 45, 10, oled.WHITE) 59 | 60 | if(direction == 0): 61 | oled.text("UP", 86, 25, oled.WHITE) 62 | else: 63 | oled.text("DOWN", 86, 25, oled.WHITE) 64 | 65 | oled.show() 66 | sleep_ms(100) 67 | 68 | 69 | 70 | -------------------------------------------------------------------------------- /PIO Codes/TCS3200 Colour Sensor Demo/TCS3200.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from time import sleep_ms, ticks_us 3 | from rp2 import asm_pio, StateMachine, PIO 4 | from micropython import const 5 | 6 | 7 | t1 = 0 8 | t2 = 0 9 | t_diff = 0 10 | 11 | 12 | class TCS3200(): 13 | 14 | @asm_pio() 15 | 16 | def IO_ops(): 17 | irq(clear, 0) # clear irq 0 18 | wait(1, pin, 0) # wait for high logic on pin index 0, i.e sense pin 19 | irq(rel(0)) # raise IRQ 0 20 | wait(0, pin, 0) # wait for logic low on pin index 0, i.e sense pin 21 | 22 | 23 | def irq_0_handler(sm): 24 | global t1, t2, t_diff 25 | t2 = ticks_us() 26 | t_diff = (t2 - t1) 27 | t1 = t2 28 | 29 | 30 | def __init__(self, _f_pin, _s0_pin, _s1_pin, _s2_pin, _s3_pin): 31 | self.LOW_POWER_MODE = const(0x00) 32 | self.F_2_PC_MODE = const(0x01) 33 | self.F_20_PC_MODE = const(0x02) 34 | self.F_100_PC_MODE = const(0x03) 35 | 36 | self.RED_FILTER = const(0x00) 37 | self.CLEAR_FILTER = const(0x01) 38 | self.BLUE_FILTER = const(0x02) 39 | self.GREEN_FILTER = const(0x03) 40 | 41 | 42 | self.f_pin = Pin(_f_pin, Pin.IN) 43 | self.s0_pin = Pin(_s0_pin, Pin.OUT) 44 | self.s1_pin = Pin(_s1_pin, Pin.OUT) 45 | self.s2_pin = Pin(_s2_pin, Pin.OUT) 46 | self.s3_pin = Pin(_s3_pin, Pin.OUT) 47 | 48 | self.sm = StateMachine(0, 49 | TCS3200.IO_ops, 50 | in_base = self.f_pin) 51 | 52 | self.sm.irq(TCS3200.irq_0_handler) 53 | 54 | 55 | def get_raw_reading(self, out_mode, filter_mode): 56 | global t_diff 57 | 58 | self.sm.active(0) 59 | 60 | if(out_mode == self.F_2_PC_MODE): 61 | self.s1_pin.off() 62 | self.s0_pin.on() 63 | 64 | elif(out_mode == self.F_20_PC_MODE): 65 | self.s1_pin.on() 66 | self.s0_pin.off() 67 | 68 | elif(out_mode == self.F_100_PC_MODE): 69 | self.s1_pin.on() 70 | self.s0_pin.on() 71 | 72 | else: 73 | self.s1_pin.off() 74 | self.s0_pin.off() 75 | 76 | if(filter_mode == self.CLEAR_FILTER): 77 | self.s3_pin.off() 78 | self.s2_pin.on() 79 | 80 | elif(filter_mode == self.BLUE_FILTER): 81 | self.s3_pin.on() 82 | self.s2_pin.off() 83 | 84 | elif(filter_mode == self.GREEN_FILTER): 85 | self.s3_pin.on() 86 | self.s2_pin.on() 87 | 88 | else: 89 | self.s3_pin.off() 90 | self.s2_pin.off() 91 | 92 | self.sm.active(1) 93 | sleep_ms(100) 94 | 95 | period = t_diff + 1 96 | 97 | return period 98 | 99 | 100 | def get_color_reading(self): 101 | R = 0 102 | G = 0 103 | B = 0 104 | C = 0 105 | 106 | R = self.get_raw_reading(self.F_2_PC_MODE, self.RED_FILTER) 107 | G = self.get_raw_reading(self.F_2_PC_MODE, self.GREEN_FILTER) 108 | B = self.get_raw_reading(self.F_2_PC_MODE, self.BLUE_FILTER) 109 | C = self.get_raw_reading(self.F_2_PC_MODE, self.CLEAR_FILTER) 110 | 111 | return R, G, B, C 112 | 113 | 114 | def get_color_ratio(self): 115 | r = 0 116 | g = 0 117 | b = 0 118 | c = 0 119 | 120 | r, g, b, c = self.get_color_reading() 121 | 122 | r = int((c / r) * 100) 123 | g = int((c / g) * 100) 124 | b = int((c / b) * 100) 125 | 126 | c = (1000000 // c) 127 | 128 | return r, g, b, c 129 | -------------------------------------------------------------------------------- /PIO Codes/TCS3200 Colour Sensor Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms, 3 | from TCS3200 import TCS3200 4 | from ST7789 import TFT114 5 | 6 | fc = 0 7 | r = 0 8 | g = 0 9 | b = 0 10 | 11 | color_sensor = TCS3200(0, 2, 3, 4, 5) 12 | tft = TFT114() 13 | 14 | 15 | def map_value(v, x_min, x_max, y_min, y_max): 16 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 17 | 18 | 19 | def constrain(value, min_value, max_value): 20 | if(value > max_value): 21 | return max_value 22 | 23 | elif(value < min_value): 24 | return min_value 25 | 26 | else: 27 | return value 28 | 29 | 30 | def draw_and_write(value, pos, colour): 31 | bar = map_value(value, 0, 100, 0, 219) 32 | bar = constrain(bar, 0, 219) 33 | 34 | tft.text(str("%3u" %value), 110, (pos + 20), colour) 35 | 36 | tft.rect(9, pos, 222, 15, tft.WHITE) 37 | tft.fill_rect(10, (2 + pos), bar, 11, colour) 38 | 39 | 40 | while(True): 41 | r, g, b, fc = color_sensor.get_color_ratio() 42 | 43 | tft.fill(tft.BLACK) 44 | tft.text("RP2040 PICO PIO TCS3200", 30, 1, tft.CYAN) 45 | tft.text("FC/Hz: " + str("%4u" %fc), 85, 25, tft.YELLOW) 46 | draw_and_write(r, 40, tft.RED) 47 | draw_and_write(g, 70, tft.GREEN) 48 | draw_and_write(b, 100, tft.BLUE) 49 | 50 | tft.show() 51 | 52 | sleep_ms(400) 53 | 54 | 55 | -------------------------------------------------------------------------------- /PIO Codes/Traffic Lights/main.py: -------------------------------------------------------------------------------- 1 | # LED blinking at approximately 16Hz 2 | 3 | 4 | from machine import Pin 5 | from utime import sleep_ms 6 | from rp2 import PIO, asm_pio, StateMachine 7 | 8 | 9 | @asm_pio(set_init = (PIO.OUT_LOW, PIO.OUT_LOW, PIO.OUT_LOW)) 10 | def traffic_lights(): 11 | 12 | label('loop') # Loop starting point 13 | set(pins, 0b00001) # set RED LED only 14 | 15 | set(x, 30) # Roughly 31700 cycle delay loops = approximately 16s delay 16 | label("loop_R_1") 17 | set(y, 30) 18 | label("loop_R_2") 19 | nop() [31] 20 | jmp(y_dec, "loop_R_2") 21 | jmp(x_dec, "loop_R_1") 22 | 23 | 24 | set(pins, 0b00011) # Set RED and YELLOW LEDs on 25 | 26 | set(x, 20) # Roughly 14500 cycle delay loops = approximately 7.5s delay 27 | label("loop_RY_1") 28 | set(y, 20) 29 | label("loop_RY_2") 30 | nop() [31] 31 | jmp(y_dec, "loop_RY_2") 32 | jmp(x_dec, "loop_RY_1") 33 | 34 | set(pins, 0b00100) # set RED LED only 35 | 36 | set(x, 30) # Roughly 31700 cycle delay loops = approximately 16s delay 37 | label("loop_G_1") 38 | set(y, 30) 39 | label("loop_G_2") 40 | nop() [31] 41 | jmp(y_dec, "loop_G_2") 42 | jmp(x_dec, "loop_G_1") 43 | 44 | 45 | set(pins, 0b00110) # Set GREEN and YELLOW LEDs on 46 | 47 | set(x, 20) # Roughly 14500 cycle delay loops = approximately 7.5s delay 48 | label("loop_GY_1") 49 | set(y, 20) 50 | label("loop_GY_2") 51 | nop() [31] 52 | jmp(y_dec, "loop_GY_2") 53 | jmp(x_dec, "loop_GY_1") 54 | 55 | 56 | jmp('loop') 57 | 58 | 59 | sm = StateMachine(0, traffic_lights, freq = 1920, set_base = Pin(2)) 60 | 61 | sm.active(1) 62 | -------------------------------------------------------------------------------- /PIO Codes/WG26 RFID Reader/SH1107.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SPI 3 | from utime import sleep_ms, sleep_us 4 | import framebuf 5 | 6 | 7 | DC_pin = const(8) 8 | CS_pin = const(9) 9 | SCK_pin = const(10) 10 | MOSI_pin = const(11) 11 | RST_pin = const(12) 12 | 13 | SH1107_SET_LOWER_COLUMN_ADDRESS = const(0x00) 14 | SH1107_SET_UPPER_COLUMN_ADDRESS = const(0x10) 15 | SH1107_SET_PAGE_MEMORY_ADDRESSING_MODE = const(0x20) 16 | SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE = const(0x21) 17 | SH1107_SET_CONSTRAST_CONTROL = const(0x81) 18 | SH1107_SET_DC_DC_OFF_MODE = const(0x8A) 19 | SH1107_SET_DC_DC_ON_MODE = const(0x8B) 20 | SH1107_SET_SEGMENT_REMAP_NORMAL = const(0xA0) 21 | SH1107_SET_SEGMENT_REMAP_REVERSE = const(0xA1) 22 | SH1107_SET_ENTIRE_DISPLAY_OFF = const(0xA4) 23 | SH1107_SET_ENTIRE_DISPLAY_ON = const(0xA5) 24 | SH1107_SET_NORMAL_DISPLAY = const(0xA6) 25 | SH1107_SET_REVERSE_DISPLAY = const(0xA7) 26 | SH1107_SET_MULTIPLEX_RATIO = const(0xA8) 27 | SH1107_SET_DC_DC_CONTROL_MODE = const(0xAD) 28 | SH1107_DISPLAY_OFF = const(0xAE) 29 | SH1107_DISPLAY_ON = const(0xAF) 30 | SH1107_SET_PAGE_ADDRESS = const(0xB0) 31 | SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION = const(0xC0) 32 | SH1107_SET_DISPLAY_OFFSET = const(0xD3) 33 | SH1107_SET_DISPLAY_CLOCK_FREQUENCY = const(0xD5) 34 | SH1107_SET_PRECHARGE_DISCHARGE_PERIOD = const(0xD9) 35 | SH1107_SET_VCOM_DESELECT_LEVEL = const(0xDB) 36 | SH1107_SET_DISPLAY_START_LINE = const(0xDC) 37 | 38 | CMD = False 39 | DAT = True 40 | 41 | LOW = False 42 | HIGH = True 43 | 44 | 45 | class OLED_13(framebuf.FrameBuffer): 46 | def __init__(self): 47 | self.width = 128 48 | self.height = 64 49 | 50 | self.WHITE = 1 51 | self.BLACK = 0 52 | 53 | self.cs = Pin(CS_pin, Pin.OUT) 54 | self.rst = Pin(RST_pin, Pin.OUT) 55 | self.sck = Pin(SCK_pin, Pin.OUT) 56 | self.mosi = Pin(MOSI_pin, Pin.OUT) 57 | 58 | self.cs(HIGH) 59 | 60 | self.spi = SPI(1, 20000_000, polarity = 0, phase = 0,sck = self.sck, mosi = self.mosi,miso = None) 61 | 62 | self.dc = Pin(DC_pin, Pin.OUT) 63 | self.dc(HIGH) 64 | 65 | self.buffer = bytearray(self.height * (self.width // 8)) 66 | super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HMSB) 67 | self.init_display() 68 | 69 | 70 | def write(self, value, mode): 71 | self.dc(mode) 72 | self.cs(LOW) 73 | self.spi.write(bytearray([value])) 74 | self.cs(HIGH) 75 | 76 | 77 | def init_display(self): 78 | self.rst(HIGH) 79 | sleep_ms(1) 80 | self.rst(LOW) 81 | sleep_ms(10) 82 | self.rst(HIGH) 83 | 84 | self.write(SH1107_DISPLAY_OFF, CMD) 85 | 86 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS | 0x00), CMD) 87 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS | 0x00), CMD) 88 | 89 | self.write((SH1107_SET_PAGE_ADDRESS | 0x00), CMD) 90 | 91 | self.write(SH1107_SET_DISPLAY_START_LINE, CMD) 92 | self.write(0x00, CMD) 93 | self.write(SH1107_SET_CONSTRAST_CONTROL, CMD) 94 | self.write(0x6F, CMD) 95 | self.write(SH1107_SET_VERTICAL_MEMORY_ADDRESSING_MODE, CMD) 96 | 97 | self.write(SH1107_SET_SEGMENT_REMAP_NORMAL, CMD) 98 | self.write((SH1107_SET_COMMON_OUTPUT_SCAN_DIRECTION | 0x00), CMD) 99 | self.write(SH1107_SET_ENTIRE_DISPLAY_OFF, CMD) 100 | 101 | self.write(SH1107_SET_NORMAL_DISPLAY, CMD) 102 | self.write(SH1107_SET_MULTIPLEX_RATIO, CMD) 103 | self.write(0x3F, CMD) 104 | 105 | self.write(SH1107_SET_DISPLAY_OFFSET, CMD) 106 | self.write(0x60, CMD) 107 | 108 | self.write(SH1107_SET_DISPLAY_CLOCK_FREQUENCY, CMD) 109 | self.write(0x41, CMD) 110 | 111 | self.write(SH1107_SET_PRECHARGE_DISCHARGE_PERIOD, CMD) 112 | self.write(0x22, CMD) 113 | 114 | self.write(SH1107_SET_VCOM_DESELECT_LEVEL, CMD) 115 | self.write(0x35, CMD) 116 | 117 | self.write(SH1107_SET_DC_DC_CONTROL_MODE, CMD) 118 | self.write(SH1107_SET_DC_DC_OFF_MODE, CMD) 119 | self.write(SH1107_DISPLAY_ON, CMD) 120 | 121 | 122 | def show(self): 123 | self.write(SH1107_SET_PAGE_ADDRESS, CMD) 124 | for page in range(0, 64): 125 | self.column = (63 - page) 126 | 127 | self.write((SH1107_SET_LOWER_COLUMN_ADDRESS + (self.column & 0x0F)), CMD) 128 | self.write((SH1107_SET_UPPER_COLUMN_ADDRESS + (self.column >> 4)), CMD) 129 | 130 | for num in range(0, 16): 131 | self.write((self.buffer[(page * 16) + num]), DAT) 132 | 133 | -------------------------------------------------------------------------------- /PIO Codes/WG26 RFID Reader/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from SH1107 import OLED_13 3 | from utime import sleep_ms 4 | from rp2 import asm_pio, StateMachine, PIO 5 | 6 | 7 | count = 0 8 | raw_card_data = 0 9 | 10 | 11 | @asm_pio() 12 | def D0_out(): 13 | irq(clear, 0) # clear irq 0 14 | wrap_target() 15 | wait(0, pin, 0) # wait for logic 0 on pin index 0 16 | irq(block, 0) # set IRQ index 0 and wait for IRQ ack 17 | wait(1, pin, 0) # wait for logic 1 on pin index 0 18 | wrap() 19 | 20 | 21 | @asm_pio() 22 | def D1_out(): 23 | irq(clear, 1) # clear irq 1 24 | wait(0, pin, 0) # wait for logic 0 on pin index 0 25 | wrap_target() 26 | wait(1, pin, 0) # wait for logic 1 on pin index 0 27 | irq(block, 1) # set IRQ index 1 and wait for IRQ ack 28 | wait(0, pin, 0) # wait for logic 0 on pin index 0 29 | wrap() 30 | 31 | 32 | def irq_0_handler(sm): 33 | global raw_card_data, count 34 | 35 | raw_card_data <<= 1 36 | count += 1 37 | 38 | 39 | def irq_1_handler(sm): 40 | global raw_card_data, count 41 | 42 | raw_card_data <<= 1 43 | count += 1 44 | raw_card_data |= 1 45 | 46 | 47 | LED = Pin(25, Pin.OUT) 48 | D0_pin = Pin(16, Pin.IN, Pin.PULL_UP) 49 | D1_pin = Pin(17, Pin.IN, Pin.PULL_UP) 50 | 51 | 52 | oled = OLED_13() 53 | 54 | oled.fill(oled.BLACK) 55 | oled.show() 56 | 57 | sm0 = StateMachine(0, D0_out, in_base = D0_pin, freq = 45000) 58 | sm1 = StateMachine(1, D1_out, in_base = D1_pin, freq = 45000) 59 | 60 | sm0.irq(irq_0_handler) 61 | sm1.irq(irq_1_handler) 62 | 63 | sm0.active(1) # run SM0 64 | sm1.active(1) # run SM1 65 | 66 | 67 | while(True): 68 | 69 | if(count >= 25): 70 | sm0.active(0) 71 | sm1.active(0) 72 | oled.fill(oled.BLACK) 73 | oled.text("Facility Code :", 1, 10, oled.WHITE) 74 | oled.text("ID Card Number:", 1, 40, oled.WHITE) 75 | card_number = (raw_card_data & 0xFFFF) 76 | facility_code = (0xFF & (raw_card_data >> 0x10)) 77 | oled.text(str("%u" % facility_code), 1, 20, oled.WHITE) 78 | oled.text(str("%u" % card_number), 1, 50, oled.WHITE) 79 | oled.show() 80 | sleep_ms(100) 81 | raw_card_data = 0 82 | count = 0 83 | sm0.active(1) 84 | sm1.active(1) -------------------------------------------------------------------------------- /Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Cloudy.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Cloudy.jpg -------------------------------------------------------------------------------- /Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Rainy.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Rainy.jpg -------------------------------------------------------------------------------- /Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Stormy.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Stormy.jpg -------------------------------------------------------------------------------- /Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Sunny.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/Pioneer 600 - BMP280 Barometer (Weather Forecast)/images/Sunny.jpg -------------------------------------------------------------------------------- /Pioneer 600 - DS18B20 Graphical Thermometer/images/img.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sshahryiar/Raspberry-Pi-Pico/a0d606835a99d9faa4ab0caebb34b616869e282d/Pioneer 600 - DS18B20 Graphical Thermometer/images/img.jpg -------------------------------------------------------------------------------- /Pioneer 600 - DS3231 RTCC and PCF8574 IO Expander Demo/DS3231.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, I2C 3 | 4 | 5 | DS3231_I2C_Address = const(0x68) 6 | 7 | DS3231_second_reg = const(0x00) 8 | DS3231_minute_reg = const(0x01) 9 | DS3231_hour_reg = const(0x02) 10 | DS3231_day_reg = const(0x03) 11 | DS3231_date_reg = const(0x04) 12 | DS3231_month_reg = const(0x05) 13 | DS3231_year_reg = const(0x06) 14 | DS3231_alarm_1_sec_reg = const(0x07) 15 | DS3231_alarm_1_min_reg = const(0x08) 16 | DS3231_alarm_1_hr_reg = const(0x09) 17 | DS3231_alarm_1_date_reg = const(0x0A) 18 | DS3231_alarm_2_min_reg = const(0x0B) 19 | DS3231_alarm_2_hr_reg = const(0x0C) 20 | DS3231_alarm_2_date_reg = const(0x0D) 21 | DS3231_control_reg = const(0x0E) 22 | DS3231_status_reg = const(0x0F) 23 | DS3231_ageoffset_reg = const(0x10) 24 | DS3231_temp_MSB_reg = const(0x11) 25 | DS3231_temp_LSB_reg = const(0x12) 26 | 27 | 28 | class DS3231(): 29 | def __init__(self, _i2c): 30 | 31 | self._24_hour_format = const(0) 32 | self._12_hour_format = const(1) 33 | self.am = const(0) 34 | self.pm = const(1) 35 | 36 | self.i2c = _i2c 37 | self.i2c_address = DS3231_I2C_Address 38 | self.init() 39 | 40 | 41 | def write(self, reg, value): 42 | if not type(value) is bytearray: 43 | value = bytearray([value]) 44 | 45 | self.i2c.writeto_mem(self.i2c_address, reg, value) 46 | 47 | 48 | def init(self): 49 | self.write(DS3231_control_reg, 0x00) 50 | self.write(DS3231_status_reg, 0x08) 51 | 52 | 53 | def read(self, reg): 54 | retval = self.i2c.readfrom_mem(self.i2c_address, reg, 1) 55 | return retval[0] 56 | 57 | 58 | def bcd_to_decimal(self, value): 59 | return ((value & 0x0F) + (((value & 0xF0) >> 4) * 10)) 60 | 61 | 62 | def decimal_to_bcd(self, value): 63 | return (((value // 10) << 4) & 0xF0) | ((value % 10) & 0x0F) 64 | 65 | 66 | def get_temperature(self): 67 | LB = self.read(DS3231_temp_LSB_reg) 68 | HB = self.read(DS3231_temp_MSB_reg) 69 | LB >>= 0x06 70 | LB &= 0x03 71 | t = LB 72 | t *= 0.25 73 | t += HB 74 | return t 75 | 76 | 77 | def get_time(self, hour_format): 78 | am_pm_state = 0 79 | 80 | second = self.bcd_to_decimal(self.read(DS3231_second_reg)) 81 | minute = self.bcd_to_decimal(self.read(DS3231_minute_reg)) 82 | 83 | if(hour_format == self._12_hour_format): 84 | tmp = self.read(DS3231_hour_reg) 85 | tmp &= 0x20 86 | tmp >>= 0x05 87 | am_pm_state = tmp 88 | hour = self.bcd_to_decimal((self.read(DS3231_hour_reg) & 0x1F)) 89 | 90 | else: 91 | hour = self.bcd_to_decimal((self.read(DS3231_hour_reg) & 0x3F)) 92 | 93 | return hour, minute, second, am_pm_state 94 | 95 | 96 | def get_calendar(self): 97 | year = self.bcd_to_decimal(self.read(DS3231_year_reg)) 98 | month = self.bcd_to_decimal((self.read(DS3231_month_reg) & 0x1F)) 99 | date = self.bcd_to_decimal((self.read(DS3231_date_reg) & 0x3F)) 100 | day = self.bcd_to_decimal((self.read(DS3231_day_reg) & 0x07)) 101 | 102 | return day, date, month, year 103 | 104 | 105 | def set_time(self, hour, minute, second, am_pm_state, hour_format): 106 | self.write(DS3231_second_reg, self.decimal_to_bcd(second)) 107 | self.write(DS3231_minute_reg, self.decimal_to_bcd(minute)) 108 | 109 | if(hour_format == self._12_hour_format): 110 | if(am_pm_state == self.pm): 111 | tmp = 0x60 112 | 113 | else: 114 | tmp = 0x40 115 | 116 | self.write(DS3231_hour_reg, ((tmp | (0x1F & (self.decimal_to_bcd(hour)))))) 117 | 118 | else: 119 | self.write(DS3231_hour_reg, ((0x3F & (self.decimal_to_bcd(hour))))) 120 | 121 | 122 | def set_calendar(self, day, date, month, year): 123 | self.write(DS3231_day_reg, (self.decimal_to_bcd(day))) 124 | self.write(DS3231_date_reg, (self.decimal_to_bcd(date))) 125 | self.write(DS3231_month_reg, (self.decimal_to_bcd(month))) 126 | self.write(DS3231_year_reg, (self.decimal_to_bcd(year))) 127 | -------------------------------------------------------------------------------- /Pioneer 600 - DS3231 RTCC and PCF8574 IO Expander Demo/PCF8574.py: -------------------------------------------------------------------------------- 1 | from machine import I2C 2 | 3 | 4 | class PCF8574(): 5 | 6 | def __init__(self, _i2c, _i2c_addr = 0x20): 7 | self.i2c = _i2c 8 | self.i2c_addr = _i2c_addr 9 | self.tmp = 0 10 | 11 | 12 | def port_read(self, mask): 13 | self.write(mask | self.read()) 14 | return self.read() 15 | 16 | 17 | def port_write(self, value): 18 | self.write(value & 0xFF) 19 | 20 | 21 | def pin_read(self, pin): 22 | return ((self.read() >> pin) & 0x01) 23 | 24 | 25 | def pin_write(self, pin, value): 26 | if(value != 0): 27 | tmp = 0x00 28 | tmp |= (1 << pin) 29 | tmp |= self.read() 30 | 31 | else: 32 | tmp = 0xFF 33 | tmp &= ~(1 << pin) 34 | tmp &= self.read() 35 | 36 | self.write(tmp) 37 | 38 | 39 | def pin_toggle(self, pin): 40 | self.tmp ^= 0x01 41 | self.pin_write(pin, self.tmp) 42 | 43 | 44 | def read(self): 45 | return self.i2c.readfrom(self.i2c_addr, 1)[0] 46 | 47 | 48 | def write(self, value): 49 | self.i2c.writeto(self.i2c_addr, bytes([value])) 50 | 51 | 52 | -------------------------------------------------------------------------------- /Pioneer 600 - DS3231 RTCC and PCF8574 IO Expander Demo/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from SSD1306_I2C import OLED1306 3 | from DS3231 import DS3231 4 | from PCF8574 import PCF8574 5 | from utime import sleep_ms 6 | 7 | 8 | i = 0 9 | j = 0 10 | kbd = 0 11 | set_read = 0 12 | index = 0 13 | day = 0 14 | date = 31 15 | month = 12 16 | year = 21 17 | hour = 23 18 | minute = 59 19 | second = 45 20 | am_pm_state = 1 21 | 22 | 23 | LED = Pin(25, Pin.OUT) 24 | i2c = I2C(1, sda = Pin(2), scl = Pin(3), freq = 100000) 25 | oled = OLED1306(i2c) 26 | rtc = DS3231(i2c) 27 | io = PCF8574(i2c) 28 | 29 | rtc.set_calendar(day, date, month, year) 30 | rtc.set_time(hour, minute, second, am_pm_state, rtc._24_hour_format) 31 | 32 | 33 | def read_keys(): 34 | global kbd 35 | 36 | kbd = io.port_read(0x0F) & 0x0F 37 | 38 | 39 | def set_parameter(value, value_max, value_min): 40 | global kbd 41 | 42 | if(kbd == 0x0B): 43 | LED.toggle() 44 | io.pin_write(7, 0) 45 | sleep_ms(30) 46 | io.pin_write(7, 1) 47 | value += 1 48 | 49 | if(value > value_max): 50 | value = value_min 51 | 52 | if(kbd == 0x0D): 53 | LED.toggle() 54 | io.pin_write(7, 0) 55 | sleep_ms(30) 56 | io.pin_write(7, 1) 57 | value -= 1 58 | 59 | if(value < value_min): 60 | value = value_max 61 | 62 | 63 | return value 64 | 65 | 66 | def select_mode(): 67 | global set_read, i, j 68 | 69 | if(kbd == 0x0B): 70 | sleep_ms(60) 71 | if(kbd == 0x0B): 72 | set_read = 1 73 | 74 | if(set_read == 1): 75 | set_time() 76 | elif(set_read == 0): 77 | get_time() 78 | 79 | 80 | def rtc_display(): 81 | global hour, minute, second, date, month, year 82 | 83 | oled.text("Time & Date", 22, 6, oled.WHITE) 84 | oled.text(str("%02u" % hour), 38, 17, oled.WHITE) 85 | oled.text(":", 52, 17, oled.WHITE) 86 | oled.text(str("%02u" % minute), 59, 17, oled.WHITE) 87 | oled.text(":", 73, 17, oled.WHITE) 88 | oled.text(str("%02u" % second), 80, 17, oled.WHITE) 89 | oled.text(str("%02u" % date), 38, 29, oled.WHITE) 90 | oled.text(".", 52, 29, oled.WHITE) 91 | oled.text(str("%02u" % month), 59, 29, oled.WHITE) 92 | oled.text(".", 73, 29, oled.WHITE) 93 | oled.text(str("%02u" % year), 80, 29, oled.WHITE) 94 | 95 | t = rtc.get_temperature() 96 | oled.text("Temperature", 22, 46, oled.WHITE) 97 | oled.text(str("%2.2f" % t), 49, 57, oled.WHITE) 98 | oled.show() 99 | 100 | 101 | def get_time(): 102 | global hour, minute, second, am_pm_state, day, date, month, year 103 | 104 | day, date, month, year = rtc.get_calendar() 105 | hour, minute, second, am_pm_state = rtc.get_time(rtc._24_hour_format) 106 | 107 | io.pin_toggle(4) 108 | sleep_ms(500) 109 | 110 | 111 | def set_time(): 112 | global hour, minute, second, am_pm_state, day, date, month, year, index, set_read, kbd 113 | 114 | if(kbd == 0x0E): 115 | sleep_ms(40) 116 | index += 1 117 | 118 | if(index > 6): 119 | index = 6 120 | 121 | if(kbd == 0x07): 122 | sleep_ms(40) 123 | index -= 1 124 | 125 | if(index < 0): 126 | index = 0 127 | 128 | if(index == 0): 129 | oled.text("Set", 0, 20, oled.WHITE) 130 | oled.text("Hr", 0, 30, oled.WHITE) 131 | hour = set_parameter(hour, 23, 0) 132 | elif(index == 1): 133 | oled.text("Set", 0, 20, oled.WHITE) 134 | oled.text("Min", 0, 30, oled.WHITE) 135 | minute = set_parameter(minute, 59, 0) 136 | elif(index == 2): 137 | oled.text("Set", 0, 20, oled.WHITE) 138 | oled.text("Sec", 0, 30, oled.WHITE) 139 | second = set_parameter(second, 59, 0) 140 | elif(index == 3): 141 | oled.text("Set", 0, 20, oled.WHITE) 142 | oled.text("Day", 0, 30, oled.WHITE) 143 | date = set_parameter(date, 31, 1) 144 | elif(index == 4): 145 | oled.text("Set", 0, 20, oled.WHITE) 146 | oled.text("Mth", 0, 30, oled.WHITE) 147 | month = set_parameter(month, 12, 1) 148 | elif(index == 5): 149 | oled.text("Set", 0, 20, oled.WHITE) 150 | oled.text("Yr", 0, 30, oled.WHITE) 151 | year = set_parameter(year, 99, 0) 152 | elif(index == 6): 153 | rtc.set_calendar(day, date, month, year) 154 | rtc.set_time(hour, minute, second, am_pm_state, rtc._24_hour_format) 155 | set_read = 0 156 | index = 0 157 | 158 | io.pin_toggle(4) 159 | sleep_ms(40) 160 | 161 | 162 | 163 | while True: 164 | oled.fill(oled.BLACK) 165 | read_keys() 166 | select_mode() 167 | rtc_display() 168 | 169 | 170 | -------------------------------------------------------------------------------- /Pioneer 600 - NEC IR Remote Decoder/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, SPI, I2C 2 | from SSD1306_I2C import OLED1306 3 | from utime import sleep_ms, sleep_us 4 | 5 | 6 | LED = Pin(26, Pin.OUT) 7 | IR = Pin(18, Pin.IN, Pin.PULL_UP) 8 | 9 | 10 | i2c = I2C(1, sda = Pin(2), scl = Pin(3), freq = 100000) 11 | oled = OLED1306(i2c) 12 | 13 | oled.fill(oled.BLACK) 14 | oled.show() 15 | 16 | 17 | def poll_pulse(counts, pin_state): 18 | count = 0 19 | 20 | while(IR.value() == pin_state and count < counts): 21 | count += 1 22 | sleep_us(100) 23 | 24 | return count 25 | 26 | 27 | while True: 28 | if(IR.value() == False): 29 | poll_pulse(120, False) 30 | poll_pulse(48, True) 31 | 32 | 33 | idx = 0 34 | cnt = 0 35 | data = [0, 0, 0, 0] 36 | 37 | for i in range (0, 32): 38 | poll_pulse(9, False) 39 | pulse_len = poll_pulse(24, True) 40 | 41 | if(pulse_len > 5): 42 | data[idx] |= (1 << cnt) 43 | 44 | if(cnt == 7): 45 | cnt = 0 46 | idx += 1 47 | else: 48 | cnt += 1 49 | 50 | if(((data[0] + data[1]) == 0xFF) and ((data[2] + data[3]) == 0xFF)): 51 | LED.on() 52 | oled.fill(oled.BLACK) 53 | oled.text("IR Data:", 0, 10) 54 | oled.text(str("0x%02X" %data[0]), 0, 25) 55 | oled.text(str("%02X" %data[1]), 32, 25) 56 | oled.text(str("%02X" %data[2]), 48, 25) 57 | oled.text(str("%02X" %data[3]), 64, 25) 58 | oled.show() 59 | print("IR Data: 0x%02x" %data[0] + "%02x" %data[1] + "%02x" %data[2] + "%02x" %data[3]) 60 | LED.off() 61 | 62 | -------------------------------------------------------------------------------- /Pioneer 600 - PCF8951 ADC-DAC + Graphical ADXL335 Accelerometer/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C 2 | from utime import sleep_ms 3 | from PCF8591 import PCF8591 4 | from SSD1306_I2C import OLED1306 5 | import framebuf 6 | 7 | 8 | LED = Pin(25, Pin.OUT) 9 | i2c = I2C(1, sda = Pin(2), scl = Pin(3), freq = 100000) 10 | oled = OLED1306(i2c) 11 | ad_da = PCF8591(i2c) 12 | 13 | 14 | fb = framebuf.FrameBuffer(bytearray( 15 | b'\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' 16 | b'\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' 17 | b'\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' 18 | b'\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' 19 | b'\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' 20 | b'\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' 21 | b'\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' 22 | b'\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' 23 | b'\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'), 24 | 36, 64, framebuf.MONO_VLSB) 25 | 26 | 27 | def map_value(v, x_min, x_max, y_min, y_max): 28 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 29 | 30 | 31 | def draw_background(): 32 | oled.text("X", 2, 6, oled.WHITE) 33 | oled.text("Y", 2, 28, oled.WHITE) 34 | oled.text("Z", 2, 50, oled.WHITE) 35 | 36 | for i in range (0, 66, 22): 37 | oled.line(13, (10 + i), 91, (10 + i), oled.WHITE) 38 | oled.line(15, (1 + i), 15, (19 + i), oled.WHITE) 39 | oled.line(11, (2 + i), 13, (2 + i), oled.WHITE) 40 | oled.line(11, (18 + i), 13, (18 + i), oled.WHITE) 41 | oled.line(12, (1 + i), 12, (3 + i), oled.WHITE) 42 | 43 | 44 | 45 | while True: 46 | oled.fill(oled.BLACK) 47 | draw_background() 48 | 49 | for i in range (16, 91): 50 | x_axis = ad_da.read(ad_da.AOut_disable | ad_da.Four_Channel_ADC | ad_da.Auto_Increment_Disable | ad_da.AIN0) 51 | y_axis = ad_da.read(ad_da.AOut_disable | ad_da.Four_Channel_ADC | ad_da.Auto_Increment_Disable | ad_da.AIN1) 52 | z_axis = ad_da.read(ad_da.AOut_disable | ad_da.Four_Channel_ADC | ad_da.Auto_Increment_Disable | ad_da.AIN2) 53 | 54 | x_plot = map_value(x_axis, 5, 220, 19, 1) 55 | y_plot = map_value(y_axis, 5, 220, 41, 23) 56 | z_plot = map_value(z_axis, 5, 220, 63, 45) 57 | 58 | oled.pixel(i, (x_plot), oled.WHITE) 59 | oled.pixel(i, (y_plot), oled.WHITE) 60 | oled.pixel(i, (z_plot), oled.WHITE) 61 | 62 | oled.blit(fb, 91, 0) 63 | 64 | oled.text(str("%3u" % x_axis), 100, 10, oled.WHITE) 65 | oled.text(str("%3u" % y_axis), 100, 30, oled.WHITE) 66 | oled.text(str("%3u" % z_axis), 100, 50, oled.WHITE) 67 | 68 | oled.show() 69 | -------------------------------------------------------------------------------- /Police Lights - GPIO/Police_Lights.py: -------------------------------------------------------------------------------- 1 | import machine 2 | import utime 3 | 4 | i = 0 5 | state = 0 6 | 7 | LED_RED = machine.Pin(4, machine.Pin.OUT) 8 | LED_BLUE = machine.Pin(5, machine.Pin.OUT) 9 | 10 | button = machine.Pin(2, machine.Pin.IN) 11 | 12 | 13 | while True: 14 | if(button.value() == False): 15 | utime.sleep_ms(10) 16 | if(button.value() == False): 17 | LED_RED.value(False) 18 | LED_BLUE.value(False) 19 | state += 1 20 | 21 | 22 | if(state == 1): 23 | 24 | LED_RED.value(1) 25 | LED_BLUE.value(0) 26 | utime.sleep_ms(200) 27 | LED_RED.value(0) 28 | LED_BLUE.value(1) 29 | utime.sleep_ms(200) 30 | 31 | elif(state == 2): 32 | LED_RED.toggle() 33 | LED_BLUE.toggle() 34 | utime.sleep_ms(200) 35 | 36 | elif(state == 3): 37 | 38 | for i in range(0, 3, 1): 39 | LED_RED.value(1) 40 | LED_BLUE.value(0) 41 | utime.sleep_ms(40) 42 | LED_RED.value(0) 43 | utime.sleep_ms(40) 44 | 45 | for i in range(0, 3, 1): 46 | LED_RED.value(0) 47 | LED_BLUE.value(1) 48 | utime.sleep_ms(40) 49 | LED_BLUE.value(0) 50 | utime.sleep_ms(40) 51 | 52 | 53 | elif(state == 4): 54 | 55 | i = 6 56 | while(i > 0): 57 | LED_RED.on() 58 | LED_BLUE.on() 59 | utime.sleep_ms(60) 60 | LED_RED.off() 61 | LED_BLUE.off() 62 | utime.sleep_ms(60) 63 | i -= 1 64 | utime.sleep(0.25) 65 | 66 | else: 67 | LED_RED.value(0) 68 | LED_BLUE.value(0) 69 | utime.sleep_us(1000000) 70 | state = 0 71 | 72 | -------------------------------------------------------------------------------- /RCWL-1605 UART SONAR Sensor Demo/RCWL1605.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import UART 3 | from utime import sleep_ms 4 | 5 | 6 | RCWL1605_measure_command = const(0xA0) 7 | RCWL1605_device_info_command = const(0xF1) 8 | 9 | 10 | class RCWL1605(): 11 | def __init__ (self, _uart): 12 | self.tx_data_frame = bytearray(0x01) 13 | self.rx_data_frame = bytearray(0x1F) 14 | 15 | self.uart = _uart 16 | 17 | 18 | def get_distance(self): 19 | r = -1 20 | d = -1 21 | 22 | self.rx_data_frame[0x00] = 0x00 23 | self.rx_data_frame[0x01] = 0x00 24 | self.rx_data_frame[0x02] = 0x00 25 | 26 | self.tx_data_frame[0x00] = RCWL1605_measure_command 27 | self.uart.write(self.tx_data_frame) 28 | sleep_ms(10) 29 | 30 | if(self.uart.any() > 0x00): 31 | self.uart.readinto(self.rx_data_frame) 32 | r = ((self.rx_data_frame[0] << 0x10) + (self.rx_data_frame[1] << 0x08) + self.rx_data_frame[2]) 33 | d = (r // 1000) 34 | 35 | return d 36 | 37 | 38 | def get_idevice_nfo(self): 39 | self.tx_data_frame[0x00] = RCWL1605_device_info_command 40 | self.uart.write(self.tx_data_frame) 41 | sleep_ms(10) 42 | 43 | if(uart.any() > 0x00): 44 | self.rx_data_frame = self.uart.read() 45 | 46 | return self.rx_data_frame 47 | -------------------------------------------------------------------------------- /RCWL-1605 UART SONAR Sensor Demo/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import UART, Pin 3 | from utime import sleep_ms 4 | from ST7735 import TFT096 5 | from RCWL1605 import RCWL1605 6 | 7 | 8 | tft = TFT096() 9 | 10 | uart = UART(1, baudrate = 9600, bits = 8, parity = None, stop = 1, tx = Pin(4), rx = Pin(5)) 11 | sonar = RCWL1605(uart) 12 | 13 | 14 | def map_value(v, x_min, x_max, y_min, y_max): 15 | return int(y_min + (((y_max - y_min)/(x_max - x_min)) * (v - x_min))) 16 | 17 | 18 | def background(): 19 | for i in range(0, 150, 9): 20 | tft.vline((4 + i), 56, 10, tft.GREEN) 21 | if(i < 144): 22 | tft.vline((9+ i), 62, 4, tft.GREEN) 23 | 24 | tft.text("RCWL1605 RP2040", 20, 4, tft.RED) 25 | tft.text("Range/mm:", 30, 32, tft.WHITE) 26 | 27 | 28 | while(True): 29 | r = sonar.get_distance() 30 | 31 | if((r == -1) or (r > 5500)): 32 | r = 5500 33 | 34 | d = map_value(r, 0, 5500, 0, 150) 35 | 36 | tft.fill(tft.BLACK) 37 | background() 38 | tft.fill_rect(4, 74, d, 4, tft.BLUE) 39 | tft.text(str("%04s" %r), 100, 32, tft.WHITE) 40 | tft.display() 41 | sleep_ms(600) 42 | 43 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Raspberry-Pi-PICO---RP2040 2 | My projects with RP2040 3 | 4 | Here are my experimental projects with Raspberry Pi Pico. 5 | -------------------------------------------------------------------------------- /RGB Cylon/main.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, PWM 3 | from utime import sleep_ms, sleep_us 4 | 5 | 6 | sleep_time = const(60) 7 | 8 | 9 | D0 = Pin(1, Pin.OUT) 10 | D1 = Pin(3, Pin.OUT) 11 | D2 = Pin(5, Pin.OUT) 12 | D3 = Pin(6, Pin.OUT) 13 | D4 = Pin(7, Pin.OUT) 14 | D5 = Pin(8, Pin.OUT) 15 | D6 = Pin(9, Pin.OUT) 16 | D7 = Pin(10, Pin.OUT) 17 | 18 | pwm1 = PWM(Pin(0)) 19 | pwm1.freq(9000) 20 | 21 | pwm2 = PWM(Pin(2)) 22 | pwm2.freq(9000) 23 | 24 | pwm3 = PWM(Pin(4)) 25 | pwm3.freq(9000) 26 | 27 | 28 | r_duty = [12043, 23676, 34503, 44155, 52302, 58668, 63036, 65256, 65254, 63028, 58656, 52286, 44135, 34481, 23652, 12017] 29 | g_duty = [58668, 63036, 65256, 65254, 63028, 58656, 52286, 44135, 34481, 23652, 12017, 12043, 23676, 34503, 44155, 52302] 30 | b_duty = [58656, 52286, 44135, 34481, 23652, 12017, 12043, 23676, 34503, 44155, 52302, 58668, 63036, 65256, 65254, 63028] 31 | 32 | 33 | def level(value): 34 | if(value == 8): 35 | D0.low() 36 | D1.high() 37 | D2.high() 38 | D3.high() 39 | D4.high() 40 | D5.high() 41 | D6.high() 42 | D7.high() 43 | 44 | elif(value == 7): 45 | D0.high() 46 | D1.low() 47 | D2.high() 48 | D3.high() 49 | D4.high() 50 | D5.high() 51 | D6.high() 52 | D7.high() 53 | 54 | elif(value == 6): 55 | D0.high() 56 | D1.high() 57 | D2.low() 58 | D3.high() 59 | D4.high() 60 | D5.high() 61 | D6.high() 62 | D7.high() 63 | 64 | elif(value == 5): 65 | D0.high() 66 | D1.high() 67 | D2.high() 68 | D3.low() 69 | D4.high() 70 | D5.high() 71 | D6.high() 72 | D7.high() 73 | 74 | elif(value == 4): 75 | D0.high() 76 | D1.high() 77 | D2.high() 78 | D3.high() 79 | D4.low() 80 | D5.high() 81 | D6.high() 82 | D7.high() 83 | 84 | elif(value == 3): 85 | D0.high() 86 | D1.high() 87 | D2.high() 88 | D3.high() 89 | D4.high() 90 | D5.low() 91 | D6.high() 92 | D7.high() 93 | 94 | elif(value == 2): 95 | D0.high() 96 | D1.high() 97 | D2.high() 98 | D3.high() 99 | D4.high() 100 | D5.high() 101 | D6.low() 102 | D7.high() 103 | 104 | elif(value == 1): 105 | D0.high() 106 | D1.high() 107 | D2.high() 108 | D3.high() 109 | D4.high() 110 | D5.high() 111 | D6.high() 112 | D7.low() 113 | 114 | else: 115 | D0.high() 116 | D1.high() 117 | D2.high() 118 | D3.high() 119 | D4.high() 120 | D5.high() 121 | D6.high() 122 | D7.high() 123 | 124 | 125 | while(True): 126 | for i in range(4, 9, 1): 127 | level(i) 128 | pwm1.duty_u16(r_duty[(i - 1)]) 129 | pwm2.duty_u16(g_duty[(i - 1)]) 130 | pwm3.duty_u16(b_duty[(i - 1)]) 131 | sleep_ms(sleep_time) 132 | 133 | for i in range(8, 4, -1): 134 | level(i) 135 | pwm1.duty_u16(r_duty[(15 - i)]) 136 | pwm2.duty_u16(g_duty[(15 - i)]) 137 | pwm3.duty_u16(b_duty[(15 - i)]) 138 | sleep_ms(sleep_time) 139 | 140 | for i in range(4, -1, -1): 141 | level(i) 142 | pwm1.duty_u16(r_duty[(15 - i)]) 143 | pwm2.duty_u16(g_duty[(15 - i)]) 144 | pwm3.duty_u16(b_duty[(15 - i)]) 145 | sleep_ms(sleep_time) 146 | 147 | for i in range(1, 5, 1): 148 | level(i) 149 | pwm1.duty_u16(r_duty[(i - 1)]) 150 | pwm2.duty_u16(g_duty[(i - 1)]) 151 | pwm3.duty_u16(b_duty[(i - 1)]) 152 | sleep_ms(sleep_time) 153 | -------------------------------------------------------------------------------- /SGP40 VoC Sensor and SHTC3 Temperature-Relative Humidity Sensor/SGP40.py: -------------------------------------------------------------------------------- 1 | from utime import sleep_ms, sleep_us 2 | from micropython import const 3 | import math 4 | import struct 5 | 6 | 7 | SGP40_I2C_ADDRESS = const(0x59) 8 | 9 | SGP40_FEATURE_SET_CMD = [0x20, 0x2F] 10 | SGP40_MEASURE_TEST_CMD = [0x28, 0x0E] 11 | SGP40_SOFT_RESET_CMD = [0x00, 0x06] 12 | SGP40_HEATER_OFF_CMD = [0x36, 0x15] 13 | SGP40_MEASURE_RAW_CMD = [0x26, 0x0F] 14 | 15 | CRC_TABLE = [ 16 | 0, 49, 98, 83, 196, 245, 166, 151, 185, 136, 219, 234, 125, 76, 31, 46, 17 | 67, 114, 33, 16, 135, 182, 229, 212, 250, 203, 152, 169, 62, 15, 92, 109, 18 | 134, 183, 228, 213, 66, 115, 32, 17, 63, 14, 93, 108, 251, 202, 153, 168, 19 | 197, 244, 167, 150, 1, 48, 99, 82, 124, 77, 30, 47, 184, 137, 218, 235, 20 | 61, 12, 95, 110, 249, 200, 155, 170, 132, 181, 230, 215, 64, 113, 34, 19, 21 | 126, 79, 28, 45, 186, 139, 216, 233, 199, 246, 165, 148, 3, 50, 97, 80, 22 | 187, 138, 217, 232, 127, 78, 29, 44, 2, 51, 96, 81, 198, 247, 164, 149, 23 | 248, 201, 154, 171, 60, 13, 94, 111, 65, 112, 35, 18, 133, 180, 231, 214, 24 | 122, 75, 24, 41, 190, 143, 220, 237, 195, 242, 161, 144, 7, 54, 101, 84, 25 | 57, 8, 91, 106, 253, 204, 159, 174, 128, 177, 226, 211, 68, 117, 38, 23, 26 | 252, 205, 158, 175, 56, 9, 90, 107, 69, 116, 39, 22, 129, 176, 227, 210, 27 | 191, 142, 221, 236, 123, 74, 25, 40, 6, 55, 100, 85, 194, 243, 160, 145, 28 | 71, 118, 37, 20, 131, 178, 225, 208, 254, 207, 156, 173, 58, 11, 88, 105, 29 | 4, 53, 102, 87, 192, 241, 162, 147, 189, 140, 223, 238, 121, 72, 27, 42, 30 | 193, 240, 163, 146, 5, 52, 103, 86, 120, 73, 26, 43, 188, 141, 222, 239, 31 | 130, 179, 224, 209, 70, 119, 36, 21, 59, 10, 89, 104, 255, 206, 157, 172 32 | ] 33 | 34 | 35 | WITHOUT_HUM_COMP = [0x26, 0x0F, 0x80, 0x00, 0xA2, 0x66, 0x66, 0x93] 36 | WITH_HUM_COMP = [0x26, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] 37 | 38 | 39 | class SGP40(): 40 | def __init__(self, _i2c): 41 | self.i2c = _i2c 42 | 43 | self.write(SGP40_FEATURE_SET_CMD) 44 | sleep_ms(40) 45 | read_buf = self.read() 46 | if (((int(read_buf[0]) << 8) | read_buf[1]) != 0x3220): 47 | raise RuntimeError("SGP40 self test failed!") 48 | 49 | self.write(SGP40_MEASURE_TEST_CMD) 50 | sleep_ms(250) 51 | read_buf = self.read() 52 | if (((int(read_buf[0]) << 8) | read_buf[1]) != 0xD400): 53 | raise RuntimeError("SGP40 self test failed!") 54 | 55 | 56 | def read(self): 57 | retval = self.i2c.readfrom_mem(int(SGP40_I2C_ADDRESS), 0, 3) 58 | return retval 59 | 60 | 61 | def write(self, cmd): 62 | self.i2c.writeto_mem(int(SGP40_I2C_ADDRESS), int(cmd[0]), bytes([int(cmd[1])])) 63 | 64 | 65 | def write_block(self, cmd): 66 | self.i2c.writeto_mem(int(SGP40_I2C_ADDRESS), int(cmd[0]), bytes(cmd[1:8])) 67 | 68 | 69 | def __crc(self, msb, lsb): 70 | crc = 0xff 71 | crc ^= msb 72 | crc = CRC_TABLE[crc] 73 | if lsb is not None: 74 | crc ^= lsb 75 | crc = CRC_TABLE[crc] 76 | return crc 77 | 78 | 79 | def read_raw(self): 80 | self.write_block(WITHOUT_HUM_COMP) 81 | sleep_ms(40) 82 | read_buf = self.read() 83 | return ((int(read_buf[0]) << 8) + read_buf[1]) 84 | 85 | 86 | def raw_measurement(self, temperature, humidity): 87 | rh_parameter = struct.pack(">H", math.ceil((humidity * 0xFFFF) / 100)) 88 | rh_crc = self.__crc(rh_parameter[0], rh_parameter[1]) 89 | 90 | t_parameter = struct.pack(">H", math.ceil(((temperature + 45) * 0xFFFF) / 175)) 91 | t_crc = self.__crc(t_parameter[0], t_parameter[1]) 92 | 93 | WITH_HUM_COMP[2:3] = list(rh_parameter) 94 | WITH_HUM_COMP[4] = int(rh_crc) 95 | WITH_HUM_COMP[5:6] = list(t_parameter) 96 | WITH_HUM_COMP[7] = int(t_crc) 97 | 98 | self.write_block(WITH_HUM_COMP) 99 | sleep_ms(60) 100 | read_buf = self.read() 101 | return ((int(read_buf[0]) << 8) + read_buf[1]) -------------------------------------------------------------------------------- /SGP40 VoC Sensor and SHTC3 Temperature-Relative Humidity Sensor/SHTC3.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from struct import unpack_from 3 | from utime import sleep_us,sleep_ms 4 | 5 | 6 | SHTC3_I2C_ADDRESS = const(0x70) 7 | 8 | SHTC3_REG_SLEEP = const(0xB098) 9 | SHTC3_REG_WAKEUP = const(0x3517) 10 | SHTC3_REG_SOFT_RESET = const(0x805D) 11 | SHTC3_REG_READ_ID = const(0xEFC8) 12 | 13 | SHTC3_REG_NORMAL_T_F = const(0x7866) 14 | SHTC3_REG_NORMAL_H_F = const(0x58E0) 15 | 16 | SHTC3_REG_NORMAL_T_F_STRETCH = const(0x7CA2) 17 | SHTC3_REG_NORMAL_H_F_STRETCH = const(0x5C24) 18 | 19 | SHTC3_REG_LOW_POWER_T_F = const(0x609C) 20 | SHTC3_REG_LOW_POWER_H_F = const(0x401A) 21 | 22 | SHTC3_REG_LOW_POWER_T_F_STRETCH = const(0x6458) 23 | SHTC3_REG_LOW_POWER_H_F_STRETCH = const(0x44DE) 24 | 25 | SHTC3_NORMAL_MEAS = [SHTC3_REG_NORMAL_T_F, SHTC3_REG_NORMAL_H_F] 26 | SHTC3_LOW_POWER_MEAS = [SHTC3_REG_LOW_POWER_T_F, SHTC3_REG_LOW_POWER_H_F] 27 | SHTC3_NORMAL_MEAS_STRETCH = [SHTC3_REG_NORMAL_T_F_STRETCH, SHTC3_REG_NORMAL_H_F_STRETCH] 28 | SHTC3_LOW_POWER_MEAS_STRETCH = [SHTC3_REG_LOW_POWER_T_F_STRETCH, SHTC3_REG_LOW_POWER_H_F_STRETCH] 29 | 30 | SHTC3_MEAS = [SHTC3_NORMAL_MEAS, SHTC3_LOW_POWER_MEAS] 31 | SHTC3_MEAS_STRETCH = [SHTC3_NORMAL_MEAS_STRETCH, SHTC3_LOW_POWER_MEAS_STRETCH] 32 | SHTC3_MEAS_ALL = [SHTC3_MEAS, SHTC3_MEAS_STRETCH] 33 | 34 | 35 | class SHTC3(): 36 | 37 | def __init__(self, _i2c): 38 | self.cmd = bytearray(2) 39 | self.buffer = bytearray(6) 40 | self.i2c = _i2c 41 | 42 | self.i2c.writeto(SHTC3_I2C_ADDRESS, bytes([0x00, 0x00, 0x00])) 43 | print("SHTC3 ID = {:x}".format(self.read_ID())) 44 | 45 | 46 | @staticmethod 47 | def crc8(buffer: bytearray) -> int: 48 | crc = 0xFF 49 | for byte in buffer: 50 | crc ^= byte 51 | for _ in range(0, 8, 1): 52 | if(crc & 0x80): 53 | crc = ((crc << 1) ^ 0x31) 54 | else: 55 | crc = (crc << 1) 56 | return (crc & 0xFF) 57 | 58 | 59 | def write_command(self, command:int): 60 | self.cmd[1] = (command & 0xFF) 61 | self.cmd[0] = (command >> 0x08) 62 | self.i2c.writeto(SHTC3_I2C_ADDRESS, self.cmd) 63 | 64 | 65 | def sleep(self): 66 | self.write_command(SHTC3_REG_SLEEP) 67 | sleep_us(300) 68 | 69 | 70 | def wakeup(self): 71 | self.write_command(SHTC3_REG_WAKEUP) 72 | sleep_us(300) 73 | 74 | 75 | def soft_reset(self): 76 | self.write_command(SHTC3_REG_SOFT_RESET) 77 | sleep_us(300) 78 | 79 | 80 | def read_ID(self): 81 | self.write_command(SHTC3_REG_READ_ID) 82 | self.buffer=self.i2c.readfrom(SHTC3_I2C_ADDRESS, 3) 83 | id = ((self.buffer[0] << 8) | self.buffer[1]) 84 | 85 | return id 86 | 87 | 88 | def measure(self, low_power_meas = False, clk_stretch = False): 89 | command = SHTC3_MEAS_ALL[clk_stretch][low_power_meas][False] 90 | self.write_command(command) 91 | 92 | if(low_power_meas == True): 93 | sleep_ms(2) 94 | else: 95 | sleep_ms(14) 96 | 97 | self.buffer=self.i2c.readfrom(SHTC3_I2C_ADDRESS, 6) 98 | temp_data = self.buffer[0:2] 99 | temp_data_crc = self.buffer[2] 100 | hum_data = self.buffer[3:5] 101 | hum_data_crc = self.buffer[5] 102 | 103 | if((temp_data_crc != self.crc8(temp_data)) or (hum_data_crc != self.crc8(hum_data))): 104 | print("crc error") 105 | return (0, 0) 106 | else : 107 | T_RAW = ((temp_data[0] << 8) | temp_data[1]) 108 | RH_RAW = ((hum_data[0] << 8) | hum_data[1]) 109 | t = ((T_RAW * 175.0) / 65536.0) - 45.0 110 | rh = ((RH_RAW * 100.0) / 65536.0) 111 | return (t, rh) -------------------------------------------------------------------------------- /SGP40 VoC Sensor and SHTC3 Temperature-Relative Humidity Sensor/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, I2C, SoftI2C 2 | from SHTC3 import SHTC3 3 | from SGP40 import SGP40 4 | from SSD1306_mini import OLED96 5 | from VOC_Algorithm import VOC_Algorithm 6 | from utime import sleep_ms 7 | 8 | 9 | sht_i2c = SoftI2C(scl = Pin(5, Pin.IN, Pin.PULL_UP), sda = Pin(4, Pin.IN, Pin.PULL_UP), freq = 400000) 10 | oled_i2c = SoftI2C(scl = Pin(15, Pin.IN, Pin.PULL_UP), sda = Pin(14, Pin.IN, Pin.PULL_UP), freq = 400000) 11 | sgp_i2c = SoftI2C(scl = Pin(17, Pin.IN, Pin.PULL_UP), sda = Pin(16, Pin.IN, Pin.PULL_UP), freq = 400000) 12 | 13 | 14 | sht = SHTC3(sht_i2c) 15 | oled = OLED96(oled_i2c) 16 | sgp = SGP40(sgp_i2c) 17 | voc = VOC_Algorithm() 18 | 19 | 20 | while(True): 21 | t, rh = sht.measure() 22 | raw_voc = sgp.raw_measurement(t, rh) 23 | voc.value = voc.VocAlgorithm_process(raw_voc) 24 | oled.fill(oled.BLACK) 25 | oled.text("Tmp/'C :" + str("%3.2f" %t), 1, 4, oled.WHITE) 26 | oled.text("R.H./% :" + str("%3.2f" %rh), 1, 14, oled.WHITE) 27 | oled.text("VoC/ppm:" + str("%3.2f" %voc.value), 1, 24, oled.WHITE) 28 | oled.show() 29 | sleep_ms(900) -------------------------------------------------------------------------------- /Seven Segment Thermometer - Timer/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin, Timer 2 | from segment_display import seg_disp 3 | from utime import sleep_ms 4 | 5 | 6 | conversion_factor = 3.3 / 65535 7 | 8 | 9 | seg = 0 10 | value = 0 11 | 12 | 13 | def timer_callback(t): 14 | global dat, seg 15 | 16 | point = False 17 | 18 | if(seg == 0): 19 | val = int(value / 100) 20 | elif(seg == 1): 21 | val = int((value % 100) / 10) 22 | point = True 23 | elif(seg == 2): 24 | val = int(value % 10) 25 | else: 26 | val = 12 27 | 28 | disp.send_data(val, seg, point) 29 | seg += 1 30 | 31 | if(seg > 3): 32 | seg = 0 33 | 34 | 35 | tim = Timer(mode = Timer.PERIODIC, period = 1, callback = timer_callback) 36 | int_t_sensor = machine.ADC(4) 37 | disp = seg_disp() 38 | 39 | 40 | while(True): 41 | t_reading = int_t_sensor.read_u16() * conversion_factor 42 | value = int((27 - (t_reading - 0.706) / 0.001721) * 10) 43 | sleep_ms(250) 44 | -------------------------------------------------------------------------------- /Seven Segment Thermometer - Timer/segment_display.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin 3 | 4 | mosi_pin = const(11) 5 | sck_pin = const(10) 6 | rclk_pin = const(9) 7 | 8 | 9 | seg_code_list = [ 10 | 0x3F, # 0 11 | 0x06, # 1 12 | 0x5B, # 2 13 | 0x4F, # 3 14 | 0x66, # 4 15 | 0x6D, # 5 16 | 0x7D, # 6 17 | 0x07, # 7 18 | 0x7F, # 8 19 | 0x6F, # 9 20 | 0x77, # A 21 | 0x7C, # b 22 | 0x39, # C 23 | 0x5E, # d 24 | 0x79, # E 25 | 0x71 # F 26 | ] 27 | 28 | seg_pos_list = [ 29 | 0xFE, # 1st 30 | 0xFD, # 2nd 31 | 0xFB, # 3rd 32 | 0xF7, # 4th 33 | ] 34 | 35 | 36 | class seg_disp(): 37 | 38 | def __init__(self): 39 | self.mosi = Pin(mosi_pin, Pin.OUT) 40 | self.sck = Pin(sck_pin, Pin.OUT) 41 | self.rclk = Pin(rclk_pin, Pin.OUT) 42 | 43 | def send_data(self, value, pos, dot): 44 | clks = 16 45 | temp = seg_pos_list[pos] 46 | temp <<= 8 47 | temp |= seg_code_list[value] 48 | 49 | if(dot == True): 50 | temp |= 0x80 51 | 52 | self.rclk.value(False) 53 | 54 | while(clks > 0): 55 | if((temp & 0x8000) != 0x0000): 56 | self.mosi.value(True) 57 | else: 58 | self.mosi.value(False) 59 | 60 | self.sck.value(True) 61 | temp <<= 1 62 | clks -= 1 63 | self.sck.value(False) 64 | 65 | self.rclk.value(True) 66 | 67 | 68 | -------------------------------------------------------------------------------- /TFT Touch Colour Mixer/XPT2046.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, SPI 3 | 4 | 5 | XPT2046_CS_pin = const(16) 6 | XPT2046_IRQ_pin = const(17) 7 | XPT2046_SCK_pin = const(10) 8 | XPT2046_MOSI_pin = const(11) 9 | XPT2046_MISO_pin = const(12) 10 | 11 | 12 | XPT2046_CMD_RDY = const(0x90) 13 | XPT2046_CMD_RDX = const(0xD0) 14 | 15 | XPT2046_l_max = const(319) 16 | XPT2046_w_max = const(239) 17 | 18 | 19 | class touch(): 20 | def __init__(self): 21 | 22 | self.x_axis_min = 511 23 | self.x_axis_max = 4095 24 | self.y_axis_min = 4095 25 | self.y_axis_max = 511 26 | 27 | self.XPT2046_CS = Pin(XPT2046_CS_pin, Pin.OUT) 28 | self.XPT2046_SCK = Pin(XPT2046_SCK_pin, Pin.OUT) 29 | self.XPT2046_IRQ = Pin(XPT2046_IRQ_pin, Pin.IN) 30 | self.XPT2046_MISO = Pin(XPT2046_MISO_pin, Pin.IN) 31 | self.XPT2046_MOSI = Pin(XPT2046_MOSI_pin, Pin.OUT) 32 | 33 | self.XPT2046_SPI = SPI(1, 10_000_000, polarity = False, phase = False, sck = self.XPT2046_SCK, mosi = self.XPT2046_MOSI, miso = self.XPT2046_MISO) 34 | 35 | 36 | def read_word(self): 37 | retval = self.XPT2046_SPI.read(0x02, 0x00) 38 | return (((retval[0] << 0x08) | retval[1]) >> 3) 39 | 40 | 41 | def map_value(self, v, x_min, x_max, y_min, y_max): 42 | return int(y_min + (((y_max - y_min) / (x_max - x_min)) * (v - x_min))) 43 | 44 | 45 | def constrain(self, value, min_value, max_value): 46 | if(value > max_value): 47 | return max_value 48 | 49 | elif(value < min_value): 50 | return min_value 51 | 52 | else: 53 | return value 54 | 55 | 56 | def read_coordinates(self): 57 | avg_x = 0 58 | avg_y = 0 59 | samples = 4 60 | 61 | self.XPT2046_CS.off() 62 | 63 | while(samples > 0): 64 | self.XPT2046_SPI.write(bytearray([XPT2046_CMD_RDY])) 65 | avg_x += self.read_word() 66 | 67 | self.XPT2046_SPI.write(bytearray([XPT2046_CMD_RDX])) 68 | avg_y += self.read_word() 69 | 70 | samples -= 1 71 | 72 | self.XPT2046_CS.on() 73 | 74 | avg_y >>= 2 75 | avg_x >>= 2 76 | 77 | return avg_x, avg_y 78 | 79 | 80 | def get_xy(self): 81 | x_val, y_val = self.read_coordinates() 82 | 83 | x_value = self.map_value(x_val, self.x_axis_min, self.x_axis_max, 0, XPT2046_l_max) 84 | y_value = self.map_value(y_val, self.y_axis_min, self.y_axis_max, 0, XPT2046_w_max) 85 | 86 | x_val = self.constrain(x_value, 0, XPT2046_l_max) 87 | y_val = self.constrain(y_value, 0, XPT2046_w_max) 88 | 89 | return x_val, y_val 90 | 91 | 92 | def calibration(self, x_min, y_min, x_max, y_max): 93 | self.x_axis_min = x_min 94 | self.x_axis_max = x_max 95 | self.y_axis_min = y_min 96 | self.y_axis_max = y_max 97 | -------------------------------------------------------------------------------- /TFT Touch Colour Mixer/main.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | from utime import sleep_ms 3 | from neopixel import NeoPixel 4 | from ST7789 import TFT208 5 | from XPT2046 import touch 6 | 7 | 8 | cal = 0 9 | x_cal_min = 511 10 | x_cal_max = 4095 11 | y_cal_min = 4095 12 | y_cal_max = 511 13 | R_value = 0 14 | G_value = 0 15 | B_value = 0 16 | R_slider = 40 17 | G_slider = 40 18 | B_slider = 40 19 | 20 | 21 | tft = TFT208() 22 | xpt = touch() 23 | pin = Pin(0, Pin.OUT) 24 | RGB_LED = NeoPixel(pin, 1) 25 | 26 | 27 | 28 | tft.fill(tft.BLACK) 29 | tft.text("TFT Touch Calibration Point 1", 40, 100, tft.WHITE) 30 | tft.rect(1, 1, 4, 4, tft.WHITE) 31 | tft.show() 32 | cal = 10 33 | while(cal > 0): 34 | x_cal_1, y_cal_1 = xpt.read_coordinates() 35 | cal -= 1 36 | sleep_ms(400) 37 | 38 | print("x_1: " + str(x_cal_1) + " y_1: " + str(y_cal_1)) 39 | tft.text(("X: " + str(x_cal_1) + " Y: " + str(y_cal_1)), 100, 140, tft.WHITE) 40 | tft.show() 41 | sleep_ms(1200) 42 | 43 | tft.fill(tft.BLACK) 44 | tft.text("TFT Touch Calibration Point 2", 40, 100, tft.WHITE) 45 | tft.rect(316, 236, 4, 4, tft.WHITE) 46 | tft.show() 47 | 48 | cal = 10 49 | 50 | while(cal > 0): 51 | x_cal_2, y_cal_2 = xpt.read_coordinates() 52 | cal -= 1 53 | sleep_ms(400) 54 | 55 | print("x_2: " + str(x_cal_2) + " y_2: " + str(y_cal_2)) 56 | tft.text(("X: " + str(x_cal_2) + " Y: " + str(y_cal_2)), 100, 140, tft.WHITE) 57 | tft.show() 58 | sleep_ms(1200) 59 | 60 | 61 | tft.fill(tft.BLACK) 62 | tft.text("TFT Touch Calibration Point 3", 40, 100, tft.WHITE) 63 | tft.rect(1, 236, 4, 4, tft.WHITE) 64 | tft.show() 65 | 66 | cal = 10 67 | 68 | while(cal > 0): 69 | x_cal_3, y_cal_3 = xpt.read_coordinates() 70 | cal -= 1 71 | sleep_ms(400) 72 | 73 | print("x_3: " + str(x_cal_3) + " y_3: " + str(y_cal_3)) 74 | tft.text(("X: " + str(x_cal_3) + " Y: " + str(y_cal_3)), 100, 140, tft.WHITE) 75 | tft.show() 76 | sleep_ms(1200) 77 | 78 | 79 | tft.fill(tft.BLACK) 80 | tft.text("TFT Touch Calibration Point 4", 40, 100, tft.WHITE) 81 | tft.rect(316, 1, 4, 4, tft.WHITE) 82 | tft.show() 83 | 84 | cal = 10 85 | 86 | while(cal > 0): 87 | x_cal_4, y_cal_4 = xpt.read_coordinates() 88 | cal -= 1 89 | sleep_ms(400) 90 | 91 | print("x_4: " + str(x_cal_4) + " y_4: " + str(y_cal_4)) 92 | tft.text(("X: " + str(x_cal_4) + " Y: " + str(y_cal_4)), 100, 140, tft.WHITE) 93 | tft.show() 94 | sleep_ms(1200) 95 | 96 | x_cal_min = ((x_cal_1 + x_cal_3) // 2) 97 | x_cal_max = ((x_cal_2 + x_cal_4) // 2) 98 | 99 | y_cal_min = ((y_cal_1 + y_cal_4) // 2) 100 | y_cal_max = ((y_cal_2 + y_cal_3) // 2) 101 | 102 | xpt.calibration(x_cal_min, y_cal_min, x_cal_max, y_cal_max) 103 | 104 | 105 | while(True): 106 | tft.fill(tft.BLACK) 107 | 108 | tft.text("XPT2046 - RP2040 RGB Colour Generator", 10, 6, tft.WHITE) 109 | 110 | tft.fill_rect(42, 60, 100, 10, tft.WHITE) 111 | tft.fill_rect(42, 130, 100, 10, tft.WHITE) 112 | tft.fill_rect(42, 200, 100, 10, tft.WHITE) 113 | 114 | x_axis, y_axis = xpt.get_xy() 115 | 116 | if(40 <= y_axis <= 70): 117 | if(40 <= x_axis <= 140): 118 | R_slider = x_axis 119 | R_value = xpt.map_value(R_slider, 40, 140, 0, 255) 120 | 121 | if(130 <= y_axis <= 150): 122 | if(40 <= x_axis <= 140): 123 | G_slider = x_axis 124 | G_value = xpt.map_value(G_slider, 40, 140, 0, 255) 125 | 126 | if(200 <= y_axis <= 240): 127 | if(40 <= x_axis <= 140): 128 | B_slider = x_axis 129 | B_value = xpt.map_value(B_slider, 40, 140, 0, 255) 130 | 131 | tft.fill_rect(R_slider, 55, 4, 20, tft.RED) 132 | tft.fill_rect(G_slider, 125, 4, 20, tft.GREEN) 133 | tft.fill_rect(B_slider, 195, 4, 20, tft.BLUE) 134 | 135 | tft.text("R", 20, 60, tft.RED) 136 | tft.text("G", 20, 130, tft.GREEN) 137 | tft.text("B", 20, 200, tft.BLUE) 138 | 139 | tft.text(str("%3u" %R_value), 160, 60, tft.RED) 140 | tft.text(str("%3u" %G_value), 160, 130, tft.GREEN) 141 | tft.text(str("%3u" %B_value), 160, 200, tft.BLUE) 142 | 143 | tft.fill_rect(240, 100, 60, 60, tft.colour_generator(R_value, G_value, B_value)) 144 | 145 | tft.text(("0x" + str("%04X" %tft.colour_generator(R_value, G_value, B_value))), 245, 180, tft.WHITE) 146 | 147 | tft.show() 148 | 149 | RGB_LED[0] = (R_value, G_value, B_value) 150 | RGB_LED.write() 151 | 152 | -------------------------------------------------------------------------------- /Waveshare I2C RGB LCD Test/RGB_LCD_1602.py: -------------------------------------------------------------------------------- 1 | from micropython import const 2 | from machine import Pin, I2C 3 | from utime import sleep_ms, sleep_us 4 | 5 | #I2C Details 6 | RGB1602_I2C = const(1) 7 | RGB1602_I2C_SDA = Pin(6) 8 | RGB1602_I2C_SCL = Pin(7) 9 | 10 | RGB_LCD_I2C = I2C(RGB1602_I2C, sda = RGB1602_I2C_SDA, scl = RGB1602_I2C_SCL, freq = 400000) 11 | 12 | 13 | #Device I2C Addresses 14 | LCD_I2C_address = const(0x3E) 15 | RGB_I2C_address = const(0x60) 16 | 17 | #color define 18 | REG_RED = const(0x04) 19 | REG_GREEN = const(0x03) 20 | REG_BLUE = const(0x02) 21 | REG_MODE_1 = const(0x00) 22 | REG_MODE_2 = const(0x01) 23 | REG_OUTPUT = const(0x08) 24 | 25 | LCD_CLEAR_DISPLAY = const(0x01) 26 | LCD_RETURN_HOME = const(0x02) 27 | LCD_ENTRY_MODE_SET = const(0x04) 28 | LCD_DISPLAY_CONTROL = const(0x08) 29 | LCD_CURSOR_SHIFT = const(0x10) 30 | LCD_FUNCTION_SET = const(0x20) 31 | LCD_SET_CGRAM_ADDR = const(0x40) 32 | LCD_SET_DDRAM_ADDR = const(0x80) 33 | 34 | #flags for display entry mode 35 | LCD_ENTRY_RIGHT = const(0x00) 36 | LCD_ENTRY_LEFT = const(0x02) 37 | LCD_ENTRY_SHIFT_INCREMENT = const(0x01) 38 | LCD_ENTRY_SHIFT_DECREMENT = const(0x00) 39 | 40 | #flags for display on/off control 41 | LCD_DISPLAY_ON = const(0x04) 42 | LCD_DISPLAY_OFF = const(0x00) 43 | LCD_CURSOR_ON = const(0x02) 44 | LCD_CURSOR_OFF = const(0x00) 45 | LCD_BLINK_ON = const(0x01) 46 | LCD_BLINK_OFF = const(0x00) 47 | 48 | #flags for display/cursor shift 49 | LCD_DISPLAY_MOVE = const(0x08) 50 | LCD_CURSOR_MOVE = const(0x00) 51 | LCD_MOVE_RIGHT = const(0x04) 52 | LCD_MOVE_LEFT = const(0x00) 53 | 54 | #flags for function set 55 | LCD_8_BIT_MODE = const(0x10) 56 | LCD_4_BIT_MODE = const(0x00) 57 | LCD_2_LINE = const(0x08) 58 | LCD_1_LINE = const(0x00) 59 | LCD_5x8_DOTS = const(0x00) 60 | 61 | #Data / Command selection 62 | DAT = const(0x40) 63 | CMD = const(0x80) 64 | 65 | 66 | class RGB1602: 67 | def __init__(self, row, col): 68 | self._row = row 69 | self._col = col 70 | self._showfunction = (LCD_4_BIT_MODE | LCD_1_LINE | LCD_5x8_DOTS) 71 | self.initialize(self._row, self._col) 72 | 73 | 74 | def write(self, value, loc): 75 | RGB_LCD_I2C.writeto_mem(LCD_I2C_address, loc, chr(value)) 76 | 77 | 78 | def set_reg(self, reg, value): 79 | RGB_LCD_I2C.writeto_mem(RGB_I2C_address, reg, chr(value)) 80 | 81 | 82 | def set_RGB(self, r, g, b): 83 | self.set_reg(REG_RED, r) 84 | self.set_reg(REG_GREEN, g) 85 | self.set_reg(REG_BLUE, b) 86 | 87 | 88 | def goto_xy(self, x_pos, y_pos): 89 | if(y_pos == 0): 90 | x_pos |= 0x80 91 | else: 92 | x_pos |= 0xC0 93 | 94 | RGB_LCD_I2C.writeto(LCD_I2C_address, bytearray([0x80, x_pos])) 95 | 96 | 97 | def clear_home(self): 98 | self.write(LCD_CLEAR_DISPLAY, CMD) 99 | self.write(LCD_RETURN_HOME, CMD) 100 | sleep_ms(2) 101 | 102 | 103 | def put_chr(self, ch): 104 | self.write(ord(ch), DAT) 105 | 106 | 107 | def put_str(self, ch_str): 108 | for chr in ch_str: 109 | self.put_chr(chr) 110 | 111 | 112 | def display(self): 113 | self._showcontrol |= LCD_DISPLAY_ON 114 | self.write((LCD_DISPLAY_CONTROL | self._showcontrol), CMD) 115 | 116 | 117 | def initialize(self, cols, rows): 118 | if (rows > 1): 119 | self._showfunction |= LCD_2_LINE 120 | 121 | sleep_ms(50) 122 | 123 | # Send function set command sequence and try 124 | self.write((LCD_FUNCTION_SET | self._showfunction), CMD) 125 | sleep_ms(5) 126 | 127 | # Second try 128 | self.write((LCD_FUNCTION_SET | self._showfunction), CMD) 129 | sleep_ms(5) 130 | 131 | # Third try 132 | self.write((LCD_FUNCTION_SET | self._showfunction), CMD) 133 | 134 | # Finally, set # lines, font size, etc. 135 | self.write((LCD_FUNCTION_SET | self._showfunction), CMD) 136 | 137 | # Turn the display on with no cursor or blinking default 138 | self._showcontrol = (LCD_DISPLAY_ON | LCD_CURSOR_OFF | LCD_BLINK_OFF) 139 | self.display() 140 | 141 | # Clear LCD & goto to home location 142 | self.clear_home() 143 | 144 | # Initialize to default text direction 145 | self._showmode = (LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT) 146 | 147 | # Set the entry mode 148 | self.write((LCD_ENTRY_MODE_SET | self._showmode), CMD) 149 | 150 | # Backlight init 151 | self.set_reg(REG_MODE_1, 0x00) 152 | 153 | # Set LEDs controllable by both PWM and GRPPWM registers 154 | self.set_reg(REG_OUTPUT, 0xFF) 155 | 156 | # Set MODE2 values 157 | # 0010 0000 -> 0x20 (DMBLNK to 1, ie blinky mode) 158 | self.set_reg(REG_MODE_2, 0x20) 159 | 160 | #Set LCD colour to white initially 161 | self.set_RGB(255, 255, 255) 162 | 163 | -------------------------------------------------------------------------------- /Waveshare I2C RGB LCD Test/main.py: -------------------------------------------------------------------------------- 1 | from RGB_LCD_1602 import RGB1602 2 | from utime import sleep_ms 3 | 4 | 5 | i = -20.0 6 | 7 | lcd = RGB1602(2, 16) 8 | 9 | 10 | lcd.goto_xy(1, 0) 11 | lcd.put_str("WShare RGB LCD") 12 | 13 | while True: 14 | lcd.goto_xy(7, 1) 15 | lcd.put_str(str("%2.1f " % i)) 16 | i += 0.1 17 | 18 | 19 | if (-20 < i <= -10): 20 | lcd.set_RGB(127, 127, 127) 21 | 22 | elif (-10 < i <= 0): 23 | lcd.set_RGB(255, 255, 255) 24 | 25 | elif (0 < i <= 10): 26 | lcd.set_RGB(255, 0, 0) 27 | 28 | elif (10 < i <= 20): 29 | lcd.set_RGB(255, 127, 0) 30 | 31 | elif (20 < i <= 30): 32 | lcd.set_RGB(127, 127, 0) 33 | 34 | elif (30 < i <= 40): 35 | lcd.set_RGB(0, 255, 0) 36 | 37 | elif (40 < i <= 50): 38 | lcd.set_RGB(0, 255, 127) 39 | 40 | elif (50 < i <= 60): 41 | lcd.set_RGB(0, 127, 127) 42 | 43 | elif (60 < i <= 70): 44 | lcd.set_RGB(0, 127, 255) 45 | 46 | elif (70 < i <= 80): 47 | lcd.set_RGB(0, 0, 255) 48 | 49 | elif (80 < i <= 90): 50 | lcd.set_RGB(127, 0, 255) 51 | 52 | elif (90 < i <= 100): 53 | lcd.set_RGB(127, 0, 127) 54 | 55 | if (i >= 100): 56 | i = -20.0 57 | 58 | sleep_ms(100) 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | --------------------------------------------------------------------------------