🧑🏿‍🤝‍🧑🏽 ⚕️ 👨🏼‍🏭 डिजिटल प्रयोगशाला किट पर आधारित प्रयोग 🙋🏼 🍘 🐠

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

जैसा कि हमने पहले ही कहा है, बोर्ड में विभिन्न बाहरी मॉड्यूल को जोड़ने के लिए कनेक्टर्स के समूह हैं: सेंसर, एक्चुएटर और कुछ मानक सूचना बसों का उपयोग करने वाले डिवाइस।

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

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

हम विस्तार कार्ड पर XP15 कनेक्टर को एलईडी कनेक्ट करते हैं, जिसे अतिरिक्त रूप से चार तारों या एक एडेप्टर का उपयोग करके "RGB_LED" चिह्नित किया जाता है। हम एक सामान्य कैथोड (सामान्य "माइनस") के साथ एक एलईडी का उपयोग करते हैं, इसलिए सबसे लंबा एलईडी आउटपुट GND ("ग्राउंड") टर्मिनल से जुड़ा है, और शेष एलईडी आउटपुट RED / D5 (लाल), BLUE / D6 (नीला), GREEN से जुड़े हैं / डी 9 (हरा)।

D5, D6 और D9, Arduino डिजिटल पिन हैं, जिस पर आप एलईडी की चमक को नियंत्रित करने के लिए पल्स चौड़ाई मॉड्यूलेशन (PWM) प्राप्त कर सकते हैं। प्रशिक्षण मैनुअल आवश्यक न्यूनतम PWM सिद्धांत और Arduino में इस मॉडुलन को लागू करने का तरीका प्रदान करता है।

यहाँ प्रोग्राम (स्केच) के लिए कोड है जो RGB LED की चमक को नियंत्रित करता है:

स्पॉइलर

//    RGB 
//-----------------------------------------------------------------------
//   
int redPin = 5;
int greenPin = 9;
int bluePin = 6;
//-----------------------------------------------------------------------
/*     1      Arduino
    */
void setup() 
{

}

//-----------------------------------------------------------------------
/*       setup         .*/

void loop() {
   /*    256 .    value      1.*/
   for(int value = 0 ; value <= 255; value ++) { 
    //      0
    analogWrite(redPin, 255-value);
    //  
    analogWrite(greenPin, value);
    //   
    analogWrite(bluePin, 0);
    //    30 
    delay(30);
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    //  
    analogWrite(redPin, 0);
    //      0
    analogWrite(greenPin, 255-value);
    //  
    analogWrite(bluePin, value);
    //    30 
    delay(30);
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    //  
    analogWrite(redPin, value);
    //  
    analogWrite(greenPin, 0);
    //      0
    analogWrite(bluePin, 255-value);
    //    30 
    delay(30);
  }

 //  loop    
}

जब प्रोग्राम चल रहा होता है, तो एलईडी सुचारू रूप से उत्सर्जित रंग को लाल से हरा, फिर हरे से नीले और फिर नीले से लाल से बदल देता है।
हम अपने कार्यक्रम को इस तरह से पूरक करते हैं कि एलसीडी प्रत्येक रंग के चमक के अनुरूप मूल्यों को न्यूनतम (0) से अधिकतम (255) समय के प्रत्येक क्षण में प्रदर्शित करता है। बिगाड़ने के तहत संशोधित कोड दिया गया है।

स्पॉइलर

//    RGB 
//-----------------------------------------------------------------------
//   
int redPin = 5;
int greenPin = 9;
int bluePin = 6;
//    
int pwmRed;
int pwmGreen;
int pwmBlue;
//-----------------------------------------------------------------------
//   LiquidCrystalRus
#include <LiquidCrystalRus.h>
//  ,   LiquidCrystalRus
#include <LiquidCrystalExt.h>
#include <LineDriver.h>

//-----------------------------------------------------------------------
/*  ,      RS,EN,DB4,DB5,DB6,DB7 */
LiquidCrystalRus lcd(A1, A2, A3, 2, 4, 7);

//     1      Arduino
void setup() 
{
  //  LCD - 16 , 2 
  lcd.begin(16, 2);
  //      ()      
  lcd.print(" RED GREEN BLUE");
  
}

//-----------------------------------------------------------------------
//       setup         .

void loop() {
   /*    256 .    value      1.*/
   for(int value = 0 ; value <= 255; value ++) { 
    pwmGreen = value;
    pwmRed = 255 - value;
    //      0
    analogWrite(redPin, pwmRed);
    //  
    analogWrite(greenPin, pwmGreen);
    //   
    analogWrite(bluePin, 0);
    //    30 
    delay(30);
    Display();
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    pwmBlue = value;
    pwmGreen = 255 - value;
    //  
    analogWrite(redPin, 0);
    //      0
    analogWrite(greenPin, pwmGreen);
    //  
    analogWrite(bluePin, pwmBlue);
    //    30 
    delay(30);
    Display();
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    pwmRed = value;
    pwmBlue = 255 - value;
    //  
    analogWrite(redPin, pwmRed);
    //  
    analogWrite(greenPin, 0);
    //      0
    analogWrite(bluePin, pwmBlue);
    //    30 
    delay(30);
    Display();
  }

 //  loop    
}

//      ,  
void Display(){
 lcd.setCursor(0,1);
 lcd.print("                ");
 lcd.setCursor(1,1);
 lcd.print(pwmRed);
 lcd.setCursor(6,1);
 lcd.print(pwmGreen);
 lcd.setCursor(11,1);
 lcd.print(pwmBlue);
}

अब आइए बोर्ड में निर्मित बटनों का उपयोग करने का एक उदाहरण देखें।

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

Arduino में उपयुक्त कार्यक्रम डाउनलोड करें:

स्पॉइलर

//           
//-----------------------------------------------------------------------
//     LiquidCrystal
#include <LiquidCrystal.h>

//      
#define NUM_KEYS 5
//      ( )
int  adcKeyVal[NUM_KEYS] = {30, 150, 360, 535, 760};
//-----------------------------------------------------------------------
//  ,      RS,EN,DB4,DB5,DB6,DB7
LiquidCrystal lcd(A1, A2, A3, 2, 4, 7);

//-----------------------------------------------------------------------
//     1      Arduino
void setup() 
{
  //  LCD   -16   2 
  lcd.begin(16, 2);
  //      ()      

  //     Keyboard
  lcd.print("Keyboard");  
 
  //    2000 = 2 
  delay(2000); 
}

//-----------------------------------------------------------------------
//       setup         .

void loop() {
  //     key
  int key;
  
  //       ,      get_key
  key = get_key();
 
  //      
  lcd.clear();
  //      ()     
 
  //     . -      
  lcd.print(key); 
  
  //    100 = 0,1 
  delay(100);
 //  loop    
}

//-----------------------------------------------------------------------
//          
//     ,    
//     ,    
int get_key()
	{
	  int input = analogRead(A6);
	  int k;
	  for(k = 0; k < NUM_KEYS; k++) 
	    if(input < adcKeyVal[k]) 
	      return k + 1;     
	  return 0;
	}

कौन सा बटन दबाया जाता है, इसके बारे में जानकारी प्रदर्शित करने के लिए, एक एलसीडी संकेतक का उपयोग किया जाता है। यदि आप बटन दबाते हैं, तो संकेतक पर दबाए गए बटन की संख्या प्रदर्शित की जाएगी।

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

#include <LiquidCrystal.h>
LiquidCrystal lcd(A1, A2, A3, 2, 4, 7);
void setup() 
{
  lcd.begin(16, 2);
  lcd.print("Press keys");  
  delay(2000); 
}
void loop() {
  
  int input = analogRead(A6);
  lcd.clear();
  lcd.print(input); 
  delay(100);
}

इसे Arduino में लोड करने का प्रयास करें और देखें कि कौन से मान प्रदर्शित किए जाते हैं और उनकी अंशांकन के साथ तुलना करें। आइए अब हम उपरोक्त उदाहरणों का उपयोग करके एक प्रोग्राम बनाने की कोशिश करते हैं जो बटन का उपयोग करके एलईडी के नियंत्रण को लागू करता है। चलो निम्नलिखित कार्यक्षमता सेट करते हैं:

• जब आप बटन 1 (दूर बाएं) दबाते हैं, तो एक लाल बत्ती ऊपर 2 बटन पर - हरा, 3 - नीला। जब बटन फिर से दबाया जाता है, तो संबंधित प्रकाश बाहर निकल जाता है। संकेतक दिखाता है कि कौन से रंग चालू हैं।
• जब बटन 4 दबाया जाता है, तो रंग चालू और बंद हो जाते हैं,
जब बटन 5 दबाया जाता है, तो सभी रंग निकल जाते हैं।

इस तरह के एक स्केच के लिए संभावित विकल्पों में से एक है:

स्पॉइलर

//       RGB-
//-----------------------------------------------------------------------
//     LiquidCrystal
#include <LiquidCrystal.h>

//      
#define NUM_KEYS 5
//      ( )
int  adcKeyVal[NUM_KEYS] = {30, 150, 360, 535, 760};
#define redLED 5
#define greenLED 9
#define blueLED 6
//-----------------------------------------------------------------------
//  ,      RS,EN,DB4,DB5,DB6,DB7
LiquidCrystal lcd(A1, A2, A3, 2, 4, 7);
int redLEDstate = 0;
int greenLEDstate = 0;
int blueLEDstate = 0;
int flag = 0;

//-----------------------------------------------------------------------
//     1      Arduino
void setup() 
{
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(blueLED, OUTPUT);
  //  LCD   -16   2 
  lcd.begin(16, 2);
  //      ()      

  //     
  lcd.print("Try Keys + LEDs");  
 
  //    1000 = 1 
  delay(1000); 
  //    
  lcd.clear();
}

//-----------------------------------------------------------------------
//       setup         .

void loop() {
  //     key
  int key;
  //       ,      get_key
  key = get_key();
  //   ,      
  // C   flag     ,      
     if(key == 1 && flag == 0) {                                              
        digitalWrite(redLED, !digitalRead(redLED));
        flag = 1;
      }
     if(key == 2 && flag == 0) {  //   : if(key == 2 && !flag)                                            
        digitalWrite(greenLED, !digitalRead(greenLED));
        flag = 1;
      }
    if(key == 3 && !flag)  {                                              
        digitalWrite(blueLED, !digitalRead(blueLED));
        flag = 1;
      }
    if(key == 4 && !flag)  {                                              
        digitalWrite(redLED, !digitalRead(redLED));
        digitalWrite(greenLED, !digitalRead(greenLED));
        digitalWrite(blueLED, !digitalRead(blueLED));
        flag = 1;
      }
    if(key == 5 && !flag){                                              
        digitalWrite(redLED, LOW);
        digitalWrite(greenLED, LOW);
        digitalWrite(blueLED, LOW);
        flag = 1;
      }
    //      ,    
    if(!key && flag) //  if(key == 0 && flag == 1)
      {
        flag = 0;
      }        
   //        ,   
   if (digitalRead(redLED)) { //  if (digitalRead(redLED) == 1)
         lcd.setCursor(0,0);
         lcd.print("Red");
        }
        else {
         lcd.setCursor(0,0);
         lcd.print("   ");
        }
   if (digitalRead(greenLED)) {
         lcd.setCursor(5,0);
         lcd.print("Green");
        }
        else {
         lcd.setCursor(5,0);
         lcd.print("     ");
        }
    if (digitalRead(blueLED)) { 
         lcd.setCursor(11,0);
         lcd.print("Blue");
        }
        else {
         lcd.setCursor(11,0);
         lcd.print("    ");
        }

 //  loop    
}

//-----------------------------------------------------------------------
//          
//     ,    
//     ,    
int get_key()
	{
	  int input = analogRead(A6);
	  int k;
	  for(k = 0; k < NUM_KEYS; k++) 
	    if(input < adcKeyVal[k]) 
	      return k + 1;     
	  return 0;
	}

निष्कर्ष में, हम वर्णित प्रयोगों का प्रदर्शन करते हुए एक छोटा वीडियो प्रस्तुत करते हैं।

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

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

डिजिटल प्रयोगशाला किट पर आधारित प्रयोग

More articles: