👊🏼 ⛄️ 🌺 रजिस्टर पर एसटीसी 3 के माध्यम से एसईसीएम ... को रजिस्टरों पर लॉन्च करें 🕴🏾 🥗 🚟

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

आज मैं आपको बताएगा कि रजिस्टर (CMSIS) के साथ काम करने वाले LTDC मॉड्यूल को कैसे चलाना है। एचएएल और अन्य पुस्तकालय पसंद नहीं करते हैं और धार्मिक कारणों के लिए उपयोग नहीं करते हैं, लेकिन यह भी रुचि है। आप देखेंगे कि नियमित एसपीआई के रूप में रजिस्टरों पर जटिल बाह्य उपकरणों को उठाना सरल है। रुचि रखते हैं? तो फिर चलिए!

1. LTDC के बारे में थोड़ा

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

आउटपुट में, हमारे पास एक साधारण समानांतर बस है, जिसमें 24 बिट्स (RGB मॉडल के रंग प्रति 8 बिट्स), सिंक्रोनाइज़ेशन लाइन्स, ऑन / ऑफ लाइन और पिक्सेल घड़ी प्रदर्शित होती हैं। उत्तरार्द्ध, वास्तव में, एक घड़ी संकेत है जिसके द्वारा पिक्सल को डिस्प्ले में लोड किया जाता है, अर्थात, यदि हमारे पास 9.5 मेगाहर्ट्ज की आवृत्ति है, तो 1 सेकंड में हम 9.5 मिलियन पिक्सल लोड कर सकते हैं। यह सिद्धांत रूप में, निश्चित रूप से, समय और अन्य चीजों के कारण संख्या कुछ अधिक मामूली है।

LTDC के अधिक विस्तृत परिचय के लिए, मैं आपको कुछ दस्तावेज पढ़ने की सलाह देता हूं:

2. हमें क्या करने की ज़रूरत है?

एसटी माइक्रोकंट्रोलर्स ने अच्छे कारण के लिए लोकप्रियता हासिल की है, किसी भी इलेक्ट्रॉनिक घटकों के लिए सबसे महत्वपूर्ण आवश्यकता प्रलेखन है, और इसके साथ सब कुछ ठीक है। साइट निश्चित रूप से भयानक है, लेकिन मैं सभी दस्तावेजों के लिंक छोड़ दूंगा। निर्माता हमें साइकिल की पीड़ा और आविष्कार से बचाता है, इसलिए, संदर्भ पुस्तिका RM0385 में पृष्ठ 520 पर , काले और सफेद कदम दिए गए हैं, हमें क्या करने की आवश्यकता है:

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

LTDC क्लॉकिंग सक्षम करें
घड़ी प्रणाली और डेटा आउटपुट की आवृत्ति सेट करें (पिक्सेल घड़ी)
LTDC के साथ काम करने के लिए I / O पोर्ट (GPIO) कॉन्फ़िगर करें
हमारे प्रदर्शन मॉडल के लिए समय निर्धारित करें
~~संकेतों की ध्रुवता को समायोजित करें।~~ ~~पहले से ही डिफ़ॉल्ट रूप से किया गया~~
~~प्रदर्शन की पृष्ठभूमि का रंग निर्दिष्ट करें।~~ ~~हमने उसे अभी तक नहीं देखा, आप इसे "शून्य पर" छोड़ सकते हैं~~
एक विशिष्ट परत के लिए डिस्प्ले के दृश्य क्षेत्र का वास्तविक आकार निर्धारित करें
रंग प्रारूप चुनें: ARGB8888, RGB 888, RGB565, आदि।
उस सरणी के पते को निर्दिष्ट करें जो फ्रेम बफर के रूप में कार्य करेगा
एक पंक्ति में डेटा की मात्रा को इंगित करें (चौड़ाई में लंबाई)
लाइनों की संख्या इंगित करें (प्रदर्शन ऊंचाई)
उस परत को शामिल करें जिसके साथ हम काम कर रहे हैं
LTDC मॉड्यूल सक्षम करें

