🛌🏽 🗻 🎭 MSP430 पर सरल घड़ी 🈵 🤝 🤕

Arduino / LaunchPad के बारे में बड़ी संख्या में लेख पढ़ने के बाद, मैं एक समान खिलौना खरीदना चाहता था। चुनाव MSP430 पर गिर गया, क्योंकि इसकी कीमत माइक्रोकंट्रोलर की दुनिया में लॉन्च करने के लिए बहुत अधिक आकर्षक है।
दर्दनाक 5 दिनों के इंतजार के बाद, जादू का डिब्बा मेरे हाथों में था। एलईडी के साथ 10 मिनट तक खेलने के बाद, मैं कुछ और दिलचस्प करना चाहता था ... उदाहरण के लिए, एक घड़ी!

हाथ में एक पुराना सीमेंस A65 था, जो मेरी छोटी परियोजना के लिए एक दाता बन गया। हम इससे स्क्रीन निकालते हैं और सोचते हैं कि इसे कैसे कनेक्ट किया जाए। Google की एक छोटी खोज के बाद, मैं सफलतापूर्वक RadioKot फोरम थ्रेड पर समाप्त हो गया, जहां पिनआउट और स्क्रीन के प्रारंभ पर चर्चा की गई। यदि किसी को स्क्रीन को माइक्रोकंट्रोलर से जोड़ने के कार्य के साथ सामना करना पड़ता है, तो वह जानता है कि कनेक्शन आरेख को जानने के लिए पर्याप्त नहीं है, क्योंकि स्क्रीन में एक नियंत्रक है, संचार के लिए जिसके साथ आपको कमांड जानने की आवश्यकता है। उदाहरण के लिए, स्क्रीन चालू करने और मेमोरी से कचरा प्रदर्शित करने के लिए, कुछ नियंत्रकों को कई दर्जन कमांड भेजने की आवश्यकता होती है, और कुछ को 10 से कम की आवश्यकता होती है। इसलिए, अक्सर डेटशीट को नियंत्रकों पर नहीं पाया जा सकता है, और इस मामले में फोन पर ऑपरेशन के दौरान केवल स्क्रीन आरंभीकरण पढ़ने में मदद मिलती है। । लेकिन मैं भाग्यशाली था कि मेरी स्क्रीन (मेरे मामले में, LPH8731-3C, EPSON S1D15G14 कंट्रोलर के साथ) के लिए इनिशियलाइज़ेशन और कमांड्स न केवल ध्वस्त हो गए थे, बल्कि मुझे इस पर एक डेटशीट भी मिली थी।

और इसलिए, हम पिनआउट को देखते हैं, वायरिंग को मिलाप करते हैं और माइक्रोकंट्रोलर से कनेक्ट करते हैं।

LPH8731-3C के लिए पिनआउट

LPH8731-3C के लिए पिनआउट। ( रेडियोकोट मंच से लिया गया)
जहां:

सीएस - चिप का चयन करें। जब निम्न स्थिति में, चिप जानकारी प्राप्त करने के लिए तैयार है।
परिणाम - नियंत्रक रीसेट करने के लिए पैर। रीसेट सिग्नल उच्च -> निम्न -> उच्च (नियंत्रक के विनिर्देश के अनुसार, न्यूनतम समय 5ms है) से संक्रमण है।
रुपये - डेटा के प्रकार को निर्धारित करने के लिए कार्य करता है (डेटाशीट में और यह सीडी के रूप में नामित है)। एक कमांड भेजने के लिए, यह निम्न स्थिति में होना चाहिए, डेटा संचारित करने के लिए - उच्च।
सीएलके - डेटा ट्रांसमिशन के लिए एक घड़ी संकेत के रूप में कार्य करता है।
DAT - डाटा ट्रांसफर के लिए।
VDD - विनिर्देशन के अनुसार + 1.6 वी से + 3.6 वी तक।
GND - मुझे आशा है कि आप अपने लिए अनुमान लगा सकते हैं ?;
LED_A - बैकलाइट को बिजली की आपूर्ति के लिए दोनों कनेक्टर। यहां एक प्रतिरोधक के माध्यम से वोल्टेज देना बेहतर होता है (आप इसके बिना कर सकते हैं, लेकिन मेरे मामले में एलईडी में से एक को ज़्यादा गरम करना शुरू हो गया, जिसके परिणामस्वरूप स्क्रीन पर एक प्रकाश था)।
LED_K GND के लिए है।

वैसे, कुछ पहले से ही देख सकते हैं कि यहाँ SPI का उपयोग डेटा ट्रांसफर के लिए किया जाता है, ताकि CLK और DAT को MSP430 SPI पिन से जोड़ा जा सके।

हमें "बैरल ऑर्गन" मिलता है

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

कंट्रोलर से डेटा ट्रांसमिट करने की प्रक्रिया डेटशीट से ली गई है। किसी कारण से, RS / CD पिन की स्थिति यहाँ इंगित नहीं की गई है। वैसे, यदि डेटा ट्रांसफर के दौरान CS स्थिति निम्न -> उच्च में बदल जाती है, तो डेटा रिसेप्शन रुक जाएगा। लेकिन डेटा ट्रांसफर के अंत में, CS को ऊपर खींचना आवश्यक नहीं है (लेकिन अनुशंसित है)।

बुराई कोड के बिट

कोड CSS (TI के कोड कम्पोज़र स्टूडियो) के लिए है।
यहां यह पूरी तरह से नहीं है, लेकिन केवल उदाहरण के लिए टुकड़े। अंग्रेजी में टिप्पणियाँ, जैसा कि मुझे यह पसंद है :)

LPH87313C.h

/**********************************************************/ /* Pins and outputs */ /**********************************************************/ // Chip Select line pin1.0 #define LCD_CS BIT7 #define LCD_CS_DIR P1DIR #define LCD_CS_OUT P1OUT // Hardware Reset pin1.1 #define LCD_RESET BIT6 #define LCD_RESET_DIR P1DIR #define LCD_RESET_OUT P1OUT // Command/Data mode line pin1.4 #define LCD_CD BIT3 #define LCD_CD_DIR P1DIR #define LCD_CD_OUT P1OUT // SPI #define SPI UCA0TXBUF

LPH87313C.s

 void LCD_SendCmd(unsigned char Cmd) { LCD_CS_OUT |= LCD_CS; // set CS pin to High LCD_CD_OUT &= ~LCD_CD; // set CD pin to Low LCD_CS_OUT &= ~LCD_CS; SPI = Cmd; } void LCD_SendDat(unsigned char Data) { LCD_CD_OUT |= LCD_CD; // set CD pin to High SPI = Data; }

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

और यहाँ भेजने के लिए बहुत सारे कमांड हैं

सिद्धांत रूप में, अधिकांश पैरामीटर निर्धारित किए जाते हैं, लेकिन कुछ चीजों को बदला जा सकता है। उदाहरण के लिए, किस क्रम में मेमोरी को मेमोरी लिखा जाएगा (ऊपर से नीचे तक - दाएं से बाएं / नीचे से ऊपर से - दाएं से बाएं / आदि), इसके विपरीत, साथ ही साथ रंग की गहराई (256 रंग या 4096)।

LPH87313C.s

 void LCD_Init() { // Set pins to output direction LCD_CS_DIR |= LCD_CS; LCD_RESET_DIR |= LCD_RESET; LCD_CD_DIR |= LCD_CD; LCD_CS_OUT &= ~LCD_CS; LCD_RESET_OUT &= ~LCD_RESET; LCD_CD_OUT &= ~LCD_CD; __delay_cycles(160000); //wait 100ms (F_CPU 16MHz) LCD_RESET_OUT |= LCD_RESET; __delay_cycles(160000); LCD_SendCmd(0x01); //reset sw __delay_cycles(80000); LCD_SendCmd(0xc6); //initial escape LCD_SendCmd(0xb9); //Refresh set LCD_SendDat(0x00); __delay_cycles(160000); LCD_SendCmd(0xb6); //Display control LCD_SendDat(0x80); // LCD_SendDat(0x04); // LCD_SendDat(0x0a); // LCD_SendDat(0x54); // LCD_SendDat(0x45); // LCD_SendDat(0x52); // LCD_SendDat(0x43); // LCD_SendCmd(0xb3); //Gray scale position set 0 LCD_SendDat(0x02); // LCD_SendDat(0x0a); // LCD_SendDat(0x15); // LCD_SendDat(0x1f); // LCD_SendDat(0x28); // LCD_SendDat(0x30); // LCD_SendDat(0x37); // LCD_SendDat(0x3f); // LCD_SendDat(0x47); // LCD_SendDat(0x4c); // LCD_SendDat(0x54); // LCD_SendDat(0x65); // LCD_SendDat(0x75); // LCD_SendDat(0x80); // LCD_SendDat(0x85); // LCD_SendCmd(0xb5); //Gamma curve LCD_SendDat(0x01); // LCD_SendCmd(0xbd); //Common driver output select LCD_SendDat(0x00); // LCD_SendCmd(0xbe); //Power control LCD_SendDat(0x54); //0x58 before LCD_SendCmd(0x11); //sleep out __delay_cycles(800000); LCD_SendCmd(0xba); //Voltage control LCD_SendDat(0x2f); // LCD_SendDat(0x03); // LCD_SendCmd(0x25); //Write contrast LCD_SendDat(0x60); // LCD_SendCmd(0xb7); //Temperature gradient LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendDat(0x00); // LCD_SendCmd(0x03); //Booster voltage ON __delay_cycles(800000); LCD_SendCmd(0x36); //Memory access control LCD_SendDat(0x48); // LCD_SendCmd(0x2d); //Color set LCD_SendDat(0x00); // LCD_SendDat(0x03); // LCD_SendDat(0x05); // LCD_SendDat(0x07); // LCD_SendDat(0x09); // LCD_SendDat(0x0b); // LCD_SendDat(0x0d); // LCD_SendDat(0x0f); // LCD_SendDat(0x00); // LCD_SendDat(0x03); // LCD_SendDat(0x05); // LCD_SendDat(0x07); // LCD_SendDat(0x09); // LCD_SendDat(0x0b); // LCD_SendDat(0x0d); // LCD_SendDat(0x0f); // LCD_SendDat(0x00); // LCD_SendDat(0x05); // LCD_SendDat(0x0b); // LCD_SendDat(0x0f); // LCD_SendCmd(0x3a); //interface pixel format LCD_SendDat(0x03); // 0x02 for 8-bit 0x03 for 12bit __delay_cycles(1600000); LCD_SendCmd(0x29); //Display ON }

हमारा पता घर या गली नहीं है, हमारा पता है ...

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

उदाहरण के लिए, पूरी स्क्रीन को भरने के लिए, आपको रिकॉर्ड किए गए क्षेत्र की शुरुआत (x0, y0) और अंत (x101, y80) का चयन करने की आवश्यकता है। और अगर आपको केवल एक पिक्सेल का रंग बदलने की आवश्यकता है, तो हम क्रमशः क्षेत्र [x, y] [x + 1, y + 1] को निर्धारित करते हैं।

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

क्षेत्र कमांड्स

 LCD_SendCmd(0x2A); //   X (x0 - , x1 - ) LCD_SendDat(x0); LCD_SendDat(x1); LCD_SendCmd(0x2B); //   Y (y0 - , y1 - ) LCD_SendDat(y0+1); //   Y   1,   0 LCD_SendDat(y1+1); LCD_SendCmd(0x2C); //

आपको पत्र! चीनी में सच ...

हमने पहले ही पता लगा लिया है कि डिस्प्ले कैसे चालू करें और यहां तक कि ड्राइंग के लिए क्षेत्र कैसे चुनें, लेकिन मैं रंग कैसे भेजूं? प्रदर्शन 2 रंग पट्टियों के साथ काम कर सकता है:

8 बिट (256 रंग)
12 बिट (4096 रंग)

8-बिट रंग के मामले में, सब कुछ सरल है - बस प्रत्येक रंग के लिए 8 बिट्स भेजें (अर्थात्, R2R1R0G2G1G1G0B1B0, जहां R2R1R0 लाल रंग के 3 बिट्स हैं, लाल और हरे रंग के लिए 3 बिट्स, और नीले रंग के लिए 2 बिट्स)।
लेकिन 12-बिट रंग के मामले में, सब कुछ थोड़ा अधिक जटिल है। प्रत्येक शेड के लिए पहले से ही 4 बिट्स हैं। मैं एक डेटशीट से एक तस्वीर दूंगा।

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

फिर से कोड का एक हिस्सा

संपूर्ण स्क्रीन के भरण फ़ंक्शन का एक उदाहरण।

 void LCD_Flush(unsigned char R, unsigned char G, unsigned char B) { volatile int i = 4040; volatile char B0, B1, B2; B0 = ((R << 4) & 0xF0) + (G & 0x0F); B1 = ((B << 4) & 0xF0) + (R & 0x0F); B2 = ((G << 4) & 0xF0) + (B & 0x0F); LCD_SendCmd(0x2A); LCD_SendDat(0); LCD_SendDat(100); LCD_SendCmd(0x2B); LCD_SendDat(1); LCD_SendDat(80); LCD_SendCmd(0x2C); while (i--) { LCD_CD_OUT |= LCD_CD; SPI = B0; SPI = B1; SPI = B2; } }

और वादा किया गया घड़ी कहाँ है?

और अब सबसे मुश्किल हिस्सा घड़ी बनाना है। जैसा कि आप देख सकते हैं, उन्हें एक सेगमेंट संकेतक के रूप में स्टाइल किया जाता है, इसलिए घड़ी को अलग-अलग स्थानों में 2 प्रकार के सेगमेंट (ऊर्ध्वाधर और क्षैतिज) खींचना है।
पहले आपको डिजाइन पर निर्णय लेने की आवश्यकता है। एमएस से महान कार्यक्रम के लिए धन्यवाद - पेंट, यह वास्तव में मुझे इस के साथ मदद की;)।

मुझे यही मिला है। प्रत्येक खंड 12x4px आकार का है (और ऊर्ध्वाधर वाले, इसके विपरीत, 4x12px हैं)।

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

एक अनगढ़ भाषा में अश्लील शब्दों का एक सेट

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

 void drawHorizontal(char type, unsigned char x, unsigned char y) { volatile unsigned char i = 22, B2, B1, B0; if (type) { B0 = greenBright; B1 = 0; B2 = (greenBright << 4) & 0xF0; } else { B0 = greenDim; B1 = 0; B2 = (greenDim << 4) & 0xF0; } LCD_SendCmd(0x2A); LCD_SendDat(x); LCD_SendDat(x+11); LCD_SendCmd(0x2B); LCD_SendDat(y+1); LCD_SendDat(y+4); LCD_SendCmd(0x2C); __delay_cycles(4); LCD_CD_OUT |= LCD_CD; SPI = BG0; SPI = (BG1 << 4) & 0xF0; __delay_cycles(2); SPI = B2; while(i--) { if (i == 17) { SPI = B0; __delay_cycles(2); SPI = (BG0 >> 4) & 0x0F; __delay_cycles(2); SPI = (BG0 << 4) & 0xF0 + (BG1 << 4) & 0x0F; continue; } if (i == 4) { SPI = BG0; SPI = (BG1 << 4) & 0xF0; __delay_cycles(2); SPI = B2; continue; } SPI = B0; SPI = B1; SPI = B2; } SPI = B0; __delay_cycles(2); SPI = (BG0 >> 4) & 0x0F; __delay_cycles(2); SPI = (BG0 << 4) & 0xF0 + (BG1 << 4) & 0x0F; }

अब आपको संख्या को सेगमेंट के एक सेट में बदलने की आवश्यकता है (उदाहरण के लिए, 1 प्रदर्शित करने के लिए, आपको केवल सही ऊर्ध्वाधर सेगमेंट खींचने की आवश्यकता है)। मैंने इसे काफी सरलता से तय किया - मैंने विभिन्न अंकों (0 से 9 तक) के लिए खंड मानों की एक सरणी बनाई। इसमें एक अंक को प्रतिस्थापित करते हुए, मुझे 1/0 मूल्यों के साथ एक सरणी मिलती है जिसने खंडों के प्रतिपादन को नियंत्रित किया। उदाहरण के लिए, 1 का अर्थ है कि खंड को खींचना होगा, और 0 का अर्थ है कि यह आवश्यक नहीं है (या इसे "निष्क्रिय" बनाएं)। और एक समारोह बनाने के लिए क्या और कहाँ आकर्षित करना है, यह जानना मुश्किल नहीं है।

सरल सरणी

 /******************************************************************************************** * Array for Clock * ____ * _|__1_|_ * |6| |2| * |_|____|_| * _|__7_|_ * |5| |3| * |_|____|_| * |__4_| * ********************************************************************************************/ static const char HH[10][7] = { {1,1,1,1,1,1,0}, // 0 {0,1,1,0,0,0,0}, // 1 {1,1,0,1,1,0,1}, // 2 {1,1,1,1,0,0,1}, // 3 {0,1,1,0,0,1,1}, // 4 {1,0,1,1,0,1,1}, // 5 {1,0,1,1,1,1,1}, // 6 {1,1,1,0,0,0,0}, // 7 {1,1,1,1,1,1,1}, // 8 {1,1,1,1,0,1,1} // 9 };

क्लॉक ड्राइंग कोड

 void drawClock(char hh, char mm, char dots) { volatile char h0, h1, m0, m1; h0 = hh / 10; h1 = hh - (h0 * 10); m0 = mm / 10; m1 = mm - (m0 * 10); drawHorizontal(HH[h0][0], 9, 25); drawHorizontal(HH[h1][0], 31, 25); drawHorizontal(HH[m0][0], 58, 25); drawHorizontal(HH[m1][0], 80, 25); drawVertical(HH[h0][5], 6, 29); drawVertical(HH[h0][1], 20, 29); drawVertical(HH[h1][5], 28, 29); drawVertical(HH[h1][1], 42, 29); drawVertical(HH[m0][5], 55, 29); drawVertical(HH[m0][1], 69, 29); drawVertical(HH[m1][5], 77, 29); drawVertical(HH[m1][1], 91, 29); drawHorizontal(HH[h0][6], 9, 38); drawHorizontal(HH[h1][6], 31, 38); drawHorizontal(HH[m0][6], 58, 38); drawHorizontal(HH[m1][6], 80, 38); drawVertical(HH[h0][4], 6, 42); drawVertical(HH[h0][2], 20, 42); drawVertical(HH[h1][4], 28, 42); drawVertical(HH[h1][2], 42, 42); drawVertical(HH[m0][4], 55, 42); drawVertical(HH[m0][2], 69, 42); drawVertical(HH[m1][4], 77, 42); drawVertical(HH[m1][2], 91, 42); drawHorizontal(HH[h0][3], 9, 51); drawHorizontal(HH[h1][3], 31, 51); drawHorizontal(HH[m0][3], 58, 51); drawHorizontal(HH[m1][3], 80, 51); drawDots(dots); }

और इसलिए हम लेख के अंत में आते हैं। मुझे आशा है कि मैं उनके काम के सिद्धांत के बारे में विस्तार से समझाने में सक्षम था :) और एक लघु वीडियो के लिए कि वे कैसे काम करते हैं और "डॉट्स" को ब्लिंक करते हैं।

पुनश्च
शायद इस लेख में वर्तनी, व्याकरण और विराम चिह्न त्रुटियाँ हैं। यदि आप उन्हें ढूंढते हैं, तो मैं आपसे विनम्र अनुरोध करता हूं कि आप मुझे पीएम में संदेश भेजें, और टिप्पणी न लिखें।
लेख घड़ियों के क्रियान्वयन के बारे में इस तरह नहीं लिखते हैं क्योंकि वे पूरे नहीं होते हैं :) शुरू में, यह एक छोटा गैजेट बनाने की योजना बनाई गई थी, जहां प्रदर्शन, बाहरी फ्लैश मेमोरी और बाहरी घड़ी-कैलेंडर का उपयोग किया जाएगा, लेकिन जब से मैंने गलती से गलत घड़ी खरीदी, सब कुछ उठ गया :) एक और कारण - मैं एक बड़े प्रदर्शन का उपयोग करना चाहता था, लेकिन एक उपयुक्त एक नहीं खरीद सकता था, उदाहरण के लिए, चीनी नोक्ला एन 95 8 जीबी से। क्या कोई मुझे बता सकता है कि मुझे कहां खरीदना है?
अगर किसी को स्रोत कोड - संपर्क की आवश्यकता है, तो मैं साझा कर सकता हूं :) अगर किसी के पास स्क्रीन पर वर्णों के आउटपुट के कार्यान्वयन के बारे में प्रश्न हैं (प्रिंट पाठ) - मैं स्रोत कोड भी साझा कर सकता हूं (मैंने इसके बारे में नहीं लिखा था, यहां घड़ी के बारे में एक लेख लगता है ), और भी एक अलग पोस्ट पर नहीं खींचता है)। मैं सीमेंस CX75 से स्क्रीन के साथ काम करने के लिए लाइब्रेरी को भी साझा कर सकता हूं (एसएसडी -1286 नियंत्रक पर, यहां तक कि एक डेटाशीट भी है), मैंने खुद के लिए लिखा था, लेकिन गलती से इसे जला दिया।

MSP430 पर सरल घड़ी

हमें "बैरल ऑर्गन" मिलता है

हमारा पता घर या गली नहीं है, हमारा पता है ...

आपको पत्र! चीनी में सच ...

और वादा किया गया घड़ी कहाँ है?

More articles: