🐅 👩🏿‍🏫 📲 SSD1283A पर STM32 के साथ ट्रांसफ़्लेक्टिव TFT डिस्प्ले लॉन्च करें 🥗 🐌 🚿

परिचय

डिस्प्ले मॉडल को H016IT01 कहा जाता है। यह प्रदर्शन मुख्य रूप से दिलचस्प है क्योंकि यह ट्रांसफ़लेक्टिव है। इसका मतलब है कि उज्ज्वल सूरज के नीचे भी उस पर छवि दिखाई देनी चाहिए। और यह भी प्रसिद्ध चीनी साइट पर इस सुविधा के साथ लगभग एकमात्र उपलब्ध मॉडल है।

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

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

डिस्प्ले में 8 पिन हैं:

1) जीएनडी
2) वीसीसी - 5 या 3.3 वी
3) सीएस - एसपीआई चिप का चयन करें
4) RST - "0" - प्रदर्शन को बंद कर देता है, "1" - चालू करता है।
5) A0 / DC - डेटा कमांड ("0" - कमांड, "1" - डेटा)
6) एसडीए - एसपीआई मोसी
7) एससीके - एसपीआई एससीके
8) एलईडी - बैकलाइट आउटपुट, वीसीसी की तरह, 3.3 से 5 वी तक

आपको SPI का उपयोग करके डिस्प्ले को प्रोग्राम करने की आवश्यकता है, stm32f407 पर डिस्कवरी बोर्ड मुझे इसमें मदद करेगा।

एसपीआई

हालांकि मैंने SPI के माध्यम से SSD1283A के साथ बातचीत की, यह ध्यान देने योग्य है कि नियंत्रक एक समानांतर इंटरफ़ेस भी प्रदान करता है, लेकिन यह डिस्प्ले मॉडल इसका समर्थन नहीं करता है। उनका एसपीआई भी साधारण नहीं है, इसमें केवल एक एसडीए डेटा लाइन है। वास्तव में, यह MOSI लाइन है, जिसका अर्थ है कि हम प्रदर्शन से कुछ भी नहीं गिन सकते हैं, जो डेटाशीट हमें बता रही है।

पहले हम SPI को कॉन्फ़िगर करेंगे, इसके लिए हम SPI1 और GPIO पर हमला करेंगे, SDA और SCK के पैरों को एक वैकल्पिक फ़ंक्शन के रूप में कॉन्फ़िगर करें (मैंने MISO भी किया था, लेकिन यह आवश्यक नहीं है)। ऑपरेटिंग मोड को एक यूनिडायरेक्शनल ट्रांसमीटर मास्टर के रूप में कॉन्फ़िगर किया गया है।

BIT_BAND_PER(RCC->AHB1ENR ,RCC_AHB1ENR_GPIOAEN) = true; if(SPI_NUM::_1 == spi) { /*!<-------------Enable spi clocking--------------->!*/ BIT_BAND_PER(RCC->APB2ENR, RCC_APB2ENR_SPI1EN) = true; /*!<----PA5 - SCK, PA6 - MISO, PA7 - MOSI---->!*/ GPIOA->MODER |= (GPIO_MODER_MODE5_1 | GPIO_MODER_MODE6_1 | GPIO_MODER_MODE7_1); GPIOA->OSPEEDR |= (GPIO_OSPEEDR_OSPEED5_1 | GPIO_OSPEEDR_OSPEED7_1); GPIOA->AFR[0] |= (GPIO_AFRL_AFSEL5_0 | GPIO_AFRL_AFSEL5_2 | GPIO_AFRL_AFSEL6_0 | GPIO_AFRL_AFSEL6_2 | GPIO_AFRL_AFSEL7_0 | GPIO_AFRL_AFSEL7_2); /*!<-----customize SPI------>!*/ SPI1->CR1 |= (SPI_CR1_BIDIMODE | SPI_CR1_BIDIOE | SPI_CR1_SSM | SPI_CR1_SSI /*| SPI_CR1_DFF*/ | SPI_CR1_MSTR); BIT_BAND_PER(SPI1->CR1 ,SPI_CR1_SPE) = true; }

फिर हम SPI द्वारा एक साधारण बाइट ट्रांसफर फ़ंक्शन लिखते हैं:

 void stm32f407_spi::stm32f407_spi_send(uint8_t data) { SPI1->DR = data; while((SPI1->SR & SPI_SR_BSY)) continue; }

एसपीआई के लिए यह उस मोड में काम करने के लिए पर्याप्त है जिसे हमें उच्चतम संभव गति से डेटा की आवश्यकता और संचारित करना है।

प्रारंभिक प्रदर्शन

अब प्रदर्शन को इनिशियलाइज़ करने का समय है। ऐसा करने के लिए, कमांड्स का एक निश्चित क्रम भेजें। एक कमांड में 3 बाइट्स होते हैं, जहां एक बाइट कमांड नंबर होता है, और अन्य दो डेटा होते हैं। आपको कमांड ए बाइट को "0" पर भेजते समय पिन ए 0 को स्विच करना होगा, और डेटा के लिए "1" करना होगा। सुविधा के लिए, मैंने डिस्प्ले के RST, A0 और CS पिन की स्थिति को स्विच करने के लिए इनलाइन फ़ंक्शन किए।

 enum class DC : uint8_t { COMMAND, DATA }; #pragma inline=forced inline void tft_lcd_rst(bool rst) {BIT_BAND_PER(GPIOA->ODR , GPIO_ODR_OD2) = rst;} #pragma inline=forced inline void tft_lcd_dc(DC dc) {BIT_BAND_PER(GPIOA->ODR , GPIO_ODR_OD3) = static_cast<bool>(dc);} #pragma inline=forced inline void tft_lcd_cs(bool cs) {BIT_BAND_PER(GPIOA->ODR , GPIO_ODR_OD4) = cs;}

फिर कमांड लाइन इस तरह दिखाई देगी:

 void tft_lcd::tft_lcd_send(uint8_t addr, uint16_t data) { this->tft_lcd_dc(DC::COMMAND); stm32f407_spi_send(addr); this->tft_lcd_dc(DC::DATA); stm32f407_spi_send(static_cast<uint8_t>(data >> 8)); stm32f407_spi_send(static_cast<uint8_t>(data)); }

आरंभ करने के लिए, आपको कमांड के निम्नलिखित अनुक्रम को प्रस्तुत करना होगा, जिसे मैंने इस स्क्रीन के लिए arduino पुस्तकालयों में जासूसी की है:

प्रारंभिक कमांड

 static constexpr uint8_t TFT_DELAY = 0xFF; static constexpr t_tft_regs tft_regs[]= { { 0x10, 0x2F8E }, { 0x11, 0x000C }, { 0x07, 0x0021 }, { 0x28, 0x0006 }, { 0x28, 0x0005 }, { 0x27, 0x057F }, { 0x29, 0x89A1 }, { 0x00, 0x0001 }, { TFT_DELAY, 100 }, { 0x29, 0x80B0 }, { TFT_DELAY, 30 }, { 0x29, 0xFFFE }, { 0x07, 0x0223 }, { TFT_DELAY, 30 }, { 0x07, 0x0233 }, { 0x01, 0x2183 }, { 0x03, 0x6830 }, { 0x2F, 0xFFFF }, { 0x2C, 0x8000 }, { 0x27, 0x0570 }, { 0x02, 0x0300 }, { 0x0B, 0x580C }, { 0x12, 0x0609 }, { 0x13, 0x3100 }, };

जहां TFT_DELAY का मतलब है साधारण नींद निर्दिष्ट राशि। यदि आप डेटाशीट में तल्लीन हो जाते हैं, तो कुछ पते के लिए ऐसा डेटा अजीब लगेगा, क्योंकि कई पते आरक्षित बिट्स को लिखते हैं।

