I2C एलसीडी एडाप्टर मॉड्यूल का परिचय

इस पोस्ट में हम 'I2C' या 'IIC' या 'I वर्ग C' पर आधारित एलसीडी एडेप्टर मॉड्यूल पर एक नज़र डाल रहे हैं, जो Arduino और LCD डिस्प्ले के बीच वायर कनेक्शन को घटाकर सिर्फ 2 तारों तक ले जाएगा, जिससे GPIO पिन के टन की भी बचत होगी अन्य सेंसर / ड्राइव आदि

इससे पहले कि हम I2C एलसीडी एडाप्टर मॉड्यूल के बारे में चर्चा करें, यह समझना महत्वपूर्ण है कि I2C बस क्या है और यह कैसे काम करता है।

लेकिन वैसे भी आपको इस उल्लेख एलसीडी एडाप्टर के साथ काम करने के लिए I2C प्रोटोकॉल के साथ एक विशेषज्ञ होने की आवश्यकता नहीं है।

I2C कनेक्शन का चित्रण:

I2C या IIC का अर्थ है 'इंटर-इंटीग्रेटेड सर्किट', फिलिप्स सेमीकंडक्टर्स द्वारा आविष्कार की गई एक सीरियल कंप्यूटर बस है, जिसे आज NXP सेमीकंडक्टर्स के रूप में जाना जाता है। इस बस प्रणाली का आविष्कार 1982 में किया गया था।

बस क्या है?

बस केबल / तारों का एक समूह है जो डेटा को एक चिप से दूसरे चिप / एक सर्किट बोर्ड से दूसरे सर्किट बोर्ड तक ले जाता है।

I2C बस प्रोटोकॉल का मुख्य लाभ यह है कि, समर्थित माइक्रोकंट्रोलर या सेंसर या चिप्स को सिर्फ दो तारों के साथ इंटरलिंक किया जा सकता है। इस प्रोटोकॉल का लाभ उड़ाने वाला मन यह है कि, हम 127 अलग-अलग चिप्स या सेंसर / ड्राइवरों को एक मास्टर डिवाइस में इंटरकनेक्ट कर सकते हैं जो आमतौर पर सिर्फ 2 तारों के साथ एक माइक्रोकंट्रोलर है।

दो I2C तार क्या हैं?

दो तार एसडीए और एससीएल हैं जो क्रमशः सीरियल डेटा और सीरियल घड़ी हैं।

सीरियल घड़ी या SCL का उपयोग I2C बस पर डेटा संचार को सिंक करने के लिए किया जाता है। एसडीए या सीरियल डेटा वह डेटा लाइन है जिसमें वास्तविक डेटा को मास्टर से दास और इसके विपरीत से अवगत कराया जाता है। मास्टर डिवाइस सीरियल क्लॉक को नियंत्रित करता है और निर्णय लेता है कि किस गुलाम डिवाइस को संवाद करने की आवश्यकता है। कोई भी गुलाम डिवाइस पहले एक संचार शुरू नहीं कर सकता, केवल मास्टर डिवाइस ही कर सकता है।

सीरियल डेटा लाइन द्विदिश और मजबूत है, हर 8 बिट डेटा भेजने के बाद, प्राप्त करने वाला डिवाइस एक पावती बिट वापस भेजता है।

कितनी तेजी से I2C प्रोटोकॉल है?

1982 में विकसित I2C प्रोटोकॉल के मूल संस्करण ने 100 Kbps का समर्थन किया। अगले संस्करण को 1992 में मानकीकृत किया गया था जिसने 400Kbps (फास्ट मोड) का समर्थन किया और 1008 उपकरणों का समर्थन किया। अगला संस्करण 1998 में 3.4 एमबीपीएस (हाई स्पीड मोड) के साथ विकसित किया गया था।

कई अन्य I2C संस्करणों को वर्ष 2000, 2007, 2012 में विकसित किया गया था (5Mbps अल्ट्रा-फास्ट मोड के साथ) और I2C के हाल के संस्करण को 2014 में विकसित किया गया था।

I2C बस में पुल-अप प्रतिरोध क्यों?

