Geekly Articles each Day

ARDUINO DUE पर TFT डिस्प्ले के साथ काम करें

दूसरा भाग यहाँ है: http://habrahabr.ru/post/196864/
यह लेख Arduino DUE पर बहु-रंग TFT डिस्प्ले के साथ काम करने पर लेखों की एक छोटी श्रृंखला खोलता है। इस और बाद के लेखों में, हम TFT डिस्प्ले की मुख्य विशेषताओं पर विचार करेंगे, पुस्तकालयों का विवरण प्रदान करेंगे, और ऐसे प्रदर्शनों के साथ काम करते समय उत्पन्न होने वाले विशिष्ट कार्यों के उदाहरणों पर विचार करेंगे।

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

320x240 के क्रम के एक रिज़ॉल्यूशन के साथ एक ग्राफिक डिस्प्ले के साथ काम करना और उच्च मात्रा में मेमोरी की उपस्थिति और खुद माइक्रोकंट्रोलर की पर्याप्त उच्च गति की उपस्थिति का अर्थ है। इसके अलावा, कनेक्शन को अक्सर बड़ी संख्या में पिन की आवश्यकता होती है, इसलिए Arduino DUE नियंत्रक को आधार के रूप में चुना गया था।
इस लेख को लिखते समय निम्नलिखित उपकरणों को "प्रयोगात्मक सेटअप" के रूप में उपयोग किया गया था:

कृपया ध्यान दें कि नेमप्लेट को विशेष रूप से Arduino DUE के लिए डिज़ाइन किया गया है। Arduino MEGA के साथ डिस्प्ले का उपयोग करने के लिए, आपको 5v - 3.3V स्तर के कनवर्टर से लैस नेमप्लेट के एक अलग संस्करण की आवश्यकता है।
निर्माता की वेबसाइट पर प्रदर्शन और सीटीई नेमप्लेट के पिनआउट के बारे में सभी सामग्री डाउनलोड की जा सकती है:
प्रदर्शन: http://coldtears.lin3.siteonlinetest.com/files/3.2b.zip
स्किल्ड: http://coldtears.lin3.siteonlinetest.com/files/CTE_DUE_shi_.ip
TFT डिस्प्ले के साथ काम करने के लिए UTFT लाइब्रेरी का एक सेट उपयोग किया जाता है। इन पुस्तकालयों के नवीनतम संस्करण डेवलपर की वेबसाइट पर पाए जा सकते हैं: http://www.henningkarlsen.com/electronics/
डिस्प्ले कनेक्ट करने के बाद, निम्नलिखित कंट्रोलर पिन मुक्त रहते हैं: D0, D1, D8, D11-D13, D14-D24, D29-D31, D41-D43, A0-A11, DAC0, DAC1, SCL1, SDA1, जिसे आप अपनी इच्छानुसार उपयोग कर सकते हैं।

1. आधार UTFT लाइब्रेरी। सामान्य जानकारी


UTFT लाइब्रेरी को विभिन्न प्रकार के TFT डिस्प्ले के साथ काम करने के लिए डिज़ाइन किया गया है, दोनों समानांतर (8bit या 16bit) में जुड़ा हुआ है, और एक सीरियल इंटरफ़ेस के माध्यम से। प्रारंभ में, इसे ITead Studio और NKG Electronics द्वारा प्रदर्शित समर्थन के लिए विकसित किया गया था, लेकिन फिर इसमें कई अन्य निर्माताओं का समर्थन शामिल था। मूल पुस्तकालय यहां डाउनलोड किया जा सकता है: http://www.henningkarlsen.com/electronics/library.php?id=51
पुस्तकालय अंग्रेजी में बहुत अच्छे प्रलेखन के साथ आता है। यह लेख मुख्य रूप से डेवलपर के प्रलेखन पर आधारित है जिसमें एक निश्चित मात्रा में व्यावहारिक अनुभव और अतिरिक्त जानकारी शामिल है जो काम के दौरान प्राप्त की गई थी।

पुस्तकालय द्वारा समर्थित प्रदर्शनों की सूची और उनकी मुख्य विशेषताएं "UTFT समर्थित प्रदर्शन मॉड्यूल और नियंत्रक" के साथ दिए गए दस्तावेज़ में दी गई हैं, जो पुस्तकालय के साथ आपूर्ति की जाती है।
यह लाइब्रेरी बेसिक है और इसमें डिस्प्ले आउटपुट की केवल बुनियादी कार्यक्षमता है। इसके लिए कई अतिरिक्त हैं, जिसमें अतिरिक्त कार्य कार्यान्वित किए जाते हैं, जैसे कि टच स्क्रीन कंट्रोल (U_Touch), ऑन-स्क्रीन बटन (UTFT_Buttons) के साथ काम करते हैं, ग्राफिक प्रिमिटिव ड्राइंग के लिए फ़ंक्शंस का एक विस्तारित सेट (UTFT_Geometry), और कुछ डिस्प्ले में निर्मित फोंट और आइकन का उपयोग। (UTFT_CTE), आदि।
बेस लाइब्रेरी आपको लोड किए गए फोंट के साथ काम करने की अनुमति देती है। फ़ॉन्ट्स डेटा के सरणियों के रूप में संग्रहीत किए जाते हैं जो अलग-अलग फ़ाइलों में रखे जाते हैं और प्रोग्राम टेक्स्ट से जुड़े होते हैं।

2. पुस्तकालय के साथ आरंभ करना


पुस्तकालय का उपयोग AVR प्लेटफॉर्म (Arduino MEGA) पर आधारित नियंत्रकों के साथ, और ARM मंच (Arduino DUE) पर नियंत्रकों के साथ किया जा सकता है। इससे पहले कि आप Arduino DUE कंट्रोलर के साथ लाइब्रेरी का उपयोग करना शुरू करें, आपको उस फ़ोल्डर में जाने की आवश्यकता है जिसमें लाइब्रेरी स्थापित है: _ARDUINO_FOLDER_ / लाइब्रेरी / UTFT, इसमें / हार्डवेयर / आर्म फोल्डर और HW_ARM_defines फ़ाइल ढूंढें। इस फाइल में आपको लाइन को अनकंफर्ट करने की जरूरत है:
#define CTE_DUE_SHIELD 1
UTFT लाइब्रेरी में एक उपयोगी सुविधा है जो आपको उन प्रदर्शन मॉडल के आरंभीकरण कोड को अक्षम करने की अनुमति देती है जो वर्तमान में उपयोग में नहीं हैं। यह एक निश्चित मात्रा में मेमोरी बचाता है (उदाहरण के लिए, मेरा संकलित कार्यक्रम लगभग 12KB कम हो गया है)। ऐसा करने के लिए, लाइब्रेरी के रूट फ़ोल्डर में संपादक में memorysaver.h फ़ाइल खोलें और उन नियंत्रकों के नामों के साथ लाइनों को अनइंस्टॉल करें जिन्हें आप अपने प्रोजेक्ट में उपयोग करने की योजना नहीं बनाते हैं। इस मामले में, केवल एक नियंत्रक को टिप्पणी देनी चाहिए - वह जो आप उपयोग कर रहे हैं। जैसा कि ऊपर बताया गया है, हमारा डिस्प्ले ILI9481 कंट्रोलर से लैस है। इसलिए, लाइन:
//#define DISABLE_ILI9481 1 // CTE32HR
टिप्पणी छोड़ दें, और शेष पंक्तियों में हम सभी // वर्णों को लाइनों की शुरुआत में हटा देते हैं। अब आप काम कर सकते हैं।