सीएस को "0" शुरू करने के लिए, डिस्प्ले (पिन RST) को रिबूट करें, और कमांड्स टेबल के माध्यम से जाएं।

  tft_lcd_rst(false); delay(5, mS); tft_lcd_rst(true); delay(200, mS); this->tft_lcd_cs(false); delay(5, mS); /*!<--------Init display---------->!*/ for(uint8_t i = 0; i < sizeof(tft_regs)/sizeof(tft_regs[0]) ;i++) { (TFT_DELAY != tft_regs[i].address) ? (this->tft_lcd_send(tft_regs[i].address, tft_regs[i].value)): (delay(tft_regs[i].value, mS)); } delay(5, mS); this->tft_lcd_cs(true);

उसके बाद, छवि को छवि को सफेद से ग्रे रंग टेलीविजन हस्तक्षेप में बदलना चाहिए।

एक आयत बनाएँ

SSD1283A नियंत्रक आपको आयतों के साथ चित्र बनाने की अनुमति देता है, जिसके लिए 4 कमांड का उपयोग किया जाता है। 0x44 कमांड में क्रमशः उच्च और निम्न डेटा बाइट में abscissa अक्ष के साथ अंत और आयत की शुरुआत का समन्वय होता है। ऑर्डिनेट अक्ष के लिए 0x45 कमांड समान है। 0x21 कमांड में प्रारंभिक रेंडरिंग का समन्वय होता है, उच्च बाइट में y के लिए, एक्स के लिए कम बाइट में। 0x22 कमांड में वर्तमान पिक्सेल के लिए रंग है। इसका मतलब है कि इसे वर्तमान आयत के प्रत्येक पिक्सेल के लिए दोहराया जाना चाहिए। डिस्प्ले में एक विशेषता भी होती है, हालांकि इसमें 130x130 का रिज़ॉल्यूशन होता है, इसके वर्चुअल कोऑर्डिनेट ग्रिड में 132x132 के आयाम हैं, और निर्देशांक बिंदु 2x2 से गिनना शुरू करते हैं।

इस प्रकार, यदि, उदाहरण के लिए, हम 20 से 20 तक एक काले वर्ग को आकर्षित करना चाहते हैं, जिसका प्रारंभिक बिंदु स्थिति (30, 45) पर है, तो हमें निम्नलिखित अनुक्रमों को प्रसारित करने की आवश्यकता है:

0x44 0x3320 (30 + 20 + 2-1, 30 + 2)
0x45 0x422F (45 + 20 + 2-1, 45 + 2)
0x21 0x2F20
0x22 0x0000, और इस आदेश को 400 (20 * 20) बार प्रसारित किया जाना चाहिए।

तब आयत ड्रा फ़ंक्शन इस तरह दिखाई देगा (बशर्ते कि निर्देशांक 2 से पहले ही स्थानांतरित हो चुके हों):

 void tft_lcd::draw_rect(const t_rect& rec) { this->tft_lcd_send(0x44, ((rec.x1 - 1) << 8) | rec.x0); this->tft_lcd_send(0x45, ((rec.y1 - 1) << 8) | rec.y0); this->tft_lcd_send(0x21, (rec.y0 << 8) | rec.x0); for(uint16_t i = 0; i < ((rec.x1 - rec.x0) * (rec.y1 - rec.y0)); i++) { this->tft_lcd_send(0x22, rec.col); } }

एक आयत बनाने के लिए, बस इसके कोनों और रंग के निर्देशांक निर्दिष्ट करें। पूरी स्क्रीन को गुलाबी रंग से भरने का एक उदाहरण इस प्रकार होगा:

 t_rect rect = {0x02, 0x02, 0x84, 0x84, static_cast<uint16_t>(COLOUR::MAGENTA)}; this->draw_rect(rect);

परिणाम:

अक्षरों और संख्याओं को ड्रा करें

पात्रों के लिए निर्देशांक के साथ सरणियों की एक सूची बनाएं।

अक्षरों और संख्याओं के निर्देशांक की सारणियाँ

 namespace rect_coord_lit { const t_rect_coord comma[] = {{0, 20, 5, 25}, {3, 25, 5, 28}}; const t_rect_coord dot[] = {{0, 20, 5, 25}}; const t_rect_coord space[] = {{0, 0, 0, 0}}; const t_rect_coord _0[] = {{0, 0, 15, 5},{0, 5, 5, 25},{5, 20, 15, 25},{10, 5, 15, 20}}; const t_rect_coord _1[] = {{10, 0, 15, 25}}; const t_rect_coord _2[] = {{0, 0, 15, 5},{10, 5, 15, 15},{0, 10, 10, 15},{0, 15, 5, 25},{5, 20, 15, 25}}; const t_rect_coord _3[] = {{0, 0, 15, 5},{10, 5, 15, 25},{0, 10, 10, 15},{0, 20, 10, 25}}; const t_rect_coord _4[] = {{0, 0, 5, 15},{5, 10, 10, 15},{10, 0, 15, 25}}; const t_rect_coord _5[] = {{0, 0, 15, 5},{0, 5, 5, 15},{0, 10, 15, 15},{10, 15, 15, 25},{0, 20, 10, 25}}; const t_rect_coord _6[] = {{0, 0, 15, 5},{0, 5, 5, 25},{5, 10, 10, 15},{5, 20, 10, 25},{10, 10, 15, 25}}; const t_rect_coord _7[] = {{0, 0, 15, 5},{10, 5, 15, 25}}; const t_rect_coord _8[] = {{0, 0, 15, 5},{0, 5, 5, 25},{5, 20, 15, 25},{10, 5, 15, 20},{5, 10, 10, 15}}; const t_rect_coord _9[] = {{0, 0, 15, 5},{0, 5, 5, 15},{0, 20, 15, 25},{10, 5, 15, 20},{5, 10, 10, 15}}; const t_rect_coord a[] = {{0, 10, 5, 25},{5, 5, 10, 10},{5, 15, 10, 20},{10, 10, 15, 25}}; const t_rect_coord b[] = {{0, 0, 5, 25},{5, 10, 15, 15},{10, 15, 15, 20},{5, 20, 15, 25}}; const t_rect_coord c[] = {{0, 5, 15, 10},{0, 10, 5, 20},{0, 20, 15, 25}}; const t_rect_coord d[] = {{0, 10, 10, 15},{0, 15, 5, 20},{0, 20, 10, 25}, {10, 0, 15, 25}}; const t_rect_coord e[] = {{0, 5, 15, 8}, {0, 12, 15, 15}, {0, 8, 5, 25}, {10, 8, 15, 12}, {5, 20, 15, 25}}; const t_rect_coord f[] = {{5, 5, 10, 25},{5, 0, 15, 5},{0, 10, 15, 15}}; const t_rect_coord g[] = {{0, 5, 5, 20}, {5, 5, 10, 10}, {5, 15, 10, 20}, {10, 5, 15, 30}, {0, 25, 10, 30}}; const t_rect_coord h[] = {{0, 0, 5, 25},{5, 10, 15, 15},{10, 15, 15, 25}}; const t_rect_coord i[] = {{5, 3, 10, 8},{5, 10, 10, 25}}; const t_rect_coord j[] = {{5, 3, 10, 8},{5, 10, 10, 30}, {0, 25, 5, 30}}; const t_rect_coord k[] = {{0, 0, 5, 25},{5, 15, 10, 20}, {10, 10, 15, 15}, {10, 20 , 15, 25}}; const t_rect_coord l[] = {{5, 0, 10, 25}}; const t_rect_coord m[] = {{0, 10, 4, 25},{7, 10, 10, 25}, {13, 10, 17,25}, {0, 5 , 12, 10}}; const t_rect_coord n[] = {{0, 10, 5, 25},{10, 10, 15, 25}, {0, 5 , 10, 10}}; const t_rect_coord o[] = {{0, 5, 5, 25}, {10, 5, 15, 25}, {5, 5, 10, 10}, {5, 20, 10, 25}}; const t_rect_coord p[] = {{0, 5, 5, 30}, {5, 5, 15, 10}, {5, 15, 15, 20}, {10, 10, 15, 15}}; const t_rect_coord q[] = {{0, 5, 5, 20}, {5, 5, 15, 10}, {5, 15, 15, 20}, {10, 10, 15, 30}}; const t_rect_coord r[] = {{0, 10, 5, 25},{5, 5, 15, 10}}; const t_rect_coord s[] = {{3, 5, 15, 10}, {0, 8, 5, 13}, {3, 13, 12, 17}, {10, 17, 15, 22}, {0, 20, 12, 25}}; const t_rect_coord t[] = {{5, 0, 10, 25},{0, 5, 15, 10},{10, 20, 15, 25}}; const t_rect_coord u[] = {{0, 5, 5, 25},{10, 5, 15, 25},{5, 20, 10, 25}}; const t_rect_coord v[] = {{0, 5, 5, 15}, {10, 5, 15, 15}, {1, 15, 6, 20}, {9, 15, 14, 20}, {5, 20, 10, 25}}; const t_rect_coord w[] = {{0, 5, 4, 20},{7, 5, 10, 20}, {13, 5, 17, 20}, {4, 20 , 7, 25}, {10, 20 , 13, 25}}; const t_rect_coord x[] = {{0, 5, 5, 10},{10, 5, 15, 10}, {0, 20, 5, 25}, {10, 20 , 15, 25}, {5, 10 , 10, 20}}; const t_rect_coord y[] = {{0, 5, 5, 20}, {5, 15, 10, 20}, {10, 5, 15, 30}, {0, 25, 10, 30}}; const t_rect_coord z[] = {{0, 5, 15, 10}, {10, 10, 15, 13}, {5, 12, 10, 18}, {0, 17, 5, 20}, {0, 20, 15, 25}}; }

एक तालिका बनाएं जहां हम चरित्र को स्वयं (असिसी में) सहसंबंधित करते हैं, इसकी आयतों की संख्या और इसके निर्देशांक:

समन्वित सूचक तालिका

 typedef struct { char lit; uint8_t size; const t_rect_coord *rec_coord; }t_rect_coord_table; #define LITERAL_COORD(x) sizeof(x)/ sizeof(x[0]), x const t_rect_coord_table rect_coord_table[] = { {',', LITERAL_COORD(rect_coord_lit::comma)}, {'.', LITERAL_COORD(rect_coord_lit::dot)}, {'.', LITERAL_COORD(rect_coord_lit::dot)}, {' ', LITERAL_COORD(rect_coord_lit::space)}, {'0', LITERAL_COORD(rect_coord_lit::_0)}, {'1', LITERAL_COORD(rect_coord_lit::_1)}, {'2', LITERAL_COORD(rect_coord_lit::_2)}, {'3', LITERAL_COORD(rect_coord_lit::_3)}, {'4', LITERAL_COORD(rect_coord_lit::_4)}, {'5', LITERAL_COORD(rect_coord_lit::_5)}, {'6', LITERAL_COORD(rect_coord_lit::_6)}, {'7', LITERAL_COORD(rect_coord_lit::_7)}, {'8', LITERAL_COORD(rect_coord_lit::_8)}, {'9', LITERAL_COORD(rect_coord_lit::_9)}, {'a', LITERAL_COORD(rect_coord_lit::a)}, {'b', LITERAL_COORD(rect_coord_lit::b)}, {'c', LITERAL_COORD(rect_coord_lit::c)}, {'d', LITERAL_COORD(rect_coord_lit::d)}, {'e', LITERAL_COORD(rect_coord_lit::e)}, {'f', LITERAL_COORD(rect_coord_lit::f)}, {'g', LITERAL_COORD(rect_coord_lit::g)}, {'h', LITERAL_COORD(rect_coord_lit::h)}, {'i', LITERAL_COORD(rect_coord_lit::i)}, {'j', LITERAL_COORD(rect_coord_lit::j)}, {'k', LITERAL_COORD(rect_coord_lit::k)}, {'l', LITERAL_COORD(rect_coord_lit::l)}, {'m', LITERAL_COORD(rect_coord_lit::m)}, {'n', LITERAL_COORD(rect_coord_lit::n)}, {'o', LITERAL_COORD(rect_coord_lit::o)}, {'p', LITERAL_COORD(rect_coord_lit::p)}, {'q', LITERAL_COORD(rect_coord_lit::q)}, {'r', LITERAL_COORD(rect_coord_lit::r)}, {'s', LITERAL_COORD(rect_coord_lit::s)}, {'t', LITERAL_COORD(rect_coord_lit::t)}, {'u', LITERAL_COORD(rect_coord_lit::u)}, {'v', LITERAL_COORD(rect_coord_lit::v)}, {'w', LITERAL_COORD(rect_coord_lit::w)}, {'x', LITERAL_COORD(rect_coord_lit::x)}, {'y', LITERAL_COORD(rect_coord_lit::y)}, {'z', LITERAL_COORD(rect_coord_lit::z)} };