एसडीए और एससीएल 'ओपन-ड्रेन' हैं जिसका अर्थ है कि दोनों लाइनें कम हो सकती हैं लेकिन यह लाइनों को हाई नहीं कर सकती हैं, इसलिए प्रत्येक लाइनों पर एक पुल-अप रोकनेवाला जुड़ा हुआ है।

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

पुल-अप / पुल-डाउन रेसिस्टर: पुल-अप रेसिस्टर एक अवरोधक है जो आपूर्ति के + वे लाइन से जुड़ा है जो लाइन के लॉजिक स्तर को उच्च रखने के लिए है यदि लाइन न तो अधिक है और न ही कम है।

एक पुल-डाउन रोकनेवाला एक अवरोधक है जो आपूर्ति के –Ve लाइन से जुड़ा है लाइन के लॉजिक स्तर को कम रखने के लिए यदि लाइन न तो अधिक है और न ही कम है।

यह शोर को लाइनों में प्रवेश करने से भी रोकता है।

हमें उम्मीद है कि हमने I2C प्रोटोकॉल की सतह को खरोंच कर दिया है, अगर आपको I2C प्रोटोकॉल पर अधिक जानकारी चाहिए, तो कृपया सर्फ करें

YouTube और Google

अब I2C एलसीडी मॉड्यूल पर एक नजर डालते हैं:

एलसीडी डिस्प्ले के लिए 16 आउटपुट पिन हैं जो सीधे 16 एक्स 2 एलसीडी मॉड्यूल के पीछे टांका जा सकता है।

इनपुट पिन + 5 वी, जीएनडी, एसडीए और एससीएल हैं। Arduino Uno पर SDA और SCL पिन क्रमशः A4 और A5 हैं। Arduino के लिए मेगा SDA # 20 और SCL # 21 पिन है।

आइए हम तुलना करें कि जब हम I2C एडेप्टर के बिना और एडेप्टर के साथ एलसीडी को Arduino तक तार करते हैं तो यह कैसा दिखता है।

I2C एडाप्टर के बिना:

I2C एडाप्टर के साथ:

एडेप्टर को एलसीडी डिस्प्ले के पीछे टांका लगाया जाता है और जैसा कि हम देख सकते हैं कि हमने अन्य कार्यों के लिए GPIO पिन के भार को बचाया और साथ ही हम A4 और A5 में 126 और I2C उपकरणों को जोड़ना जारी रख सकते हैं।

कृपया ध्यान दें कि मानक लिक्विड क्रिस्टल लाइब्रेरी इस I2C एलसीडी एडाप्टर के साथ काम नहीं करती है, इसके लिए एक विशेष पुस्तकालय है, जो जल्द ही कवर किया जाएगा और हम आपको दिखाएंगे कि कोडिंग उदाहरण के साथ इस मॉड्यूल का उपयोग कैसे करें।

I2C एडाप्टर को 16 x 2 डिस्प्ले से कैसे कनेक्ट करें

लेख के उपरोक्त अनुभागों में हमने I2C प्रोटोकॉल की मूल बातें सीखीं और I2C LCD एडेप्टर मॉड्यूल पर एक बुनियादी अवलोकन किया। इस पोस्ट में हम यह जानने जा रहे हैं कि I2C एलसीडी एडेप्टर मॉड्यूल को 16 x 2 एलसीडी डिस्प्ले से कैसे जोड़ा जाए और हम देखेंगे कि एक उदाहरण के साथ कैसे प्रोग्राम।

I2C प्रोटोकॉल का प्रमुख लाभ यह है कि हम समर्थित सेंसर / इनपुट / आउटपुट डिवाइस को सिर्फ दो लाइनों में तार कर सकते हैं और यह Arduino के साथ सहायक है क्योंकि इसमें GPIO पिन सीमित है।

अब आइए देखें कि मॉड्यूल को एलसीडी से कैसे जोड़ा जाए।

मॉड्यूल में 16 आउटपुट पिन और 4 इनपुट पिन हैं। हम सिर्फ 16 x 2 एलसीडी डिस्प्ले के पीछे एडाप्टर को मिलाप कर सकते हैं। 4 इनपुट पिन में से दो + 5 वी और जीएनडी हैं, बाकी दो एसडीए और एससीएल हैं।

हम देख सकते हैं कि हमने अन्य इनपुट / आउटपुट कार्यों के लिए Arduino पर बहुत सारे पिन बचाए हैं।

हम छोटे पेंच ड्राइवर (लाल बॉक्स में हाइलाइट किए गए) के साथ पोटेंशियोमीटर को समायोजित करके प्रदर्शन के विपरीत को समायोजित कर सकते हैं।

अब बैकलाइटिंग को प्रोग्राम कोड में ही नियंत्रित किया जा सकता है:

एलसीडी पीछे की लाइट()

यह एलसीडी डिस्प्ले पर बैकलाइट चालू करेगा।

lcd.noBacklight ()

यह एलसीडी डिस्प्ले पर बैकलाइट बंद कर देगा।

हम देख सकते हैं कि एक जम्पर जुड़ा हुआ है, जिसे लाल बॉक्स में हाइलाइट किया गया है, अगर प्रोग्राम कमांड की परवाह किए बिना जम्पर को बैकलाइट हटा दिया जाता है।

अब हार्डवेयर सेटअप हो गया है, अब देखते हैं कि कोड कैसे बनाया जाता है। कृपया याद रखें कि I2C एलसीडी मॉड्यूल को विशेष की आवश्यकता है

पुस्तकालय और पहले से स्थापित 'लिक्विड क्रिस्टल' पुस्तकालय ने काम नहीं किया।

आप यहाँ से I2C LCD लाइब्रेरी डाउनलोड कर सकते हैं और Arduino IDE में जोड़ सकते हैं:

github.com/marcoschwartz/LiquidCrystal_I2C

पिछली पोस्ट से हमने सीखा कि I2C उपकरणों का पता है जिसके द्वारा मास्टर या माइक्रोकंट्रोलर डिवाइस की पहचान कर सकते हैं और संचार कर सकते हैं।

ज्यादातर मामलों में, I2C एलसीडी मॉड्यूल के लिए पता '0x27' होगा। लेकिन अलग-अलग निर्माण का अलग-अलग पता हो सकता है। हमें कार्यक्रम में सही पता दर्ज करना होगा, तभी आपका एलसीडी डिस्प्ले कार्य करेगा।

पते को खोजने के लिए बस 5V को Vcc और GND को Arduino के GND और I2C मॉड्यूल के SCL पिन को A5 और SDA से A4 में कनेक्ट करें और नीचे दिए गए कोड को अपलोड करें।

यह कनेक्ट किए गए I2C उपकरणों को स्कैन करेगा और उनका पता दिखाएगा।

// -------------------------------- //
#include
void setup()
{
Wire.begin()
Serial.begin(9600)
while (!Serial)
Serial.println('-----------------------')
Serial.println('I2C Device Scanner')
Serial.println('-----------------------')
}
void loop()
{
byte error
byte address
int Devices
Serial.println('Scanning...')
Devices = 0
for (address = 1 address <127 address++ )
{
Wire.beginTransmission(address)
error = Wire.endTransmission()
if (error == 0)
{
Serial.print('I2C device found at address 0x')
if (address <16)
{
Serial.print('0')
}
Serial.print(address, HEX)
Serial.println(' !')
Devices++
}
else if (error == 4)
{
Serial.print('Unknown error at address 0x')
if (address <16)
Serial.print('0')
Serial.println(address, HEX)
}
}
if (Devices == 0)
{
Serial.println('No I2C devices found ')
}
else
{
Serial.println('-------------- done -------------')
Serial.println('')
}
delay(5000)
}
// -------------------------------- //

कोड अपलोड करें और सीरियल मॉनिटर खोलें।

जैसा कि हम देख सकते हैं कि दो उपकरणों का पता लगाया गया था और उनके पते प्रदर्शित किए गए थे, लेकिन यदि आप केवल I2C एलसीडी मॉड्यूल का पता ढूंढना चाहते हैं, तो आपको स्कैन करते समय किसी अन्य I2C उपकरणों को कनेक्ट नहीं करना चाहिए।
इसलिए निष्कर्ष में हमें '0x27' पता मिला।

