धावकों, एथलीटों और खिलाड़ियों के लिए एक स्वचालित स्टॉपवॉच बनाना

इस पोस्ट में हम एक स्टॉपवॉच का निर्माण करने जा रहे हैं जो स्वचालित रूप से टाइमर शुरू करता है जब धावक चलना शुरू कर देता है और धावक अंत तक पहुंचने पर टाइमर बंद हो जाता है। प्रारंभ और समाप्ति बिंदु के बीच का बीता हुआ समय 16 x 2 एलसीडी पर प्रदर्शित होता है।

पहले एक सरल और अत्यंत सटीक Arduino स्टॉप वॉच सर्किट को कॉन्फ़िगर करना सीखना सीखें।

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

मैकेनिकल बनाम इलेक्ट्रॉनिक स्टॉपवॉच

पहले पारंपरिक मैकेनिकल हैंडहेल्ड स्टॉपवॉच अधिक आम थी, और सभी के लिए इसका इस्तेमाल किया जाता था।

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

मैकेनिकल स्टॉप क्लॉक मूल रूप से स्प्रिंग पावर के माध्यम से काम करता है, जिसे घड़ी डिवाइस के शीर्ष पर दिए गए घुंडी घुमाने से मैन्युअल रूप से घुमावदार होने की आवश्यकता होती है।

हालांकि आधुनिक डिजिटल स्टॉप घड़ियों की तुलना में, यांत्रिक प्रकारों को मिलीसेकंड की सीमा में महत्वपूर्ण रूप से आदिम और गलत माना जा सकता है।

एक Arduino का उपयोग करना

और आज माइक्रोकंट्रोलर के आगमन के साथ, ये स्टॉप घड़ियों माइक्रोसेकंड रेंज के लिए बेहद सटीक और विश्वसनीय बन गए हैं।

यहाँ प्रस्तुत Arduino स्टॉप वॉच सर्किट इन आधुनिक माइक्रोकंट्रोलर पावर्ड डिज़ाइनों में से एक है जो सबसे सटीक है, वाणिज्यिक आधुनिक स्टॉप वॉच गैजेट्स के बराबर होने की उम्मीद की जा सकती है।

आइए जानें प्रस्तावित Arduino स्टॉप क्लॉक सर्किट का निर्माण कैसे करें:

आपको निर्माण के लिए निम्नलिखित बिल सामग्री की आवश्यकता होगी:

हार्डवेयर आवश्यक है

एक Arduino LCD कीपैड शील्ड (SKU: DFR0009)

एक Arduino एक बोर्ड

एक Arduino USB केबल

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

कोड

/*
Standalone Arduino StopWatch
By Conor M - 11/05/15
Modified by Elac - 12/05/15
*/
// call the necessary libraries
#include
#include
// these are the pins used on the shield for this sketch
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7)
// variables used on more than 1 function need to be declared here
unsigned long start, finished, elapsed
boolean r = false
// Variables for button debounce time
long lastButtonPressTime = 0 // the last time the button was pressed
long debounceDelay = 50 // the debounce time keep this as low as possible
void setup()
{
lcd.begin(16, 2) // inicialize the lcd (16 chars, 2 lines)
// a little introduction :)
lcd.setCursor(4, 0) // set the cursor to first character on line 1 - NOT needed (it sets automatically on lcd.begin()
lcd.print('Arduino')
lcd.setCursor(3, 1) // set the cursor to 4th character on line 2
lcd.print('StopWatch')
delay(2000) // wait 2 seconds
lcd.clear() // clear the display
lcd.print('Press select for')
lcd.setCursor(2, 1) // set the cursor to 3rd character on line 2
lcd.print('Start & Stop')
}
void loop()
{
CheckStartStop()
DisplayResult()
}
void CheckStartStop()
{
int x = analogRead (0) // assign 'x' to the Arduino's AnalogueInputs (Shield's buttons)
if (x 600 ) // if the button is SELECT
{
if ((millis() - lastButtonPressTime) > debounceDelay)
{
if (r == false)
{
lcd.clear()
lcd.setCursor(2, 0) // needed
lcd.print('Elapsed Time')
start = millis() // saves start time to calculate the elapsed time
}
else if (r == true)
{
lcd.setCursor(2, 0) // needed
lcd.print(' Final Time ')
}
r = !r
}
lastButtonPressTime = millis()
}
}
void DisplayResult()
{
if (r == true)
{
finished = millis() // saves stop time to calculate the elapsed time
// declare variables
float h, m, s, ms
unsigned long over
// MATH time!!!
elapsed = finished - start
h = int(elapsed / 3600000)
over = elapsed % 3600000
m = int(over / 60000)
over = over % 60000
s = int(over / 1000)
ms = over % 1000
// display the results
lcd.setCursor(0, 1)
lcd.print(h, 0) // display variable 'h' - the 0 after it is the
number of algorithms after a comma (ex: lcd.print(h, 2) would print
0,00
lcd.print('h ') // and the letter 'h' after it
lcd.print(m, 0)
lcd.print('m ')
lcd.print(s, 0)
lcd.print('s ')
if (h <10)
{
lcd.print(ms, 0)
lcd.print('ms ')
}
}
}

7 सेगमेंट डिस्प्ले जोड़ना

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

जैसा कि हम पहले से ही जानते हैं कि स्टॉपवॉच एक उपकरण है जो घंटों से लेकर मिलीसेकेंड रेंज (अधिकतर) तक की संक्षिप्त अवधि को ट्रैक करने में मदद करता है। स्टॉपवॉच कार्यक्षमता के साथ सुसज्जित लगभग सभी सस्ते डिजिटल कलाई घड़ियों, लेकिन घड़ियों में से कोई भी हमारे स्वयं के लिए एक बनाने का उत्साह नहीं दे सकती है और 7 सेगमेंट एलईडी डिस्प्ले के साथ स्टॉपवॉच ढूंढना असाधारण है।

श्री अबू-हफ्स ने हमें 4 डिस्प्ले के साथ एक स्टॉपवॉच, दो मिनट के लिए और दो सेकंड (MM: SS) कॉन्फ़िगरेशन के लिए डिज़ाइन करने का सुझाव दिया। लेकिन हम में से अधिकांश के लिए यह संभव नहीं हो सकता है, इसलिए हमने मिलिसकॉन्ड रेंज के लिए दो और डिस्प्ले जोड़े हैं इसलिए अब प्रस्तावित डिज़ाइन MM: SS: mS कॉन्फ़िगरेशन में होगा।

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

सर्किट:

प्रस्तावित स्टॉपवॉच में छह आईसी 4026 होते हैं जो सात खंड प्रदर्शन चालक, छह 7 खंड एलईडी डिस्प्ले, एक अरुडिनो बोर्ड, पुश बटन के एक जोड़े और 10K प्रतिरोधों के जोड़े होते हैं।

अब आइए समझते हैं कि आईसी 4026 को 7 सेगमेंट डिस्प्ले से कैसे जोड़ा जाए।

7 सेगमेंट का डिस्प्ले किसी भी रंग का आम कैथोड डिस्प्ले हो सकता है। 7 सेगमेंट का डिस्प्ले 5 वी सप्लाई से आसानी से मारा जा सकता है, इसलिए डिस्प्ले के प्रत्येक सेगमेंट पर 330 ओम रेज़र अनिवार्य है।

अब आइए IC 4026 का पिन आरेख देखें:

• पिन # 1 क्लॉक इनपुट है।
• पिन # 2 घड़ी अक्षम है, यदि यह पिन अधिक है, तो यह डिस्प्ले पर गिनती को अक्षम करता है।
• पिन # 3 डिस्प्ले सक्षम है यदि यह पिन कम है तो डिस्प्ले को ट्यून किया जाएगा और इसके विपरीत।
• पिन # 5 कैरी-आउट है, जो आईसी 10 की गणना करते समय उच्च हो जाता है।
• पिन 6, 7, 9, 10, 11, 12, 13 डिस्प्ले आउटपुट हैं।
• पिन # 8 जीएनडी है।
• पिन # 16 Vcc है।
• पिन # 15 रीसेट किया गया है, अगर हम इस पिन को ऊंचा करते हैं तो गिनती शून्य हो जाती है।
• पिन # 4 और # 14 का उपयोग नहीं किया जाता है।

कनेक्शन आरेख प्रदर्शित करें:

7 सेगमेंट डिस्प्ले के किसी भी जीएनडी पिन को जमीन से जोड़ा जा सकता है। IC को 5V आपूर्ति या Arduino के 5V आउटपुट पिन से संचालित किया जाना चाहिए।

केवल एक डिस्प्ले के लिए उपरोक्त योजनाबद्ध, पांच अन्य डिस्प्ले के लिए समान दोहराएं।

यहाँ योजनाबद्ध बाकी है:

सर्किट 9V बैटरी से संचालित हो सकता है। दो बटन यहां दिए गए हैं, एक समय शुरू करने के लिए और दूसरा रुकने के लिए। Arduino पर रीसेट बटन दबाकर, समय गणना प्रदर्शन पर शून्य पर रीसेट हो जाएगी।

दो पुश बटन पिन # 2 और # 3 से जुड़े हैं जो Arduino / Atmega328P माइक्रोकंट्रोलर के हार्डवेयर व्यवधान हैं।

आइए समझते हैं कि रुकावट क्या है:

इंटरप्ट दो प्रकार के होते हैं: हार्डवेयर इंटरप्ट और सॉफ्टवेयर इंटरप्ट। यहां हम केवल हार्डवेयर इंटरप्ट का उपयोग कर रहे हैं।

एक रुकावट माइक्रोकंट्रोलर के लिए एक संकेत है, जो किसी घटना पर तुरंत प्रतिक्रिया करने के लिए माइक्रोकंट्रोलर बनाता है।

ATmega328P माइक्रोकंट्रोलर पिन # 2 और # 3 के साथ Arduino बोर्डों में केवल दो हार्डवेयर इंटरप्ट पिन हैं। Arduino मेगा में दो से अधिक हार्डवेयर इंटरप्ट पिन हैं।

माइक्रोकंट्रोलर एक ही समय में दो कार्य नहीं कर सकते हैं। उदाहरण के लिए बटन प्रेस और गिनती संख्या के लिए जाँच।

माइक्रोकंट्रोलर एक साथ दो घटनाओं को अंजाम नहीं दे सकते हैं, अगर हम बटन प्रेस और गिनती संख्या की जांच के लिए एक कोड लिखते हैं, तो बटन प्रेस को केवल तभी पता चलेगा जब माइक्रोकंट्रोलर कोड के बटन प्रेस डिटेक्शन टुकड़े को पढ़ता है, बाकी समय (संख्याओं की गणना करता है) बटन काम नहीं करता है।

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

इंटरप्ट सिग्नल को हमेशा सर्वोच्च प्राथमिकता दी जाती है, मुख्य फ़ंक्शन (कोड की मुख्य लाइनें) को रोका जाएगा और उस विशेष रुकावट के लिए सौंपे गए (कोड का दूसरा टुकड़ा) फ़ंक्शन को निष्पादित करेगा।

स्टॉपवॉच या सुरक्षा प्रणालियों आदि जैसे महत्वपूर्ण अनुप्रयोगों के लिए यह बहुत महत्वपूर्ण है, जहां प्रोसेसर को किसी घटना के जवाब में तुरंत कार्रवाई करने की आवश्यकता होती है।

Arduino में हम हार्डवेयर इंटरप्ट को निम्नानुसार असाइन करते हैं:

संलग्न करें (0, प्रारंभ, RISING)

• '0' का अर्थ है रुकावट संख्या शून्य (माइक्रोकंट्रोलर में सब कुछ शून्य से शुरू होता है) जो पिन # 2 है।
• 'प्रारंभ' रुकावट फ़ंक्शन का नाम है, आप यहां कुछ भी नाम दे सकते हैं।
• 'RISING' यदि पिन # 2 (जो शून्य के बीच में है) उच्च जाता है, तो इंटरप्ट फ़ंक्शन निष्पादित होता है।

संलग्नक (1, रोकना, रिझाना)

• '1' का अर्थ है बाधा संख्या एक जो पिन # 3 है।
• 'रोक' व्यवधान का नाम है।

हम 'RALLING' को 'FALLING' से भी बदल सकते हैं, अब जब इंटरप्ट पिन कम हो जाता है तो इंटरप्ट फंक्शन निष्पादित होता है।

हम “RISING” को “CHANGE” से भी बदल सकते हैं, अब जब भी इंटरप्ट पिन हाई से लो या लो से हाई हो जाता है, तो इंटरप्ट फंक्शन निष्पादित होता है।

रुकावट समारोह को निम्नानुसार सौंपा जा सकता है:

शून्य प्रारंभ () // प्रारंभ बाधा का नाम है।

{{

// यहाँ कार्यक्रम

}

रुकावट फ़ंक्शन संभव के रूप में छोटा होना चाहिए और विलंब () फ़ंक्शन का उपयोग नहीं किया जा सकता है।

यह निष्कर्ष निकालता है कि Arduino से संबंधित हार्डवेयर इंटरप्ट सॉफ़्टवेयर व्यवधान को भविष्य के लेख में समझाया जाएगा।

अब आप जानते हैं कि हमने पिन को बाधित करने के लिए स्टार्ट और स्टॉप बटन को क्यों कनेक्ट किया।

सर्किट को डायग्राम के अनुसार कनेक्ट करें बाकी सर्किट आत्म-व्याख्यात्मक है।

कार्यक्रम:

//----------------Program Developed by R.GIRISH---------------//
int vmin = 0
int vsec = 0
int vms = 0
boolean Run = false
const int Min = 7
const int sec = 6
const int ms = 5
const int reset_pin = 4
void setup()
{
pinMode(Min, OUTPUT)
pinMode(sec, OUTPUT)
pinMode(ms, OUTPUT)
pinMode(reset_pin, OUTPUT)
digitalWrite(Min, LOW)
digitalWrite(sec, LOW)
digitalWrite(ms, LOW)
digitalWrite(reset_pin, HIGH)
digitalWrite(reset_pin, LOW)
attachInterrupt(0, start, RISING)
attachInterrupt(1, Stop, RISING)
}
void loop()
{
if (Run)
{
vms = vms + 1
digitalWrite(ms, HIGH)
delay(5)
digitalWrite(ms, LOW)
delay(5)
if (vms == 100)
{
vsec = vsec + 1
digitalWrite(sec, HIGH)
digitalWrite(sec, LOW)
vms = 0
}
if (vsec == 60)
{
vmin = vmin + 1
digitalWrite(Min, HIGH)
digitalWrite(Min, LOW)
digitalWrite(reset_pin, HIGH)
digitalWrite(reset_pin, LOW)
vsec = 0
}
}
}
void start()
{
Run = true
}
void Stop()
{
Run = false
}
//----------------Program Developed by R.GIRISH---------------//
अब यह कोड समाप्त हो गया है।

स्टॉपवॉच विशेष रूप से नास्तिकों के लिए विकसित किया गया है

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

नोट: यह परियोजना एक समय में एक उपयोगकर्ता द्वारा कवर किए गए बिंदु 'बी' से बिंदु 'बी' के बीच के समय को मापने के लिए डिज़ाइन की गई है।

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

आइए सर्किट के प्रत्येक घटक को विस्तार से देखें।

घटक कार्य विवरण

सर्किट को काफी सरल रखा गया है, इसमें 16 x 2 एलसीडी मॉड्यूल, कुछ प्रतिरोधक, दो एलडीआर और एक पुश बटन होता है।

LCD और arduino के बीच का इंटरफ़ेस मानक है हम कई अन्य LCD आधारित परियोजनाओं में समान कनेक्शन पा सकते हैं।

लेजर एनालॉग का पता लगाने के लिए दो एनालॉग पिन A0 और A1 का उपयोग किया जाता है। एनालॉग पिन ए 2 पुश बटन से जुड़ा है जो स्टॉपवॉच को बांटने के लिए उपयोग किया जाता है।

तीन प्रतिरोधों, दो 4.7K और एक 10K पुल डाउन डाउन प्रतिरोधों हैं जो इनपुट पिन को कम रहने में मदद करते हैं।

इष्टतम दृश्यता के लिए एलसीडी मॉड्यूल में विपरीत समायोजन के लिए 10K पोटेंशियोमीटर प्रदान किया गया है।

प्रस्तावित सर्किट ने लेजर के लिए गलती का पता लगाने वाले तंत्र के साथ डिजाइन किया है। यदि लेजर में से कोई एक गलती है या एलडीआर के साथ ठीक से संरेखित नहीं है, तो यह एलसीडी डिस्प्ले पर एक त्रुटि संदेश प्रदर्शित करता है।

यदि START लेज़र कार्य नहीं कर रहा है, तो यह प्रदर्शित करता है कि 'laser प्रारंभ 'लेज़र काम नहीं कर रहा है'

यदि STOP लेजर कार्य नहीं कर रहा है, तो यह प्रदर्शित करता है कि 'not स्टॉप 'लेजर काम नहीं कर रहा है'

· यदि दोनों लेजर काम नहीं कर रहे हैं, तो यह प्रदर्शित करता है कि 'दोनों लेजर काम नहीं कर रहे हैं'

· यदि दोनों लेजर ठीक से काम कर रहे हैं, तो यह प्रदर्शित करता है कि 'दोनों लेजर ठीक काम कर रहे हैं'

त्रुटि संदेश तब तक दिखाई देता है जब तक कि लेजर मॉड्यूल को ठीक नहीं किया जाता है या एलडीआर के साथ ठीक से संरेखण नहीं किया जाता है।

यह चरण समस्या से मुक्त होने के बाद, सिस्टम स्टैंडबाय मोड में जाता है और '-system स्टैंडबाय-' प्रदर्शित करता है। इस बिंदु पर उपयोगकर्ता किसी भी समय पुश बटन दबाकर सेटअप को हाथ कर सकता है।

एक पुश बटन दबाया जाता है सिस्टम उपयोगकर्ता से गति का पता लगाने के लिए तैयार है और प्रदर्शित करता है 'सिस्टम तैयार है'।

धावक 'स्टार्ट' लेजर से कुछ इंच की दूरी पर हो सकता है।

यदि 'स्टार्ट' लेजर बाधित हो जाता है तो समय गिनना शुरू हो जाता है और प्रदर्शित होता है 'समय की गणना की जा रही है ...' समय की गणना बैक ग्राउंड में की जाती है।

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

नोट: रीडिंग खाली करने के लिए arduino पर रीसेट बटन दबाएं।

रनिंग ट्रैक पर सर्किट कैसे सेट करें:

कृपया LDR और Arduino सर्किट के बीच जुड़ने के लिए मोटे तारों का उपयोग करें क्योंकि इन दोनों के बीच की दूरी कई मीटर अलग हो सकती है, और वोल्टेज को महत्वपूर्ण रूप से छोड़ना चाहिए। LDR1 और LDR2 के बीच की दूरी कुछ सौ मीटर अधिकतम हो सकती है।

LDR कैसे माउंट करें:

LDR को खोखले अपारदर्शी ट्यूब के अंदर रखा जाना चाहिए और सामने के हिस्से को भी कवर किया जाना चाहिए और लेजर बीम के प्रवेश के लिए व्यास में केवल कुछ मिलीमीटर के साथ एक छेद बनाया जाता है।

LDR को सीधे सूर्य के प्रकाश से संरक्षित किया जाना चाहिए क्योंकि यह लेजर बीम और प्रकाश के अन्य स्रोत से अंतर नहीं कर सकता है और उपयोगकर्ता से गति को पंजीकृत नहीं कर सकता है।

कार्यक्रम कोड:

//-------- Program developed by R.GIRISH-------//
#include
LiquidCrystal lcd(12,11,5,4,3,2)
int strt = A0
int stp = A1
int btn = A2
int M = 0
int S = 0
int mS = 0
float dly = 10.0
void setup()
{
lcd.begin(16,2)
pinMode(strt,INPUT)
pinMode(stp,INPUT)
pinMode(btn,INPUT)
}
void loop()
{
if(digitalRead(strt)==HIGH && digitalRead(stp)==HIGH)
{
lcd.setCursor(0,0)
lcd.print('Both lasers are')
lcd.setCursor(0,1)
lcd.print(' working fine')
delay(4000)
{
while(digitalRead(btn)==LOW)
{
lcd.clear()
lcd.print('-System Standby-')
lcd.setCursor(0,1)
lcd.print('Press Start btn')
delay(100)
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('System is ready')
lcd.setCursor(0,1)
lcd.print('----------------')
while(digitalRead(strt)==HIGH)
{
delay(1)
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Time is being')
lcd.setCursor(0,1)
lcd.print('Calculated......')
while(digitalRead(stp)==HIGH)
{
delay(dly)
mS = mS+1
if(mS==100)
{
mS=0
S = S+1
}
if(S==60)
{
S=0
M = M+1
}
}
while(true)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print(M)
lcd.print(':')
lcd.print(S)
lcd.print(':')
lcd.print(mS)
lcd.print(' (M:S:mS)')
lcd.setCursor(0,1)
lcd.print('Press Reset')
delay(1000)
}
}
}
if(digitalRead(strt)==HIGH && digitalRead(stp)==LOW)
{
lcd.setCursor(0,0)
lcd.print(''Stop' laser is')
lcd.setCursor(0,1)
lcd.print(' not working')
delay(100)
}
if(digitalRead(strt)==LOW && digitalRead(stp)==HIGH)
{
lcd.setCursor(0,0)
lcd.print(''Start' laser is')
lcd.setCursor(0,1)
lcd.print(' not working')
delay(100)
}
if(digitalRead(strt)==LOW && digitalRead(stp)==LOW)
{
lcd.setCursor(0,0)
lcd.print('Both lasers are')
lcd.setCursor(0,1)
lcd.print(' not working')
delay(100)
}
lcd.clear()
}
//-------- Program developed by R.GIRISH-------//

लेखक का प्रोटोटाइप:

स्प्लिट टाइमर सुविधा के साथ उन्नयन

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

परिचय

इस परियोजना का सुझाव इस वेबसाइट श्री एंड्रयू वाकर के शौकीन चावला पाठकों में से एक ने दिया था।

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

4 LDRs को छोड़कर अधिकांश हार्डवेयर को अपरिवर्तित रखा गया है, लेकिन कोड में भारी संशोधन हुआ है।

विभाजित समय दिखाते हुए योजनाबद्ध आरेख:

उपरोक्त सर्किट में कुछ घटक हैं और शुरुआती अनुकूल हैं। कोई और स्पष्टीकरण की आवश्यकता नहीं है, बस सर्किट आरेख के अनुसार तार।

एलडीआर तार कैसे करें:

LDR 2 को मुख्य सर्किट आरेख पर दिखाया गया है जो समानांतर में 4 और LDR को जोड़ता है जैसा कि ऊपर चित्र में दिखाया गया है।

लेआउट आरेख:

लेजर को कैसे रखा जाए, इस बारे में मूल व्यवस्था ऊपर दी गई है। कृपया ध्यान दें कि LDRs के बीच की दूरी ट्रैक की लंबाई के आधार पर उपयोगकर्ता की पसंद हो सकती है।

कार्यक्रम:

//------------Developed By R.Girish-------//
#include
LiquidCrystal lcd(12,11,5,4,3,2)
const int start = A2
const int strt = A0
const int END = A1
boolean y = true
boolean x = true
unsigned int s1 = 0
unsigned int s2 = 0
unsigned int s3 = 0
unsigned int s4 = 0
unsigned int s5 = 0
unsigned int m1 = 0
unsigned int m2 = 0
unsigned int m3 = 0
unsigned int m4 = 0
unsigned int m5 = 0
unsigned int ms1 = 0
unsigned int ms2 = 0
unsigned int ms3 = 0
unsigned int ms4 = 0
unsigned int ms5 = 0
unsigned int S = 0
unsigned int M = 0
unsigned int mS = 0
unsigned int count = 0
void setup()
{
lcd.begin(16,2)
pinMode(start, INPUT)
pinMode(strt, INPUT)
pinMode(END, INPUT)
if(digitalRead(strt) == LOW)
{
while(true)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Start Laser is')
lcd.setCursor(0,1)
lcd.print(' not working')
delay(2500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Please align the')
lcd.setCursor(0,1)
lcd.print('lasers properly')
delay(2500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('and press reset.')
delay(2500)
}
}
if(digitalRead(END) == LOW)
{
while(true)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('All 5 lasers')
lcd.setCursor(0,1)
lcd.print('are misaligned')
delay(2500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Please align the')
lcd.setCursor(0,1)
lcd.print('lasers properly')
delay(2500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('and press reset.')
delay(2500)
}
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('-System Standby-')
lcd.setCursor(0,1)
lcd.print('Press Start btn')
if(digitalRead(start) == LOW)
{
while(x)
{
if(digitalRead(start) == HIGH)
{
x = false
}
}
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('System is ready')
lcd.setCursor(0,1)
lcd.print('----------------')
while(y)
{
if(digitalRead(strt) == LOW)
{
y = false
}
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Time is being')
lcd.setCursor(0,1)
lcd.print('Calculated....')
mS = 12
}
void loop()
{
delay(1)
mS = mS + 1
if(mS==1000)
{
mS=0
S = S+1
}
if(S==60)
{
S=0
M = M+1
}
if(digitalRead(END) == LOW)
{
count = count + 1
if(count == 1)
{
ms1 = mS
s1 = S
m1 = M
delay(500)
}
if(count == 2)
{
ms2 = mS
s2 = S
m2 = M
delay(500)
}
if(count == 3)
{
ms3 = mS
s3 = S
m3 = M
delay(500)
}
if(count == 4)
{
ms4 = mS
s4 = S
m4 = M
delay(500)
}
if(count == 5)
{
ms5 = mS
s5 = S
m5 = M
Display()
}
}
}
void Display()
{
ms1 = ms1 + 500
ms2 = ms2 + 500
ms3 = ms3 + 500
ms4 = ms4 + 500
ms5 = ms5 + 500
if(ms1 >= 1000)
{
ms1 = ms1 - 1000
s1 = s1 + 1
if(s1 >= 60)
{
m1 = m1 + 1
}
}
if(ms2 >= 1000)
{
ms2 = ms2 - 1000
s2 = s2 + 1
if(s2 >= 60)
{
m2 = m2 + 1
}
}
if(ms3 >= 1000)
{
ms3 = ms3 - 1000
s3 = s3 + 1
if(s3 >= 60)
{
m3 = m3 + 1
}
}
if(ms4 >= 1000)
{
ms4 = ms4 - 1000
s4 = s4 + 1
if(s4 >= 60)
{
m4 = m4 + 1
}
}
if(ms5 >= 1000)
{
ms5 = ms5 - 1000
s5 = s5 + 1
if(s5 >= 60)
{
m5 = m5 + 1
}
}
while(true)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Spilt 1)')
lcd.print(m1)
lcd.print(':')
lcd.print(s1)
lcd.print(':')
lcd.print(ms1)
lcd.setCursor(0,1)
lcd.print('Split 2)')
lcd.print(m2)
lcd.print(':')
lcd.print(s2)
lcd.print(':')
lcd.print(ms2)
delay(2500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Split 3)')
lcd.print(m3)
lcd.print(':')
lcd.print(s3)
lcd.print(':')
lcd.print(ms3)
lcd.setCursor(0,1)
lcd.print('Split 4)')
lcd.print(m4)
lcd.print(':')
lcd.print(s4)
lcd.print(':')
lcd.print(ms4)
delay(2500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Split 5)')
lcd.print(m5)
lcd.print(':')
lcd.print(s5)
lcd.print(':')
lcd.print(ms5)
lcd.setCursor(0,1)
lcd.print('---Press Reset--')
delay(2500)
}
}
//------------Developed By R.Girish-------//

इस स्वचालित स्टॉपवॉच को कैसे संचालित करें:

• पूर्ण सेटअप के साथ, पहले लेज़रों को बिजली दें और फिर अगले Arduino सर्किट को चालू करें।
• यदि सभी लेज़रों को LDRs के साथ ठीक से संरेखित किया गया है, तो प्रदर्शन त्रुटि संदेशों के साथ संकेत नहीं देगा। यदि कोई है, तो कृपया उन्हें ठीक से संरेखित करें।
• अब सर्किट 'सिस्टम स्टैंडबाय है' प्रदर्शित करता है। अब 'स्टार्ट' बटन दबाएं और यह प्रदर्शित करेगा कि 'सिस्टम तैयार है'।
• इस बिंदु पर जब एकल खिलाड़ी LDR 1 लाइट बीम को बाधित करता है, तो टाइमर शुरू होता है और यह प्रदर्शित करता है 'समय चल रहा है ...'।
• जैसे ही खिलाड़ी अंतिम बिंदु यानी LDR 6 पर पहुंचता है, टाइमर बंद हो जाता है और यह सर्किट द्वारा रिकॉर्ड किए गए 5 विभाजन समय को प्रदर्शित करता है।
• उपयोगकर्ता को टाइमर रीसेट करने के लिए arduino पर रीसेट बटन दबाना होगा।
क्यों यह स्वचालित स्टॉपवॉच प्रदर्शन पर लाइव टाइमिंग नहीं दिखा सकती है क्योंकि पारंपरिक स्टॉपवॉच करता है (बल्कि यह एक स्थिर पाठ 'समय की गणना की जा रही है ...') प्रदर्शित करता है?
वास्तविक समय में समय प्रदर्शित करने के लिए, Arduino को LCD प्रदर्शन के लिए अतिरिक्त निर्देशों को निष्पादित करना होगा। यह कुछ माइक्रोसेकंड को कुछ मिलीसेकंड देरी से कोड के मुख्य समय ट्रैकिंग टुकड़े में जोड़ देगा, जिससे गलत परिणाम हो सकते हैं।

यदि आपके कोई और प्रश्न हैं, तो कृपया टिप्पणी अनुभाग के माध्यम से व्यक्त करें।