Gränssnitt 16×2 LCD-modul utan I2C: En omfattande guide för Arduino och ESP32

Den här artikeln dyker djupt in i en värld av gränssnitt mellan en 16×2 LCD-modul med mikrokontroller som Arduino och ESP32, speciellt med fokus på installationen utan att använda en I2C-modul. Vi kommer att utforska varför du kan välja den här metoden, hur den fungerar och ger en detaljerad handledning för att ansluta och programmera din LCD. Om du vill förstå grunderna i LCD-gränssnitt och hur man kör en 16×2 lcd-skärm utan att lita på bekvämligheten med en I2C-adapter, är det här guiden för dig.

1. Vad är en 16×2 LCD och varför gränssnitt den?

En 16×2 LCD-skärm, förkortning för en 16 tecken med 2 rader flytande kristalldisplay, är en vanlig och mångsidig displaymodul. Den används för att presentera text och numerisk information på ett tydligt och kortfattat sätt. Till skillnad från komplexa grafiska skärmar är 16×2 LCD-skärmar relativt enkla att köra, vilket gör dem perfekta för olika mikrokontrollerprojekt. "16×2" hänvisar till dess kapacitet att visa 16 tecken på var och en av dess två rader, vilket gör den lämplig för att visa sensoravläsningar, projektstatus eller användarmeddelanden. Genom att använda dessa lcd-displaymoduler med mikrokontroller som arduino eller ESP32 kan dina projekt interagera med användaren genom att visa information i en läsbar form. De är relativt billiga och lätta att använda.

Överklagandet av 16×2 lcd modulen ligger i dess enkelhet och låga kostnad. Det är en häftklammer inom elektronik för olika hobby- och professionella projekt på grund av dess förmåga att visa text och siffror utan kostnaden för mer komplexa displaytekniker. Genom att använda den här modulen kan utvecklare av inbyggda system skapa enheter som kan ge visuell feedback, utan att använda komplexa grafiska skärmar. Den enkla integrationen gör 16×2 lcds till ett mycket användbart displayverktyg för att visa information från olika sensorer.

2. Varför välja gränssnitt till en 16×2 LCD-skärm utan I2C?

Medan I2C-moduler erbjuder bekvämligheten att minska antalet stift som krävs för gränssnitt, har det flera fördelar att välja att ansluta en 16×2 lcd utan i2c direkt. För det första ger det en djupare förståelse för de underliggande kommunikationsprotokollen och hur LCD-modulen fungerar, vilket gör den till en fantastisk pedagogisk upplevelse. För det andra, genom att inte lita på i2c-gränssnittet undviker du komplexiteten i i2c-bussen och potentiella adresskonflikter. Detta kan vara viktigt om du möter begränsningar i ditt projekt eller vill minska komplexiteten i din i2c-enhetsanslutning. Du är inte begränsad av en adress.

Dessutom kan direkt gränssnitt vara fördelaktigt för projekt där varje stift på din mikrokontroller är värdefull. En i2c-modul minskar vanligtvis antalet stift du måste använda till 2, men dessa 2 stift är dedikerade till i2c-kommunikation och kan behövas för något annat, medan du använder gränssnitt utan en i2c-modul kan du fritt välja vilka stift du vill använda. Gränssnitt utan en i2c-modul ger dig full kontroll över anslutningen. Direktanslutning kan också vara snabbare för att visa data, eftersom i2c-kommunikation måste utföras innan data kan överföras till LCD-skärmen. Detta är inte alltid kritiskt, men är något att tänka på när man designar applikationer som kräver snabba uppdateringstider för det visade innehållet.

3. Vilken hårdvara krävs för att ansluta en 16×2 LCD-skärm utan en I2C-modul?

För att ansluta en 16×2 LCD-modul utan i2c behöver du några viktiga komponenter. Kärnan är en standard 16×2 lcd, som vanligtvis levereras med 16 stift för anslutning. Du behöver också en mikrokontroller, som en Arduino Uno eller ESP32. Dessutom behöver du bygelkablar för att ansluta de olika stiften på lcd-modulen till din mikrokontroller. Dessutom behövs en potentiometer för att justera kontrasten på LCD-skärmen. En brödbräda kan vara till stor hjälp för att hålla allt snyggt sammankopplat och organiserat.

