पीसी हार्डवेयर मॉनिटर: 6 चरण (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:20

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

जैसा कि मैं एक इंजीनियर नहीं हूं और न ही एक प्रोग्रामर हूं, लेकिन सिर्फ एक सोल्डरिंग आयरन और कुछ आत्म-सिखाया ज्ञान वाला लड़का है, यह सिर्फ एक कदम-दर-चरण निर्देश योग्य नहीं होगा, मैं समस्या पर ध्यान केंद्रित करने का भी प्रयास करूंगा उन पहलुओं को हल करना और शोध करना जो मुझे इस निर्माण के लिए प्रेरित करते हैं।

अस्वीकरण: मेरा सारा काम क्रिएटिव कॉमन एट्रिब्यूशन-शेयरलाइक 4.0 के रूप में साझा किया गया है। मैंने पूरे इंटरनेट पर कई उदाहरणों से प्रेरणा ली है, अगर आप इस काम के कुछ हिस्से को अपना मानते हैं, तो कृपया मुझे श्रेय के लिए संपर्क करें। कोई उल्लंघन करने का इरादा नहीं है, मुझे किसी भी गलती को सुधारने में खुशी होगी। धन्यवाद

दूसरा अस्वीकरण: मेरा काम इस तरह साझा किया गया है। मेरे किसी भी कोड या निर्देश के उपयोग से होने वाली किसी भी क्षति के लिए मैं जिम्मेदार नहीं हूं।

आपूर्ति

• Arduino नैनो (या यदि आप चाहें तो UNO)
• टीएफटी डिस्प्ले। मेरे मामले में यह ILI9486 / ILI9488L संगत 3.5 "डिस्प्ले है।
• तापमान सेंसो। म्यू केस में एक एनालॉग TMP36 टेम्प सेंसर।
• केबल, तार, ड्यूपॉन्ट कनेक्टर (उस पर बाद में और अधिक)
• (वैकल्पिक) परीक्षण के लिए ब्रेडबोर्ड
• (वैकल्पिक लेकिन अनुशंसित) एक छोटा सा परफ़ॉर्मर

चरण 1: व्यवहार्यता अध्ययन (क्रमबद्ध)

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

1. किसी भी खोज के पृष्ठ ३ या ४ के बाद परेशान न हों, यह लगभग हमेशा समय की बर्बादी है। बजाय
2. खोज शब्दों को बदलें, बस दूसरे दृष्टिकोण से प्रश्न को दोबारा दोहराएं (यानी: "आर्डिनो तापमान सेंसर" -> "आर्डिनो के साथ तापमान पढ़ें")।

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

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

मैं Arduino पर आधारित कुछ चाहता था, क्योंकि मेरे पास पहले से ही था, यह अच्छी तरह से प्रलेखित है और इसका समुदाय फल-फूल रहा है। यहाँ कोई समस्या नहीं है, जैसा कि मैंने पहले कहा था कि बहुत सारी जानकारी है।

मैं चाहता था कि एक बड़ा डिस्प्ले कुछ मीटर दूर से स्पष्ट रूप से देखा जा सके और यह मेरे निर्माण के लुक'न'फील में फिट हो, इसमें किसी भी नोकिया और एलसीडी कैरेक्टर डिस्प्ले को शामिल नहीं किया गया था। OLED भी सवाल से बाहर हैं, क्योंकि वे छोटे हैं। इसलिए मैंने TFT कलर डिस्प्ले का विकल्प चुना। टच स्क्रीन की कोई आवश्यकता नहीं है, क्योंकि यह पीसी के अंदर होगा। मुझे एक 3.5 एक मिला, जो पहले से ही Arduino के लिए डिज़ाइन किया गया है, ~ 15€ अमेज़न पर। काफी अच्छा।

अब, हार्डवेयर की पहचान हो जाने के बाद, मैंने सॉफ्टवेयर पर ध्यान केंद्रित किया।

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

इसी तरह की कई परियोजनाओं का अध्ययन करने के बाद, मैंने सभी हार्डवेयर जानकारी और FPS के लिए RivaTuner प्राप्त करने के लिए OpenHardwareMonitor का उपयोग करने पर समझौता किया, क्योंकि ये मुफ़्त और पर्याप्त दस्तावेज हैं।

चरण 2: हार्डवेयर परीक्षण

टांका लगाने वाले लोहे को चालू करने और किसी भी इलेक्ट्रॉनिक घटक को समय और स्थान में हमेशा के लिए ठीक करने से पहले, एक परीक्षण प्रोटोटाइप (टिप नंबर दो) बनाने के लिए अच्छा अभ्यास है। सौभाग्य से, यह अब 1995 नहीं है। आजकल छोटे ब्रेडबोर्ड पर भी काफी जटिल प्रोटोटाइप की व्यवस्था करना काफी आसान है। मेरे मामले में, TFT डिस्प्ले में Arduino Uno के लिए पिनआउट में गिरावट थी, इसलिए मैंने इसे अपने Arduino uno पर गिरा दिया और उदाहरण पुस्तकालयों के साथ खेलना शुरू कर दिया और इसके संचालन सिद्धांतों और सीमाओं को समझने के लिए संदर्भ मैनुअल को पढ़ा।

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

लाइन के नीचे कुछ बिंदु पर, मेरे पास डिस्प्ले पर एक खाली जगह थी, लेकिन पीसी सेंसर का कोई भी डेटा वास्तव में उपयोगी नहीं था, इसलिए मैंने परिवेश के तापमान के लिए मामले के अंदर एक तापमान सेंसर लगाने का फैसला किया। डिस्प्ले लगभग सभी Arduino पिन को खा जाता है, सौभाग्य से एनालॉग पिन A5 अप्रयुक्त है, इसलिए मैंने एक TMP36 को बांध दिया। मैंने एक DHT22 का भी परीक्षण किया, लेकिन यह इस एप्लिकेशन के लिए बहुत अधिक है।

टीएमपी 36 के लिए बहुत सारे उदाहरण हैं, मैंने इनमें से एक को एक समारोह में कॉपी किया है। TMP35 में 3 पिन होते हैं, विन 5V पर जाता है, GND ग्राउंड पर जाता है और आउट A5 पिन करता है। मैंने विन और जीएनडी के बीच 0.1uF सिरेमिक कैपेसिटर रखा। वे कहते हैं कि इसकी जरूरत है। शायद इस मामले में यह बेकार है, लेकिन … मैंने बेहतर तापमान पढ़ने के लिए Arduino एनालॉग संदर्भ वोल्टेज को 3.3v पिन पर भी सेट किया है। इस मामले में अभी भी बेकार है, लेकिन …

चरण 3: Arduino कोड

कृपया इस चरण में स्पष्टीकरण का पालन करने के लिए शामिल Arduino कोड को डाउनलोड करें और खोलें। मैंने कोड में बाढ़ के बिना स्पष्ट होने के लिए पर्याप्त टिप्पणियां छोड़ने की कोशिश की।

आपको निश्चित रूप से MCUFRIEND_kbv और Adafruit GFX लाइब्रेरी की आवश्यकता होगी। दोनों Arduino IDE से आसानी से इंस्टॉल किए जा सकते हैं।

कार्यक्रम को इस तरह के वर्गों में विभाजित किया जा सकता है:

1. सभी वैश्विक चर और अन्य आवश्यक सामग्री को परिभाषित और घोषित करें
2. डिस्प्ले को इनिशियलाइज़ करें, बाहरी संदर्भ सेट करें और UI को ड्रा करें (यह सब सेटअप () फ़ंक्शन में निहित है, क्योंकि इसे केवल एक बार चलाना चाहिए)
3. सीरियल कनेक्शन से डेटा पढ़ें और इसे सरणी में आवंटित करें (लूप () फ़ंक्शन)
4. बाहरी अस्थायी सेंसर डेटा पढ़ें (readExtTemp () फ़ंक्शन)
5. प्रदर्शन पर डेटा प्रिंट करें (प्रिंटडेटा () फ़ंक्शन)
6. लूप पर वापस

खंड 1: घोषणाएं और परिभाषाएं

कोड के प्रारंभिक खंड में, मैंने बहुत सारे पॉइंटर्स और सरणियों का उपयोग किया है, इसलिए मैं चक्रों के लिए लिखने के लिए कोड की बहुत सारी दोहराव वाली पंक्तियों को संक्षिप्त में निचोड़ने में सक्षम हूं। हाँ, मैं आलसी हूँ। जैसा कि आप देख सकते हैं कि मैंने एक पॉइंटर ऐरे घोषित किया है और इसे pics.h फ़ाइल से सभी चित्रों के साथ पॉप्युलेट किया है। इससे सभी चिह्नों को खींचने के लिए FOR साइकिल चाल करना संभव हो गया।

खंड 2: सेटअप (), ज्यादातर यूआई ड्राइंग

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

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

जैसा कि आप कोड में देख सकते हैं, मैंने एसडी कार्ड पर चित्रों का उपयोग करने से बचने का फैसला किया, क्योंकि यह वास्तव में लोड करने में धीमा है। मैंने PROGMEM मेमोरी में सभी चिह्नों को शामिल करने और समर्पित drawLine() कमांड के साथ रेखाएँ खींचने का निर्णय लिया। यह छोटे UI सुधारों के लिए भी उपयोगी है।

यूआई को गहराई की झलक देने के कमजोर प्रयास में, मैंने अलग-अलग रंगों के साथ और एक छोटे से ऑफसेट के साथ दो सब कुछ (रेखाएं, आयत, चित्र) खींचा। अफसोस की बात है कि यह वह परिणाम नहीं है जिसकी मुझे उम्मीद थी, लेकिन यह चाल चलेगा।

इस फ़ंक्शन की अंतिम पंक्तियाँ TFT पर प्लेसहोल्डर्स को प्रिंट करने के लिए हैं, जब तक कि Arduino डेटा प्राप्त नहीं कर लेता।

खंड 3: मुख्य लूप (), डेटा लाने और स्वरूपण

यहां जादू होता है: सीरियल के माध्यम से डेटा प्राप्त होता है, सही चर को सौंपा जाता है और फिर मुद्रित किया जाता है। यह सब कम से कम पंक्तियों में प्राप्त करने के लिए, मैंने एक स्विच केस कमांड और एक चक्र के लिए उपयोग किया।

मैं जिस संचार प्रोटोकॉल के साथ आया था, उसे दो भागों में विभाजित किया गया है: एक प्रारंभिक निष्पादन एक बार हैंडशेक और वास्तविक डेटा भाग।

पीसी प्रोग्राम शुरू होने पर ऑटोकनेक्शन सुविधा को लागू करने के लिए हैंडशेक की आवश्यकता होती है। यह इस प्रकार चलता है:

• पीसी हैंडशेक स्ट्रिंग भेजता है (इस मामले में सिर्फ "*****;" है)
• Arduino एक प्रतिक्रिया वापस भेजता है

बहुत आसान।

डेटा भाग इस तरह दिखता है: "i: xxx, yyy, zzz, aaa,;" इसका मतलब है:

"i" सूचकांक है, मैंने इसे कोड में घटक चयनकर्ता कहा है। "मैं" मान हैं:

• मैं = 0 - नाम। निम्नलिखित मान डिस्प्ले पर एफआईआर पंक्ति में दिखाए गए नाम हैं। यह केवल एक बार डिस्प्ले पर भेजा और प्रिंट किया जाएगा, क्योंकि आज सीपीयू और जीपीयू को हॉटस्वैप करना काफी मुश्किल है…
• i=1 - पहला कॉलम डेटा - निम्न मान डिस्प्ले के बाएं आधे हिस्से में ऊपर से नीचे तक दिखाए जाते हैं। मेरे मामले में: सीपीयू अस्थायी, सीपीयू लोड, रैम उपयोग, मदरबोर्ड अस्थायी।
• i=2 - दूसरा कॉलम डेटा - जैसा कि ऊपर है, लेकिन प्रदर्शन के दाहिने आधे हिस्से के लिए
• i=3 - प्रिंट कमांड। इस मामले में कच्ची सीरियल स्ट्रिंग सिर्फ "3:;" होगी क्योंकि अन्य डेटा की जरूरत नहीं है।

"xxx, yyy, zzz, aaa" वास्तविक मान हैं। उन्हें arduino द्वारा स्ट्रिंग्स के रूप में पढ़ा जाता है और संपूर्ण स्वरूपण पीसी प्रोग्राम द्वारा किया जाता है। i=0 के लिए ये मान हार्डवेयर नामों के लिए प्रत्येक 14 वर्ण हैं। i=1 या 2 के लिए ये केवल तीन वर्ण होंगे, जो प्रति सेकंड तापमान और फ़्रेम दिखाने के लिए पर्याप्त होंगे। बेशक ":", "," और ";" इन क्षेत्रों में वर्ण वर्जित हैं।

":" घटक चयनकर्ता और मूल्यों के बीच विभाजक है, "," मान विभाजक है और ";" पंक्ति का अंत है

डेटा प्राप्त करते समय, Arduino इसे ";" तक एक स्ट्रिंग के रूप में सहेजेगा। प्रतीक प्राप्त होता है, तो यह ":" प्रतीक की तलाश करेगा और घटक चयनकर्ता मान प्राप्त करने के लिए इसका उपयोग करेगा। इसका उपयोग स्विच केस फ़ंक्शन के पालन के लिए सही प्रक्रिया का चयन करने के लिए किया जाएगा। इसका उपयोग allData सरणी में सही अनुक्रमणिका का चयन करने के लिए भी किया जाता है।

इसके बाद Arduino "," प्रतीक की तलाश करेगा और मानों को allData सरणी में डालने के लिए आगे बढ़ेगा।

यदि घटक चयनकर्ता 0 है, तो प्रिंटनाम ध्वज सत्य पर सेट हो जाएगा। यदि घटक चयनकर्ता 3 है, तो readExtTemp () और प्रिंटडेटा () फ़ंक्शन कहलाते हैं।

धारा 4: readExtTemp () फ़ंक्शन

यहाँ कहने के लिए बहुत कुछ नहीं है, यह पिन A5 से 32 बार पढ़ता है और तापमान मान को एक स्ट्रिंग के रूप में आउटपुट करता है। मैं विद्रोहियों के साथ हूं, इसलिए मैं सेल्सियस का उपयोग करता हूं। 100°C से अधिक कुछ भी गलत है इसलिए इसे डिस्प्ले पर "---" के रूप में दिखाया जाएगा। 100 डिग्री सेल्सियस से कम किसी भी चीज़ के लिए डिस्प्ले पर 3 वर्णों के स्थान को कवर करने के लिए पर्याप्त स्थान रखने के लिए प्रारूपित किया जाएगा। सेंसर को हटाना और फिर से लगाना संभव है और कोई अजीब मूल्य नहीं दिखाया जाएगा।

धारा 5: प्रिंटडेटा () फ़ंक्शन

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

धारा 6: लूप पर वापस

स्वयं को पर्याप्त समझाते हुए, मैं कहूंगा …

pics.h फ़ाइल

यहां मैंने UI के लिए सभी आइकन संग्रहीत किए हैं। डिस्प्ले में शामिल एसडी कार्ड रीडर का उपयोग करना संभव है, लेकिन मेरे पास अपने काले और सफेद आइकन के लिए Arduino में पर्याप्त मेमोरी बची है।

मैंने उन्हें जूनियर आइकन एडिटर के साथ डिज़ाइन किया है क्योंकि यह मुफ़्त है और पिक्सेल पेंटिंग छोटे आइकन के लिए काफी अच्छा है। मुझे SKAARHOJ ऑनलाइन टूल के साथ आइकन फाइलों (पीएनजी के रूप में सहेजी गई) को कनवर्ट करना पड़ा।

चरण 4: विजुअल बेसिक कोड

यहाँ वीबी कोड है

नोटिस: यह पहली बार है जब मैं विजुअल स्टूडियो प्रोजेक्ट साझा करता हूं। मैंने अभी प्रोजेक्ट फ़ोल्डरों की प्रतिलिपि बनाई है और उन्हें ज़िपित किया है। अगर यह काम नहीं करता है, तो कृपया मुझे इस तरह की परियोजनाओं को साझा करने का एक बेहतर तरीका बताएं। धन्यवाद।

जैसा कि मैंने पहले कहा, मैं सी# या अन्य भाषाओं में जीयूआई बनाने में असमर्थ हूं, लेकिन मुझे बहुत समय पहले विजुअल बेसिक में कुछ अनुभव हुए थे। मैंने विजुअल बेसिक वातावरण के साथ विजुअल स्टूडियो कम्युनिटी संस्करण (यह बिल्कुल मुफ्त है) डाउनलोड किया। खैर, मुझे बहुत सी चीजों का पता लगाना था, क्योंकि पिछली बार जब मैंने वीबी का इस्तेमाल किया था तो यह संस्करण 2005 या ऐसा था … लेकिन इंटरनेट हमेशा की तरह अच्छे संकेतों से भरा है।

कुछ इंटरफ़ेस सामग्री का पता लगाने के बाद, नया संस्करण वास्तव में पुराने की तुलना में आसान और अधिक लचीला है।

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

"फाइनल" प्रोग्राम पॉपअप मेनू के साथ सिर्फ एक ट्रे आइकन है जो विभिन्न नियंत्रण दिखाता है और दो लिस्टबॉक्स के साथ एक मुख्य फॉर्म दिखाता है जो Arduino को भेजे गए डेटा को दिखाता है।

मैंने एक ऑटोकनेक्ट फ़ंक्शन और "बूट पर प्रारंभ करें" फ़ंक्शन लागू किया। उस पर और बाद में।

मुख्य कार्यक्रम OpenHardwareMonitor लाइब्रेरी और RivaTuner साझा मेमोरी लाइब्रेरी का उपयोग करके विभिन्न उदाहरणों और कोड के स्निपेट्स का एक अनुकूलन है।

कार्यक्रम इस प्रकार है:

• OpenHardwareMonitor और RTSSSm पुस्तकालयों से डेटा प्राप्त करें
• संचार प्रोटोकॉल के लिए सभी डेटा तैयार और प्रारूपित करें
• Arduino को डेटा भेजें
• धोये और दोहराएं

बेशक हार्डवेयर नाम शुरुआत में पढ़े जाते हैं और केवल एक बार भेजे जाते हैं।

एफपीएस काउंटर केवल तभी सक्रिय होता है जब एक संगत ऐप का उपयोग किया जाता है (उदाहरण के लिए एक गेम, एक 3 डी मॉडलिंग प्रोग्राम, और इसी तरह), अन्यथा "---" प्लेसहोल्डर को डिस्प्ले पर भेजा जाएगा।

मैं गहराई से यह नहीं बताऊंगा कि पुस्तकालयों से मूल्य कैसे प्राप्त करें, क्योंकि यह इंटरनेट पर अच्छी तरह से प्रलेखित है और कोड से कुछ हद तक समझ में आता है। केवल OpenHardwareMonitor (अब से OHMonitor पर, क्योंकि जीवन बहुत छोटा है) पुस्तकालय के माध्यम से दिखाने के लिए मदरबोर्ड तापमान प्राप्त करने की समस्याओं के बारे में बताना चाहता हूं। मेरे पास एक Asus Maximus VIII Gene MoBo है, जो मदरबोर्ड पर एक fu**ton तापमान सेंसर से लैस है, लेकिन OHMonitor ने उन्हें तापमान सेंसर #1, #2… #n और कहीं भी तापमान स्थान निर्दिष्ट नहीं किया है। इसलिए मुझे भयानक आसुस एआई सूट सॉफ्टवेयर स्थापित करना पड़ा, जहां सेंसर में कम से कम NAMES हों और दो कार्यक्रमों के बीच विभिन्न तापमानों की तुलना करें। ऐसा लगता है कि OHMonitor के लिए मेरा मदरबोर्ड जेनेरिक टेम्प सेंसर # 2 है, इसलिए जैसा कि आप MoBo सामान के तहत Timer1_tick सब में देख सकते हैं, मुझे सही रीडिंग प्राप्त करने के लिए "# 2" स्ट्रिंग वाले सेंसर नाम की तलाश करनी थी।

टीएल; डीआर: आपको अपने लिए सही मदरबोर्ड तापमान सेंसर की देखभाल करनी होगी। बाकी शायद जाना अच्छा है।

हालाँकि यह सिर्फ संस्करण 1 है, मैं इस गैजेट को अपना अन्य पीसी स्थापित करने की योजना बना रहा हूं, इसलिए मैं शायद सेंसर का चयन करने का एक तरीका लागू करूंगा और शायद चलते-फिरते Arduino पर इंटरफ़ेस को फिर से डिज़ाइन कर दूंगा।

ऑटोकनेक्ट फंक्शन

यह फ़ंक्शन वास्तव में सरल है: यदि पीसी एक Arduino से जुड़ा नहीं है, तो प्रत्येक x मिलीसेकंड (टाइमर 1 पर आधारित) इस फ़ंक्शन को कहा जाता है। यह पीसी पर हर COM पोर्ट से जुड़ने की कोशिश करता है, सफल होने पर यह हैंडशेक स्ट्रिंग "*****;" भेजता है। यदि उत्तर "R" है, तो सही उपकरण जुड़ा हुआ है और सामान्य प्रक्रिया का पालन किया जाता है। अन्यथा, यह अगले COM पोर्ट का प्रयास करता है।

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

बूट फ़ंक्शन पर प्रारंभ करें

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

सिस्टम ट्रे चिह्न

NotifyIcon और ContextMenu ऑब्जेक्ट्स के लिए धन्यवाद, मैं ऐप को नियंत्रित करने के लिए एक आसान और मोटा तरीका लागू करने में सक्षम हूं। ट्रे आइकन पर बस राइट क्लिक करें और मेनू दिखाई देता है। ये ओपियन हैं:

• बूट पर प्रारंभ करें: बूट फ़ंक्शन पर प्रारंभ को सक्षम या अक्षम करने के लिए आप इसे चेक और अनचेक कर सकते हैं
• ऑटोकनेक्ट: ऊपर जैसा ही है, लेकिन ऑटोकनेक्ट फ़ंक्शन को संभालता है
• कनेक्ट/डिस्कनेक्ट: यह कनेक्शन को संभालता है। ऑटोकनेक्शन सक्षम के साथ काम नहीं करता
• ताज़ा करने का समय: एक ड्रॉप डाउन सबमेनू देता है, आप ताज़ा समय 1 से दस सेकंड तक चुन सकते हैं
• अधिकतम करें: मुख्य विंडो खोलता है। आइकन पर डबल क्लिक करने के समान
• बाहर निकलें: आत्म व्याख्यात्मक

सॉफ्टवेयर का संकलन

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

आप यहां OpenHardwareMonitor लाइब्रेरी पा सकते हैं। आपको सॉफ्टवेयर डाउनलोड करना होगा, ज़िप फाइल को खोलना होगा और प्रोजेक्ट फोल्डर में OpenHardwareMonitorLib. DLL फाइल को कॉपी करना होगा।

यहां RTSSharedMemoryNET लाइब्रेरी का लिंक दिया गया है, आपको अपने आर्किटेक्चर के लिए डाउनलोड और कंपाइल करना होगा, फिर RTSS[TL;DR]moryNET. DLL को yout प्रोजेक्ट फोल्डर में कॉपी करना होगा।

अब आपको अपने कोड में एक संदर्भ जोड़ने की जरूरत है, यहां निर्देश दें

बस एक ही आर्किटेक्चर के लिए RTSS[TL; DR]moryNET और PCHwMon सर्वर प्रोजेक्ट दोनों को संकलित करना सुनिश्चित करें।

मैंने एक रेडीमेड सेटअप प्रोग्राम शामिल किया है, ताकि आप विजुअल बेसिक के साथ छेड़छाड़ किए बिना पूरी चीज इंस्टॉल कर सकें। यह x86 के लिए संकलित है, x86 और x64 दोनों आर्किटेक्चर पर काम करेगा। इसे चलाने के लिए. NET Framework 4.7.2 की आवश्यकता होती है।

किसी भी स्थिति में, आपको RivaTuner इंस्टॉल करना होगा। आप इसे यहां एक स्टैंडअलोन ऐप के रूप में पा सकते हैं या आप एमएसआई आफ्टरबर्नर इंस्टॉल कर सकते हैं, जिसमें RTServer शामिल होना चाहिए।

चरण 5: अंतिम हार्डवेयर कार्यान्वयन