Adding support for NodeMCU board

README.md

@@ -21,6 +21,8 @@ Files
 | pyb_i2c_adafruit_lcd_test.py  | Test for Adafruit backpack            |
 | pyb_i2c_lcd.py                | Pyboard I2C HAL for PCF8574 backpack  |
 | pyb_i2c_lcd_test.py           | Test for PCF8574 backpack             |
+| nodemcu_gpio_lcd.py           | NodeMCU GPIO HAL                      |
+| nodemcu_gpio_lcd_test.py      | NodeMCU test using 4-bit GPIO         |
 
 
 The files which end in _test.py are examples which show how the corresponding

lcd/nodemcu_gpio_lcd.py

@@ -0,0 +1,165 @@
+from lcd import LcdApi
+from machine import Pin
+from utime import sleep_ms, sleep_us
+
+class GpioLcd(LcdApi):
+    """Implements a character based lcd connected via GPIO pins."""
+
+    def __init__(self, rs_pin, enable_pin, d0_pin=None, d1_pin=None,
+                 d2_pin=None, d3_pin=None, d4_pin=None, d5_pin=None,
+                 d6_pin=None, d7_pin=None, rw_pin=None, backlight_pin=None,
+                 num_lines=2, num_columns=16):
+        """Constructs the GpioLcd object. All of the arguments must pyb.Pin
+        objects which ddescribe which pin the given line from the LCD is
+        connected to.
+
+        When used in 4-bit mode, only D4, D5, D6, and D7 are physically
+        connected to the LCD panel. This function allows you call it like
+        GpioLcd(rs, enable, D4, D5, D6, D7) and it will interpret that as
+        if you had actually called:
+        GpioLcd(rs, enable, d4=D4, d5=D5, d6=D6, d7=D7)
+
+        The enable 8-bit mode, you need pass d0 thru d7.
+
+        The rw pin isn't used by this library, but if you specify it, then
+        it will be set low.
+        """
+        self.rs_pin = rs_pin
+        self.enable_pin = enable_pin
+        self.rw_pin = rw_pin
+        self.backlight_pin = backlight_pin
+        self._4bit = True
+        if d4_pin and d5_pin and d6_pin and d7_pin:
+            self.d0_pin = d0_pin
+            self.d1_pin = d1_pin
+            self.d2_pin = d2_pin
+            self.d3_pin = d3_pin
+            self.d4_pin = d4_pin
+            self.d5_pin = d5_pin
+            self.d6_pin = d6_pin
+            self.d7_pin = d7_pin
+            if self.d0_pin and self.d1_pin and self.d2_pin and self.d3_pin:
+                self._4bit = False
+        else:
+            # This is really 4-bit mode, and the 4 data pins were just
+            # passed as the first 4 arguments, so we switch things around.
+            self.d0_pin = None
+            self.d1_pin = None
+            self.d2_pin = None
+            self.d3_pin = None
+            self.d4_pin = d0_pin
+            self.d5_pin = d1_pin
+            self.d6_pin = d2_pin
+            self.d7_pin = d3_pin
+        self.rs_pin.init(Pin.OUT)
+        self.rs_pin.low()
+        if self.rw_pin:
+            self.rw_pin.init(Pin.OUT)
+            self.rw_pin.low()
+        self.enable_pin.init(Pin.OUT)
+        self.enable_pin.low()
+        self.d4_pin.init(Pin.OUT)
+        self.d5_pin.init(Pin.OUT)
+        self.d6_pin.init(Pin.OUT)
+        self.d7_pin.init(Pin.OUT)
+        self.d4_pin.low()
+        self.d5_pin.low()
+        self.d6_pin.low()
+        self.d7_pin.low()
+        if not self._4bit:
+            self.d0_pin.init(Pin.OUT)
+            self.d1_pin.init(Pin.OUT)
+            self.d2_pin.init(Pin.OUT)
+            self.d3_pin.init(Pin.OUT)
+            self.d0_pin.low()
+            self.d1_pin.low()
+            self.d2_pin.low()
+            self.d3_pin.low()
+        if self.backlight_pin is not None:
+            self.backlight_pin.init(Pin.OUT)
+            self.backlight_pin.low()
+
+        # See about splitting this into begin
+
+        sleep_ms(20)   # Allow LCD time to powerup
+        # Send reset 3 times
+        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
+        sleep_ms(5)    # need to delay at least 4.1 msec
+        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
+        sleep_ms(1)
+        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
+        sleep_ms(1)
+        cmd = self.LCD_FUNCTION
+        if not self._4bit:
+            cmd |= self.LCD_FUNCTION_8BIT
+        self.hal_write_init_nibble(cmd)
+        sleep_ms(1)
+        LcdApi.__init__(self, num_lines, num_columns)
+        if num_lines > 1:
+            cmd |= self.LCD_FUNCTION_2LINES
+        self.hal_write_command(cmd)
+
+    def hal_pulse_enable(self):
+        """Pulse the enable line high, and then low again."""
+        self.enable_pin.low()
+        sleep_us(1)
+        self.enable_pin.high()
+        sleep_us(1)       # Enable pulse needs to be > 450 nsec
+        self.enable_pin.low()
+        sleep_us(100)     # Commands need > 37us to settle
+
+    def hal_write_init_nibble(self, nibble):
+        """Writes an initialization nibble to the LCD.
+
+        This particular function is only used during intiialization.
+        """
+        self.hal_write_4bits(nibble >> 4)
+
+    def hal_backlight_on(self):
+        """Allows the hal layer to turn the backlight on."""
+        if self.backlight_pin:
+            self.backlight_pin.high()
+
+    def hal_backlight_off(self):
+        """Allows the hal layer to turn the backlight off."""
+        if self.backlight_pin:
+            self.backlight_pin.low()
+
+    def hal_write_command(self, cmd):
+        """Writes a command to the LCD.
+
+        Data is latched on the falling edge of E.
+        """
+        self.rs_pin.low()
+        self.hal_write_8bits(cmd)
+        if cmd <= 3:
+            # The home and clear commands require a worst
+            # case delay of 4.1 msec
+            sleep_ms(5)
+
+    def hal_write_data(self, data):
+        """Write data to the LCD."""
+        self.rs_pin.high()
+        self.hal_write_8bits(data)
+
+    def hal_write_8bits(self, value):
+        """Writes 8 bits of data to the LCD."""
+        if self.rw_pin:
+            self.rw_pin.low()
+        if self._4bit:
+            self.hal_write_4bits(value >> 4)
+            self.hal_write_4bits(value)
+        else:
+            self.d3_pin.value(value & 0x08)
+            self.d2_pin.value(value & 0x04)
+            self.d1_pin.value(value & 0x02)
+            self.d0_pin.value(value & 0x01)
+            self.hal_write_4bits(value >> 4)
+
+    def hal_write_4bits(self, nibble):
+        """Writes 4 bits of data to the LCD."""
+        self.d7_pin.value(nibble & 0x08)
+        self.d6_pin.value(nibble & 0x04)
+        self.d5_pin.value(nibble & 0x02)
+        self.d4_pin.value(nibble & 0x01)
+        self.hal_pulse_enable()

lcd/nodemcu_gpio_lcd_test.py

@@ -0,0 +1,51 @@
+"""Implements a character based lcd connected general purpose IO pins."""
+
+from machine import Pin
+from utime import sleep, ticks_ms
+from nodemcu_gpio_lcd import GpioLcd
+
+# Wiring used for this example:
+#
+#  1 - Vss (aka Ground) - Connect to one of the ground pins on you NodeMCU board.
+#  2 - VDD - Connect to 3V
+#  3 - VE (Contrast voltage) - I'll discuss this below
+#  4 - RS (Register Select) connect to D0 (as per call to GpioLcd)
+#  5 - RW (Read/Write) - connect to ground
+#  6 - EN (Enable) connect to D1 (as per call to GpioLcd)
+#  7 - D0 - leave unconnected
+#  8 - D1 - leave unconnected
+#  9 - D2 - leave unconnected
+# 10 - D3 - leave unconnected
+# 11 - D4 - connect to D2 (as per call to GpioLcd)
+# 12 - D5 - connect to D3 (as per call to GpioLcd)
+# 13 - D6 - connect to D4 (as per call to GpioLcd)
+# 14 - D7 - connect to D5 (as per call to GpioLcd)
+# 15 - A (BackLight Anode) - Connect to 3V
+# 16 - K (Backlight Cathode) - Connect to Ground
+#
+# On 14-pin LCDs, there is no backlight, so pins 15 & 16 don't exist.
+#
+# The Contrast line (pin 3) typically connects to the center tap of a
+# 10K potentiometer, and the other 2 legs of the 10K potentiometer are
+# connected to pins 1 and 2 (Ground and VDD)
+#
+
+def test_main():
+    """Test function for verifying basic functionality."""
+    print("Running test_main")
+    lcd = GpioLcd(rs_pin=Pin(16),
+                  enable_pin=Pin(5),
+                  d4_pin=Pin(4),
+                  d5_pin=Pin(0),
+                  d6_pin=Pin(2),
+                  d7_pin=Pin(14),
+                  num_lines=2, num_columns=20)
+    lcd.putstr("It Works!\nSecond Line")
+    sleep(3)
+    lcd.clear()
+    count = 0
+    while True:
+        lcd.move_to(0, 0)
+        lcd.putstr("%7d" % (ticks_ms() // 1000))
+        sleep(1)
+        count += 1