Add SeeedStudio Grove RGB LCD (#10)

Uses JHD1313M1 I2C HD44780 compatible character LCD with PCA9633 I2C
RGB LED driver

Author: mcauser

README.md

@@ -43,6 +43,8 @@ Files
 | pyb_gpio_lcd_test.py          | Pyboard test using 4-bit GPIO         |
 | pyb_i2c_adafruit_lcd.py       | Pyboard MCP23008 I2C HAL              |
 | pyb_i2c_adafruit_lcd_test.py  | Pyboard test using Adafruit backpack  |
+| pyb_i2c_grove_rgb_lcd.py      | Pyboard Grove I2C RGB LCD HAL         |
+| pyb_i2c_grove_rgb_lcd_test.py | Pyboard test using Grove I2C RGB LCD  |
 | pyb_i2c_lcd.py                | Pyboard PCF8574 I2C HAL               |
 | pyb_i2c_lcd_test.py           | Pyboard test using PCF8574 backpack   |
 

lcd/pyb_i2c_grove_rgb_lcd.py

@@ -0,0 +1,82 @@
+"""Implements a SeeedStudio Grove RGB LCD JHD1313M1 HD44780 compatible character LCD connected on I2C."""
+
+from lcd_api import LcdApi
+from pyb import I2C, delay
+
+# No jumper selectable address
+DEFAULT_LCD_I2C_ADDR = 0x3e
+# Software configurable address
+DEFAULT_RGB_I2C_ADDR = 0x62
+
+class I2cLcd(LcdApi):
+    """Implements a HD44780 character LCD connected to I2C."""
+
+    def __init__(self, i2c, i2c_addr, num_lines, num_columns, bl_i2c_addr):
+        self.i2c = i2c
+        self.i2c_addr = i2c_addr
+        self.bl_i2c_addr = bl_i2c_addr
+        # Put LCD into 4 bit mode
+        self.hal_write_command(self.LCD_FUNCTION)
+        delay(1)
+        LcdApi.__init__(self, num_lines, num_columns)
+        cmd = self.LCD_FUNCTION
+        if num_lines > 1:
+            cmd |= self.LCD_FUNCTION_2LINES
+        self.hal_write_command(cmd)
+        # init backlight
+        self.i2c.mem_write(0, self.bl_i2c_addr, 0) # MODE1
+        self.i2c.mem_write(0, self.bl_i2c_addr, 1) # MODE2
+
+    def backlight_rgb(self, r, g, b):
+        self.i2c.mem_write(170, self.bl_i2c_addr, 8) # LEDOUT
+        self.i2c.mem_write(r, self.bl_i2c_addr, 4) # Red
+        self.i2c.mem_write(g, self.bl_i2c_addr, 3) # Green
+        self.i2c.mem_write(b, self.bl_i2c_addr, 2) # Blue
+
+    def backlight_invert_on(self):
+        self.i2c.mem_write(16, self.bl_i2c_addr, 1) # MODE2 bit4 INVRT 1=on
+
+    def backlight_invert_off(self):
+        self.i2c.mem_write(0, self.bl_i2c_addr, 1) # MODE2 bit4 INVRT 0=off
+
+    def backlight_blink(self, duty, freq):
+        self.i2c.mem_write(32, self.bl_i2c_addr, 1) # MODE2 bit5 DMBLNK 1=blinking
+        self.i2c.mem_write(255, self.bl_i2c_addr, 8) # LEDOUT = PWMx + GRPPWM
+        # blink
+        self.i2c.mem_write(duty, self.bl_i2c_addr, 6) # GRPPWM = duty cycle
+        self.i2c.mem_write(freq, self.bl_i2c_addr, 7) # GRPFREQ = blinking period (24hz - 10.73s)
+
+    def backlight_brightness(self, duty):
+        self.i2c.mem_write(0, self.bl_i2c_addr, 1) # MODE2 bit5 DMBLNK 0=dimming
+        self.i2c.mem_write(255, self.bl_i2c_addr, 8) # LEDOUT = PWMx + GRPPWM
+        # set brightness
+        self.i2c.mem_write(duty, self.bl_i2c_addr, 6) # GRPPWM = global brightness
+
+    def backlight_normal(self):
+        self.i2c.mem_write(170, self.bl_i2c_addr, 8) # LEDOUT = PWMx
+
+    def backlight_sleep(self):
+        self.i2c.mem_write(16, self.bl_i2c_addr, 0) # MODE1 bit4 SLEEP 1=low power mode, oscillator off
+
+    def backlight_wake(self):
+        self.i2c.mem_write(0, self.bl_i2c_addr, 0) # MODE1 bit4 SLEEP 0=normal power mode
+
+    def hal_backlight_on(self):
+        """Allows the hal layer to turn the backlight on."""
+        self.i2c.mem_write(85, self.bl_i2c_addr, 0x08)
+
+    def hal_backlight_off(self):
+        """Allows the hal layer to turn the backlight off."""
+        self.i2c.mem_write(0, self.bl_i2c_addr, 0x08)
+
+    def hal_write_command(self, cmd):
+        """Writes a command to the LCD."""
+        self.i2c.mem_write(cmd, self.i2c_addr, self.LCD_DDRAM)
+        if cmd <= 3:
+            # The home and clear commands require a worst
+            # case delay of 4.1 msec
+            delay(5)
+
+    def hal_write_data(self, data):
+        """Write data to the LCD."""
+        self.i2c.mem_write(data, self.i2c_addr, self.LCD_CGRAM)

lcd/pyb_i2c_grove_rgb_lcd_test.py

@@ -0,0 +1,173 @@
+"""Implements a SeeedStudio Grove RGB LCD JHD1313M1 HD44780 compatible character LCD connected on I2C."""
+
+from pyb import I2C, delay, millis
+from pyb_i2c_grove_rgb_lcd import I2cLcd
+
+import time
+from urandom import getrandbits
+
+# No jumper selectable address
+DEFAULT_LCD_I2C_ADDR = 0x3e
+# Software configurable address
+DEFAULT_RGB_I2C_ADDR = 0x62
+
+def test_main():
+    """Test function for verifying basic functionality."""
+    print("Running test_main")
+    i2c = I2C(1, I2C.MASTER)
+    lcd = I2cLcd(i2c, DEFAULT_LCD_I2C_ADDR, 2, 16, DEFAULT_RGB_I2C_ADDR)
+    lcd.putstr("It Works!\nSecond Line")
+    lcd.backlight_rgb(255,255,255)
+    lcd.blink_cursor_on()
+    time.sleep_ms(1000)
+
+    lcd.clear()
+    lcd.putstr("Seeed Grove LCD RGB Backlight")
+    time.sleep_ms(1000)
+
+    # 16 columns, 2 rows
+    lcd.clear()
+    lcd.putstr("1234567890123456abcdefghijklmnop")
+    time.sleep_ms(1000)
+
+    lcd.hide_cursor();
+    lcd.clear()
+    lcd.putstr("Red")
+    lcd.backlight_rgb(255,0,0)
+    time.sleep_ms(1000)
+
+    lcd.clear()
+    lcd.putstr("Green")
+    lcd.backlight_rgb(0,255,0)
+    time.sleep_ms(1000)
+
+    lcd.clear()
+    lcd.putstr("Blue")
+    lcd.backlight_rgb(0,0,255)
+    time.sleep_ms(1000)
+
+    # invert background colour
+    lcd.clear()
+    lcd.putstr("Blue")
+    time.sleep_ms(1000)
+    lcd.backlight_invert_on()
+    lcd.putstr(" Inverted")
+    time.sleep_ms(1000)
+    lcd.clear()
+    lcd.putstr("Blue")
+    lcd.backlight_invert_off()
+    time.sleep_ms(1000)
+
+    # pwm blinking
+    lcd.clear()
+    lcd.putstr("Blinking PWM\nDuty=127 Freq=1")
+    lcd.backlight_rgb(255,0,0)
+    lcd.backlight_blink(127,1)
+    time.sleep_ms(2000)
+    lcd.backlight_normal()
+
+    lcd.clear()
+    lcd.putstr("Blinking PWM\nDuty=100 Freq=10")
+    lcd.backlight_rgb(255,255,0)
+    lcd.backlight_blink(100,10)
+    time.sleep_ms(2000)
+    lcd.backlight_normal()
+
+    lcd.clear()
+    lcd.putstr("Blinking PWM\nDuty=10 Freq=20")
+    lcd.backlight_rgb(0,255,255)
+    lcd.backlight_blink(10,20)
+    time.sleep_ms(5000)
+    lcd.backlight_normal()
+
+    # pwm global brightness
+    lcd.clear()
+    lcd.putstr("Brightness 255")
+    lcd.backlight_brightness(255)
+    time.sleep_ms(1000)
+    lcd.clear()
+    lcd.putstr("Brightness 127")
+    lcd.backlight_brightness(127)
+    time.sleep_ms(1000)
+    lcd.clear()
+    lcd.putstr("Brightness 63")
+    lcd.backlight_brightness(63)
+    time.sleep_ms(1000)
+    lcd.clear()
+    lcd.putstr("Brightness 1")
+    lcd.backlight_brightness(1)
+    time.sleep_ms(1000)
+    lcd.clear()
+    lcd.putstr("Brightness 0")
+    lcd.backlight_brightness(0)
+    time.sleep_ms(1000)
+
+    # take the rgb driver oscillator offline
+    lcd.clear()
+    lcd.backlight_normal()
+    lcd.backlight_brightness(255)
+    lcd.backlight_rgb(255,0,0)
+
+    # low power mode
+    lcd.backlight_sleep()
+    lcd.putstr("low power mode\n")
+    time.sleep_ms(2000)
+
+    # cant change background colour while oscillator is offline
+    lcd.backlight_rgb(0,255,255)
+    lcd.putstr("cant change bg")
+    time.sleep_ms(2000)
+
+    # full power mode
+    lcd.clear()
+    lcd.putstr("full power mode\n")
+    lcd.backlight_wake()
+    # pending change applied
+    lcd.putstr("bg now changed")
+    time.sleep_ms(2000)
+
+    # rainbow
+    lcd.clear()
+    lcd.putstr("Rainbow")
+    for i in range(2):
+        rainbow(lcd, 10)
+    time.sleep_ms(1000)
+
+    # random
+    lcd.clear()
+    lcd.putstr("Random")
+    randomColors(lcd, 30, 100)
+
+
+# Helper for converting 0-255 offset to a colour tuple
+def wheel(offset):
+    # The colours are a transition r - g - b - back to r
+    offset = 255 - offset
+    if offset < 85:
+        return (255 - offset * 3, 0, offset * 3)
+    if offset < 170:
+        offset -= 85
+        return (0, offset * 3, 255 - offset * 3)
+    offset -= 170
+    return (offset * 3, 255 - offset * 3, 0)
+
+# Helper for setting a colour tuple
+def hue(lcd, n):
+    r,g,b = wheel(n & 255)
+    lcd.backlight_rgb(r,g,b)
+
+# cycle through all colours of the rainbow
+def rainbow(lcd, sleep):
+    for n in range(256):
+        hue(lcd, n)
+        time.sleep_ms(sleep)
+
+# show n random colours
+def randomColors(lcd, count, sleep):
+    for r in range(count):
+        r,g,b = (getrandbits(8), getrandbits(8), getrandbits(8))
+        lcd.backlight_rgb(r,g,b)
+        time.sleep_ms(sleep)
+
+#if __name__ == "__main__":
+test_main()