Den viktigaste utmaningen när du ansluter en 16×2 lcd utan i2c är att det kräver fler stift från din mikrokontroller än att använda en i2c-adapter. Specifikt kommer vi att använda 6 stift för att styra LCD-skärmen, plus två stift för att styra strömförsörjningen och jord. Därför bör du planera din mikrokontrollerkrets med tillräckligt många tillgängliga utgångsstift. Att ha dessa stift tillgängliga ger dig full kontroll över LCD:n. Potentiometern låter dig justera kontrasten så att texten på lcd-displayen syns tydligt.

4. Hur fungerar 16×2 LCD-skärmen internt?

16×2 LCD-skärmen är baserad på HD44780-kontrollern eller ett kompatibelt chip. Denna styrenhet hanterar visningen av tecken och accepterar kommandon via ett parallellt gränssnitt. Gränssnittet använder vanligtvis 8 datastift (D0-D7) eller 4 datastift i 4-bitarsläge (D4-D7), plus kontrollstift (RS, R/W och EN). Varje teckenposition på LCD-skärmen adresseras internt av styrenheten. När du skickar ett kommando eller en teckendata tar HD44780-styrenheten emot kommandot och agerar därefter.

HD44780-styrenheten använder specifika kommandon för uppgifter som att rensa skärmen, ställa in markörens position eller initiera LCD-skärmen. Att förstå den här arkitekturen är avgörande när du skriver kod för att styra LCD:n utan den abstraktion som en i2c-modul ger. Kommandona skickas till displayen över datastiften och kommunikationssättet bestäms av kontrollstiften. Detta gör det också möjligt för kontrollern att arbeta med olika typer av skärmstorlekar som 20×4, 16×2 lcd-skärmen använder en fördefinierad teckenuppsättning som kan visas på skärmen.

5. Hur ansluter man en 16×2 LCD direkt till en Arduino?

Ansluta en 16×2 lcd direkt till en Arduino innebär ledning av varje nödvändig stift. Först måste du ansluta LCD:ns VSS-stift till jord (GND) och VDD-stiftet till 5V, detta är din strömförsörjning. V0-stiftet (kontrastjustering) är anslutet till potentiometerns mittstift; de andra två stiften på potentiometern är anslutna till jord och 5v för att göra en spänningsdelare som vi kommer att använda för att ändra kontrasten på LCD-skärmen. Anslut sedan RS-stiftet (Register Select) på LCD-skärmen till ett digitalt stift på arduino (t.ex. stift 12). R/W (läs/skriv)-stiftet bör vara jordat eftersom vi endast kommer att skriva data till LCD-skärmen. EN (Enable)-stiftet måste anslutas till ett annat digitalt stift på arduino (t.ex. stift 11).

Anslut sedan datastiften D4 till D7 till digitala stift på arduino, till exempel stift 5, 4, 3 respektive 2. På detta sätt använder vi 4-bitarsläget, vilket är vanligt, eftersom det använder färre stift. 4-bitarsläget är enklare och använder mindre kablar jämfört med 8-bitarsläget. Bakgrundsbelysningsstiften A (anod) och K (katod) ska kopplas till 5V respektive GND med ett strömbegränsande motstånd på anoden vid behov. Se till att du använder ett kretsschema för att vägleda denna process. Stiften är ibland olika numrerade för vissa lcd-moduler. Stiftlayouten kan alltid hittas i LCD-modulens datablad.

6. Programmera din Arduino för att driva 16×2 LCD: En detaljerad handledning

För att programmera din arduino för att ansluta till 16×2 lcd, måste du använda LiquidCrystal-biblioteket. Börja med att öppna arduino-id och inkludera liquidcrystal-biblioteket i din projektkod. Initiera lcd-objektet i din kod och ange stiften som används för anslutningen. I vårt exempel är det stift: RS, EN, D4, D5, D6, D7. Till exempel: LiquidCrystal lcd(12, 11, 5, 4, 3, 2);. Initiera LCD-skärmen inuti setup()-funktionen genom att anropa lcd.begin(16, 2); för att ställa in antalet kolumner och rader på LCD-skärmen. Du bör också initiera lcd:n med hjälp av initiera lcd-funktionen.

Nu, i loop-funktionen, kan du använda olika kommandon för att visa data på LCD-skärmen. Du kan till exempel ställa in markörens position med lcd.setCursor(kolumn, rad); och visa text med lcd.print("Hej världen");. Du kan rensa displayen med lcd.clear(); kommando. Du kan skapa ett kort program och köra några koder för att testa kortet och efter att jag kopplat in allt. Du kan använda seriell monitor för att felsöka programmet. Liquidcrystal-biblioteket hanterar all HD44780-lågnivåkommunikation åt dig, så du behöver inte oroa dig för att skicka individuella bytesekvenser och styrsignaler. Nyckelfunktionen är lcd.print() som används för att visa data.

#omfatta 

// Definiera stift anslutna till LCD-skärmen
konst int rs = 12, sv = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;

// Initiera LCD-objekt
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

ogiltig inställning() {
  // Ställ in antalet kolumner och rader
  lcd.börja(16, 2);
  // Skriv ut ett meddelande till LCD-skärmen
  lcd.skriva ut("Hej, LCD!");
}

ogiltig slinga() {
  // Ställ markören på den andra raden
  lcd.setCursor(0, 1);
  // Visa tiden
  lcd.skriva ut(millis()/1000); lcd.skriva ut("sekunder");
}

7. Hur är det med ESP32? Ansluter en 16×2 LCD-skärm utan I2C på en ESP32

Att använda en 16×2 LCD-skärm utan i2c på en ESP32 liknar att göra det på en Arduino, men med några mindre skillnader. ESP32 är en 3,3V mikrokontroller, medan 16×2 lcd är vanligtvis konstruerad för att fungera vid 5V. Därför kan du behöva använda nivåskiftare för spänningskompatibilitet mellan ESP32 och LCD:s logikstift. Alternativt kan användning av ett esp32-kort med nivåväxling eliminera behovet av externa nivåväxlingskretsar. Den fysiska kabeldragningen blir i stort sett densamma som med en Arduino. Anslut VSS till jord och VDD till 5V (eller 3,3V om du använder en 3,3V lcd eller nivåväxlare).

Koden i arduino-id kommer att vara nästan densamma som den som tillhandahålls för arduino med små eller inga ändringar. Använd LiquidCrystal-biblioteket på samma sätt som i Arduino-handledningen. Kom ihåg att definiera dina stiftanslutningar korrekt i LiquidCrystal lcd objekt. Kontrollera alltid databladet för din lcd-modul för att säkerställa att stiften är korrekt anslutna. Kontrollera även pinouten på ditt ESP32-kort för att säkerställa korrekta anslutningar. Var medveten om de olika stift som kan vara tillgängliga och välj de rätta för din applikation.

8. Hur skapar man anpassade tecken på en 16×2 LCD utan I2C?

Att skapa anpassade tecken på en 16×2 lcd är möjligt, även utan hjälp av en i2c-modul. Med HD44780-kontrollern kan du definiera upp till 8 anpassade tecken. Du skapar anpassade tecken genom att definiera ett mönster av byte, där varje byte representerar en rad av teckenmatrisen på 5×8 pixlar. För att göra detta skapar du först en byte-array som definierar pixelmönstret för din anpassade karaktär. Varje byte representerar en rad av tecknet.

Använd sedan lcd.createChar(plats, teckenkarta) funktion i Arduino-koden. Platsargumentet definierar vilken av de 8 tillgängliga platserna för att lagra det nya tecknet (0 till 7), och characterMap är byte-arrayen som du just skapade. Du kan sedan visa din egen karaktär genom att använda lcd.write(plats) i din kod, var plats är den plats du tidigare definierat. Detta görs med hjälp av lcd-objektet som du har skapat tidigare. Detta är extremt användbart om din applikation behöver unika tecken som inte är tillgängliga i standardteckenuppsättningen för LCD-modulen.

9. Felsökning av vanliga problem vid gränssnitt till en 16×2 LCD-skärm utan I2C

Att använda en 16×2 lcd utan en i2c-adapter kan, även om det är enkelt, presentera några vanliga problem. Det första problemet är felaktig ledning. Dubbelkolla alltid kretsschemat och se till att alla anslutningar är korrekta. Ett vanligt fel är att vända polariteten på strömförsörjningsstiften på LCD-modulen, vilket kan skada den permanent. Se också till att dina kablar är ordentligt anslutna. För det andra kan en felaktig initiering av lcd-objektet orsaka problem. Dubbelkolla att stiften är korrekt initierade enligt anslutningen till kortet. Även typen av lcd-modul kan kräva en något annorlunda initieringssekvens.

Kontrastinställningarna måste också justeras korrekt med potentiometern för att justera kontrasten på LCD-skärmen tills texten är tydligt synlig. Om skärmen är tom eller förvrängd kan du ha ett ledningsfel eller problem med strömförsörjningen. Se till att du har en stabil strömförsörjning och rätt spänning. Du kan också kontrollera koden med hjälp av seriell monitor för att felsöka möjliga problem. Om du fortfarande har problem, överväg att konsultera arduino-forumet. Det är vanligt att se att andra kan ha ställts inför samma problem. Reddit är anonymt så du kommer säkert att få ett namn eller förslag.

10. Avancerade tekniker och framtida projekt med 16×2 LCD-skärmar

När du har bemästrat grunderna för att ansluta en 16×2 lcd utan i2c, kan du utforska mer avancerade tekniker. Detta inkluderar att visa realtidsdata från sensorer eller skapa ett menysystem. Du kan också använda de anpassade tecknen för att skapa enkel grafik och statusikoner för ditt projekt. Kom ihåg att alltid använda databladet för lcd-modulen som visas för att verifiera specifika anslutningskrav för din lcd-modul. Metoden vi använder ger flexibilitet när det gäller mikrokontrollerstift som kan användas.

Du kan använda flera sådana lcd-skärmar om du behöver visa mer information, men tänk på antalet stift du använder. Prova också att experimentera med att visa siffror med hjälp av lcd.print() kommando och prova olika sätt att använda ställ in markörens position funktion för att placera olika föremål i olika delar av displayen. Detta öppnar upp för många alternativ för dina framtida projekt. Kunskapen du får genom att styra LCD-skärmen utan I2C ger en bra utgångspunkt för att styra mer avancerade bildskärmstyper.

Viktiga tips: 10 saker att komma ihåg när du använder 16×2 LCD-skärm utan I2C

• Förstå grunderna: 16×2 lcd-modulen styrs genom 6-10 kontroll- och datastift utan en i2c-modul.
• Stiftanslutningar är avgörande: Kontrollera databladet för den specifika pinouten för din lcd-modul.
• Kontrastjustering: Använd alltid en potentiometer för att justera kontrasten på LCD-skärmen.
• LiquidCrystal bibliotek: Använd LiquidCrystal bibliotek i arduino iden för att förenkla programmeringen.
• Initiering: Initiera alltid LCD-skärmen korrekt med hjälp av lcd.begin(16, 2);.
• Datavisning: Använd lcd.print() för att visa data till displaymodulen.
• Anpassade tecken: Skapa anpassade tecken med hjälp av lcd.createChar() när du behöver dem.
• Felsökning: Dubbelkolla alla ledningar, kod och anslutningar för att identifiera orsaken till eventuella problem.
• Pin tillgänglighet: Var uppmärksam på mikrokontrollerstiften som används när du bestämmer dig för att använda den här metoden.
• Gå vidare: Utforska avancerade tekniker för att skapa ännu mer komplexa applikationer.

Genom att följa den här omfattande guiden bör du vara väl rustad för att börja koppla din 16×2 lcd-modul direkt med en Arduino eller ESP32 och visa informationen som dina projekt kräver, utan en i2c-adapter.