डरावना? और मैं डर गया था, लेकिन यह पूरी कार्यवाही के साथ 20 मिनट के लिए काम करने के लिए निकला। एक कार्य है, योजना की योजना है और इसे पूरा करने के लिए ही बनी हुई है।

3. घड़ी प्रणाली की स्थापना

पहला आइटम हमें LTDC मॉड्यूल को एक घड़ी संकेत भेजने की आवश्यकता है, यह आरसीसी रजिस्टर को लिखकर किया जाता है:

RCC->APB2ENR |= RCC_APB2ENR_LTDCEN;

अगला, आपको बाहरी क्वार्ट्ज (एचएसई) से घड़ी की आवृत्ति को 216 मेगाहर्ट्ज की आवृत्ति तक कॉन्फ़िगर करना होगा, अर्थात अधिकतम करने के लिए। पहला कदम क्वार्ट्ज गुंजयमान यंत्र से घड़ी के स्रोत को चालू करना और तैयार ध्वज की प्रतीक्षा करना है:

 RCC->CR |= RCC_CR_HSEON; while (!(RCC->CR & RCC_CR_HSERDY));

अब नियंत्रक फ्लैश मेमोरी के लिए देरी सेट करें, जैसा कि वह कोर फ्रिक्वेंसी पर काम करना नहीं जानती। इसका मूल्य, बाकी डेटा की तरह, संदर्भ मैनुअल से लिया गया है:

 FLASH->ACR |= FLASH_ACR_LATENCY_5WS;

अब, वांछित आवृत्ति प्राप्त करने के लिए, मैं इनपुट से 25 मेगाहर्ट्ज को 25 से विभाजित करूंगा और 1 मेगाहर्ट्ज प्राप्त करूंगा। अगला, पीएलएल I में 432 से गुणा करें, क्योंकि भविष्य में / 2 के न्यूनतम मूल्य के साथ एक आवृत्ति विभक्त होता है और आपको इसे दो बार आवृत्ति लागू करने की आवश्यकता होती है। उसके बाद, हम PLL इनपुट को हमारे क्वार्ट्ज गुंजयमान यंत्र (HSE) से जोड़ते हैं:

 RCC->PLLCFGR |= RCC_PLLCFGR_PLLM_0 | RCC_PLLCFGR_PLLM_3 | RCC_PLLCFGR_PLLM_4; RCC->PLLCFGR |= RCC_PLLCFGR_PLLN_4 | RCC_PLLCFGR_PLLN_5 | RCC_PLLCFGR_PLLN_7 | RCC_PLLCFGR_PLLN_8; RCC->PLLCFGR |= RCC_PLLCFGR_PLLSRC;

अब PLL को सक्षम करें और तैयार ध्वज की प्रतीक्षा करें:

 RCC->CR |= RCC_CR_PLLON; while((RCC->CR & RCC_CR_PLLRDY) == 0){}

हम अपने PLL के आउटपुट को सिस्टम फ़्रीक्वेंसी के स्रोत के रूप में निर्दिष्ट करते हैं और तैयार ध्वज की प्रतीक्षा करते हैं:

 RCC->CFGR |= RCC_CFGR_SW_PLL; while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_1) {}

यह सामान्य घड़ी सेटिंग को समाप्त करता है और हम अपने प्रदर्शन (पिक्सेल घड़ी) के लिए घड़ी की आवृत्ति (PLLSAI) की स्थापना के लिए आगे बढ़ते हैं। डेटशीट के अनुसार PLLSAI के लिए संकेत विभक्त / 25 के बाद लिया जाता है, अर्थात, इनपुट पर हमारे पास 1 मेगाहर्ट्ज है। हमें लगभग 9.5 मेगाहर्ट्ज की आवृत्ति प्राप्त करने की आवश्यकता है, इसके लिए हम 1 मेगाहर्ट्ज की आवृत्ति को 192 से गुणा करते हैं, और फिर 5 और 4 के दो डिवाइडर का उपयोग करके हम वांछित मान PLLSAI = 1 MHz * 192/5/4/ 9.6 MHz प्राप्त करते हैं:

 RCC->PLLSAICFGR |= RCC_PLLSAICFGR_PLLSAIN_6 | RCC_PLLSAICFGR_PLLSAIN_7; RCC->PLLSAICFGR |= RCC_PLLSAICFGR_PLLSAIR_0 | RCC_PLLSAICFGR_PLLSAIR_2; RCC->DCKCFGR1 |= RCC_DCKCFGR1_PLLSAIDIVR_0; RCC->DCKCFGR1 &= ~RCC_DCKCFGR1_PLLSAIDIVR_1;

