मैं HD44780 आधारित एलसीडी को कैसे कनेक्ट कर सकता हूं?

Question

इस प्रश्न पर विस्तार । मैं GPIO पिन और विभिन्न ट्रेडऑफ के लिए HD44780 को हुक करने के लिए कुछ अलग तरीके देख रहा हूं।

यहाँ मेरी "वर्ल्ड क्लॉक" I²C का उपयोग करके आरपीआई बंद है

अब तक मैं सिर्फ 6 GPIO पिन का उपयोग करके काम कर रहा हूं जो Adafruit के ट्यूटोरियल के समान है और MCP23017 का उपयोग करके I²C संस्करण

अन्य विचार जो मैं काम करना चाहूंगा वो हैं:

• CD4094 का उपयोग करना

6 GPIO पिन संस्करण सरल है, लेकिन का उपयोग करता है 6 मूल्यवान GPIO पिंस
CD4094 संस्करण बहुत सस्ता है और केवल 2 GPIO पिन की जरूरत है I²C संस्करण केवल थोड़ा अधिक महंगा है, लेकिन एक भी MCP23017 के साथ 6 प्रदर्शित करता है अप करने के लिए चला सकते हैं और साझा I²C अन्य उपकरणों के साथ

क्या कोई अन्य विकल्पों के बारे में सोच सकता है?

Comments

इस पर एक नज़र डालें: schnatterente.net/technik/… यह रास्पबेरी पाई + एचडी 44780 डिस्प्ले के लिए एक वास्तविक शांत आरएसएस रीडर है! :)

Answer 1

6 जीपीओ पिन

यहां वह कोड है जो मैं वर्तमान में उपयोग कर रहा हूं। अभी तक सिर्फ GPIO काम कर रहा है। देखने के लिए test_gpioफ़ंक्शन देखें / बदलें जो GPIO पिन एलसीडी मॉड्यूल पर किस पिन से जुड़े हैं।

import time
import RPi.GPIO as GPIO

class LCD_GPIO(object):
    # Timing constants
    E_PULSE = 0.00005
    E_DELAY = 0.00005
    def __init__(self, RS, E, D4, D5, D6, D7):
        self.RS = RS
        self.E = E
        self.D4 = D4
        self.D5 = D5
        self.D6 = D6
        self.D7 = D7

        GPIO.setmode(GPIO.BCM)        # Use BCM GPIO numbers
        GPIO.setup(self.E, GPIO.OUT)  # E
        GPIO.setup(self.RS, GPIO.OUT) # RS
        GPIO.setup(self.D4, GPIO.OUT) # DB4
        GPIO.setup(self.D5, GPIO.OUT) # DB5
        GPIO.setup(self.D6, GPIO.OUT) # DB6
        GPIO.setup(self.D7, GPIO.OUT) # DB7

    def lcd_byte(self, data, mode):
        GPIO.output(self.RS, mode)

        for bits in (data>>4, data):
            GPIO.output(self.D4, bits&0x01)
            GPIO.output(self.D5, bits&0x02)
            GPIO.output(self.D6, bits&0x04)
            GPIO.output(self.D7, bits&0x08)

            # Toggle E
            time.sleep(self.E_DELAY)
            GPIO.output(self.E, True)
            time.sleep(self.E_PULSE)
            GPIO.output(self.E, False)
            time.sleep(self.E_DELAY)


class LCD_23017(object):
    pass

class LCD_4094(object):
    pass    

class HD47780(object):
    LCD_CHR = True
    LCD_CMD = False
    # Base addresses for lines on a 20x4 display
    LCD_BASE = 0x80, 0xC0, 0x94, 0xD4

    def __init__(self, driver, rows=2, width=16):
        self.rows = rows
        self.width = width
        self.driver = driver
        self.lcd_init()

    def lcd_init(self):
        # Initialise display
        lcd_byte = self.driver.lcd_byte
        for i in 0x33, 0x32, 0x28, 0x0C, 0x06, 0x01:
            lcd_byte(i, self.LCD_CMD)


    def lcd_string(self, message):
        # Send string to display
        lcd_byte = self.driver.lcd_byte
        lcd_byte(self.LCD_BASE[0], self.LCD_CMD)
        for i in bytearray(message.ljust(self.width)):
            lcd_byte(i, self.LCD_CHR)

def test_gpio():
    driver = LCD_GPIO(RS=7, E=8, D4=25, D5=24, D6=23, D7=18)
    lcd = HD47780(driver=driver, rows=4, width=20)
    lcd.lcd_string("Welcome gnibbler")


def main():
    test_gpio()

if __name__ == "__main__":
    main()

Answer 2

I²C

इसे हुक करना काफी सरल है। मैं जिस विशेष डिस्प्ले का उपयोग कर रहा हूं उसका कंट्रास्ट पिन (V _O ) जमीन से जुड़े होने की जरूरत है। आमतौर पर आप इसे वी _एसएस और वी _{सीसी के} बीच वोल्टेज सेट करने के लिए एक पोटेंशियोमीटर से जोड़ते हैं

मेरे डिस्प्ले में बैकलाइट नहीं है, इसलिए मैंने योजनाबद्ध पर अव्यवस्था को कम करने के लिए उन्हें कनेक्ट नहीं किया है। यदि आपका बैकलाइट है, तो आपको निश्चित रूप से इसे सामान्य तरीके से जोड़ना चाहिए

आप MCP23017 के प्रत्येक पोर्ट के समानांतर 3 डिस्प्ले तक कनेक्ट कर सकते हैं। एकमात्र अंतर यह है कि प्रत्येक डिस्प्ले से सक्षम पिन को एक अलग पिन (GPB1-GPB3) से कनेक्ट करने की आवश्यकता है

#!/usr/bin/env python
"""World Clock Demo
   It should be fairly obvious how to change this code to work for other timezones"""
import time

class LCD_23017(object):
    # Timing constants
    E_PULSE = 0.00005
    E_DELAY = 0.00005
    def __init__(self, bus, addr, port, rs, en):
        self.bus = bus
        self.addr = addr
        self.rs = rs
        self.en = en

        self.DIRECTION = 0x00 if port == 'A' else 0x01
        self.DATA = 0x12 if port == 'A' else 0x13

        self.bus.write_byte_data(addr, self.DIRECTION, 0x00)

    def lcd_byte(self, data, rs):
        rs <<= self.rs
        en = 1 << self.en
        for nybble in (data&0xf0, data<<4):
            self.bus.write_byte_data(self.addr, self.DATA, nybble | rs)
            time.sleep(self.E_DELAY)
            self.bus.write_byte_data(self.addr, self.DATA, nybble | rs | en)
            time.sleep(self.E_PULSE)
            self.bus.write_byte_data(self.addr, self.DATA, nybble | rs)


class HD47780(object):
    LCD_CHR = True
    LCD_CMD = False
    # Base addresses for lines on a 20x4 display
    LCD_BASE = 0x80, 0xC0, 0x94, 0xD4

    def __init__(self, driver, rows=2, width=16):
        self.rows = rows
        self.width = width
        self.driver = driver
        self.lcd_init()

    def lcd_init(self):
        # Initialise display
        lcd_byte = self.driver.lcd_byte
        for i in 0x33, 0x32, 0x28, 0x0C, 0x06, 0x01:
            lcd_byte(i, self.LCD_CMD)

    def lcd_string(self, message, line=0):
        # Send string to display
        lcd_byte = self.driver.lcd_byte
        lcd_byte(self.LCD_BASE[line], self.LCD_CMD)
        for i in bytearray(message.ljust(self.width)):
            lcd_byte(i, self.LCD_CHR)


def test_i2c():
    from datetime import datetime
    import pytz
    import smbus

    ## For Rev1.0 Raspberry Pi
    driver1 = LCD_23017(bus=smbus.SMBus(0), addr=0x27, port='B', rs=0, en=1)
    driver2 = LCD_23017(bus=smbus.SMBus(0), addr=0x27, port='B', rs=0, en=2)
    driver3 = LCD_23017(bus=smbus.SMBus(0), addr=0x27, port='B', rs=0, en=3)

    ## For Rev2.0 Raspberry Pi
    #driver1 = LCD_23017(bus=smbus.SMBus(1), addr=0x27, port='B', rs=0, en=1)
    #driver2 = LCD_23017(bus=smbus.SMBus(1), addr=0x27, port='B', rs=0, en=2)
    #driver3 = LCD_23017(bus=smbus.SMBus(1), addr=0x27, port='B', rs=0, en=3)


    lcd1 = HD47780(driver=driver1, rows=2, width=16)
    lcd2 = HD47780(driver=driver2, rows=2, width=16)
    lcd3 = HD47780(driver=driver3, rows=2, width=16)
    lcd1.lcd_string("    New York")
    lcd2.lcd_string("     London")
    lcd3.lcd_string("    Melbourne")
    new_york_tz = pytz.timezone("America/New_York")
    london_tz = pytz.timezone("Europe/London")
    melbourne_tz = pytz.timezone("Australia/Melbourne")
    while True:
        time.sleep(1-time.time()%1)  # Wait until the next second
        lcd1.lcd_string(datetime.now(new_york_tz).ctime()[3:], line=1)
        lcd2.lcd_string(datetime.now(london_tz).ctime()[3:], line=1)
        lcd3.lcd_string(datetime.now(melbourne_tz).ctime()[3:], line=1)

def main():
    test_i2c()

if __name__ == "__main__":
    main()

Comments

धन्यवाद। यह काम करता हैं!। यह बेहतरीन पोस्ट मुझे बहुत मदद करती है। केवल newbies के लिए एक टिप्पणी (मेरे जैसे)। यदि आप रास्पबेरी Rev.2 का उपयोग करते हैं, तो कोड में बस = smbus.SMBus (0) के बजाय बस = smbus.SMBus (1) का उपयोग करें। इस आदेश को चलाने के द्वारा पता लगाया जा सकता है: "sudo i2cdetect -y 1" (रास्पबेरी Rev.1 के लिए 1 के बजाय 1 का उपयोग करें)। मेरे मामले में 0x27 के बजाय 0x20 था। बहुत बहुत धन्यवाद।