परियोजना में पुस्तकालय का उपयोग इसकी लोडिंग और आरंभीकरण के साथ शुरू होता है। प्रारंभिक विकल्प उपयोग किए गए प्रदर्शन के प्रकार पर निर्भर करते हैं। हम आधार UTFT लाइब्रेरी को लोड करते हैं और एक ऑब्जेक्ट बनाते हैं - एक डिस्प्ले जिसे myGLCD कहा जाता है। पैरामीटर - डिस्प्ले मॉडल की पहचानकर्ता और पिन नंबर जिनसे आरएस, डब्ल्यूआर, सीएस, आरएसटी और एएलई लाइनें जुड़ी हुई हैं। इन मापदंडों को डिस्प्ले निर्माता के साथ चेक किया जाना चाहिए या लाइब्रेरी के साथ आने वाले समर्थित डिस्प्ले की सूची से चुना जाना चाहिए।
हमारे संस्करण में, 480x320 के रिज़ॉल्यूशन के साथ 3.2 '' डिस्प्ले और कोल्ड इलेक्ट्रॉनिक्स द्वारा निर्मित ILI9481 नियंत्रक को CTE32HR के रूप में नामित किया गया है। इसी समय, नेमप्लेट सर्किट के अनुसार, नियंत्रण रेखाएं 25-28 पिन से जुड़ी होती हैं।
#include <UTFT.h>
UTFT myGLCD(CTE32HR,25,26,27,28);
अगला, आपको बाहरी फोंट कनेक्ट करने की आवश्यकता है (हम अभी के लिए अंतर्निहित डिस्प्ले फोंट का उपयोग नहीं करेंगे - यह एक और चर्चा का विषय है)। पुस्तकालय तीन बुनियादी फोंट के साथ आता है। इन फोंट के लिए विज्ञापन लाइनें इस तरह दिखती हैं:
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];
इसलिए, हमने लाइब्रेरी को कनेक्ट और इनिशियलाइज़ किया, फोंट अटैच किया, अब हमें अपने डिस्प्ले को void सेटअप () प्रक्रिया में आरम्भ करना है:
void setup() {
myGLCD.InitLCD();
myGLCD.clrScr();
}
InitLCD () कमांड आपको प्रदर्शन के ऊर्ध्वाधर या क्षैतिज अभिविन्यास को सेट करने की अनुमति देता है। डिफ़ॉल्ट रूप से (यदि कमांड को पैरामीटर के बिना कहा जाता है), क्षैतिज अभिविन्यास सेट किया गया है। ClrScr () कमांड बस प्रदर्शन को साफ करता है। कृपया ध्यान दें कि पुस्तकालय में पूरे प्रदर्शन की पृष्ठभूमि के रंग की कोई अवधारणा नहीं है। सफाई के बाद, प्रदर्शन हमेशा काला हो जाता है।

और अंत में, लाइब्रेरी कमांड्स की विस्तृत चर्चा में जाने से पहले, हम अपना सरलतम उदाहरण समाप्त करते हैं - BigFont फ़ॉन्ट का चयन करें और प्रदर्शन की शीर्ष पंक्ति के केंद्र में "हैलो, वर्ल्ड!" प्रिंट करें:
void loop() {
myGLCD.setFont(BigFont);
myGLCD.print("Hello, world!",CENTER,0);
}

3. लाइब्रेरी कमांड


पुस्तकालय के साथ काम करते समय, आपको इसे Arduino पुस्तकालयों के साथ फ़ोल्डर में स्थापित करना होगा और निर्देश का उपयोग करके इसे कनेक्ट करना होगा:
#include <UTFT.h>
आदेशों का विवरण मुख्य रूप से पुस्तकालय के साथ आपूर्ति की जाने वाली अंग्रेजी भाषा के मैनुअल से लिया जाता है, और व्यावहारिक टिप्पणियों और उदाहरणों द्वारा महत्वपूर्ण रूप से पूरक है। इसलिए ...

UTFT - दिए गए नाम के साथ एक बेस डिस्प्ले क्लास बनाता है, मॉडल पहचानकर्ता और कनेक्शन विधि को पैरामीटर के रूप में दर्शाया जाता है।
दो विकल्प संभव हैं: एक समानांतर इंटरफ़ेस वाले मॉडल के लिए, कमांड का रूप है:
UTFT _NAME_ (model, RS, WR, CS, RST, ALE) जहां _NAME_ प्रदर्शन ऑब्जेक्ट का एक मनमाना नाम है, जिसका उपयोग किसी भी एक्सेस के लिए उपसर्ग के रूप में किया जाएगा, मॉडल एक विशिष्ट प्रदर्शन के मॉडल की पहचानकर्ता है (समर्थित मॉडल की सूची देखें) और RS, WR, CS, RST और ALE एक पिन नंबर है जिससे डिस्प्ले मॉड्यूल के संबंधित नियंत्रण संकेत एक ढाल के माध्यम से जुड़े होते हैं। सभी समर्थित मॉडल में ALE सिग्नल नहीं है, यदि आपके मॉडल में यह नहीं है, तो बस इस पैरामीटर को छोड़ दें।
एक सीरियल इंटरफ़ेस वाले मॉडल के लिए, कमांड का रूप है:
UTFT _NAME_ (model, SDA, SCL, CS, RST, RS) जहां एसडीए, एससीएल, सीएस, आरएसटी और आरएस पिन नंबर हैं, जिनसे सीरियल इंटरफ़ेस के संबंधित सिग्नल जुड़े हुए हैं। RS पैरामीटर वैकल्पिक है; यह कुछ प्रदर्शन मॉडल के लिए सेट नहीं है।
इस कमांड के साथ एक लाइन को परिभाषा क्षेत्र में रखा गया है और किसी भी अन्य लाइब्रेरी कमांड से पहले होना चाहिए। निर्दिष्ट प्रदर्शन नाम का उपयोग बाद के सभी पुस्तकालय आदेशों के लिए उपसर्ग के रूप में किया जाना चाहिए।

InitLCD - प्रदर्शन को आरंभीकृत करता है और क्षैतिज या ऊर्ध्वाधर अभिविन्यास सेट करता है। अभिविन्यास पहचानकर्ता एक पैरामीटर के रूप में निर्दिष्ट है।
मापदंडों के बिना दिए गए, कमांड क्षैतिज अभिविन्यास सेट करता है। यदि आप पैरामीटर PORTRAIT या 0 निर्दिष्ट करते हैं - ऊर्ध्वाधर अभिविन्यास का चयन किया जाएगा, यदि आप LANDSCAPE या 1 - क्षैतिज निर्दिष्ट करते हैं।
क्षैतिज अभिविन्यास के साथ, नियंत्रक कनेक्टर बाईं ओर स्थित हैं, नीचे एक ऊर्ध्वाधर एक के साथ। अन्य विकल्प प्रदान नहीं किए गए हैं। पैरामीटर के रूप में 0 और 1 को छोड़कर अन्य संख्याओं को सेट करना सूचना के विकृत प्रदर्शन की ओर जाता है।
यह आदेश आमतौर पर शून्य सेटअप () अनुभाग में उपयोग किया जाता है, लेकिन इसका उपयोग मुख्य प्रोग्राम लूप में भी किया जा सकता है, जैसे कि, अन्य के लिए, यहां:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { } void loop() { myGLCD.InitLCD(1); myGLCD.setFont(BigFont); myGLCD.print("Hello, world!",CENTER,0); delay(1000); myGLCD.InitLCD(0); myGLCD.setFont(BigFont); myGLCD.print("Hello, world!",CENTER,0); delay(1000); }

सिद्धांत रूप में, प्रदर्शन सेंसर को डिस्प्ले से जोड़कर, एक टैबलेट की तरह स्क्रीन फ्लिप की व्यवस्था करना संभव होगा;)) सच्चाई यह है कि आरंभीकरण के दौरान प्रदर्शन थोड़े समय के लिए सफेद चमकता है, जो कुछ हद तक धारणा को खराब करता है। ;)
यह कमांड बैकग्राउंड कलर को ब्लैक, टेक्स्ट व्हाइट में सेट करता है, "कोई नहीं" के लिए उपयोग किए जाने वाले फॉन्ट का नाम रीसेट करता है, और जब तक फॉन्ट स्पष्ट रूप से सेट नहीं हो जाता है, तब तक सभी प्रिंट कमांड के परिणाम अप्रत्याशित हो जाते हैं। आरंभीकरण के बाद, प्रदर्शन को साफ करने की सिफारिश की जाती है (देखें clrScr कमांड), और स्क्रीन को काले रंग से भर दिया जाएगा।

clrScr - प्रदर्शन को साफ करता है, प्रदर्शन पर प्रदर्शित सभी सूचनाओं को मिटाता है और प्रदर्शन को काले रंग से भरता है। इसका कोई पैरामीटर नहीं है।
प्रदर्शन को साफ करते समय, निर्दिष्ट पृष्ठभूमि का रंग (सेटबॅकलाइन कमांड देखें) रीसेट नहीं होता है और समान रहता है, लेकिन प्रदर्शन अभी भी काले रंग से भरा हुआ है। एक अलग पृष्ठभूमि के रंग के साथ प्रदर्शन को साफ़ करने के लिए, आपको fillScr कमांड का उपयोग करना चाहिए। ClrScr कमांड को निम्नलिखित उदाहरण द्वारा दर्शाया गया है:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); delay(1000); myGLCD.setBackColor(0,255,0); myGLCD.clrScr(); delay(1000); myGLCD.setFont(BigFont); myGLCD.print("FFFFFFFF", CENTER,0); } void loop() { }

नियंत्रक के रीसेट होने के बाद, डिस्प्ले को इनिशियलाइज़ किया जाता है, फिर 1 सेकंड के बाद इसे क्लियर किया जाता है (डिस्प्ले ब्लैक हो जाता है) और एक सेकंड के बाद प्रतीकों को प्रदर्शित किया जाता है, जबकि हम देखते हैं कि सफाई से पहले बैकग्राउंड का रंग नहीं बदला।
अगले कुछ आदेशों पर विचार करने से पहले, आपको लाइब्रेरी कमांड में रंग सेट करने की सुविधाओं पर विचार करने की आवश्यकता है।

रंग कोडिंग प्रणाली
लाइब्रेरी में रंगों को कई तरीकों से सेट किया जाता है। रंग डेटा का प्रतिनिधित्व करने के लिए आंतरिक प्रारूप RGB565 है। इस प्रारूप में, रंग को 16-बिट मान के साथ एन्कोड किया गया है, जिसमें लाल और नीले रंग का स्तर पाँच बिट्स के साथ एन्कोड किया गया है, और छह के साथ हरा है। अधिकांश पुस्तकालय आदेश देते हैं जो रंग के साथ काम करते हैं, तीन संख्याओं के रूप में दिए गए मूल्यों को अल्पविराम द्वारा अलग करते हैं। इनमें से प्रत्येक संख्या संबंधित रंग (आर, जी, बी) के स्तर के लिए जिम्मेदार है। प्रत्येक संख्या के लिए अनुमत मान 0 से 255 तक हैं।

इस प्रकार, रंग RGB888 प्रारूप में उपयोगकर्ता द्वारा निर्धारित किए जाते हैं, और RGB565 का उपयोग पुस्तकालय के अंदर किया जाता है। निम्न सूत्र का उपयोग करके लाइब्रेरी के अंदर प्रारूप रूपांतरण किया जाता है:
word color = ((r&248)<<8 | (g&252)<<3 | (b&248)>>3);
जहां आरजीबी ५६५ प्रारूप में रंग का मूल्य है, और आर, जी, और बी उपयोगकर्ता परिभाषित रंग मूल्य हैं। यह इस प्रारूप में है कि वर्तमान रंग का निर्धारण करने के लिए सभी फ़ंक्शन वापस आ गए हैं।
रंग निर्दिष्ट करते समय, यह ध्यान में रखा जाना चाहिए कि आर, जी, और बी के निर्दिष्ट मूल्यों के सभी संयोजन अलग-अलग रंगों का उत्पादन नहीं करेंगे। इसलिए, उदाहरण के लिए, लाल स्तर 255 और 253 के मान समान स्तर का लाल देते हैं। नीचे दिया गया प्रोग्राम आर, जी और बी के अधिकतम और न्यूनतम मूल्यों को प्रदर्शित करता है जो कि रंग सेटिंग कमांड में प्रोग्राम में निर्दिष्ट रंग प्राप्त करने के लिए मान्य हैं। गणना करने के लिए, myGLCD.setBackColor कमांड के मापदंडों में दशमलव रंग r, g और b को चयनित करें, प्रोग्राम को संकलित करें और चलाएं। प्रदर्शन myGLCD.getBackColor फ़ंक्शन द्वारा दिए गए RGB565 सिस्टम में रंग कोड दिखाता है, साथ ही साथ r, g, और b के न्यूनतम और अधिकतम मान भी देता है, जिससे आप इस रंग को प्राप्त कर सकते हैं।
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { myGLCD.setBackColor(245,34,112); myGLCD.setColor(VGA_NAVY); word CurrentColor=myGLCD.getBackColor(); byte R_1 = highByte(CurrentColor)>>3; byte R_min = R_1<<3; byte R_max = R_min|7; byte G_1 = highByte(CurrentColor)<<5; G_1 = G_1>>2|lowByte(CurrentColor)>>5; byte G_min = G_1<<2; byte G_max = G_min|3; byte B_1 = lowByte(CurrentColor)<<3; B_1 = B_1>>3; byte B_min = B_1<<3; byte B_max = B_min|7; myGLCD.print("GetColor", 0,0); myGLCD.print("RGB888 Min", 0,36); myGLCD.print("RGB888 Max", 0,54); myGLCD.printNumI(CurrentColor, 162,0); myGLCD.printNumI(R_min, 162,36); myGLCD.printNumI(R_max, 162,54); myGLCD.printNumI(G_min, 212,36); myGLCD.printNumI(G_max, 212,54); myGLCD.printNumI(B_min, 262,36); myGLCD.printNumI(B_max, 262,54); }

कुछ मानक रंग पहचानकर्ताओं का उपयोग करके सेट किए जा सकते हैं:
VGA_BLACK - काला,
VGA_SILVER - रजत
VGA_GRAY - ग्रे
VGA_WHITE - सफेद
VGA_MAROON - लाल भूरा
VGA_RED - लाल
VGA_PURPLE - मैजेंटा
VGA_FUCHSIA - फुशिया
VGA_GREEN - हरा
VGA_LIME - चूना
VGA_NAVY - नौसेना
VGA_BLUE - नीला
VGA_TEAL - ब्लू ग्रीन
VGA_AQUA - समुद्र की लहर
यदि आप इन रंगों के लिए आरजीबी कोड जानना चाहते हैं, तो उपरोक्त कार्यक्रम में myGLCD.setBackColor कमांड में तीन नंबरों के स्थान पर रंग पहचानकर्ता को प्रतिस्थापित करें, संकलन और लॉन्च के बाद, कोड डिस्प्ले पर दिखाई देंगे।

इसलिए, हम पुस्तकालय आदेशों पर विचार जारी रखते हैं:

fillScr - प्रदर्शन को साफ़ करता है, प्रदर्शन पर प्रदर्शित सभी सूचनाओं को मिटाता है और इसे एक पैरामीटर के रूप में निर्दिष्ट पृष्ठभूमि रंग के साथ भरता है।
पृष्ठभूमि का रंग तीन संख्याओं या रंग पहचानकर्ता द्वारा निर्दिष्ट किया जाता है, उदाहरण के लिए, इस तरह:
fillScr(0,0,0); //
fillScr(255,255,255); //
fillScr(255,128,0); //
fillScr(VGA_RED); //
यह आदेश, clrScr की तरह, प्रिंट कमांड के लिए निर्दिष्ट पृष्ठभूमि रंग को नहीं बदलता है, इसलिए जब निर्दिष्ट रंग से भरे हुए डिस्प्ले पर प्रिंट किया जाता है, तो आपको पृष्ठभूमि का रंग निर्दिष्ट करना होगा (setBackColor कमांड देखें)।

setColor - मुद्रण और ग्राफिक आदिम ड्राइंग के लिए सभी आदेशों के लिए "स्याही" का रंग सेट करता है। आवश्यक रंग एक पैरामीटर के रूप में निर्दिष्ट किया गया है।
फिलर्स कमांड के लिए रंगों को उसी तरह सेट किया जाता है - या तो संख्याओं के साथ या मानक रंगों के पहचानकर्ताओं के साथ। एक उदाहरण:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { myGLCD.setColor(VGA_RED); myGLCD.print("Hello, World!",CENTER,0); myGLCD.setColor(VGA_NAVY); myGLCD.print("Hello, World!",CENTER,18); myGLCD.setColor(VGA_TEAL); myGLCD.print("Hello, World!",CENTER,36); myGLCD.setColor(VGA_LIME); myGLCD.print("Hello, World!",CENTER,54); while(1); }

setBackColor - प्रिंट कमांड के लिए पृष्ठभूमि का रंग सेट करता है। आवश्यक रंग एक पैरामीटर के रूप में निर्दिष्ट किया गया है।
रंगों को सामान्य तरीके से सेट किया जाता है - संख्याओं या पहचानकर्ताओं द्वारा (fillScr कमांड देखें); हालाँकि, इस कमांड के लिए एक और पहचानकर्ता है - VGA_TRANSPARENT, जो "पारदर्शी" पृष्ठभूमि पर वर्णों को मुद्रित करने की अनुमति देता है।
यदि आपको काले रंग के अलावा किसी भी रंग से भरे डिस्प्ले पर प्रिंट करने की आवश्यकता है, तो आपको setBackColor कमांड के साथ एक ही बैकग्राउंड कलर सेट करना होगा, या setBackColor कमांड (VGA_TRANSPARENT) का उपयोग करना होगा।

getColor - स्याही के रंग का वर्तमान मूल्य लौटाता है। इसका कोई पैरामीटर नहीं है।

getBackColor –Returns वर्तमान पृष्ठभूमि रंग मान। इसका कोई पैरामीटर नहीं है।

ये दोनों फ़ंक्शन RGB565 प्रारूप में वर्तमान निर्दिष्ट रंग के अनुरूप शब्द प्रकार का मान लौटाते हैं। इस मान को setColor, SetBackColor और fillScr कमांड में एक पैरामीटर के रूप में पारित किया जा सकता है, उदाहरण के लिए:
setColor(32586);
यह कमांड सेट कलर (120,232,80) या सेटक्लोर (125,233,84) के समान रंग देता है, जैसा कि ऊपर चर्चा की गई RGB565 कलर डिकोडिंग प्रोग्राम के साथ देखा जा सकता है।

getDisplayXSize - चयनित अभिविन्यास के लिए पिक्सेल में प्रदर्शन चौड़ाई लौटाता है। इसका कोई पैरामीटर नहीं है।

getDisplayYSize - चयनित अभिविन्यास के लिए पिक्सेल में प्रदर्शन ऊंचाई देता है। इसका कोई पैरामीटर नहीं है।

इन दो कार्यों को निम्न उदाहरण द्वारा स्पष्ट किया जा सकता है:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { } void loop() { myGLCD.InitLCD(PORTRAIT); myGLCD.setFont(BigFont); myGLCD.clrScr(); myGLCD.print("Screen Width=",0,0); myGLCD.printNumI(myGLCD.getDisplayXSize(),250,0); myGLCD.print("Screen Height=",0,18); myGLCD.printNumI(myGLCD.getDisplayYSize(),250,18); delay(2000); myGLCD.InitLCD(LANDSCAPE); myGLCD.setFont(BigFont); myGLCD.clrScr(); myGLCD.print("Screen Width=",0,0); myGLCD.printNumI(myGLCD.getDisplayXSize(),250,0); myGLCD.print("Screen Height=",0,18); myGLCD.printNumI(myGLCD.getDisplayYSize(),250,18); delay(2000); }

जब प्रोग्राम शुरू होता है (ओरिएंटेशन वर्टिकल पर सेट होता है), डिस्प्ले की चौड़ाई 320 पिक्सल होगी, और ऊंचाई 480 होगी, 2 सेकंड के बाद ओरिएंटेशन क्षैतिज में बदल जाएगा और चौड़ाई 480 पिक्सल के बराबर हो जाएगी और ऊंचाई 320 हो जाएगी।
प्रिंट कमांड पर विचार करने और फोंट के साथ काम करने से पहले, आपको UTFT लाइब्रेरी में फोंट का उपयोग करने के तरीकों पर अधिक विस्तार से ध्यान देना चाहिए।

प्रिंट कमांड के लिए बाहरी फोंट।
बाहरी फोंट को एक्सटेंशन .c के साथ अलग-अलग फाइलों में संग्रहीत किया जाता है और वे डेटा एरे होते हैं जिनमें फॉन्ट मापदंडों के बारे में जानकारी होती है और वर्णों के ग्राफिक चित्र होते हैं।
फ़ॉन्ट स्ट्रिंग के साथ जुड़ा हुआ है "बाहरी uint8_t _ FONT_NAME_;"। एक्सटर्नल स्पेसियर इंगित करता है कि फॉन्ट डेटा ऐरे दूसरी फाइल में है, और फॉन्ट का नाम फॉन्ट फाइल से लिया गया है। कृपया ध्यान दें कि यह फ़ाइल नाम नहीं है, लेकिन स्वयं फ़ॉन्ट का नाम (वे भिन्न हो सकते हैं)। उपयोग किए गए फोंट को आपके प्रोग्राम में एक्सटर्नल स्पेसियर का उपयोग करके घोषित किया जाना चाहिए। उदाहरण के लिए, इस तरह:
extern uint8_t BigFont[];
पुस्तकालय तीन मुख्य फोंट के साथ आता है:

SevenSegNumFont फ़ॉन्ट 7-खंड डिजिटल संकेतक की नकल करता है।
अतिरिक्त फ़ॉन्ट यहां देखे जा सकते हैं:
http://www.henningkarlsen.com/electronics/r_fonts.php

और यहां एक ऑनलाइन सेवा है जो आपको विशेष रूप से तैयार छवि फ़ाइलों से अपने स्वयं के फोंट बनाने की अनुमति देती है:
http://www.henningkarlsen.com/electronics/t_make_font_file.php

लाइब्रेरी में शामिल फॉन्ट्स को DefaultFonts.c फाइल में लाइब्रेरी के रूट फोल्डर में स्टोर किया जाता है। अतिरिक्त फ़ॉन्ट (स्वतंत्र रूप से या उपरोक्त लिंक से डाउनलोड किए गए) को आपके प्रोजेक्ट के फ़ोल्डर में रखने की सिफारिश की जाती है, अन्यथा कंपाइलर उन्हें नहीं मिल सकता है।

फ़ॉन्ट फाइलें उपयोगिता जानकारी और फ़ॉन्ट की एक एन्कोडेड ग्राफिक छवि युक्त सरणियों की परिभाषा हैं। नाम के अलावा, फ़ॉन्ट फ़ाइल के अंदर की टिप्पणियों में पिक्सेल में वर्ण के आकार के बारे में जानकारी भी होती है (पाठ प्रदर्शित करने के लिए निर्देशांक सेट करते समय यह जानकारी उपयोगी होगी), फ़ॉन्ट डेटा सरणी द्वारा कब्जा की गई मेमोरी की मात्रा और इस फ़ॉन्ट में निर्दिष्ट वर्णों की संख्या। 95 अक्षरों के "पूर्ण" फोंट, "डिजिटल" (10 वर्ण) और "सबसेट" (वर्णों की एक अलग संख्या) के बीच भेद।
सरणी के पहले 4 बाइट्स में ओवरहेड जानकारी होती है:

बाइट 0 - पिक्सेल में क्षैतिज फ़ॉन्ट आकार
बाइट 1 - पिक्सेल में ऊर्ध्वाधर फ़ॉन्ट आकार
बाइट 2 फ़ॉन्ट के पहले वर्ण का कोड है ("पूर्ण" फोंट के लिए यह 0x20 है, अर्थात, "डिजिटल" के लिए एक अंतरिक्ष कोड - 0x30 - वर्ण कोड "शून्य" है)।
बाइट 3 - फ़ॉन्ट वर्णों की संख्या ("पूर्ण" फोंट के लिए 0x5F, "डिजिटल" के लिए - 0x0A)।

प्रारूप की पेचीदगियों और कस्टम फोंट बनाने के बारे में और अधिक पढ़ें: http://www.henningkarlsen.com/electronics/h_utft_fonts_101.php

यदि आप 7-सेगमेंट संकेतक के रूप में स्टाइल किए गए बड़ी संख्या के साथ काम करने की योजना बनाते हैं, तो हम तुरंत वैकल्पिक सेवेनसेनमफॉन्टप्लॉट फ़ॉन्ट के साथ सेवेनसेनमफोंट फ़ॉन्ट को बदलने की सलाह देते हैं, जिसे यहां डाउनलोड किया जा सकता है:
http://www.henningkarlsen.com/electronics/dlfont.php?id=21&t=c
यह एक बहुत उपयोगी प्रतीक ":" की उपस्थिति से प्रतिष्ठित है, जो मानक फ़ॉन्ट में नहीं है। फ़ॉन्ट फ़ाइल को आपके प्रोग्राम के साथ फ़ोल्डर में रखा जाना चाहिए, बाहरी uint8_t SevenSegNumFont [घोषणा] को बदलें; एक्सटर्न पर uint8_t SevenSegNumFontPlus []; फिर प्रोजेक्ट को बंद करें और फिर से खोलें। फ़ॉन्ट फ़ाइल प्रोजेक्ट के साथ आसन्न टैब में खुलनी चाहिए।

setFont - प्रिंट कमांड के लिए फ़ॉन्ट सेट करता है। फ़ॉन्ट नाम एक पैरामीटर के रूप में पारित किया गया है।
फ़ॉन्ट को पहले प्रोग्राम डेफिनेशन एरिया में घोषित किया जाना चाहिए। एक उदाहरण:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t SmallFont[]; void setup() { myGLCD.InitLCD(); myGLCD.setFont(SmallFont); myGLCD.clrScr(); myGLCD.print("Hello, World!",0,0); } void loop() {}

getFont - नियंत्रक मेमोरी में वर्तमान फ़ॉन्ट के पते पर एक संकेतक लौटाता है।
एक उदाहरण पर विचार करें। हमने थोड़ा पहले उल्लेख किया है कि फ़ॉन्ट डेटा सरणी में पहले चार बाइट्स में फ़ॉन्ट गुणों के बारे में जानकारी है। वर्तमान फ़ॉन्ट के लिए यह जानकारी सीधे नियंत्रक मेमोरी से प्राप्त की जा सकती है और कार्यक्रम में उपयोग की जा सकती है। निम्न प्रोग्राम चर में रखता है और पिक्सेल में वर्ण आकार प्रदर्शित करता है, पहले चरित्र का कोड और सेटफॉन्ट कमांड द्वारा निर्दिष्ट वर्तमान फ़ॉन्ट के पात्रों की संख्या।
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); SerialUSB.begin(9600); } void loop() { uint8_t* FontAddr = myGLCD.getFont(); byte CurrentFontX = *FontAddr; byte CurrentFontY = *(FontAddr+1); byte CurrentFontStartCode = *(FontAddr+2); byte CurrentFontSymNumber = *(FontAddr+3); myGLCD.printNumI(CurrentFontX, 0,0); myGLCD.printNumI(CurrentFontY, 0,18); myGLCD.printNumI(CurrentFontStartCode, 0,36); myGLCD.printNumI(CurrentFontSymNumber, 0,54);

इसी तरह, आप वर्तमान फ़ॉन्ट के किसी भी बाइट का उपयोग कर सकते हैं।

getFontXsize - पिक्सेल में वर्तमान फ़ॉन्ट के चरित्र का क्षैतिज आकार (चौड़ाई) लौटाता है। इसका कोई पैरामीटर नहीं है।

getFontYXsize - पिक्सेल में वर्तमान फ़ॉन्ट के चरित्र का ऊर्ध्वाधर आकार (ऊंचाई) लौटाता है। इसका कोई पैरामीटर नहीं है।

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

प्रिंट - पाठ प्रदर्शित करता है, एक वर्ण चर की सामग्री या स्ट्रिंग का एक प्रकार है। प्रिंट क्षेत्र के ऊपरी बाएं कोने के आउटपुट टेक्स्ट और निर्देशांक पैरामीटर के रूप में पारित किए जाते हैं। एक अन्य वैकल्पिक पैरामीटर आपको किसी दिए गए ढलान के साथ मुद्रण योग्य रेखा की स्थिति की अनुमति देता है।
यह कमांड टेक्स्ट जानकारी को आउटपुट करने के लिए है। प्रिंट निर्देशांक X और Y पिक्सेल में निर्दिष्ट हैं और इन्हें स्पष्ट रूप से या पूर्णांक चर या अभिव्यक्ति के माध्यम से प्रेषित किया जा सकता है। तीन पूर्वनिर्धारित पहचानकर्ता भी हैं जिन्हें एक्स समन्वय के रूप में उपयोग करने के लिए डिज़ाइन किया गया है:

पाठ जानकारी को दोहरे उद्धरण चिह्नों में संलग्न स्ट्रिंग के रूप में दर्शाया जा सकता है:
myGLCD.print("Hello, World!", 0,0);
या तो स्ट्रिंग के एक चर के
String text = "Hello, World!";
myGLCD.print(text, 0,0);
रूप में : या एक फ़ंक्शन के परिणामस्वरूप जो स्ट्रिंग मान लौटाता है:
int valueInt = 12345;
myGLCD.print(String(valueInt), 0,0);
float valueFloat = 12345.67;
myGLCD.print(String(valueFloat), 0,18);
निर्देश प्रत्येक कमांड कॉल के लिए व्यक्तिगत रूप से सेट किए जाते हैं, कमांड द्वारा वर्तमान प्रिंट स्थिति वापस नहीं की जाती है। इसलिए, आपको अगले प्रिंट कमांड के लिए स्वतंत्र रूप से स्थिति की गणना करनी चाहिए। यह काफी सरल तरीके से किया जा सकता है। निम्न उदाहरण एक पंक्ति (कोई स्थान) पर एक पंक्ति में दो स्ट्रिंग मान प्रिंट करता है:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { int X=0; int Y=0; int valueInt1 = 12345; myGLCD.print(String(valueInt1), X,Y); X=X+myGLCD.getFontXsize()*String(valueInt1).length(); int valueInt2 = 67890; myGLCD.print(String(valueInt2), X,Y); }

एक स्थान के साथ प्रदर्शित मूल्यों को अलग करने के लिए, X की गणना मूल्य को एक वर्ण की चौड़ाई से बढ़ाना होगा। और यहाँ छपाई दो लाइनों में की जाती है:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { int X=0; int Y=0; int valueInt1 = 12345; myGLCD.print(String(valueInt1), X,Y); Y=Y+myGLCD.getFontYsize(); int valueInt2 = 67890; myGLCD.print(String(valueInt2), X,Y); }    LEFT, CENTER  RIGHT       : #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { int Y=60; myGLCD.print("Hello, World!", LEFT, Y); Y=Y+myGLCD.getFontYsize(); myGLCD.print("Goodbye, World!", LEFT,Y); Y=Y+myGLCD.getFontYsize()*4; myGLCD.print("Hello, World!", CENTER, Y); Y=Y+myGLCD.getFontYsize(); myGLCD.print("Goodbye, World!", CENTER,Y); Y=Y+myGLCD.getFontYsize()*4; myGLCD.print("Hello, World!", RIGHT, Y); Y=Y+myGLCD.getFontYsize(); myGLCD.print("Goodbye, World!", RIGHT,Y); }

एक अन्य वैकल्पिक पैरामीटर आपको 0 से 359 डिग्री के कोण पर झुकी हुई रेखाओं को मुद्रित करने की अनुमति देता है। रोटेशन प्रिंट निर्देशांक (ऊपरी बाएं कोने) के सापेक्ष सेट किया गया है। कोण का शून्य मान सामान्य क्षैतिज मुद्रण की ओर जाता है, फिर जैसे-जैसे कोण बढ़ता है, पाठ निर्दिष्ट कोण द्वारा दक्षिणावर्त घुमाता है। निम्नलिखित उदाहरण एक मजेदार ग्राफिक प्रभाव प्रदान करता है:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { int X=240; int Y=160; for (int DEG=0; DEG<360; DEG+=20) { String text = "Hello, World!"; myGLCD.print(text, X,Y, DEG); } }

किसी कोण पर पाठ को प्रिंट करते समय, पूर्वनिर्धारित पहचानकर्ता LEFT, CENTER और RIGHT के उपयोग की अनुशंसा नहीं की जाती है, क्योंकि उन्हें पुस्तकालय द्वारा पर्याप्त रूप से गणना नहीं की जा सकती है। यही है, संरेखण की गणना अभी भी की जाती है जैसे कि लाइन क्षैतिज रूप से मुद्रित की जाती है, और रोटेशन संरेखण के बाद बाहर किया जाता है और अभी भी प्रिंट क्षेत्र के ऊपरी बाएं कोने के सापेक्ष है।
वैसे, प्रिंट कमांड डिस्प्ले से बाहर का रास्ता निर्धारित करने में सक्षम नहीं हैं। इसलिए आपको अपने आप को अधिकतम लाइन की लंबाई का पालन करना होगा। यदि रेखा बहुत लंबी है, तो पहले से ही मुद्रित पाठ के शीर्ष पर इसकी "पूंछ" प्रदर्शित की जा सकती है। यदि आप प्रदर्शन की निचली सीमा से बाहर निकलते हैं, तो परिणाम अप्रत्याशित हो सकता है।

PrintNumI - पूर्णांक या पूर्णांक चर की सामग्री को प्रदर्शित करता है। आउटपुट मान और प्रिंट क्षेत्र के ऊपरी बाएं कोने के निर्देशांक पैरामीटर के रूप में पारित किए जाते हैं। वैकल्पिक पैरामीटर आपको आउटपुट प्रारूप को नियंत्रित करने की अनुमति देते हैं।
प्रिंट निर्देशांक प्रिंट कमांड के लिए उसी तरह सेट किए जाते हैं। स्थिति X पर एक चिन्ह के साथ संख्याओं को प्रिंट करते समय, संख्या चिह्न प्रदर्शित किया जाता है, और फिर पहला अंक। जब अहस्ताक्षरित संख्याओं या पॉजिटिव मानों को स्थिति X पर प्रिंट करते हैं, तो संख्या का पहला अंक प्रदर्शित किया जाता है।
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myGLCD.setFont(BigFont); } void loop() { byte X=100; byte Y=10; int Num1 = 1234; int Num2 = -1234; unsigned int Num3= 12345; myGLCD.printNumI(Num1,X,Y); Y=Y+myGLCD.getFontYsize(); myGLCD.printNumI(Num2,X,Y); Y=Y+myGLCD.getFontYsize(); myGLCD.printNumI(Num3,X,Y); }

मुद्रित किए जाने वाले मूल्य को एक पूर्णांक के रूप में प्रेषित किया जा सकता है:
myGLCD.printNumI(1250,0,0);
या पूर्णांक प्रकारों में से एक का एक चर:
int Num = 1324;
myGLCD.printNumI(Num,0,0);
किसी फ़ंक्शन या अभिव्यक्ति के परिणाम को प्रिंट करना भी संभव है जो पूर्णांक मान है:
myGLCD.printNumI(myGLCD.getFontYsize()*2,0,0);
पूर्णांक मानों के साथ काम करते समय, याद रखें कि Arduide DUE में अंतर प्रकार संग्रहीत किया जाता है। 2-2147,483,648 से 2,147,483,647 तक स्वीकार्य मानों की श्रेणी के साथ 4-बाइट संख्या के रूप में लंबा प्रकार।
अहस्ताक्षरित int और अहस्ताक्षरित लंबे प्रकारों को PrintNumI कमांड द्वारा समर्थित नहीं किया जाता है, अर्थात मान को कमांड में पारित किया जा सकता है, लेकिन इसे एक हस्ताक्षरित संख्या के रूप में प्रदर्शित किया जाएगा। चार प्रकार, इसके विपरीत, अहस्ताक्षरित के रूप में माना जाता है।

इस आदेश के अतिरिक्त वैकल्पिक पैरामीटर आपको आउटपुट संख्याओं के लिए प्रारूप सेट करने की अनुमति देते हैं। लंबाई पैरामीटर प्रदर्शन पर प्रदर्शित संख्या द्वारा कब्जा किए गए वर्णों की न्यूनतम संख्या (संख्या का संकेत सहित) निर्धारित करता है। यदि संख्या के बिट्स की लंबाई निर्दिष्ट मान से कम है, तो वर्णों की अनुपलब्ध संख्या को बाईं ओर वर्णों की आवश्यक संख्या के साथ पूरक किया गया है। भराव पैरामीटर आपको एक चरित्र (डिफ़ॉल्ट रूप से, एक स्थान) निर्दिष्ट करने की अनुमति देता है, जो संख्या को पूरक करेगा। इन वर्णों का संयोजन, विशेष रूप से, सही सीमा पर संरेखित संख्याओं के आउटपुट को व्यवस्थित करने के लिए या समय या तारीख को आउटपुट करते समय तुच्छ शून्य के साथ मूल्यों को पूरक करने की अनुमति देता है। यानी सामान्य निर्माण के बजाय:
byte Day = 2;
byte Month = 9;
int Year = 2013;
if (Day<10){
myGLCD.print("0",0,0);
myGLCD.printNumI(Day,16,0);
}else{
myGLCD.printNumI(Day,0,0);}
myGLCD.print(".", 32,0);
if (Month<10){
myGLCD.print("0",48,0);
myGLCD.printNumI(Month,64,0);
}else{
myGLCD.printNumI(Month,48,0,2,'0');}
myGLCD.print(".", 80,0);
myGLCD.printNumI(Year,96,0);
आप बस लिख सकते हैं:
byte Day = 2;
byte Month = 9;
int Year = 2013;
myGLCD.printNumI(Day,0,0,2,'0');
myGLCD.print(".", 32,0);
myGLCD.printNumI(Month,48,0,2,'0');
myGLCD.print(".", 80,0);
myGLCD.printNumI(Year,96,0);
क्या यह इतना बेहतर नहीं है?

PrintNumF - एक वास्तविक संख्या या एक वास्तविक प्रकार के एक चर की सामग्री को प्रदर्शित करता है। आउटपुट मान, दशमलव बिंदु के बाद वर्णों की संख्या, और प्रिंट क्षेत्र के ऊपरी बाएं कोने के निर्देशांक पैरामीटर के रूप में पारित किए जाते हैं। वैकल्पिक पैरामीटर आपको आउटपुट प्रारूप को नियंत्रित करने की अनुमति देते हैं।
प्रिंट निर्देशांक अन्य प्रिंट कमांडों की तरह ही सेट किए जाते हैं। प्रदर्शित वास्तविक मूल्य को एक वास्तविक प्रकार (फ्लोट) के एक चर के रूप में, एक संख्या के रूप में निर्दिष्ट किया जा सकता है, और एक फ़ंक्शन के रूप में जो एक वास्तविक परिणाम या अभिव्यक्ति देता है, जिसका परिणाम एक वास्तविक संख्या है।
दशमलव बिंदु के बाद वर्णों की संख्या 1 से 5 तक सेट की जा सकती है। शून्य मान की अनुमति नहीं है (इस मामले में, संख्या को पूर्णांक प्रकार में डालने और प्रिंटन्यूमी कमांड का उपयोग करने की अनुशंसा की जाती है)। उदाहरण के लिए, कमांड:
myGLCD.printNumF(-234.3442, 2, 0, 0);
आपको संख्या -234.34 प्रदर्शित करने की अनुमति देता है।
संख्या को घातीय रूप में और "फ़्लोटिंग पॉइंट" के साथ प्रारूप में निर्दिष्ट किया जा सकता है, जबकि आउटपुट "फ़्लोटिंग पॉइंट" के साथ प्रारूप में होगा। उदाहरण के लिए, दो आदेश:
myGLCD.printNumF(-2.343442E2, 2, 0, 0);
myGLCD.printNumF(-234.3442, 2, 0, 0);
समान मूल्य प्रदर्शित करें -234.34
वैकल्पिक विभक्त पैरामीटर आपको एक वर्ण को फिर से परिभाषित करने की अनुमति देता है जो दशमलव बिंदु (डिफ़ॉल्ट '' ') के रूप में कार्य करता है। उदाहरण के लिए, कमांड:
myGLCD.printNumF(-234.3442, 2, 0, 0, ',');
आपको दशमलव बिंदु प्रतीक को अल्पविराम से बदलने की अनुमति देता है। इस मामले में, निश्चित रूप से, आपको अभी भी अवधि का उपयोग करके कार्यक्रम में नंबर दर्ज करना होगा। प्रतिस्थापन केवल उत्पादन को प्रभावित करता है।
वैकल्पिक लंबाई और भराव पैरामीटर समान रूप से PrintNumF कमांड पर काम करते हैं, जिससे आप संख्या प्रदर्शित करते समय न्यूनतम वर्णों को नियंत्रित कर सकते हैं। लंबाई पैरामीटर प्रदर्शित संख्या के कब्जे वाले सभी वर्णों को ध्यान में रखता है, जिसमें साइन, पूर्णांक भाग, दशमलव बिंदु और आंशिक भाग शामिल हैं। उदाहरण के लिए, कमांड:
myGLCD.printNumF(-234.3442, 2, 0, 0, '.', 10, '0');
नंबर -1000234.34 (मूल संख्या, तीन तुच्छ शून्य द्वारा पूरक है ताकि कुल संख्या 10 परिचित हो) प्रदर्शित करता है।
चेतावनी!वैकल्पिक लंबाई पैरामीटर का उपयोग करते समय, विभक्त पैरामीटर सेट किया जाना चाहिए, अन्यथा सिस्टम एक विभाजक वर्ण कोड के रूप में लंबाई मान की व्याख्या करने की कोशिश करेगा, जिससे अप्रत्याशित परिणाम हो सकते हैं।
अब आज्ञाओं के समूह पर चलते हैं जो आपको प्रदर्शन पर ग्राफिक प्राइमिटिव्स को प्रदर्शित करने की अनुमति देते हैं - अंक, रेखाएं, आयताकार और सर्कल।

drawPixel - एक बिंदु प्रदर्शित करता है। एक बिंदु का रंग सेट कलर () कमांड द्वारा निर्धारित वर्तमान रंग मान से निर्धारित होता है।
X और Y निर्देशांक पैरामीटर के रूप में पारित किए जाते हैं।
पैरामीटर संख्याओं, चर, कार्यों या अभिव्यक्तियों के परिणामों द्वारा निर्दिष्ट किए जा सकते हैं। पैरामीटर एक वास्तविक संख्या हो सकती है, लेकिन आंशिक भाग को छोड़ दिया जाएगा। यह सुनिश्चित करना भी आवश्यक है कि बिंदु के निर्देशांक प्रदर्शन से परे नहीं जाते हैं, अन्यथा बिंदु बिल्कुल वैसा नहीं हो सकता है जहाँ आप इसे देखने की उम्मीद करते हैं;) प्रदर्शन से परे जाने को नियंत्रित करने के लिए, आप getDisplayXsize () और getDisplayYsize () कार्यों का उपयोग पहले चर्चा कर सकते हैं।
ड्रापिक्सल कमांड का उपयोग करने का एक उदाहरण - निम्नलिखित निर्माण अलग-अलग बिंदुओं से निर्मित एक साइनसॉइड प्रदर्शित करेगा:
for (int x=0; x<48; x++) {
int y=(sin(x)*10)+100;
myGLCD.drawPixel(x*10,320-y);

कमांड के अगले समूह को मापदंडों के रूप में, दो बिंदुओं के निर्देशांक की आवश्यकता होती है जो प्रदर्शित आंकड़े के आकार को निर्धारित करते हैं।

drawLine - प्रारंभ और अंत बिंदुओं के निर्देशांक द्वारा निर्दिष्ट रेखा को प्रदर्शित करता है।
लाइन ड्राइंग की दिशा प्रारंभ और अंत बिंदुओं के स्थान पर निर्भर करती है। उदाहरण के लिए, एक रेखा:
myGLCD.drawLine(10,20,100,200);
बिंदुओं के बीच के वर्तमान रंग को निर्देशांक X = 10, Y = 20 को पहले बिंदु के लिए और दूसरे के लिए X = 100, Y = 200 के बीच खींचती है। रेखा:
myGLCD.drawLine(100,200,10,20);
समान बिंदुओं के बीच समान रेखा खींचती है, लेकिन रेखाचित्र की दिशा विपरीत होगी।

drawRect - दो विपरीत कोनों के निर्देशांक द्वारा परिभाषित आयत प्रदर्शित करता है।
निर्देशांक उसी तरह निर्धारित किए जाते हैं जैसे कि ड्रालाइन कमांड के लिए।

drawRoundRect - दो विपरीत कोनों के निर्देशांक को देखते हुए, गोल कोनों के साथ एक आयत प्रदर्शित करता है।
एक आयत का न्यूनतम पक्ष आकार 5 पिक्सेल तक सीमित है। छोटे पक्षों को निर्दिष्ट करते समय, आयत प्रदर्शित नहीं किया जा सकता है।

fillRect - दो विपरीत कोनों के निर्देशांक द्वारा परिभाषित एक भरा हुआ आयत प्रदर्शित करता है।
आयत को वर्तमान रंग से खींचा और भरा गया है।

fillRoundRect - गोल कोनों के साथ एक भरा हुआ आयत प्रदर्शित करता है, जिसे दो विपरीत कोनों के निर्देशांक दिए गए हैं ।
यह कमांड उसी तरह से कार्य करता है जैसे कि ड्राड्राउंड रेक्ट कमांड।

निम्नलिखित दो कमांड सर्किल और सर्कल ड्राइंग के लिए अभिप्रेत हैं और तीन मापदंडों की आवश्यकता होती है: सर्कल के केंद्र (या सर्कल) और त्रिज्या के एक्स और वाई निर्देशांक।

drawCircle - केंद्र और त्रिज्या के निर्देशांक द्वारा परिभाषित एक वृत्त प्रदर्शित करता है।
सर्कल के त्रिज्या को नकारात्मक मान नहीं लेना चाहिए, क्योंकि इस मामले में यह सही ढंग से प्रदर्शित नहीं किया जाएगा।
निम्न आदेश 50 पिक्सल के त्रिज्या के साथ एक वृत्त प्रदर्शित करता है और एक बिंदु पर निर्देशांक X = 100 और Y = 120:
drawCircle(100,120,50);

fillCircle - केंद्र और त्रिज्या के निर्देशांक द्वारा निर्धारित वर्तमान रंग से भरा एक चक्र प्रदर्शित करता है।
नकारात्मक त्रिज्या मानों के लिए, वृत्त प्रदर्शित नहीं होता है।

इसलिए, हमने ग्राफिक आदिम ड्राइंग के लिए कमांड्स की जांच की। वैसे, UTFT लाइब्रेरी के लिए, UTFT_Geometry ऐड-ऑन है, जो आपको त्रिकोण (समोच्च और भरे हुए), परिपत्र आर्क्स और सर्कल क्षेत्रों को प्रदर्शित करने की अनुमति देता है। हम निम्नलिखित लेखों में से एक में इस ऐड के साथ काम करने पर विचार करेंगे।

और अब बहुत कम बचा है: दो कमांड जो आपको डिस्प्ले पर एक विशेष रूप से तैयार किए गए रास्टर की छवि को प्रदर्शित करने की अनुमति देते हैं:

ड्राबैटमैप - डिस्प्ले पर विशेष रूप से तैयार किए गए रास्टर ग्राफिक छवि को प्रदर्शित करता है।
पैरामीटर छवि के ऊपरी बाएं कोने, उसके आयामों और उस सरणी के नाम के निर्देशांक हैं जिसमें एन्कोडेड छवि संग्रहीत है।
वैकल्पिक पैरामीटर स्केल आपको प्रदर्शित होने पर छवि के स्केलिंग को नियंत्रित करने की अनुमति देता है।
इस कमांड के लिए छवि विशेष उपयोगिता ImageConverter565.exe का उपयोग करके तैयार की गई है, जो लाइब्रेरी के साथ आती है और टूल फ़ोल्डर में स्थित है। और यहां आप ऑनलाइन छवि रूपांतरण सेवा का उपयोग कर सकते हैं:
http://www.henningkarlsen.com/electronics/t_imageconverter565.php
कनवर्टर jpg, png और gif फ़ाइल स्वरूपों के साथ काम कर सकता है।

एक उदाहरण के रूप में, एक बिटमैप छवि और इसकी पृष्ठभूमि पर एक पाठ संदेश प्रदर्शित करने के कार्य पर विचार करें। बेशक, 480x320 पिक्सेल आकार की एक पृष्ठभूमि छवि नियंत्रक की मेमोरी में अस्वीकार्य रूप से बड़ी मात्रा में जगह लेगी, इसलिए हम 2 गुना (240x160 पिक्सल) से कम की छवि का उपयोग करते हैं और स्केलिंग का उपयोग करते हैं।
छवि को तैयार करने के लिए, आपको ImageConverter565.exe फ़ाइल को चलाने की आवश्यकता है, और इसमें अपनी छवि के साथ फ़ाइल खोलें। अगला, हम "ध्वज को कम करें" ध्वज को सेट करेंगे और आवश्यक चित्र आकार (240x160) सेट करेंगे। "इस रूप में सहेजें" स्विच में, ".c" का चयन करें, और "लक्ष्य बोर्ड" स्विच में, "चिपकिट / Arduino ड्यू" का चयन करें। "सरणी नाम" फ़ील्ड में, चित्र का नाम सेट करें और "सहेजें" पर क्लिक करें।

कनवर्टर के परिणामस्वरूप, हमें एक्सटेंशन .c के साथ एक फ़ाइल मिलती है, जो चित्र और एन्कोडेड छवि के बारे में जानकारी संग्रहीत करेगी। इस फ़ाइल को आपकी परियोजना के फ़ोल्डर में रखा जाना चाहिए और प्रोग्राम में एक एक्सटर्नल स्पेसियर का उपयोग करके उसी तरह से घोषित किया जाना चाहिए जैसे हमने फोंट के लिए किया था। केवल वर्ग कोष्ठक में हेक्साडेसिमल प्रारूप में सरणी के आकार को इंगित करना आवश्यक है (यह मान सरणी के पहले तत्व में है, आप इसे किसी भी पाठ संपादक में परिणामी फ़ाइल को खोलकर देख सकते हैं)।
सरणी को कॉपी और कनेक्ट करने के बाद प्रोग्राम फ़ाइल को बंद करना और फिर से खोलना याद रखें। इस स्थिति में, सरणी फ़ाइल प्रोग्राम टैब के बगल में अगले टैब पर खुलेगी। हमारे कार्यक्रम का पाठ इस तरह दिखेगा:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; extern unsigned short background[0x9600]; void setup() { myGLCD.InitLCD(); myGLCD.setColor(0,255,0); myGLCD.setFont(BigFont); myGLCD.setBackColor(VGA_TRANSPARENT); } void loop() { myGLCD.drawBitmap (0,0, 240, 160, background,2); myGLCD.print("Hello, World!", CENTER,50); while(1); }

इस प्रकार, हम आउटपुट को एक पिक्चर के डिस्प्ले के ऊपरी बाएँ कोने में सेट करते हैं, जिसका नाम सरणी में रखा गया है जिसकी पृष्ठभूमि 240 से 160 पिक्सेल है, लेकिन जब से हमने स्केल पैरामीटर का उपयोग किया है, जो कि दो है, चित्र पूरे डिस्प्ले तक खिंच जाएगा। अगला, "VGA_TRANSPARENT" पैरामीटर का उपयोग करते हुए चित्र के शीर्ष पर, जो मुद्रण करते समय पृष्ठभूमि की "पारदर्शिता" प्रदान करता है, हम एक पाठ संदेश प्रदर्शित करते हैं। काफी बेकार - लगभग 100kb सिर्फ एक तस्वीर के लिए, लेकिन सुंदर;)

अतिरिक्त मापदंडों के साथ इस कमांड को कॉल करने का एक और रूप संभव है, जिससे आप किसी दिए गए कोण पर छवि को घुमा सकते हैं। इस मामले में तीन पैरामीटर होने चाहिए: deg - छवि rox के रोटेशन का कोण - रोटेशन के केंद्र का X निर्देशांक, रॉय - रोटेशन के केंद्र का Y- समन्वय। रोटेशन कोण डिग्री (0 से 359 तक) में निर्दिष्ट किया गया है, और रोटेशन रॉक्स और रॉय के केंद्र के निर्देशांक को चित्र के ऊपरी बाएं कोने से गिना जाता है। एक उदाहरण पर विचार करें। हम लाइब्रेरी के साथ आपूर्ति की गई इंफ़ॉर्मेशन फ़ाइल का उपयोग इमेज के रूप में करते हैं (यह लाइब्रेरी रूट फ़ोल्डर के / उदाहरण / Arduino (ARM) / UTFT_Bitmap सबफ़ोल्डर में स्थित है। तस्वीर का आकार 32x32 पिक्सेल है, सरणी का आकार 0x400 है। निम्नलिखित कार्यक्रम अपनी धुरी पर घूमते हुए एक चित्र प्रदर्शित करेगा:
 #include <UTFT.h> UTFT myGLCD(CTE32HR,25,26,27,28); extern uint8_t BigFont[]; extern unsigned short info[0x400]; void setup() { myGLCD.InitLCD(); myGLCD.fillScr(VGA_WHITE); } void loop() { for (int R=0; R<360; R+=10){ myGLCD.drawBitmap (100,100, 32, 32, info,R,16,16); } }

दुर्भाग्य से, एक ही समय में रोटेशन और स्केलिंग संभव नहीं है।

और अंत में, कुछ और कमांड:

lcdOff - प्रदर्शन बंद कर देता है। इसका कोई पैरामीटर नहीं है।

lcdOn - डिस्प्ले को चालू करता है। इसका कोई पैरामीटर नहीं है।

LcdOff () कमांड निष्पादित होने के बाद, डिस्प्ले बंद हो जाता है और जब तक lcdOn () कमांड निष्पादित नहीं होता है, तब तक किसी भी कमांड का जवाब नहीं देता है।
डेवलपर के अनुसार, ये दोनों टीमें केवल PCF8833 कंट्रोलर के साथ डिस्प्ले के लिए कार्यान्वित की जाती हैं, इसलिए उन्हें केवल हमारे डिस्प्ले पर अनदेखा किया जाता है।

setContrast - प्रदर्शन के विपरीत सेट करता है। पैरामीटर कंट्रास्ट की मात्रा है।
एक पैरामीटर के रूप में, एक सशर्त मूल्य परिभाषित किया गया है जो प्रदर्शन के विपरीत को निर्धारित करता है: 0 (न्यूनतम विपरीत) से 64 (अधिकतम विपरीत)।
यह आदेश केवल PCF8833 नियंत्रक के साथ प्रदर्शित करने के लिए भी लागू किया गया है, इसलिए हमारे प्रदर्शन पर कोई विपरीत परिवर्तन नहीं होगा और कमांड को अनदेखा किया जाएगा।

निष्कर्ष


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

Source: https://habr.com/ru/post/In196600/

More articles:


All Articles