🤘🏻 🔺 🕕 माइक्रोचिप में हिंदू कोड 🥜 📡 👉🏽

एसडी-कार्ड को माइक्रोकंट्रोलर से जल्दी कनेक्ट करना आवश्यक था, और कार्य सरल लग रहा था - एक अच्छा माइक्रोचिप सब कुछ के लिए पुस्तकालय प्रदान करता है ^{(ओह, पुस्तकालयों पर एक लिंक डालना भाग्य नहीं है)} , लेकिन उनके कोड को देखने के बाद, सिर पर बाल चलना शुरू हो गया।

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

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

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

तो, अगर आप माइक्रोचिप में इस तरह से प्रोग्राम करना सीखना चाहते हैं, तो इन सरल सुझावों का पालन करें ...

0. अधिक कोड - अधिक लाभ!

जब आपको माइक्रोचिप में नौकरी मिलती है तो आपको याद रखने के लिए सबसे महत्वपूर्ण बात यह है: "वे अभी भी कोड की लाइनों के लिए भुगतान करते हैं!" इसलिए, किसी भी तरह से स्रोत ग्रंथों की मात्रा बढ़ाएं। सामान्य सलाह, इसलिए उदाहरणों के बिना, कल्पना को शामिल करें।

1. शैली के क्लासिक्स

हिंदू ~~फिल्म~~ शैली की क्लासिक शुरुआत से ही अडिग रही है। वार्म अप करने के लिए, यह अनुमान लगाने की कोशिश करें कि "MDD फाइल सिस्टम \ SD-SPI.c" लाइन 1042 पर फाइल में निहित कोड के इस टुकड़े के पीछे क्या छिपा है:

if(localCounter != 0x0000) { localPointer--; while(1) { SPIBUF = 0xFF; localPointer++; if((--localCounter) == 0x0000) { break; } while(!SPISTAT_RBF); *localPointer = (BYTE)SPIBUF; } while(!SPISTAT_RBF); *localPointer = (BYTE)SPIBUF; }

ANSWER में देखने के लिए जल्दी मत करो - यह सरल है:

 //    (      )    while (localCounter--) { SPIBUF = 0xFF; while (!SPISTAT_RBF); *localPointer++ = SPIBUF; } //    ,        //      -    while (localCounter) { localCounter--; SPIBUF = 0xFF; while (!SPISTAT_RBF); *localPointer++ = SPIBUF; }

2. कॉपी-पेस्ट

कल्पना की अनुपस्थिति में, कॉपी-पेस्ट भी उपयुक्त है, हालांकि अफवाहों के अनुसार कई नियोक्ता कॉपी-पेस्ट के लिए कोड की जांच करते हैं, माइक्रोचिप स्पष्ट रूप से उनमें से एक नहीं है। याद रखें, मैक्रोज़ का उपयोग कभी भी हिंदू कोड के साथ आटा काटने के लिए न करें - वे बुराई और बदसूरत कोड को कम करते हैं। उदाहरण के लिए, MDD फ़ाइल सिस्टम \ FSIO.c फ़ाइल में बीस बार दोहराता हुआ एक टुकड़ा:

ctrl + v

 if (utfModeFileName) { utf16path++; i = *utf16path; } else { temppath++; i = *temppath; }

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

ऊपर के टुकड़े के लिए सरल और स्पष्ट प्रतिस्थापन

 #define getnextpathchar() ( utfModeFileName ? *++utf16path : *++temppath ) // -   ... i = getnextpathchar(); //

पहले विकल्प के पक्ष में 10: 1 का अनुपात, और निरपेक्ष रूप से बीस दोहराव दिए गए, यह कई सौ रुपये है!

3. लाइन कोड

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

ऐसा करने के लिए स्वतंत्र महसूस करें

 fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part3[1]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part3[0]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part2[5]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part2[4]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part2[3]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part2[2]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part2[1]; fileFoundString[fileFoundLfnIndex--] = lfnObject.LFN_Part2[0]; tempShift.byte.LB = lfnObject.LFN_Part1[8]; tempShift.byte.HB = lfnObject.LFN_Part1[9]; fileFoundString[fileFoundLfnIndex--] = tempShift.Val; tempShift.byte.LB = lfnObject.LFN_Part1[6]; tempShift.byte.HB = lfnObject.LFN_Part1[7]; fileFoundString[fileFoundLfnIndex--] = tempShift.Val; tempShift.byte.LB = lfnObject.LFN_Part1[4]; tempShift.byte.HB = lfnObject.LFN_Part1[5]; fileFoundString[fileFoundLfnIndex--] = tempShift.Val; tempShift.byte.LB = lfnObject.LFN_Part1[2]; tempShift.byte.HB = lfnObject.LFN_Part1[3]; fileFoundString[fileFoundLfnIndex--] = tempShift.Val; tempShift.byte.LB = lfnObject.LFN_Part1[0]; tempShift.byte.HB = lfnObject.LFN_Part1[1]; fileFoundString[fileFoundLfnIndex--] = tempShift.Val;

संरचनाओं का प्रारंभिक बाय-बाय होना चाहिए; सरल इनिशियलाइज़र लिखने की आवश्यकता नहीं है:

 const somestruct mystruct = {"Field1", 2, 4, 8 .... };

ऐसा करने में संकोच न करें, हारने वालों के लिए यादगार, और यह असली पैसा है

 gDataBuffer[0] = 0xEB; //Jump instruction gDataBuffer[1] = 0x3C; gDataBuffer[2] = 0x90; gDataBuffer[3] = 'M'; //OEM Name "MCHP FAT" gDataBuffer[4] = 'C'; gDataBuffer[5] = 'H'; gDataBuffer[6] = 'P'; gDataBuffer[7] = ' '; gDataBuffer[8] = 'F'; gDataBuffer[9] = 'A'; gDataBuffer[10] = 'T'; gDataBuffer[11] = 0x00; //Sector size gDataBuffer[12] = 0x02; gDataBuffer[13] = disk->SecPerClus; //Sectors per cluster gDataBuffer[14] = 0x20; //Reserved sector count gDataBuffer[15] = 0x00; disk->fat = 0x20 + disk->firsts; gDataBuffer[16] = 0x02; //number of FATs gDataBuffer[17] = 0x00; //Max number of root directory entries - 512 files allowed gDataBuffer[18] = 0x00; gDataBuffer[19] = 0x00; //total sectors gDataBuffer[20] = 0x00; gDataBuffer[21] = 0xF8; //Media Descriptor gDataBuffer[22] = 0x00; //Sectors per FAT gDataBuffer[23] = 0x00; gDataBuffer[24] = 0x3F; //Sectors per track gDataBuffer[25] = 0x00; gDataBuffer[26] = 0xFF; //Number of heads gDataBuffer[27] = 0x00; // Hidden sectors = sectors between the MBR and the boot sector gDataBuffer[28] = (BYTE)(disk->firsts & 0xFF); gDataBuffer[29] = (BYTE)((disk->firsts / 0x100) & 0xFF); gDataBuffer[30] = (BYTE)((disk->firsts / 0x10000) & 0xFF); gDataBuffer[31] = (BYTE)((disk->firsts / 0x1000000) & 0xFF); // Total Sectors = same as sectors in the partition from MBR gDataBuffer[32] = (BYTE)(secCount & 0xFF); gDataBuffer[33] = (BYTE)((secCount / 0x100) & 0xFF); gDataBuffer[34] = (BYTE)((secCount / 0x10000) & 0xFF); gDataBuffer[35] = (BYTE)((secCount / 0x1000000) & 0xFF); gDataBuffer[36] = fatsize & 0xFF; //Sectors per FAT gDataBuffer[37] = (fatsize >> 8) & 0xFF; gDataBuffer[38] = (fatsize >> 16) & 0xFF; gDataBuffer[39] = (fatsize >> 24) & 0xFF; gDataBuffer[40] = 0x00; //Active FAT gDataBuffer[41] = 0x00; gDataBuffer[42] = 0x00; //File System version gDataBuffer[43] = 0x00; gDataBuffer[44] = 0x02; //First cluster of the root directory gDataBuffer[45] = 0x00; gDataBuffer[46] = 0x00; gDataBuffer[47] = 0x00; gDataBuffer[48] = 0x01; //FSInfo gDataBuffer[49] = 0x00; gDataBuffer[50] = 0x00; //Backup Boot Sector gDataBuffer[51] = 0x00; gDataBuffer[52] = 0x00; //Reserved for future expansion gDataBuffer[53] = 0x00; gDataBuffer[54] = 0x00; gDataBuffer[55] = 0x00; gDataBuffer[56] = 0x00; gDataBuffer[57] = 0x00; gDataBuffer[58] = 0x00; gDataBuffer[59] = 0x00; gDataBuffer[60] = 0x00; gDataBuffer[61] = 0x00; gDataBuffer[62] = 0x00; gDataBuffer[63] = 0x00; gDataBuffer[64] = 0x00; // Physical drive number gDataBuffer[65] = 0x00; // Reserved (current head) gDataBuffer[66] = 0x29; // Signature code gDataBuffer[67] = (BYTE)(serialNumber & 0xFF); gDataBuffer[68] = (BYTE)((serialNumber / 0x100) & 0xFF); gDataBuffer[69] = (BYTE)((serialNumber / 0x10000) & 0xFF); gDataBuffer[70] = (BYTE)((serialNumber / 0x1000000) & 0xFF); gDataBuffer[82] = 'F'; gDataBuffer[83] = 'A'; gDataBuffer[84] = 'T'; gDataBuffer[85] = '3'; gDataBuffer[86] = '2'; gDataBuffer[87] = ' '; gDataBuffer[88] = ' '; gDataBuffer[89] = ' ';

4. रिक्त स्थान से बाइक या पैसे का आविष्कार करना

फाइल “MDD फाइल सिस्टम \ FSIO.c” में फाइल 60bjectCopy फ़ंक्शन की लाइन 6065 पर विचार ने मुझे एक और विचार के लिए प्रेरित किया, मुझे संदेह है कि अगर उनके पास अधिक अलग संरचनाएं थीं, तो SomeObjectCopy प्रकट होगी

स्वयं कार्य करें

 void FileObjectCopy(FILEOBJ foDest, FILEOBJ foSource) { int size; BYTE* dest; BYTE* source; int Index; dest = (BYTE*)foDest; source = (BYTE*)foSource; size = sizeof(FSFILE); for (Index = 0; Index < size; Index++) { dest[Index] = source[Index]; } }

विवरण आकर्षण सादगी के साथ:

FileObjectCopy फ़ंक्शन एक निर्दिष्ट FSFILE ऑब्जेक्ट की एक एक्ससाइट कॉपी बना देगा।

यदि कोड से निम्नानुसार "एक्ज़िमा" == "सटीक" है, तो यह संरचनाओं के प्रत्यक्ष असाइनमेंट के लिए एक लाभदायक प्रतिस्थापन है - एएनएसआई सी में एक मानक संचालन, और कंपाइलर द्वारा बनाया गया, यह हार्डवेयर एफएसआर / इंडियाफ़ रजिस्टरों का उपयोग करने के बाद से तेज़ और अधिक कॉम्पैक्ट होना चाहिए। Memcpy (डी, एस, आकार (ओं)) विभिन्न वस्तुओं के लिए उपयुक्त है और यह जल्दी से भी काम करता है, किसी भी मामले में, इसका संयोजन कार्यान्वयन।

FileObjectCopy के लाभहीन संस्करण, HITech C18 से असंतुष्ट संस्करण

 ; *FileObject1 = *FileObject2; //     ;    MOVLW FileObject1 >> 8 MOVWF FSR1H MOVLW FileObject1 MOVWF FSR1L MOVLW FileObject2 >> 8 MOVWF FSR0H MOVLW FileObject2 MOVWF FSR0L ;  MOVLW sizeof(*FileObject) loop: MOVFF POSTINC0, POSTINC1 ;       DECFSZ WREG, F BRA loop

ठीक है, कोड को फुलाए जाने के लिए अभी भी बहुत कम चीजें हैं, जिसके साथ आप कुछ जोड़ सकते हैं - तीन लाइनें, जैसे:

 int FSerror (void) { return FSerrno; }

यहां तक कि अगर यह केवल पढ़ने के लिए केवल चर बनाने के लिए है, तो इस तरह के मैक्रो कंपाइलर को शपथ लेने के लिए पर्याप्त है जहां आवश्यक हो:

 #define FSerror() ( FSerrno )

5. कट्टरता के साथ टिप्पणियाँ

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

यहां तक कि एक खाली टोपी महत्वपूर्ण लगती है

 /************************************************************************** Function: void func (void) Summary: Does a hard work Conditions: This function should not be called by the user Input: None Return Values: None Side Effects: None Description: This function will do <a hard work>, with <none> input parameter.... Remarks: Optimize code later **************************************************************************/

6. वास्तुकला की सुविधाओं का उपयोग करें

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

कोड को इस तरह से लिखें कि यह संकलक के विभिन्न संस्करणों के तहत भी संकलित न हो सके, और सभी विशिष्ट #pragma का उपयोग करें। इस स्थिति में, प्रत्येक फ़ंक्शन कम से कम दो संकलक और तीन से चार PIC आर्किटेक्चर के लिए संस्करणों में मौजूद होगा, कोड वृद्धि के लिए 8 गुना तक।

कोड की मात्रा को दोगुना करने में मदद करने के लिए, PIC कंपाइलर्स में RAM और ROM पॉइंटर्स अलग-अलग होते हैं, अर्थात्, माइक्रो टेक में हाई टेक या "const rom char *" में स्पष्ट रूप से या स्पष्ट रूप से "const char *" में परिवर्तित नहीं किया जा सकता है। । जो, सामान्य तौर पर, उच्च तकनीक में कोई समस्या पैदा नहीं करता है, क्योंकि शून्य, दूर और कांस्ट पॉइंटर्स सभी मेमोरी को संबोधित कर सकते हैं और रोम और रैम दोनों पर लागू हो सकते हैं। लेकिन सी के माइक्रोचिप कार्यान्वयन में, यह दो कार्यों का निर्माण कर सकता है: एक रोम के साथ काम कर रहा है, और दूसरा रैम के साथ - शुद्ध लाभ। आपको एक फ़ंक्शन के साथ कभी भी संतुष्ट नहीं होना चाहिए जो रैम के साथ काम करता है (और, यदि आवश्यक हो, तो वहां रोम से स्थिरांक लोड होता है)।

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

एक निष्कर्ष के बजाय

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

माइक्रोचिप में हिंदू कोड