तब एक वर्ण के ड्राइंग कार्य इस तरह दिखाई देंगे:

 void tft_lcd::draw_lit(char ch, const t_rect_coord *rect_coord, uint16_t colour, uint16_t x0, uint16_t y0, uint8_t size) { t_rect rec = {0}; rec.col = colour; uint8_t ctr = size; uint8_t i = 0; while(ctr--) { rec.x0 = x0 + rect_coord[i].x0; rec.y0 = y0 + rect_coord[i].y0; rec.x1 = x0 + rect_coord[i].x1; rec.y1 = y0 + rect_coord[i].y1; i++; this->draw_rect(rec); } } void tft_lcd::draw_char(char ch, uint16_t colour, uint16_t x0, uint16_t y0) { x0 += 2; y0 +=2; for(const auto &field : rect_coord_table) { if(field.lit == ch) { draw_lit(ch, field.rec_coord, colour, x0, y0, field.size); } } }

Draw_char फ़ंक्शन एक परिमित राज्य मशीन का प्रतिनिधित्व करता है, जहां एक लूप के लिए समन्वय तालिका के प्रत्येक क्षेत्र से गुजरता है और प्रतीक द्वारा एक मैच की खोज करता है। यदि कोई मिलान पाया जाता है, तो डेटा को draw_lit फ़ंक्शन में स्थानांतरित कर दिया जाता है, जो दिए गए निर्देशांक पर वांछित आयतों की संख्या खींचता है।

रेखा चित्र इस तरह दिखेगा:

 void tft_lcd::draw_string(char *ch, COLOUR colour, uint16_t x0, uint16_t y0) { while(*ch) { this->draw_char(*ch, static_cast<uint16_t>(colour), x0, y0); x0+= 20; ch++; } }

अब यह लाइन, इसकी प्रारंभिक स्थिति और रंग निर्धारित करने के लिए पर्याप्त है। नए अक्षर जोड़ने के लिए, बस निर्देशांक की एक सरणी बनाएं और इसे तालिका में जोड़ें। कोड द्वारा यादृच्छिक लाइनों का एक उदाहरण:

 this->draw_string("123456", COLOUR::GREEN, 5, 0); this->draw_string("habr,.", COLOUR::WHITE, 5, 30); this->draw_string("abcdef", COLOUR::RED, 5, 60); this->draw_string("stwxyz", COLOUR::YELLOW, 5, 90);

इस मोड में, डिस्प्ले तेज है, आंख ड्राइंग प्रक्रिया को नोटिस नहीं करती है।

सभी इच्छुक लोगों के लिए, पूरा प्रोजेक्ट कोड लिंक पर देखा जा सकता है ।

SSD1283A पर STM32 के साथ ट्रांसफ़्लेक्टिव TFT डिस्प्ले लॉन्च करें

परिचय

एसपीआई

प्रारंभिक प्रदर्शन

एक आयत बनाएँ

अक्षरों और संख्याओं को ड्रा करें

More articles: