क्या मेरे कार्यक्रम के लिए सिर्फ 1 प्रोसेसर कोर हो सकता है?

12

मुझे GPIO पिन पर उच्च -> निम्न और निम्न -> उच्च सिग्नल एज के बीच समय का अंतर है। मैंने सरल प्रोग्राम लिखा है जो ऐसा करता है। कुछ समय तक इसे चलाने के बाद मैं परिणाम (0,01 s रूपांतरों) से काफी खुश था। लेकिन समय-समय पर 0,5 s त्रुटि जैसी थी। मैं सोच रहा था कि यह उस समय चल रही कुछ अन्य सिस्टम प्रक्रिया के कारण हो सकता है। तो मेरा सवाल है:

क्या मैं अपने प्रोग्राम के लिए एक प्रोसेसर कोर आरक्षित कर सकता हूं और सिस्टम के लिए अन्य 3 कोर दे सकता हूं?

मैं रास्पियन जेसी लाइट का उपयोग कर रहा हूं, इसलिए मुझे लगता है कि इसे चलाने के लिए 3 कोर पर्याप्त होंगे।

operating-systems process

— NonStandardModel
स्रोत

4

मुझे लगता है कि आप GPIO पिन की स्थिति के लिए लूप में मतदान कर रहे हैं। यह अतिसंवेदनशील है कि ऑपरेटिंग सिस्टम आपके प्रोग्राम को निष्पादित करने का निर्णय कैसे लेता है, जो कि अपना अधिकांश समय सीपीयू को व्यस्त रखने में बिताएगा, जबकि वास्तव में उपयोगी कुछ भी नहीं है। आप किसी दिए गए GPIO पिन पर एक बाधा को स्थापित करने का एक तरीका देखना चाहते हैं, जिसका उपयोग आप GPIO पिन पर सिग्नल किनारों के बीच अपने प्रोग्राम को सोने के लिए कर सकते हैं।

— फ्लोरियन कैस्टेलन

4

यह पता लगाएं कि आपकी परियोजना क्या है, लेकिन कभी-कभी एक माइक्रोकंट्रोलर एक बेहतर फिट होता है, खासकर जब आपको अधिक वास्तविक समय जैसी प्रणाली की आवश्यकता होती है। Arduino बहुत सारे विकल्प प्रदान करता है, और आप अपना कार्यक्रम C / C ++ में लिख सकते हैं।

— स्नेकडोक

@Florian RPi.GPIO में एक फंक्शन है जो इंटरप्ट के समान है। यह कार्यक्रम का पता लगाने तक कार्यक्रम को अवरुद्ध कर देगा (स्रोत: sourceforge.net/p/raspberry-gpio-python/wiki/Inputs )।

— NonStandardModel

@ स्नेकडॉक मुझे पता है कि माइक्रोकंट्रोलर बेहतर है। मैं इससे बचने की उम्मीद कर रहा था, क्योंकि मुझे माइक्रोसेकंड परिशुद्धता की आवश्यकता नहीं है। एक सेकंड का 1/100 पर्याप्त से अधिक है। इसके अलावा मुझे बस समय की आवश्यकता है, इसलिए यदि कोई देरी है तो मैं उम्मीद कर रहा था कि शुरुआत और रोक के लिए समान होगा। यदि यह काम नहीं करता है तो मुझे डेटा स्टोर करने के लिए आरपीआई से जुड़े माइक्रोकंट्रोलर के साथ जाना होगा।

— NonStandardModel

1

या PI पर चलने वाला Realtime OS प्राप्त करें। आपके सेटअप के साथ समस्या यह है कि यह OS द्वारा "सर्वश्रेष्ठ प्रयास" पर निर्भर करता है। आपके कार्यक्रम के GPIO के विशेषाधिकार प्राप्त उपयोग का अनुरोध करने पर उसी समय और क्या चल रहा है, इस पर निर्भर करते हुए, यह उस ओएस पर प्रदर्शन कर रहे अन्य कार्यों के पीछे कतारबद्ध हो सकता है। आप उपयोगकर्ता कार्यक्रम को सिस्टम कार्यों की तुलना में कम प्राथमिकता देंगे। प्रीमेशन भी है, जिसका अर्थ है कि आपके प्रोग्राम के रनटाइम के दौरान इसे चलाने के लिए एक और प्रक्रिया के लिए OS द्वारा "पॉज़ किया गया और एक तरफ सेट" किया जा सकता है, जिसका अर्थ है कि आपकी टाइमिंग अवलोकनों को तिरछा किया जा सकता है।

— स्नेकॉक

13

एक कोर समर्पित करना शायद ओवरकिल है।

मेरा सुझाव है कि आप मेरी पिगियो लाइब्रेरी को आज़माएँ । डिफ़ॉल्ट रूप से यह GPIO स्तर में 10। के भीतर परिवर्तन होगा।

एक त्वरित परीक्षण के रूप में, मेरा सुझाव है कि आप इस पायथन उदाहरण को देखें , जो कि GPIO पर अंतिम संक्रमण के बाद से किसी भी GPIO स्तर के संक्रमण और microseconds में समय को मुद्रित करेगा।

पिसी को डिफ़ॉल्ट रूप से जेसी लाइट में स्थापित नहीं किया गया है। या तो लिंक्ड साइट से नवीनतम इंस्टॉल करें या रिपॉजिटरी में पुराने संस्करण को स्थापित करें।

sudo apt-get install pigpio python-pigpio python3-pigpio

pigpio - Library for Raspberry Pi GPIO control
python-pigpio - Python module which talks to the pigpio daemon (Python 2)
python3-pigpio - Python module which talks to the pigpio daemon (Python 3)

— joan
स्रोत

मैं आपके पिगियो पुस्तकालय की कोशिश करूंगा। अभी मुझे एक और प्रोजेक्ट खत्म करना है, लेकिन मैं इस पर वापस जाऊंगा। मैं कुछ हफ्तों में रिपोर्ट करूंगा। धन्यवाद!

— NonStandardModel

4

आप इस Cyberciti लेखschedutils में वर्णित के रूप में अपने कार्यक्रम को एक कोर में बंद कर सकते हैं :

sudo apt-get install schedutils
sudo taskset -c 3 -p 13545  # Lock PID 13545 to core 3

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

nice -n -20 your-program

आपके समय के मुद्दों के कुछ अन्य संभावित कारण हैं। ये कुछ भी करने में उतने आसान नहीं हैं:

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

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

— एमिल विकासस्ट्रम
स्रोत

2

अच्छा होने के बजाय प्रक्रिया को वास्तविक समय की प्राथमिकता देना बेहतर होगा जो यह सुनिश्चित करेगा कि यह गैर-वास्तविक समय प्रक्रियाओं के लिए प्राथमिकता में चले।

— जौन

अच्छी बात है, मैं उस बारे में एक टिप्पणी जोड़ूंगा।

— एमिल विक्रोत्स्म

1

"gc.disable ()" यदि आप कचरा संग्राहक को अक्षम करते हैं तो क्या होता है?

— कीन

@ कीन आप एक मेमोरी लीक प्राप्त कर सकते हैं। यह कहें कि आपके पास एक ऑब्जेक्ट A है जिसमें एक चर है जो B. Python को इंगित करता है, इस संदर्भ को एक संख्या के रूप में ट्रैक करेगा, यह जानता है कि B के पास 1 ऑब्जेक्ट है जो इसकी ओर इशारा करता है। जब आपको इसकी आवश्यकता न हो, तब A निकालें। बी के लिए संदर्भ संख्या कम हो जाएगी, और अगर यह 0 हिट करता है तो पायथन बी को भी मुक्त कर सकता है। इसे रेफरेंस काउंटिंग कहा जाता है। लेकिन अब कहते हैं कि B का A पर वापस संदर्भ है। अब आपके पास एक दूसरे को इंगित करने वाली वस्तुओं का एक समूह है। उनमें से कोई भी 0 हिट नहीं करेगा और मुक्त किया जाएगा। जीसी ऐसे समूहों को ढूंढ सकता है और उन्हें हटा सकता है जब मुख्य कार्यक्रम "क्लस्टर" में इंगित नहीं करता है।

— एमिल विक्रोस्म

1

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

— NonStandardModel

2

चूंकि आपको समय की आवश्यकताएं हैं, रास्पबेरी पाई अब इसके लिए उपयुक्त मंच नहीं है। यह वास्तविक समय का मंच नहीं है और समय को हस्तक्षेप के विभिन्न स्रोतों द्वारा फेंक दिया जा सकता है।

इसके बजाय आपको इस समय को मापने के लिए एक माइक्रोकंट्रोलर का उपयोग करना चाहिए, अधिमानतः इंटरप्ट का उपयोग करना, और बाद में पाई को जानकारी पास करना।

— मैक्सथन चान
स्रोत

1

यह एक रास्पबेरी पाई पर GPIO पिन पर व्यवधान प्राप्त करना संभव नहीं है?

— फ्लोरियन कैस्टेलन

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

— सीन होलीहेन

1

आपकी आवश्यकता के अनुसार मुझे नहीं लगता कि आपको एक ही कोर प्रोसेसर का उपयोग करने की आवश्यकता है। आपको यह सुनिश्चित करने की आवश्यकता है कि आपका कार्यक्रम हर समय चलता है। इसे प्राप्त करने के लिए, आप अपने कार्यक्रम की प्राथमिकता बहुत अधिक निर्धारित कर सकते हैं, ताकि यह किसी अन्य प्रक्रिया से परेशान न हो।

जहाँ तक मुझे OS (सामान्य प्रयोजन OS) का पता है, जिसका उपयोग हम वास्तविक समय प्रणालियों में उपयोग करने के लिए डिज़ाइन नहीं किया गया है, इसलिए यदि आप अपनी प्रक्रिया को वास्तविक समय में चलाना चाहते हैं, ताकि कोई अन्य प्रक्रिया इसे बाधित न करे, तो आपको जाने की आवश्यकता है रीयल टाइम OS (RTOS) के लिए। शायद वे कोर चयन के साथ आएंगे। :)

— विश्वजीत विशु
स्रोत

1

वहाँ अच्छा मुक्त RTOS हैं?

— कीन

RTLinux और Vxworks RTOS के उदाहरण हैं और वे अच्छे भी हैं। लेकिन आपको स्थापित करने से पहले ओएस (इसके निर्माण के लिए क्या फ़ोकस था) के बारे में अध्ययन करने की आवश्यकता है, ताकि यह आपकी आवश्यकताओं को पूरा कर सके।

— विश्वजीत विशु