अंतिम चरण के रूप में, हम PLLSAI को प्रदर्शन के लिए सक्षम करते हैं और तैयार-टू-वर्क फ्लैग की प्रतीक्षा करते हैं:

 RCC->CR |= RCC_CR_PLLSAION; while ((RCC->CR & RCC_CR_PLLSAIRDY) == 0) {}

यह घड़ी प्रणाली के मूल सेटअप को पूरा करता है, ताकि भूल न जाए और फिर पीड़ित न हो, चलो सभी इनपुट / आउटपुट पोर्ट (GPIO) पर क्लॉकिंग सक्षम करें। हमारे पास बैटरी पावर नहीं है, कम से कम डिबगिंग के लिए, इसलिए हम बचत नहीं करते हैं:

 RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOEEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOFEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOGEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOHEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOJEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOKEN;

4. I / O पोर्ट्स (GPIO) कॉन्फ़िगर करना

जीपीओ स्थापित करना बहुत सरल है - हमारे पास वैकल्पिक उत्पादन के रूप में और उच्च आवृत्ति पर कॉन्फ़िगर किए जाने वाले LTDC बस के सभी पैर हैं। ऐसा करने के लिए, पृष्ठ 201 पर संदर्भ पुस्तिका में हमारे पास यह टिप है:

तालिका इंगित करती है कि आवश्यक सेटिंग प्राप्त करने के लिए आपको किन रजिस्टरों में बिट सेट करने की आवश्यकता है। यह ध्यान देने योग्य है कि सभी ब्रेसिज़ अक्षम हैं। कहाँ देखने के लिए क्या वैकल्पिक समारोह में शामिल करने के लिए? और इसके लिए, हमारे नियंत्रक पर डेटाशीट में पृष्ठ 76 पर जाएं और निम्नलिखित तालिका देखें:

जैसा कि आप देख सकते हैं, तालिका का तर्क सरल है: हमें अपने फ़ंक्शन की आवश्यकता है, हमारे मामले में LTDC B0, तो हम देखते हैं कि यह किस GPIO पर है (PE4, उदाहरण के लिए) और शीर्ष पर हम उस विकल्प की संख्या देखते हैं जिसे हम कॉन्फ़िगर करने के लिए उपयोग करेंगे (हमारे साथ AF14)। वैकल्पिक आउटपुट, LTDC B0 के साथ पुश-आउटपुट के रूप में हमारे आउटपुट को कॉन्फ़िगर करने के लिए, हमें निम्नलिखित कोड लिखना होगा:

 GPIOE->MODER &= ~GPIO_MODER_MODER4; GPIOE->MODER |= GPIO_MODER_MODER4_1; GPIOE->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR4_1; GPIOE->AFR[0] &= ~GPIO_AFRL_AFRL4_0; GPIOE->AFR[0] |= GPIO_AFRL_AFRL4_1 | GPIO_AFRL_AFRL4_2 | GPIO_AFRL_AFRL4_3;

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

 GPIOK->MODER &= ~GPIO_MODER_MODER3; GPIOK->MODER |= GPIO_MODER_MODER3_0;

यह सेटिंग PK3 आउटपुट के लिए है, जो हमारी बैकलाइट को चालू और बंद करता है। वैसे, आप इसे सुचारू रूप से चमक को समायोजित करने के लिए पुश भी कर सकते हैं। PI12 के लिए, जिसमें एक डिस्प्ले (DISP) शामिल है, सब कुछ समान है। इन 2 पिनों पर गति डिफ़ॉल्ट रूप से कम है, क्योंकि उनसे कुछ उच्च-आवृत्ति क्रियाओं की आवश्यकता नहीं होती है।

आप डिबग बोर्ड के सर्किट बोर्ड पर, या अपने स्वयं के डिवाइस के सर्किट आरेख पर अन्य सभी I / O बंदरगाहों को देख सकते हैं।

5. समय और उनकी सेटिंग्स

एक भौतिक दृष्टिकोण से समय सामान्य देरी है। मुझे लगता है कि आपने बार-बार देरी (1) प्रकार के विभिन्न विकृतियों का अवलोकन किया है जब आप ILI9341 के समान SPI / I2C नियंत्रकों के साथ प्रदर्शित कोड उदाहरणों को देखते थे। वहां, एक देरी की आवश्यकता है ताकि नियंत्रक, उदाहरण के लिए, कमांड को स्वीकार करने, उसे निष्पादित करने और फिर डेटा के साथ कुछ करने का समय हो। LTDC के मामले में, सब कुछ उसी के बारे में है, केवल हम बैसाखी नहीं बनाएंगे और क्यों नहीं - हमारे माइक्रोकंट्रोलर स्वयं हार्डवेयर में आवश्यक समय को कॉन्फ़िगर करने में सक्षम हैं। उन्हें ऐसे डिस्प्ले की आवश्यकता क्यों है जहां कोई नियंत्रक नहीं है? हां, यह प्राथमिक है कि पिक्सल की पहली पंक्ति को भरने के बाद, अगली पंक्ति पर जाएं और अपनी शुरुआत में वापस लौटें। यह डिस्प्ले के उत्पादन की तकनीक के कारण है, और इसलिए प्रत्येक विशिष्ट डिस्प्ले मॉडल का अपना समय है।

हमें किन मूल्यों की आवश्यकता है, यह जानने के लिए, एसटी वेबसाइट पर जाएं और एसटीएम 32 एफ 746-डिस्को डिबग बोर्ड के आरेख को देखें । वहां हम देख सकते हैं कि डिस्प्ले RK043FN48H-CT672B है और इसके लिए प्रलेखन उपलब्ध है, उदाहरण के लिए, यहाँ । हम खंड 13.३.१ में पृष्ठ १३ पर सबसे अधिक रुचि रखते हैं:

ये हमारे मूल्य हैं जिन्हें हमें स्थापित करते समय आवश्यकता होगी। प्रलेखन में भी बहुत कुछ है जो दिलचस्प है, उदाहरण के लिए, बस और इतने पर सिग्नल आरेख, जिसे आपको आवश्यकता हो सकती है, उदाहरण के लिए, आप प्रदर्शन को FPGA या CPLD में उठाना चाहते हैं।

सेटिंग्स पर जाएं। सबसे पहले, इन मूल्यों को मेरे सिर में नहीं रखने के लिए, मैं उन्हें परिभाषित के रूप में व्यवस्थित करूंगा:

 #define DISPLAY_HSYNC ((uint16_t)30) #define DISPLAY_HBP ((uint16_t)13) #define DISPLAY_HFP ((uint16_t)32) #define DISPLAY_VSYNC ((uint16_t)10) #define DISPLAY_VBP ((uint16_t)2) #define DISPLAY_VFP ((uint16_t)2)

एक दिलचस्प विशेषता है। टाइमिंग पल्स चौड़ाई , जिसे DISPLAY_HSYNC कहा जाता है, केवल 5 MHz की पिक्सेल घड़ी आवृत्ति के लिए तालिका में एक मान है, लेकिन 9 और 12 MHz के लिए यह नहीं है। आपके प्रदर्शन के लिए इस समय का चयन करने की आवश्यकता है, मुझे 30 का यह मान मिला, जब एसटी के उदाहरणों में यह अलग था। पहली शुरुआत में, यदि आपको इसकी सेटिंग में कोई त्रुटि है, तो छवि को बाईं ओर या दाईं ओर स्थानांतरित कर दिया जाएगा। यदि यह दाईं ओर है, तो हम समय घटाते हैं; यदि बाईं ओर, हम इसे बढ़ाते हैं। वास्तव में, यह दृश्य क्षेत्र की उत्पत्ति को प्रभावित करता है, जिसे हम बाद में देखेंगे। बस ध्यान रखें, और हमारे AN4861 के पेज 24 से निम्न चित्र इस पूरे पैराग्राफ को समझने में मदद करेगा:

एक छोटा अमूर्त यहाँ सुविधाजनक है। हमारे पास 2 डिस्प्ले जोन हैं: दृश्यमान और सामान्य। दृश्य क्षेत्र में 272 पिक्सेल के 480 के घोषित रिज़ॉल्यूशन के साथ आयाम हैं, और कुल क्षेत्र दृश्यमान + हमारी समयावधि है, जिनमें से प्रत्येक पर 3 हैं। यह समझने के लिए भी सार्थक है (यह अब अमूर्त नहीं है) कि एक सिस्टम टिक 1 पिक्सेल है, इसलिए कुल क्षेत्रफल 480 पिक्सेल + HSYNC + HBP + HFP है।

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

समय निर्धारित करने के लिए, मैंने प्रोजेक्ट के अंदर भविष्य के लिए खुद को एक छोटी सी "चीट शीट" बना लिया है, यह आपको यह समझने में भी मदद करेगा कि यह क्या विशिष्ट है और इसे कहाँ लिखना है:

 /* *************************** Timings for TFT display********************************** * * HSW = (DISPLAY_HSYNC - 1) * VSH = (DISPLAY_VSYNC - 1) * AHBP = (DISPLAY_HSYNC + DISPLAY_HBP - 1) * AVBP = (DISPLAY_VSYNC + DISPLAY_VBP - 1) * AAW = (DISPLAY_HEIGHT + DISPLAY_VSYNC + DISPLAY_VBP - 1) * AAH = (DISPLAY_WIDTH + DISPLAY_HSYNC + DISPLAY_HBP - 1) * TOTALW = (DISPLAY_HEIGHT + DISPLAY_VSYNC + DISPLAY_VBP + DISPLAY_VFP - 1) * TOTALH = (DISPLAY_WIDTH + DISPLAY_HSYNC + DISPLAY_HBP + DISPLAY_HFP - 1) * */

यह "चीट शीट" कहां से आया ... सबसे पहले, आपने एक समान "सूत्र" पहले पैराग्राफ के एक जोड़े को देखा था। दूसरे, हमारे AN4861 के पेज 56 पर जाएं:

यह सच है, मुझे आशा है कि आपने इस चीट शीट के आने से पहले समय का भौतिक अर्थ समझ लिया है और मुझे यकीन है कि आप स्वयं इसे संकलित कर सकते हैं। इसमें कुछ भी जटिल नहीं है, और आरएम और एएन की तस्वीरें नेत्रहीन रूप से छवि निर्माण प्रक्रिया पर समय के प्रभाव को समझने में मदद करती हैं।

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

 LTDC->SSCR |= ((DISPLAY_HSYNC - 1) << 16 | (DISPLAY_VSYNC - 1)); LTDC->BPCR |= ((DISPLAY_HSYNC+DISPLAY_HBP-1) << 16 | (DISPLAY_VSYNC+DISPLAY_VBP-1)); LTDC->AWCR |= ((DISPLAY_WIDTH + DISPLAY_HSYNC + DISPLAY_HBP - 1) << 16 | (DISPLAY_HEIGHT + DISPLAY_VSYNC + DISPLAY_VBP - 1)); LTDC->TWCR |= ((DISPLAY_WIDTH + DISPLAY_HSYNC + DISPLAY_HBP + DISPLAY_HFP -1)<< 16 |(DISPLAY_HEIGHT + DISPLAY_VSYNC + DISPLAY_VBP + DISPLAY_VFP - 1));

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

 LTDC->BCCR = 0;

संदर्भ पुस्तिका में एक अद्भुत चित्रण है जो स्पष्ट रूप से दर्शाता है कि हमारे पास वास्तव में 3 परतें हैं: पृष्ठभूमि, परत 1 और परत 2। पृष्ठभूमि परत "कास्टेड" है और इसे केवल एक विशिष्ट रंग से भरा जा सकता है, लेकिन यह अविश्वसनीय रूप से उपयोगी भी हो सकता है। भविष्य जीयूआई डिजाइन। इसके अलावा, यह चित्रण स्पष्ट रूप से परतों की प्राथमिकता को दर्शाता है, जिसका अर्थ है कि हम पृष्ठभूमि पर रंग तभी देखेंगे जब शेष परतें या तो खाली या पारदर्शी होंगी।

एक उदाहरण के रूप में, मैं परियोजना के पृष्ठों में से एक दिखाऊंगा, जहां टेम्पलेट के कार्यान्वयन के दौरान पृष्ठभूमि एक रंग से भर गई थी और नियंत्रक ने पूरे पृष्ठ को फिर से नहीं बनाया, लेकिन केवल व्यक्तिगत क्षेत्र, जो कई अन्य कार्यों के लिए लगभग 50-60 एफपीएस प्राप्त करने की अनुमति देता है।

6. LTDC सेटअप का अंतिम भाग

LTDC सेटिंग्स को 2 खंडों में विभाजित किया गया है: पहले पूरे LTDC मॉड्यूल के लिए आम हैं और LTDC रजिस्टर समूह में स्थित हैं, और दूसरा दो परतों में से एक में कॉन्फ़िगर किया गया है और LTDC_Layer1 और LTDC_Layer2 समूह में हैं ।

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

 LTDC_Layer2->WHPCR |= (((DISPLAY_WIDTH + DISPLAY_HBP + DISPLAY_HSYNC - 1) << 16) | (DISPLAY_HBP + DISPLAY_HSYNC)); LTDC_Layer2->WVPCR |= (((DISPLAY_HEIGHT + DISPLAY_VSYNC + DISPLAY_VBP - 1) << 16) |(DISPLAY_VSYNC + DISPLAY_VBP));

जैसा कि आप देख सकते हैं, सब कुछ समय के साथ जैसा है। दृश्य क्षेत्र के शुरुआती बिंदु (x0, y0) में दो समय का योग होता है: HSYNC + HBP और VSYNC + VBP। समापन बिंदु (X1, y1) के निर्देशांक की गणना करने के लिए, पिक्सेल में चौड़ाई और ऊंचाई को केवल मूल्य डेटा में जोड़ा जाता है।

अब आपको प्राप्त डेटा के प्रारूप को कॉन्फ़िगर करने की आवश्यकता है। ARGB8888 प्रारूप का उपयोग करते समय अधिकतम गुणवत्ता प्राप्त की जाती है, लेकिन एक ही समय में हमें कब्जे वाली मेमोरी की अधिकतम मात्रा मिलती है। एक पिक्सेल में 32 बिट्स या 4 बाइट्स होती हैं, जिसका मतलब है कि पूरी स्क्रीन 4 * 480 * 272 = 522,240 बाइट्स लेती है, यानी हमारी सबसे कमजोर कंट्रोलर की आधी फ्लैश मेमोरी। डरो मत - क्यूएसपीआई के माध्यम से बाहरी एसडीआरएएम और फ्लैश-मेमोरी को जोड़ना स्मृति समस्याओं को हल करता है और इस प्रारूप पर कोई प्रतिबंध नहीं है, हम अच्छी गुणवत्ता में आनन्दित होते हैं। यदि आप स्थान बचाना चाहते हैं या आपका प्रदर्शन 24-बिट प्रारूप का समर्थन नहीं करता है, तो इसके लिए अधिक उपयुक्त मॉडल का उपयोग किया जाता है, उदाहरण के लिए, RGB565। डिस्प्ले और कैमरा दोनों के लिए एक बहुत लोकप्रिय प्रारूप, और सबसे महत्वपूर्ण बात यह है कि इसका उपयोग करते समय, 1 पिक्सेल केवल 5 + 6 + 5 = 16 बिट्स या 2 बाइट्स लेता है। तदनुसार, परत द्वारा कब्जा की गई मेमोरी की मात्रा 2 गुना कम होगी। डिफ़ॉल्ट रूप से, नियंत्रक के पास पहले से ही ARGB8888 प्रारूप कॉन्फ़िगर किया गया है और इस तरह दिखता है:

 LTDC_Layer2->PFCR = 0;

