రన్నర్లు, అథ్లెట్లు మరియు క్రీడాకారుల కోసం ఆటోమేటిక్ స్టాప్‌వాచ్‌ను తయారు చేయడం

సమస్యలను తొలగించడానికి మా పరికరాన్ని ప్రయత్నించండి





ఈ పోస్ట్‌లో మేము స్టాప్‌వాచ్‌ను నిర్మించబోతున్నాం, ఇది రన్నర్ రన్ అవ్వడం ప్రారంభించినప్పుడు స్వయంచాలకంగా టైమర్‌ను ప్రారంభిస్తుంది మరియు రన్నర్ చివరికి చేరుకున్నప్పుడు టైమర్ ఆగిపోతుంది. ప్రారంభ మరియు ముగింపు బిందువు మధ్య గడిచిన సమయం 16 x 2 LCD లో ప్రదర్శించబడుతుంది.

మొదట సరళమైన మరియు చాలా ఖచ్చితమైన ఆర్డునో స్టాప్ వాచ్ సర్క్యూట్‌ను ఎలా కాన్ఫిగర్ చేయాలో నేర్చుకోవడం ద్వారా ప్రారంభిద్దాం.



స్టాప్‌వాచ్ అనేది మానవీయంగా నియంత్రించబడిన సమయ గడియార పరికరం, ఇది సక్రియం చేయబడిన ఒక నిర్దిష్ట సమయం నుండి ప్రారంభించి, చివరికి నిష్క్రియం చేయబడిన సమయం యొక్క పొడవును కొలవడానికి రూపొందించబడింది. అదే పరికరం యొక్క పెద్ద వేరియంట్ అంటారు చర్యను దూరం నుండి పర్యవేక్షించడానికి ఉపయోగించే స్టాప్ క్లాక్ మరియు సాధారణంగా స్పోర్ట్స్ స్టేడియం మొదలైన వాటిలో కనిపిస్తుంది.

మెకానికల్ vs ఎలక్ట్రానిక్ స్టాప్‌వాచ్

పూర్వం సాంప్రదాయ యాంత్రిక హ్యాండ్‌హెల్డ్ స్టాప్‌వాచ్ సర్వసాధారణం, మరియు అందరూ ఈ ప్రయోజనం కోసం ఉపయోగించారు.



యాంత్రిక వ్యవస్థలో స్టాప్ వాచ్ ఫంక్షన్లను అమలు చేయడానికి మాకు రెండు ప్రెస్ బటన్లు ఉన్నాయి. ఒకటి ఒకసారి నొక్కడం ద్వారా స్టాప్ గడియారాన్ని ప్రారంభించడానికి మరియు గడిచిన సమయాన్ని రికార్డ్ చేయడానికి అదే బటన్‌ను మరోసారి నొక్కడం ద్వారా సమయాన్ని ఆపడానికి .... గడియారాన్ని తిరిగి సున్నాకి రీసెట్ చేయడానికి రెండవ బటన్ ఉపయోగించబడింది.

మెకానికల్ స్టాప్ క్లాక్ ప్రాథమికంగా స్ప్రింగ్ పవర్ ద్వారా పనిచేసింది, గడియారం పరికరం పైభాగంలో ఇచ్చిన ముడుచుకున్న నాబ్‌ను తిప్పడం ద్వారా మానవీయంగా మూసివేసే కాలం అవసరం.

అయితే ఆధునిక డిజిటల్ స్టాప్ గడియారాలతో పోలిస్తే, యాంత్రిక రకాలను మిల్లీసెకన్ల పరిధిలో గణనీయంగా ప్రాచీనమైన మరియు సరికానిదిగా పరిగణించవచ్చు.

Arduino ఉపయోగించి

మరియు నేడు మైక్రోకంట్రోలర్ రావడంతో, ఈ స్టాప్ గడియారాలు మైక్రోసెకండ్ పరిధికి చాలా ఖచ్చితమైనవి మరియు నమ్మదగినవిగా మారాయి.

ఇక్కడ అందించిన ఆర్డునో స్టాప్ వాచ్ సర్క్యూట్ ఈ ఆధునిక మైక్రోకంట్రోలర్ పవర్డ్ డిజైన్లలో ఒకటి, ఇది చాలా ఖచ్చితమైనది వాణిజ్య ఆధునిక స్టాప్ వాచ్ గాడ్జెట్‌లతో సమానంగా ఉంటుందని expected హించవచ్చు.

ప్రతిపాదిత ఆర్డునో స్టాప్ క్లాక్ సర్క్యూట్‌ను ఎలా నిర్మించాలో నేర్చుకుందాం:

నిర్మాణం కోసం మీకు ఈ క్రింది పదార్థాల బిల్లు అవసరం:

హార్డ్వేర్ అవసరం

Arduino LCD కీప్యాడ్ షీల్డ్ (SKU: DFR0009)

Arduino LCD కీప్యాడ్ షీల్డ్ (SKU: DFR0009)

Arduino ONE బోర్డు

ఆర్డునో UNO

Arduino USB కేబుల్

arduino usb కేబుల్

మీరు పై విషయాలను సంపాదించి, వాటిని ఒకదానితో ఒకటి కట్టిపడేసిన తర్వాత, ఈ క్రింది స్కెచ్ కోడ్‌ను మీ ఆర్డునో బోర్డ్‌లోకి కాన్ఫిగర్ చేయడం మరియు స్టాప్ క్లాక్ ఫంక్షన్ల మాయాజాలం చూడటం.

కోడ్

