स्विच के साथ एलईडी चालू और बंद करें

Question

मैं कोड लिखने की कोशिश कर रहा हूं कि जब यह बंद हो जाए और एक स्पर्श पुश बटन स्विच का उपयोग कर रहा हो तो इसे चालू करने के लिए एक एलईडी प्राप्त करें। मैंने लिखा है कि मेरा मानना ​​है कि वायरिंगपाइ लाइब्रेरी के साथ सही कोड है, लेकिन मैं केवल इसे चालू करने के लिए प्राप्त कर सकता हूं जब यह बंद होता है और इसके बाद इसे बंद करने के लिए नहीं मिल सकता है। बहुत ही कम उदाहरणों पर और कई बार-बार दबाने के बाद जब एलईडी चालू होगी और मैं बटन दबाऊंगा, लेकिन मुझे यकीन है कि यह काम करने वाला नहीं है।

#include <wiringPi.h>
int main (void)
{
    wiringPiSetup ();
    pinMode (0, OUTPUT);
    pinMode (1, INPUT);
    digitalWrite (0, LOW);
    for(;;)
    {
        if(digitalRead (1) == LOW)
        {
            if(digitalRead (0) == HIGH)
                digitalWrite (0, LOW);
            else if(digitalRead (0) == LOW)
                digitalWrite (0, HIGH);
         }
     }
     return 0;
}

मैंने एक छवि संलग्न की है कि सर्किट कैसे वायर्ड है।

Comments

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

@ माइक मैं ऐसा नहीं मानता। यदि कोई कथन संसाधित होने के बाद मैं एक विलंब सम्मिलित करने का प्रयास करूंगा।

@duskwuff यह सवाल निश्चित रूप से प्रोग्रामिंग के बारे में है।

एक स्थानीय वैरिएबल रखें जिसमें लेड की चालू स्थिति (ON / OFF) हो (शायद एक एनम के माध्यम से) आउटपुट पिन की स्थिति को पढ़ने की कोशिश न करें। इसके बजाय इनपुट पिन के उच्च से निम्न तक इनपुट स्थिति परिवर्तन के किनारे का पता लगाएं। फिर स्थानीय चर वर्तमान स्थिति को अद्यतन करें: outputimagevar = (outputimagevar == उच्च)? कम ज्यादा; तब डिजिटलवाइट (0, आउटपुटमेजवर); फिर, जब इनपुट LOW से HIGH में बदलता है, तो HIGH से LOW डिटेक्शन लॉजिक को रीसेट करें। इसके अलावा, इनपुट स्थिति को 'डिसाइड' करना सुनिश्चित करें, शायद आश्वासन देकर (कहें) 3 लगातार एक ही राज्य को दिखाते हैं।

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

Answer 1

कोड के लिए वायरिंग सही लगती है।

समस्या यह है कि कोड बहुत तंग पाश में है। सिद्धांत रूप में, जब बटन दबाया जाता है, तो लूप बॉडी बार-बार एलईडी को चालू और बंद करता है। सिद्धांत रूप में, एक 50/50 मौका होगा जब बटन जारी किया जाता है, तो एलईडी को (या बंद) छोड़ दिया जाता है। क्या आप बटन दबाए जाने पर चमक में बदलाव को नोटिस करते हैं। गौर करने के लिए पर्याप्त नहीं हो सकता है।

व्यवहार में, एलईडी को छोड़ने की प्रवृत्ति का कारण यह है कि आप यह देखने के लिए परीक्षण करते हैं कि क्या यह पहले से ही चालू है। पिन 0 हाई लिखना आउटपुट पर 3.3 V लागू होता है। लेकिन वह तार एलईडी से जुड़ा हुआ है और पिन आउटपुट होने के लिए कॉन्फ़िगर किया गया है। एलईडी वोल्टेज को काफी कम कर सकता है क्योंकि इसे पढ़ने पर हाई के रूप में पंजीकृत नहीं किया जा सकता है, लेकिन कभी-कभी ऐसा होता है क्योंकि यह कटऑफ के पास है।

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

#include <wiringPi.h>
int main (void)
{
    wiringPiSetup ();
    pinMode (0, OUTPUT);
    pinMode (1, INPUT);
    digitalWrite (0, LOW);

    int prevButton = HIGH, LED = 0;

    for(;;)
    {
        if(prevButton == HIGH && digitalRead(1) == LOW)  // a falling edge
        {
            prevButton = LOW;

            if(LED)
            {
                LED = 0;
                digitalWrite(0, LOW);
            }
            else
            {
                LED = 1;
                digitalWrite(0, HIGH);
            }
        }
        else if(prevButton == LOW && digitalRead(1) == HIGH)  // a rising edge, do nothing
        {
            prevButton = HIGH;
        )

        // Add a delay here to debounce the button 

    }
    return 0;
}

Answer 2

वर्तमान GPIO राज्य से इसे हटाने की कोशिश करने के बजाय सामान्य चर में "राज्य" बनाए रखना अधिक सरल है।

इसके अलावा "व्यस्त-लूप" प्रत्येक सीपीयू चक्र का उपभोग करेगा ओएस प्रक्रिया की अनुमति देगा; इस तरह की एक सरल प्रक्रिया के लिए, आप देखेंगे कि आपका सीपीयू लोड 100% तक बढ़ जाएगा! आपको usleep()उदाहरण के लिए कॉल के साथ अन्य कार्यों के लिए सीपीयू को त्यागने की प्रक्रिया की अनुमति देनी चाहिए । देरी भी स्विच को डी-बाउंस करने का काम करेगी।

#include <wiringPi.h>
#include <unistd.h>

int main (void)
{
  wiringPiSetup ();
  pinMode (0, OUTPUT);
  pinMode (1, INPUT);
  digitalWrite (0, LOW);

  // Initial state
  int led = LOW ;
  bool button_down = (digitalRead(1) == LOW) ;

  for(;;)
  {
    // If button-down event (Hi-lo transition)...
    if( !button_down && digitalRead(1) == LOW )
    { 
      // Keep button state
      button_down = true ;

      // Toggle LED state
      led = (led == LOW) ? HIGH : LOW ;
      digitalWrite( 0, led ) ;
    }
    // Button up event...
    else if( button_down && digitalRead(1) == HIGH ) 
    {
      // Keep button state
      button_down = false ;
    }

    usleep( 10000 ) ;
  }

  return 0;
}