यदि आपको ARGB8888 से भिन्न प्रारूप की आवश्यकता है, तो संदर्भ मैनुअल में पेज 533 और 534 पर जाएं और नीचे दी गई सूची से वांछित प्रारूप चुनें:

अब एक सरणी बनाएं और उसका पता LTDC को दें, यह एक फ्रेम बफर में बदल जाएगा और हमारी परत का "प्रतिबिंब" होगा। उदाहरण के लिए, आपको पहली पंक्ति में 1 पिक्सेल को सफेद रंग से भरना होगा, इसके लिए आपको इस सरणी के पहले तत्व को केवल रंग मान (0xFFFFFFFF) लिखना होगा। दूसरी पंक्ति में पहली पिक्सेल भरने की आवश्यकता है? फिर हम संख्या (480 + 1) के साथ तत्व में रंग मूल्य भी लिखते हैं। 480 - एक पंक्ति विराम बनाओ, फिर उस पंक्ति में संख्या जोड़ो जिसकी हमें ज़रूरत है।

यह सेटिंग इस तरह दिखती है:

 #define DISPLAY_WIDTH ((uint16_t)480) #define DISPLAY_HEIGHT ((uint16_t)272) const uint32_t imageLayer2[DISPLAY_WIDTH * DISPLAY_HEIGHT]; LTDC_Layer2->CFBAR = (uint32_t)imageLayer2;

एक अच्छे तरीके से, LTDC को कॉन्फ़िगर करने के बाद, आपको const modifier को हटाने और RAM में फ्रेम बफर प्राप्त करने के लिए SDRAM को कॉन्फ़िगर करने की भी आवश्यकता है, क्योंकि एमके की अपनी रैम 4 बाइट वाली एक परत के लिए भी पर्याप्त नहीं है। हालांकि यह परिधीय के सही विन्यास का परीक्षण करने के लिए चोट नहीं करता है।

अगला, आपको अल्फा लेयर के मान को निर्दिष्ट करने की आवश्यकता है, अर्थात, हमारी लेयर 2 परत के लिए पारदर्शिता, इसके लिए हम 0 से 255 तक का मान लिखते हैं, जहाँ 0 पूरी तरह से पारदर्शी परत है, 255 पूरी तरह से अपारदर्शी है, जो 100% दृश्यमान है।

 LTDC_Layer2->CACR = 255;

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

 LTDC_Layer2->CFBLR |= (((PIXEL_SIZE * DISPLAY_WIDTH) << 16) | (PIXEL_SIZE * DISPLAY_WIDTH + 3)); LTDC_Layer2->CFBLNR |= DISPLAY_HEIGHT;

अंतिम दो चरण बने हुए हैं, अर्थात् परत 2 का समावेश और लि। परिधीय मॉड्यूल। ऐसा करने के लिए, संबंधित बिट्स लिखें:

 LTDC_Layer2->CR |= LTDC_LxCR_LEN; LTDC->GCR |= LTDC_GCR_LTDCEN;

यह हमारे मॉड्यूल के कॉन्फ़िगरेशन को पूरा करता है और आप हमारे डिस्प्ले के साथ काम कर सकते हैं!

7. LTDC के साथ काम करने के बारे में थोड़ा

डिस्प्ले के साथ सभी काम अब केवल इमेजलेयर 2 सरणी में डेटा लिखने के लिए नीचे आते हैं, इसका आकार 272 तत्वों द्वारा 480 है, जो पूरी तरह से हमारे संकल्प से मेल खाता है और प्रदर्शन पर एक सरल सत्य - 1 सरणी तत्व = 1 पिक्सेल ।