अब हम उदाहरण के रूप में एक डिजिटल घड़ी बनाने जा रहे हैं क्योंकि दो I2C डिवाइस, एलसीडी मॉड्यूल और आरटीसी या वास्तविक समय घड़ी मॉड्यूल हैं। दोनों मॉड्यूल दो तारों से जुड़े होंगे।

निम्नलिखित पुस्तकालय डाउनलोड करें:
आरटीसी पुस्तकालय: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

RTC में समय कैसे सेट करें

• Arduino IDE खोलें और फ़ाइल> उदाहरण> DS1307RTC> निर्धारित समय पर नेविगेट करें।
• पूर्ण हार्डवेयर और खुले सीरियल मॉनिटर के साथ कोड अपलोड करें और आप कर रहे हैं।

सर्किट आरेख:

कार्यक्रम:

//------------Program Developed by R.Girish-------//
#include
#include
#include
#include
LiquidCrystal_I2C lcd(0x27, 16, 2)
void setup()
{
lcd.init()
lcd.backlight()
}
void loop()
{
tmElements_t tm
lcd.clear()
if (RTC.read(tm))
{
if (tm.Hour >= 12)
{
lcd.setCursor(14, 0)
lcd.print('PM')
}
if (tm.Hour <12)
{
lcd.setCursor(14, 0)
lcd.print('AM')
}
lcd.setCursor(0, 0)
lcd.print('TIME:')
if (tm.Hour > 12)
{
if (tm.Hour == 13) lcd.print('01')
if (tm.Hour == 14) lcd.print('02')
if (tm.Hour == 15) lcd.print('03')
if (tm.Hour == 16) lcd.print('04')
if (tm.Hour == 17) lcd.print('05')
if (tm.Hour == 18) lcd.print('06')
if (tm.Hour == 19) lcd.print('07')
if (tm.Hour == 20) lcd.print('08')
if (tm.Hour == 21) lcd.print('09')
if (tm.Hour == 22) lcd.print('10')
if (tm.Hour == 23) lcd.print('11')
}
else
{
lcd.print(tm.Hour)
}
lcd.print(':')
lcd.print(tm.Minute)
lcd.print(':')
lcd.print(tm.Second)
lcd.setCursor(0, 1)
lcd.print('DATE:')
lcd.print(tm.Day)
lcd.print('/')
lcd.print(tm.Month)
lcd.print('/')
lcd.print(tmYearToCalendar(tm.Year))
} else {
if (RTC.chipPresent())
{
lcd.setCursor(0, 0)
lcd.print('RTC stopped!!!')
lcd.setCursor(0, 1)
lcd.print('Run SetTime code')
} else {
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Read error!')
lcd.setCursor(0, 1)
lcd.print('Check circuitry!')
}
}
delay(1000)
}
//------------Program Developed by R.Girish-------//

ध्यान दें:

लिक्विड क्रिस्टल_ आई 2 सी एलसीडी (0x27, 16, 2)

'0x27' वह पता है जिसे हमने स्कैन करके पाया और 16 और 2 एलसीडी डिस्प्ले पर पंक्तियों और स्तंभों की संख्या है।

RTC के लिए हमें पता खोजने की कोई आवश्यकता नहीं है, लेकिन हमने '0x68' को स्कैन करते समय पाया, लेकिन वैसे भी RTC पुस्तकालय इसे संभाल लेगा।

अब देखते हैं कि हमने वायर कंजेशन को कितना कम किया और Arduino पर GPIO पिन को बचाया।

केवल 4 तार एलसीडी डिस्प्ले से जुड़े हैं, लाल बॉक्स में हाइलाइट किए गए हैं।

इसके अलावा Arduino से केवल 4 तार जुड़े हुए हैं और RTC मॉड्यूल समान पंक्तियों को साझा करता है।

अब तक आप I2C पर बुनियादी ज्ञान प्राप्त कर चुके हैं और I2C एलसीडी एडेप्टर मॉड्यूल का उपयोग कैसे करें।
आपको यह पोस्ट पसंद आया? क्या आपका कोई प्रश्न है? कृपया टिप्पणी अनुभाग में व्यक्त करें, आपको त्वरित उत्तर मिल सकता है।