/*
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 సెగ్మెంట్ ఎల్ఈడి డిస్‌ప్లే మరియు ఆర్డునో ఉపయోగించి స్టాప్‌వాచ్ సర్క్యూట్ నిర్మాణానికి సంబంధించిన వివరాలతో ముందుకు వెళ్దాం. ఈ ప్రాజెక్ట్‌ను అర్థం చేసుకోవడానికి కీలకమైన అంతరాయాలు మరియు డిస్ప్లే డ్రైవర్ ఐసిలకు సంబంధించిన అంశాలను మేము అన్వేషిస్తాము. ఈ ప్రాజెక్ట్ యొక్క ఆసక్తిగల రీడర్లలో ఒకరైన మిస్టర్ అబూ-హాఫ్స్ ఈ ప్రాజెక్ట్ను సూచించారు.

స్టాప్‌వాచ్ అనేది పరికరం అని మనకు ఇప్పటికే తెలుసు, ఇది గంటల నుండి మిల్లీసెకన్ల పరిధి వరకు (ఎక్కువగా) క్లుప్త సమయాన్ని ట్రాక్ చేయడానికి సహాయపడుతుంది. స్టాప్‌వాచ్ కార్యాచరణతో కూడిన దాదాపు అన్ని చౌకైన డిజిటల్ మణికట్టు గడియారాలు, కానీ గడియారాలు ఏవీ మన కోసం ఒకదాన్ని తయారుచేసే అభిరుచిని ఇవ్వలేవు మరియు 7 సెగ్మెంట్ ఎల్‌ఇడి డిస్‌ప్లేతో స్టాప్‌వాచ్‌ను కనుగొనడం అసాధారణమైనది.

మిస్టర్ అబూ-హాఫ్స్ 4 డిస్ప్లేలతో స్టాప్ వాచ్ రూపకల్పన చేయాలని సూచించారు, రెండు నిమిషాలు మరియు రెండు సెకన్లు (MM: SS) కాన్ఫిగరేషన్. కానీ మనలో చాలా మందికి ఇది సాధ్యమయ్యే డిజైన్ కాకపోవచ్చు, కాబట్టి మేము మిల్లీసెకండ్ రేంజ్ కోసం మరో రెండు డిస్‌ప్లేను జోడించాము, కాబట్టి ఇప్పుడు ప్రతిపాదిత డిజైన్ MM: SS: mS కాన్ఫిగరేషన్‌లో ఉంటుంది.

మీకు కొన్ని కారణాల వల్ల MM: SS కాన్ఫిగరేషన్ అవసరమైతే, మీరు మిల్లీసెకండ్ పరిధి 7 సెగ్మెంట్ డిస్ప్లేలను మరియు దాని డ్రైవర్ IC లను కనెక్ట్ చేయవలసిన అవసరం లేదు, సర్క్యూట్ యొక్క మొత్తం కార్యాచరణ ఇప్పటికీ ప్రభావితం కాదు.

సర్క్యూట్:

ప్రతిపాదిత స్టాప్‌వాచ్‌లో ఆరు ఐసి 4026 ఉంటుంది, ఇది ఏడు సెగ్మెంట్ డిస్ప్లే డ్రైవర్, ఆరు 7 సెగ్మెంట్ ఎల్‌ఇడి డిస్‌ప్లేలు, ఒక ఆర్డునో బోర్డు, రెండు పుష్ బటన్లు మరియు 10 కె రెసిస్టర్‌లను కలిగి ఉంటుంది.

IC 4026 నుండి 7 సెగ్మెంట్ డిస్ప్లేని ఎలా కనెక్ట్ చేయాలో ఇప్పుడు అర్థం చేసుకుందాం.

7 సెగ్మెంట్ డిస్ప్లే ఏదైనా రంగు యొక్క సాధారణ కాథోడ్ ప్రదర్శన కావచ్చు. 7 సెగ్మెంట్ డిస్ప్లే 5 వి సరఫరా ద్వారా సులభంగా చంపబడుతుంది, కాబట్టి డిస్ప్లే యొక్క ప్రతి విభాగంలో 330 ఓం రెసిస్టర్ తప్పనిసరి.

ఇప్పుడు IC 4026 యొక్క పిన్ రేఖాచిత్రాన్ని చూద్దాం:

  • పిన్ # 1 గడియారం ఇన్పుట్.
  • పిన్ # 2 క్లాక్ డిసేబుల్, ఈ పిన్ ఎక్కువగా ఉంటే ప్రదర్శనలో ఉన్న కౌంట్‌ను డిసేబుల్ చేస్తుంది.
  • పిన్ # 3 డిస్ప్లే ఎనేబుల్ అయితే ఈ పిన్ తక్కువగా ఉంటే డిస్ప్లే ట్యూన్ అవుతుంది మరియు దీనికి విరుద్ధంగా ఉంటుంది.
  • పిన్ # 5 క్యారీ-అవుట్, ఇది IC 10 లెక్కించినప్పుడు ఎక్కువగా ఉంటుంది.
  • పిన్స్ 6, 7, 9, 10, 11, 12, 13 డిస్ప్లే అవుట్‌పుట్‌లు.
  • పిన్ # 8 GND.
  • పిన్ # 16 Vcc.
  • పిన్ # 15 రీసెట్ చేయబడింది, మేము ఈ పిన్ను ఎక్కువ చేస్తే కౌంట్ సున్నాకి మారుతుంది.
  • పిన్స్ # 4 మరియు # 14 ఉపయోగించబడవు.

కనెక్షన్ రేఖాచిత్రాన్ని ప్రదర్శించు:

LCD డిస్ప్లే కనెక్షన్ రేఖాచిత్రం:

7 సెగ్మెంట్ డిస్ప్లే యొక్క GND పిన్‌లో ఏదైనా ఒకదానిని భూమికి అనుసంధానించవచ్చు. IC తప్పనిసరిగా 5V సరఫరా లేదా Arduino యొక్క 5V అవుట్పుట్ పిన్ నుండి శక్తినివ్వాలి.

కేవలం ఒక ప్రదర్శన కోసం పై స్కీమాటిక్, ఐదు ఇతర డిస్ప్లేల కోసం అదే పునరావృతం చేయండి.

మిగిలిన స్కీమాటిక్ ఇక్కడ ఉంది:

7 సెగ్మెంట్ డిస్ప్లేతో ఆర్డునోను ఉపయోగించడం ఆపు

సర్క్యూట్ 9 వి బ్యాటరీ నుండి శక్తినివ్వవచ్చు. ఇక్కడ రెండు బటన్లు ఒకటి సమయం ప్రారంభించడానికి మరియు మరొకటి ఆపడానికి. Arduino లో రీసెట్ బటన్‌ను నొక్కడం ద్వారా, సమయ గణన ప్రదర్శనలో సున్నాకి రీసెట్ చేయబడుతుంది.

రెండు పుష్ బటన్ పిన్ # 2 మరియు # 3 లకు అనుసంధానించబడి ఉంది, ఇవి ఆర్డునో / అట్మెగా 328 పి మైక్రోకంట్రోలర్ యొక్క హార్డ్వేర్ అంతరాయం.

అంతరాయం ఏమిటో అర్థం చేసుకుందాం:

రెండు రకాల అంతరాయాలు ఉన్నాయి: హార్డ్‌వేర్ అంతరాయం మరియు సాఫ్ట్‌వేర్ అంతరాయం. ఇక్కడ మేము హార్డ్వేర్ అంతరాయాన్ని మాత్రమే ఉపయోగిస్తున్నాము.

అంతరాయం అనేది మైక్రోకంట్రోలర్‌కు సంకేతం, ఇది మైక్రోకంట్రోలర్ ఒక సంఘటనకు వెంటనే స్పందించేలా చేస్తుంది.

ATmega328P మైక్రోకంట్రోలర్ పిన్ # 2 మరియు # 3 తో ​​ఆర్డునో బోర్డులలో కేవలం రెండు హార్డ్‌వేర్ అంతరాయ పిన్‌లు మాత్రమే ఉన్నాయి. Arduino మెగాలో రెండు కంటే ఎక్కువ హార్డ్‌వేర్ అంతరాయ పిన్‌లు ఉన్నాయి.

మైక్రోకంట్రోలర్లు ఒకేసారి రెండు విధులు చేయలేరు. ఉదాహరణకు బటన్ ప్రెస్ కోసం తనిఖీ చేయడం మరియు సంఖ్యలను లెక్కించడం.

మైక్రోకంట్రోలర్లు ఒకేసారి రెండు సంఘటనలను అమలు చేయలేరు, బటన్ ప్రెస్ మరియు లెక్కింపు సంఖ్యలను తనిఖీ చేయడానికి మేము ఒక కోడ్ వ్రాస్తే, మైక్రోకంట్రోలర్ బటన్ ప్రెస్ డిటెక్షన్ భాగాన్ని చదివినప్పుడు మాత్రమే బటన్ ప్రెస్ కనుగొనబడుతుంది, మిగిలిన సమయం (సంఖ్యలను లెక్కిస్తుంది) బటన్ పనిచేయదు.

కాబట్టి బటన్ ప్రెస్‌ను గుర్తించడంలో ఆలస్యం ఉంటుంది మరియు కొన్ని కారణాల వల్ల కోడ్ తాత్కాలికంగా ఆగిపోతే, బటన్ ప్రెస్ ఎప్పటికీ కనుగొనబడదు. ఈ రకమైన సమస్యలను నివారించడానికి అంతరాయం ప్రవేశపెట్టబడింది.

అంతరాయ సిగ్నల్‌కు ఎల్లప్పుడూ అధిక ప్రాధాన్యత ఇవ్వబడుతుంది, ప్రధాన ఫంక్షన్ (కోడ్ యొక్క ప్రధాన పంక్తులు) నిలిపివేయబడతాయి మరియు నిర్దిష్ట అంతరాయం కోసం కేటాయించిన (కోడ్ యొక్క మరొక భాగం) ఫంక్షన్‌ను అమలు చేస్తుంది.

స్టాప్‌వాచ్ లేదా సెక్యూరిటీ సిస్టమ్స్ వంటి క్లిష్టమైన అనువర్తనాలకు ఇది చాలా ముఖ్యం. ఇక్కడ ఒక సంఘటనకు ప్రతిస్పందనగా ప్రాసెసర్ తక్షణ చర్య తీసుకోవాలి.

Arduino లో మేము హార్డ్‌వేర్ అంతరాయాన్ని ఇలా కేటాయించాము:

అటాచ్ ఇంటరప్ట్ (0, ప్రారంభం, RISING)

  • “0” అంటే అంతరాయ సంఖ్య సున్నా (మైక్రోకంట్రోలర్లలో ప్రతిదీ సున్నా నుండి మొదలవుతుంది) అంటే పిన్ # 2.
  • “ప్రారంభం” అనేది అంతరాయ ఫంక్షన్ యొక్క పేరు, మీరు ఇక్కడ ఏదైనా పేరు పెట్టవచ్చు.
  • పిన్ # 2 (ఇది అంతరాయ సున్నా) ఎక్కువగా ఉంటే “RISING”, అంతరాయ ఫంక్షన్ అమలు అవుతుంది.

అటాచ్ ఇంటరప్ట్ (1, ఆపు, రైజింగ్)

  • “1” అంటే పిన్ # 3 అయిన అంతరాయ నంబర్ వన్.
  • “ఆపు” అనేది అంతరాయం యొక్క పేరు.

మేము 'RISING' ను 'FALLING' తో కూడా భర్తీ చేయవచ్చు, ఇప్పుడు అంతరాయ పిన్ తక్కువగా వెళ్ళినప్పుడు అంతరాయ ఫంక్షన్ అమలు అవుతుంది.

మనం “RISING” ని “CHANGE” తో కూడా భర్తీ చేయవచ్చు, ఇప్పుడు అంతరాయ పిన్ ఎత్తైన నుండి తక్కువ లేదా తక్కువ నుండి ఎప్పుడు, అంతరాయ ఫంక్షన్ అమలు అవుతుంది.

అంతరాయ ఫంక్షన్‌ను ఈ క్రింది విధంగా కేటాయించవచ్చు:

void start () // start అనేది అంతరాయం యొక్క పేరు.

{

// ఇక్కడ ప్రోగ్రామ్

}

అంతరాయ ఫంక్షన్ సాధ్యమైనంత తక్కువగా ఉండాలి మరియు ఆలస్యం () ఫంక్షన్ ఉపయోగించబడదు.

ఆర్డునోకు సంబంధించిన హార్డ్‌వేర్ అంతరాయ సాఫ్ట్‌వేర్ అంతరాయం భవిష్యత్ వ్యాసంలో వివరించబడుతుందని తేల్చింది.

పిన్‌లకు అంతరాయం కలిగించడానికి మేము ప్రారంభ మరియు స్టాప్ పుష్ బటన్లను ఎందుకు కనెక్ట్ చేశామో ఇప్పుడు మీకు తెలుసు.

రేఖాచిత్రం ప్రకారం సర్క్యూట్‌ను కనెక్ట్ చేయండి మిగిలిన సర్క్యూట్ స్వీయ వివరణాత్మకమైనది.

కార్యక్రమం:

//----------------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---------------//

ఇప్పుడు అది కోడ్‌ను ముగించింది.

స్టాప్‌వాచ్ ప్రత్యేకంగా అథ్లెట్ల కోసం అభివృద్ధి చేయబడింది

చివరగా, అవసరమైన కాన్సెప్ట్ కోసం ఇతరులపై ఆధారపడకుండా వారి రన్నింగ్ నైపుణ్యాలను అభివృద్ధి చేసుకోవాలనుకునే అథ్లెట్ల కోసం పై కాన్సెప్ట్స్ కామ్ వాస్తవానికి ఎలా అప్‌గ్రేడ్ అవుతుందో తెలుసుకుందాం మరియు టైమర్ / స్టాప్‌వాచ్‌ను ఆపండి. స్టాప్‌వాచ్‌ను ఎవరైనా ప్రారంభించడం / ఆపడం కంటే మీ కదలికను గుర్తించడం ద్వారా స్వయంచాలకంగా టైమర్‌ను ప్రారంభించడం మంచిది, ఇది వారి ప్రతిచర్య సమయాన్ని కూడా జోడించవచ్చు.

గమనిక: ఈ ప్రాజెక్ట్ ఒక సమయంలో ఒక వినియోగదారు కవర్ చేసిన ‘బి’ పాయింట్ నుండి పాయింట్ ‘ఎ’ మధ్య సమయాన్ని కొలిచేందుకు రూపొందించబడింది.

సెటప్‌లో ప్రారంభ స్థానం మరియు ముగింపు స్థానం వద్ద ఉంచిన రెండు లేజర్‌లు ఉంటాయి, రెండు ఎల్‌డిఆర్‌లు రెండు లేజర్ మాడ్యూల్‌కు ఎదురుగా ఉంచబడతాయి. అథ్లెట్ ‘ప్రారంభ’ లేజర్‌కు అంతరాయం కలిగించినప్పుడు సమయం లెక్కించడం ప్రారంభమవుతుంది మరియు అథ్లెట్ ముగింపుకు చేరుకున్నప్పుడు, ‘ఎండింగ్’ లేజర్‌కు అంతరాయం కలిగిస్తుంది మరియు టైమర్ ఆగిపోతుంది మరియు గడిచిన సమయాన్ని రెండు పాయింట్ల మధ్య ప్రదర్శిస్తుంది. ప్రతిపాదిత ఆలోచనలో గడిచిన సమయాన్ని కొలవడానికి ఉపయోగించే పద్ధతి ఇది.

సర్క్యూట్ యొక్క ప్రతి భాగాన్ని వివరంగా చూద్దాం.

భాగాలు పని వివరాలు

సర్క్యూట్ చాలా సరళంగా ఉంచబడుతుంది, ఇది 16 x 2 LCD మాడ్యూల్, కొన్ని రెసిస్టర్లు, రెండు LDR లు మరియు పుష్ బటన్ కలిగి ఉంటుంది.

LCD మరియు arduino మధ్య ఇంటర్ఫేస్ ప్రామాణికమైనది, అనేక ఇతర LCD ఆధారిత ప్రాజెక్టులలో ఇలాంటి కనెక్షన్‌ను మనం కనుగొనవచ్చు.

లేజర్ అంతరాయాలను గుర్తించడానికి రెండు అనలాగ్ పిన్స్ A0 మరియు A1 ఉపయోగించబడతాయి. అనలాగ్ పిన్ A2 పుష్ బటన్‌తో అనుసంధానించబడి ఉంది, ఇది స్టాప్‌వాచ్‌ను ఆర్మ్ చేయడానికి ఉపయోగించబడుతుంది.

మూడు రెసిస్టర్లు, రెండు 4.7 కె మరియు ఒక 10 కె పుల్-డౌన్ రెసిస్టర్లు, ఇవి ఇన్పుట్ పిన్స్ తక్కువ స్థాయిలో ఉండటానికి సహాయపడతాయి.

సరైన దృశ్యమానత కోసం ఎల్‌సిడి మాడ్యూల్‌లో కాంట్రాస్ట్‌ను సర్దుబాటు చేయడానికి 10 కె పొటెన్షియోమీటర్ అందించబడుతుంది.

ప్రతిపాదిత సర్క్యూట్ లేజర్‌ల కోసం తప్పు గుర్తించే విధానంతో రూపొందించబడింది. లేజర్‌లో ఏదైనా లోపం లేదా ఎల్‌డిఆర్‌తో సరిగ్గా సమలేఖనం చేయకపోతే, ఇది ఎల్‌సిడి డిస్‌ప్లేలో దోష సందేశాన్ని ప్రదర్శిస్తుంది.

ST START లేజర్ పనిచేయకపోతే, అది “‘ ప్రారంభ ’లేజర్ పనిచేయడం లేదు”

ST STOP లేజర్ పనిచేయకపోతే, అది “‘ స్టాప్ ’లేజర్ పనిచేయడం లేదు”

Both రెండు లేజర్‌లు పనిచేయకపోతే, అది “రెండు లేజర్‌లు పనిచేయడం లేదు”

Both రెండు లేజర్‌లు సరిగ్గా పనిచేస్తుంటే, అది “రెండు లేజర్‌లు బాగా పనిచేస్తున్నాయి”

లేజర్ మాడ్యూల్ స్థిరంగా లేదా ఎల్‌డిఆర్‌తో అమరిక సరిగ్గా జరిగే వరకు దోష సందేశం కనిపిస్తుంది.

ఈ దశ సమస్య లేకుండా ఉంటే, సిస్టమ్ స్టాండ్‌బై మోడ్‌కు వెళ్లి “-సిస్టమ్ స్టాండ్‌బై-” ను ప్రదర్శిస్తుంది. ఈ సమయంలో వినియోగదారు ఎప్పుడైనా పుష్ బటన్‌ను నొక్కడం ద్వారా సెటప్‌ను ఆర్మ్ చేయవచ్చు.

ఒక పుష్ బటన్ నొక్కినప్పుడు సిస్టమ్ వినియోగదారు నుండి కదలికను గుర్తించడానికి సిద్ధంగా ఉంది మరియు “సిస్టమ్ సిద్ధంగా ఉంది” అని ప్రదర్శిస్తుంది.

రన్నర్ ‘ప్రారంభ’ లేజర్ నుండి కొన్ని అంగుళాలు ఉండవచ్చు.

“ప్రారంభ” లేజర్‌కు అంతరాయం ఏర్పడితే సమయం లెక్కించడం ప్రారంభమవుతుంది మరియు ప్రదర్శనలు ”సమయం లెక్కించబడుతోంది ……” సమయం వెనుక మైదానంలో లెక్కించబడుతుంది.

రన్నర్ “స్టాప్” లేజర్‌కు చేరే / అంతరాయం కలిగించే వరకు గడిచిన సమయం ప్రదర్శించబడదు. సాంప్రదాయిక స్టాప్‌వాచ్ వలె ఎల్‌సిడిలో గడిచిన సమయాన్ని ప్రదర్శించడం, మైక్రోకంట్రోలర్‌లో అమలు చేయడానికి అనేక అదనపు సూచనలు అవసరం, ఇది సెటప్ యొక్క ఖచ్చితత్వాన్ని గణనీయంగా క్షీణిస్తుంది.

గమనిక: రీడింగులను క్లియర్ చేయడానికి arduino పై రీసెట్ బటన్ నొక్కండి.

రన్నింగ్ ట్రాక్‌లో సర్క్యూట్‌ను ఎలా సెట్ చేయాలి:

LDR లు మరియు arduino సర్క్యూట్ మధ్య కనెక్ట్ అవ్వడానికి దయచేసి మందపాటి వైర్లను వాడండి, ఎందుకంటే ఈ రెండింటి మధ్య దూరం చాలా మీటర్ల దూరంలో ఉండవచ్చు మరియు వోల్టేజ్ గణనీయంగా పడిపోకూడదు. LDR1 మరియు LDR2 మధ్య దూరం గరిష్టంగా కొన్ని వందల మీటర్లు.

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 ఎల్‌డిఆర్‌లు ఉన్నాయి, అవన్నీ వాటి మధ్య ఏకరీతి దూరంతో లేదా పరిస్థితులను బట్టి మరియు వినియోగదారు ఎంపికను బట్టి రన్నింగ్ ట్రాక్‌లో ఉంచవచ్చు.

4 ఎల్‌డిఆర్‌లను చేర్చడం మినహా చాలావరకు హార్డ్‌వేర్ మారదు, కాని కోడ్ భారీ మార్పులకు గురైంది.

స్ప్లిట్ సమయాన్ని చూపించే స్కీమాటిక్ రేఖాచిత్రం:

స్ప్లిట్ టైమ్‌తో ఆటోమేటిక్ స్టాప్‌వాచ్

పై సర్క్యూట్లో కొన్ని భాగాలు మరియు బిగినర్స్ ఫ్రెండ్లీ ఉంటాయి. మరింత వివరణ అవసరం లేదు, సర్క్యూట్ రేఖాచిత్రం ప్రకారం వైర్ చేయండి.

LDR లను వైర్ చేయడం ఎలా:

LDR 2 ప్రధాన సర్క్యూట్ రేఖాచిత్రంలో చూపబడింది పై రేఖాచిత్రంలో చూపిన విధంగా మరో 4 LDR లను సమాంతరంగా కనెక్ట్ చేస్తుంది.

లేఅవుట్ రేఖాచిత్రం:

పైన పేర్కొన్నది లేజర్‌ను ఎలా ఉంచాలో ప్రాథమిక అమరిక. ట్రాక్ పొడవును బట్టి LDR ల మధ్య దూరం వినియోగదారు ఎంపిక అవుతుంది.

కార్యక్రమం:

//------------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-------//

ఈ ఆటోమేటిక్ స్టాప్‌వాచ్‌ను ఎలా ఆపరేట్ చేయాలి:

Completed పూర్తయిన సెటప్‌తో, మొదట లేజర్‌లకు శక్తినివ్వండి, ఆపై తదుపరి ఆర్డునో సర్క్యూట్‌ను ఆన్ చేయండి.
L అన్ని లేజర్‌లు ఎల్‌డిఆర్‌లతో సరిగ్గా సమలేఖనం చేయబడితే, ప్రదర్శన దోష సందేశాలతో ప్రాంప్ట్ చేయదు. ఏదైనా ఉంటే, దయచేసి వాటిని సరిగ్గా సమలేఖనం చేయండి.
• ఇప్పుడు సర్క్యూట్ “సిస్టమ్ స్టాండ్‌బై” ను ప్రదర్శిస్తుంది. ఇప్పుడు “ప్రారంభించు” బటన్‌ను నొక్కండి మరియు అది “సిస్టమ్ సిద్ధంగా ఉంది” అని ప్రదర్శిస్తుంది.
Point ఈ సమయంలో, సోలో ప్లేయర్ LDR 1 లైట్ బీమ్‌కు అంతరాయం కలిగించినప్పుడు, టైమర్ మొదలవుతుంది మరియు ఇది “సమయం లెక్కించబడుతోంది….”
Player ఆటగాడు ముగింపు స్థానానికి చేరుకున్న వెంటనే, LDR 6, టైమర్ ఆగిపోతుంది మరియు ఇది సర్క్యూట్ నమోదు చేసిన 5 స్ప్లిట్ సమయాన్ని ప్రదర్శిస్తుంది.
• టైమర్‌ను రీసెట్ చేయడానికి వినియోగదారు arduino లోని రీసెట్ బటన్‌ను నొక్కాలి.
సాంప్రదాయ స్టాప్‌వాచ్ మాదిరిగా ఈ స్వయంచాలక స్టాప్‌వాచ్ ప్రదర్శనలో ప్రత్యక్ష సమయాన్ని ఎందుకు చూపించలేదు (అయితే ఇది “సమయం లెక్కించబడుతోంది….” అనే స్థిర వచనాన్ని ప్రదర్శిస్తుంది)?
నిజ సమయంలో టైమింగ్‌ను ప్రదర్శించడానికి, ఆర్డునో ఎల్‌సిడి డిస్‌ప్లేకు అదనపు సూచనలను అమలు చేయాలి. ఇది కోడ్ యొక్క ప్రధాన సమయ ట్రాకింగ్ భాగానికి కొన్ని మైక్రోసెకన్ల ఆలస్యాన్ని జోడిస్తుంది, ఇది సరికాని ఫలితాలకు దారితీస్తుంది.

మీకు ఇంకా ఏవైనా ప్రశ్నలు ఉంటే, దయచేసి వ్యాఖ్య విభాగం ద్వారా వ్యక్తపరచండి.




మునుపటి: Arduino LCD కీప్యాడ్ షీల్డ్ (SKU: DFR0009) డేటాషీట్ తర్వాత: ఆర్డునో రాండమ్ RGB లైట్ జనరేటర్ సర్క్యూట్