एक उदाहरण के रूप में, मैंने एक चित्र को एक सरणी में लिखा था जिसे मैंने एलसीडी छवि कनवर्टर में बदल दिया था, लेकिन वास्तव में इसकी संभावना नहीं है कि आपके कार्य इस तक सीमित होंगे। दो तरीके हैं: एक तैयार किए गए जीयूआई का उपयोग करना और इसे स्वयं लिखना। अपेक्षाकृत सरल कार्यों जैसे कि टेक्स्ट आउटपुट, ग्राफिंग और इसी तरह, मैं आपको अपना खुद का GUI लिखने की सलाह देता हूं, इसमें थोड़ा समय लगेगा और आपको इसके संचालन की पूरी समझ होगी। जब कार्य बड़ा और कठिन होता है, और अपना स्वयं का GUI विकसित करने का समय नहीं होता है, तो मैं आपको सलाह देता हूं कि आप तैयार किए गए समाधानों पर ध्यान दें, उदाहरण के लिए, uGFX और इस तरह।

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

 typedef enum ColorDisplay { RED = 0xFFFF0000, GREEN = 0xFF00FF00, BLUE = 0xFF0000FF, BLACK = 0xFF000000, WHITE = 0xFFFFFFFF } Color; void SetPixel (uint16_t setX, uint16_t setY, Color Color) { uint32_t numBuffer = ((setY - 1) * DISPLAY_WIDTH) + setX; imageLayer2[numBuffer] = Color; }

जब हम निर्देशांक को एक फ़ंक्शन में लेते हैं, तो हम उन्हें उस सरणी की संख्या में पुनर्गणना करते हैं जो दिए गए निर्देशांक से मेल खाती है और फिर प्राप्त तत्व को प्राप्त रंग लिखें। इस फ़ंक्शन के आधार पर, आप पहले से ही ज्यामिति, पाठ और अन्य जीयूआई "उपहार" प्रदर्शित करने के लिए कार्यों को लागू कर सकते हैं। मुझे लगता है कि विचार समझ में आता है, लेकिन इसे जीवन में कैसे लाया जाए यह आपके विवेक पर है।

परिणाम

जैसा कि आप देख सकते हैं, रजिस्टरों (सीएमएसआईएस) पर भी जटिल बाह्य उपकरणों का कार्यान्वयन एक मुश्किल काम नहीं है, आपको बस यह समझने की आवश्यकता है कि यह अंदर कैसे काम करता है। बेशक, यह समझने के बिना फर्मवेयर विकसित करने के लिए अब फैशनेबल है कि क्या हो रहा है, लेकिन यह एक मृत अंत है यदि आप एक इंजीनियर बनने की योजना बनाते हैं, न कि ...

यदि आप HAL या SPL में समाधान के साथ परिणामी कोड की तुलना करते हैं, तो आप देखेंगे कि रजिस्टरों में लिखा कोड अधिक कॉम्पैक्ट है। उन टिप्पणियों में से कुछ जोड़े जहां आपको इसकी आवश्यकता है और इसे फ़ंक्शन में लपेटकर, हमें कम से कम HAL / SPL के रूप में अच्छी तरह से पठनीयता मिलती है, और यदि आपको याद है कि संदर्भ मैनुअल दस्तावेज़ पंजीकृत हैं, तो CMSIS का उपयोग करना अधिक सुविधाजनक है।

1) TrueSTUDIO में स्रोतों के साथ परियोजना यहां डाउनलोड की जा सकती है

2) उन लोगों के लिए जो GitHub को देखने में अधिक सहज हैं

3) यहाँ एलसीडी इमेज कन्वर्टर कोड में छवियों को परिवर्तित करने के लिए उपयोगिता डाउनलोड करें

रजिस्टर पर एसटीसी 3 के माध्यम से एसईसीएम ... को रजिस्टरों पर लॉन्च करें