Add files via upload

Author: sshahryiar

GLCD SONAR/PCD8544.py

@@ -0,0 +1,153 @@
+from micropython import const
+from pyb import Pin, SPI
+from utime import sleep_ms
+from ustruct import pack
+import framebuf
+
+
+PCD8544_DC_pin = 'X2'
+PCD8544_CS_pin = 'X3'
+PCD8544_RST_pin = 'X1'
+PCD8544_SCK_pin = 'X6'
+PCD8544_MOSI_pin = 'X8'
+
+PCD8544_FUNCTION_SET     = const(0x20)
+PCD8544_POWER_DOWN       = const(0x04)
+PCD8544_ADDRESSING_VERT  = const(0x02)
+PCD8544_EXTENDED_INSTR   = const(0x01)
+
+PCD8544_DISPLAY_BLANK    = const(0x08)
+PCD8544_DISPLAY_ALL      = const(0x09)
+PCD8544_DISPLAY_NORMAL   = const(0x0C)
+PCD8544_DISPLAY_INVERSE  = const(0x0D)
+
+PCD8544_TEMP_COEFF_0     = const(0x04)
+PCD8544_TEMP_COEFF_1     = const(0x05)
+PCD8544_TEMP_COEFF_2     = const(0x06) 
+PCD8544_TEMP_COEFF_3     = const(0x07)
+
+PCD8544_BIAS_1_100       = const(0x10)
+PCD8544_BIAS_1_80        = const(0x11)
+PCD8544_BIAS_1_65        = const(0x12)
+PCD8544_BIAS_1_48        = const(0x13)
+PCD8544_BIAS_1_40        = const(0x14) 
+PCD8544_BIAS_1_24        = const(0x15)
+PCD8544_BIAS_1_18        = const(0x16)
+PCD8544_BIAS_1_10        = const(0x17)
+PCD8544_SET_VOP          = const(0x80)
+PCD8544_COL_ADDR         = const(0x80)
+PCD8544_BANK_ADDR        = const(0x40) 
+
+CMD = False
+DAT = True
+
+LOW = False
+HIGH = True
+
+PCD8544_GLCD_WIDTH = const(84)
+PCD8544_GLCD_HEIGHT = const(48)
+
+
+class PCD8544(framebuf.FrameBuffer):
+    def __init__(self):
+        self.width = PCD8544_GLCD_WIDTH
+        self.height = PCD8544_GLCD_HEIGHT
+        
+        self.BLACK = const(0xFF)
+        self.WHITE = const(0x00)
+
+        self.PCD8544_CS = Pin(PCD8544_CS_pin, Pin.OUT_PP)
+        self.PCD8544_RST = Pin(PCD8544_RST_pin, Pin.OUT_PP)
+        self.PCD8544_SCK = Pin(PCD8544_SCK_pin, Pin.OUT_PP)
+        self.PCD8544_MOSI = Pin(PCD8544_MOSI_pin, Pin.OUT_PP)
+
+        self.PCD8544_SPI = SPI(1, SPI.CONTROLLER, baudrate = 4_000_000, polarity = 0, phase = 0)
+        
+        self.PCD8544_DC = Pin(PCD8544_DC_pin, Pin.OUT_PP)
+        
+        self.buffer = bytearray((self.height * self.width) // 8) #84 x 48 = 504
+        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
+        
+        self.init()
+
+
+
+    def init(self):
+        self.function = PCD8544_FUNCTION_SET
+        self.disp_reset()
+        self.addressing(True)
+        self.set_contrast(PCD8544_BIAS_1_40, PCD8544_TEMP_COEFF_2, 63)
+        self.disp_invert(False)
+        self.clear()
+
+
+    def disp_reset(self):
+        self.PCD8544_CS.value(HIGH)
+        self.PCD8544_DC.value(HIGH)
+
+        self.PCD8544_RST.value(HIGH)
+        sleep_ms(10)
+        self.PCD8544_RST.value(LOW)
+        sleep_ms(20)
+        self.PCD8544_RST.value(HIGH)
+
+
+    def send(self, value, mode):
+        self.PCD8544_CS.value(LOW)
+        self.PCD8544_DC.value(mode)
+        
+        if(mode == DAT):
+            self.PCD8544_SPI.write(pack('B'*len(value), *value))
+        else:
+            self.PCD8544_SPI.write(bytearray([value]))
+            
+        self.PCD8544_CS.value(HIGH)
+
+
+    def set_xy(self, x_pos, y_pos):
+    	self.send((PCD8544_COL_ADDR | x_pos), CMD)
+    	self.send((PCD8544_BANK_ADDR | y_pos), CMD)
+
+
+    def addressing(self, horizontal_or_vertical = True):
+    	if(horizontal_or_vertical == True):
+    		self.function &= ~PCD8544_ADDRESSING_VERT
+    	else:
+    		self.function |= PCD8544_ADDRESSING_VERT
+
+    	self.send(self.function, CMD)
+
+
+    def clear(self):
+        self.send(([0] * 504), DAT) #84 x 48 = 504
+        self.set_xy(0, 0)
+
+
+    def disp_invert(self, mode):
+        if(mode == True):
+            self.send(PCD8544_DISPLAY_INVERSE, CMD)
+        else:
+            self.send(PCD8544_DISPLAY_NORMAL, CMD)
+
+
+    def disp_power(self, mode):
+        if(mode == True):
+            self.function &= ~PCD8544_POWER_DOWN
+        else:
+            self.function |= PCD8544_POWER_DOWN
+
+        self.send(self.function, CMD)
+
+
+    def set_contrast(self, bias = PCD8544_BIAS_1_40, t_coff = PCD8544_TEMP_COEFF_2, contrast = 63):
+        self.send((self.function | PCD8544_EXTENDED_INSTR), CMD)
+        self.send(t_coff, CMD)
+        self.send(bias, CMD)
+        self.send(PCD8544_SET_VOP | contrast, CMD)
+        self.send((self.function & ~PCD8544_EXTENDED_INSTR), CMD)
+        
+        
+        
+    def show(self):
+    	self.send(self.buffer, DAT)
+

GLCD SONAR/main.py

@@ -0,0 +1,93 @@
+from pyb import Pin, LED, Timer
+from utime import sleep_ms, sleep_us
+from PCD8544 import PCD8544
+
+
+last_capture = 0
+pulse_width = 0
+
+
+led = LED(1)
+
+echo_pin = Pin('X4', Pin.IN)
+trigger_pin = Pin('X5', Pin.OUT_PP)
+
+
+glcd = PCD8544()
+
+glcd.fill(glcd.WHITE)
+glcd.show()
+
+
+def input_capture(timer):
+    global last_capture, pulse_width
+    
+    if echo_pin.value(): 
+        last_capture = in_cap.capture()
+        
+    else: 
+        pulse_width = (in_cap.capture() - last_capture)
+        pulse_width &= 0x0FFFFFFF
+
+
+TIM2 = Timer(2,
+             prescaler = 83,
+             period = 0x0FFFFFFF)
+
+in_cap = TIM2.channel(4,
+                      mode = Timer.IC,
+                      pin = echo_pin,
+                      polarity = Timer.BOTH,
+                      callback = input_capture)
+
+
+def map_value(v, x_min, x_max, y_min, y_max):
+    return int(y_min + (((y_max - y_min) / (x_max - x_min)) * (v - x_min)))
+
+
+def constrain(value, min_value, max_value):
+    if(value > max_value):
+        return max_value
+    
+    elif(value < min_value):
+        return min_value
+    
+    else:
+        return value
+
+
+def trigger_sensor():
+    led.on()
+    trigger_pin.high()
+    sleep_us(20)
+    trigger_pin.low()
+    sleep_ms(300)
+
+
+def display():
+    global pulse_width
+        
+    distance = constrain(pulse_width, 0, 42000)
+    distance = (pulse_width / 5.8)
+    bar = map_value(distance, 0, 4000, 2, 80)
+    
+    glcd.fill(glcd.WHITE)
+    glcd.text("PYB SONAR", 4 , 2, glcd.BLACK)
+    glcd.text("D/mm: " + str("%3u  " %distance), 1 , 16, glcd.BLACK)
+    
+    for i in range(2, 83, 10):
+        glcd.vline(i, 42, 5, glcd.BLACK)
+        glcd.vline((i - 5) , 42, 3, glcd.BLACK)   
+    
+    glcd.rect(1, 32, 83, 8, glcd.BLACK)
+    glcd.rect(2, 34, bar, 4, glcd.BLACK, True)
+    
+    glcd.show()
+    pulse_width = 0
+    led.off()
+    sleep_ms(300)
+    
+
+while(True):
+    trigger_sensor()    
+    display()  

RCWL-1670 SONAR/RGB_LCD.py

@@ -0,0 +1,123 @@
+from micropython import const
+from utime import sleep_ms
+
+
+AiP31068_LCD_I2C_address = const(0x3E)
+PCA9633_I2C_address = const(0x60)
+
+REG_RED = const(0x04)
+REG_GREEN = const(0x03)
+REG_BLUE = const(0x02)
+REG_MODE_1 = const(0x00)
+REG_MODE_2 = const(0x01)
+REG_OUTPUT = const(0x08)
+
+LCD_CLEAR_DISPLAY = const(0x01)
+LCD_RETURN_HOME = const(0x02)
+LCD_ENTRY_MODE_SET = const(0x04)
+LCD_DISPLAY_CONTROL = const(0x08)
+LCD_CURSOR_SHIFT = const(0x10)
+LCD_FUNCTION_SET = const(0x20)
+LCD_SET_CGRAM_ADDR = const(0x40)
+LCD_SET_DDRAM_ADDR = const(0x80)
+
+LCD_ENTRY_RIGHT = const(0x00)
+LCD_ENTRY_LEFT = const(0x02)
+LCD_ENTRY_SHIFT_INCREMENT = const(0x01)
+LCD_ENTRY_SHIFT_DECREMENT = const(0x00)
+
+LCD_DISPLAY_ON = const(0x04)
+LCD_DISPLAY_OFF = const(0x00)
+LCD_CURSOR_ON = const(0x02)
+LCD_CURSOR_OFF = const(0x00)
+LCD_BLINK_ON = const(0x01)
+LCD_BLINK_OFF = const(0x00)
+
+LCD_DISPLAY_MOVE = const(0x08)
+LCD_CURSOR_MOVE = const(0x00)
+LCD_MOVE_RIGHT = const(0x04)
+LCD_MOVE_LEFT = const(0x00)
+
+LCD_8_BIT_MODE = const(0x10)
+LCD_4_BIT_MODE = const(0x00)
+LCD_2_LINE = const(0x08)
+LCD_1_LINE = const(0x00)
+LCD_5x8_DOTS = const(0x00)
+
+DAT = const(0x40)
+CMD = const(0x80)
+
+
+class RGB_LCD():
+    
+    def __init__(self, _i2c):
+        self._row = 2
+        self._col = 16
+        self.i2c = _i2c
+        self._showfunction = (LCD_4_BIT_MODE | LCD_1_LINE | LCD_5x8_DOTS)
+        self.init(self._row, self._col)
+        
+        
+    def write_to_LCD(self, value, loc):
+        self.i2c.writeto_mem(AiP31068_LCD_I2C_address, loc, chr(value))
+    
+    
+    def write_to_RGB_LED(self, reg, value):
+        self.i2c.writeto_mem(PCA9633_I2C_address, reg, chr(value))
+        
+       
+    def set_RGB(self, r, g, b):
+        self.write_to_RGB_LED(REG_RED, r)
+        self.write_to_RGB_LED(REG_GREEN, g)
+        self.write_to_RGB_LED(REG_BLUE, b)
+        
+        
+    def goto_xy(self, x_pos, y_pos):
+        if(y_pos == 0):
+          x_pos |= 0x80
+        else:
+          x_pos |= 0xC0
+
+        self.i2c.writeto(AiP31068_LCD_I2C_address, bytearray([0x80, x_pos]))
+      
+      
+    def clear_home(self):
+        self.write_to_LCD(LCD_CLEAR_DISPLAY, CMD)
+        self.write_to_LCD(LCD_RETURN_HOME, CMD)
+        sleep_ms(2)
+      
+      
+    def display(self):
+        self._showcontrol |= LCD_DISPLAY_ON 
+        self.write_to_LCD((LCD_DISPLAY_CONTROL | self._showcontrol), CMD)
+    
+
+    def put_chr(self, ch):
+        self.write_to_LCD(ord(ch), DAT)
+        
+        
+    def put_str(self, ch_str):
+        for chr in ch_str:
+            self.put_chr(chr)
+
+
+    def init(self, cols, rows):
+        if (rows > 1):
+            self._showfunction |= LCD_2_LINE 
+        sleep_ms(50)
+        self.write_to_LCD((LCD_FUNCTION_SET | self._showfunction), CMD)
+        sleep_ms(5)
+        self.write_to_LCD((LCD_FUNCTION_SET | self._showfunction), CMD)
+        sleep_ms(5)
+        self.write_to_LCD((LCD_FUNCTION_SET | self._showfunction), CMD)
+        self.write_to_LCD((LCD_FUNCTION_SET | self._showfunction), CMD)
+        self._showcontrol = (LCD_DISPLAY_ON | LCD_CURSOR_OFF | LCD_BLINK_OFF)
+        self.display()
+        self.clear_home()
+        self._showmode = (LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT)
+        self.write_to_LCD((LCD_ENTRY_MODE_SET | self._showmode), CMD)
+
+        self.write_to_RGB_LED(REG_MODE_1, 0x00)
+        self.write_to_RGB_LED(REG_OUTPUT, 0xFF)
+        self.write_to_RGB_LED(REG_MODE_2, 0x20)
+        self.set_RGB(255, 255, 255)