הכנת שעון עצר אוטומטי לרצים, ספורטאים וספורטאים

בפוסט זה אנו הולכים לבנות שעון עצר אשר מפעיל אוטומטית טיימר כאשר הרץ מתחיל לרוץ והטיימר נעצר כאשר הרץ מגיע לסופו. הזמן שחלף בין נקודת ההתחלה לסיום מוצג על גבי LCD בגודל 16x2.

ראשית נתחיל בללמוד כיצד להגדיר מעגל שעון עצירה פשוט ומדויק במיוחד של Arduino.

שעון עצר הוא מכשיר שעון זמן שנשלט ידנית המיועד למדידת משך הזמן שעבר אולי החל מנקודת זמן מסוימת כשהוא הופעל, וכשהוא הושבת סופית. גרסה גדולה יותר של אותו מכשיר נקראת שעון העצירה המשמש לניטור הפעולה מרחוק ונמצא בדרך כלל באצטדיון ספורט וכו '.

שעון עצר מכני מול אלקטרוני

מוקדם יותר שעון העצר המכני המסורתי היה שכיח יותר ושימש את כולם למטרה זו.

במערכת המכנית היו לנו שני לחצני לחיצה לביצוע פונקציות שעון עצור. אחד להפעלת שעון העצירה בלחיצה אחת, ולעצירת הזמן בלחיצה על אותו כפתור פעם נוספת להקלטת הזמן שחלף .... הכפתור השני שימש לאיפוס השעון לאפס.

שעון עצירה מכני עבד בעצם באמצעות כוח קפיץ, שדרש תקופת פירוק ידנית על ידי סיבוב הכפתור המחורץ הנתון בחלקו העליון של מכשיר השעון.

אולם לעומת השעונים הדיגיטליים המודרניים, הסוגים המכאניים יכולים להיחשב פרימיטיביים ולא מדויקים בטווח של אלפיות השנייה.

שימוש בארדואינו

והיום עם כניסתו של המיקרו-בקר, שעוני העצירה הללו הפכו מדויקים ואמינים ביותר לטווח המיקרו-שניות.

מעגל שעוני העצירה של Arduino המוצג כאן הוא אחד מהעיצוב המודרני המופעל על ידי מיקרו-בקר, אשר המדויק ביותר ניתן לצפות להיות זהה לגאדג'טים המסחריים המודרניים.

בואו ללמוד כיצד לבנות את מעגל שעון העצירה המוצע של Arduino:

תזדקק לכתב החומרים הבא לבנייה:

נדרשת חומרה

מגן מקשי LCD מסוג Arduino (מק'ט: DFR0009)

לוח ארדואינו ONE

כבל 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 פלחים

עכשיו בואו נמשיך עם הפרטים לגבי בניית מעגל שעון עצר באמצעות תצוגת LED 7 קטעים וארדואינו. אנו נבדוק את המושגים הקשורים להפרעות ולממשקי IC של מנהלי התקנים, אשר חיוניים להבנת פרויקט זה. פרויקט זה הוצע על ידי מר אבו-חפס שהוא אחד הקוראים הנלהבים באתר זה.

כידוע ששעון עצר הוא מכשיר המסייע במעקב אחר פרק זמן קצר בין שעות לטווח של אלפיות השנייה (בעיקר). כמעט כל שעוני היד הדיגיטליים הזולים המצוידים בפונקציונליות של שעון עצר, אך אף אחד מהשעונים לא יכול לתת את הלהט להכין אחד לעצמנו וגם למצוא שעון עצר עם תצוגת LED בת 7 קטעים הוא יוצא דופן.

מר אבו-האפס הציע לנו לעצב סטופר עם 4 תצוגות, שתיים לדקות ושניים לשניות (MM: SS). אך עבור רובנו זה לא יכול להיות עיצוב ריאלי, לכן הוספנו עוד שני תצוגה לטווח של אלפית השנייה ולכן כעת העיצוב המוצע יהיה בתצורת MM: SS: mS.

אם אתה רק זקוק לתצורת MM: SS מסיבה כלשהי, אינך צריך לחבר את תצוגות קטע טווח המילישניות השנייה ואת ICs הנהג שלה, כל הפונקציונליות של המעגל עדיין לא מושפעת.

המעגל:

שעון העצר המוצע מורכב משישה IC 4026 המהווים דרייבר תצוגת שבעה קטעים, שישה תצוגות LED בעלות 7 קטעים, לוח ארדואינו אחד, כמה כפתורי לחיצה וזוג נגדי 10K.

עכשיו בואו להבין איך לחבר תצוגת 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.

הצגת תרשים חיבור:

כל אחד מהסיכה GND של תצוגת 7 קטעים יכול להיות מחובר לקרקע. ה- IC חייב להיות מופעל מאספקת 5V או מסיכת הפלט של 5V של Arduino.

התרשים הנ'ל לתצוגה אחת בלבד, חזור על אותו הדבר עבור חמש תצוגות אחרות.

הנה שאר הסכמות:

המעגל עשוי להיות מופעל מסוללת 9 וולט. הם שני כפתורים המסופקים כאן אחד להתחלת הזמן ואחד לעצירה. על ידי לחיצה על כפתור האיפוס ב- Arduino, ספירת הזמן תאופס לאפס בתצוגה.

שני כפתורי הלחיצה מחוברים לסיכה מס '2 ומס' 3 שהם הפרעת חומרה של המיקרו-בקר Arduino / Atmega328P.

בואו להבין מהי הפרעה:

ישנם שני סוגים של הפרעות: הפרעת חומרה והפרעת תוכנה. כאן אנו משתמשים רק בהפרעת החומרה.

הפרעה היא אות למיקרו-בקר, מה שגורם למיקרו-בקר להגיב מיד לאירוע.

בלוחות Arduino יש רק שני סיכות להפסקת חומרה עם ATmega328P מיקרו בקר סיכה מס '2 ומס' 3. ל- Arduino מגה יש יותר משני סיכות להפסקת חומרה.

המיקרו-בקרים לא יכולים לבצע שתי פונקציות במקביל. למשל לבדוק לחיצת כפתור ולספור מספרים.

המיקרו-בקרים לא יכולים לבצע שני אירועים בו זמנית, אם אנו כותבים קוד לבדיקת לחיצת כפתור וספירת מספרים, לחיצת הכפתור תתגלה רק כאשר המיקרו-בקר קורא את פיסת קוד לחיצה על לחצן, שאר הזמן (סופר את המספרים) הכפתור לא עובד.

כך שיהיה עיכוב בזיהוי לחיצת הלחצן ומסיבה כלשהי אם הקוד נעצר באופן זמני, לחיצת הכפתור לעולם לא תתגלה. כדי להימנע מבעיות מסוג זה מופיעה הפרעה.

אות ההפרעה מקבל תמיד עדיפות גבוהה ביותר, הפונקציה הראשית (שורות קוד ראשיות) תיעצר ותבצע את הפונקציה (פיסת קוד אחרת) שהוקצתה עבור אותה הפרעה מסוימת.

זה חשוב מאוד ליישומים קריטיים בזמן כמו שעון עצר או מערכות אבטחה וכו ', כאשר המעבד צריך לנקוט פעולה מיידית בתגובה לאירוע.

בארדואינו אנו מקצים הפרעה לחומרה כ:

attachInterrupt (0, התחל, עולה)

• '0' פירושו מספר הפסיקה אפס (במיקרו-בקרים הכל מתחיל מאפס) שהוא סיכה מס '2.
• 'התחל' הוא שם של פונקציית ההפסקה, אתה יכול שם כל דבר כאן.
• 'עולה' אם הסיכה מס '2 (שהיא הפסקה אפסית) גבוהה, פונקציית ההפסקה מבוצעת.

attachInterrupt (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---------------//
עכשיו זה מסיים את הקוד.

שעון עצר שפותח במיוחד עבור האתלטים

לבסוף, בואו נלמד כיצד ניתן לשדרג את המושגים שלעיל עבור ספורטאים המעוניינים לפתח את כישורי הריצה שלהם מבלי לתלות באחרים לצורך ההתחלה הנחוצה ולעצור את הטיימר / סטופר. עדיף להפעיל את הטיימר באופן אוטומטי על ידי זיהוי התנועה שלך מאשר מישהו שמתניע / עוצר את שעון העצר, מה שעשוי להוסיף גם את זמן התגובה שלהם.

הערה: פרויקט זה מיועד למדידת הזמן שבין נקודה 'A' לנקודה 'B' המכוסה על ידי משתמש אחד בכל פעם.

ההתקנה מורכבת משני לייזרים המוצבים בנקודת ההתחלה ובנקודת הסיום, שני LDRs ממוקמים גם מול שני מודולי לייזר. כאשר הספורטאי קוטע את הלייזר 'המתחיל' הזמן מתחיל לחשב וכשהספורטאי מגיע לסוף, קוטע את הלייזר 'מסתיים' ועוצר הטיימר ומציג את הזמן שחלף בין שתי נקודות. זו השיטה בה משתמשים למדידת הזמן שחלף ברעיון המוצע.

בואו נסתכל על כל רכיב במעגל בפירוט.

רכיבי פרטי עבודה

המעגל נשמר פשוט למדי, הוא מורכב ממודול LCD בגודל 16 x 2, מעט נגדים, שני LDR וכפתור לחיצה.

הממשק בין LCD ו- arduino הוא סטנדרטי, ואנחנו יכולים למצוא חיבור דומה בפרויקטים רבים אחרים מבוססי LCD.

שני סיכות אנלוגיות A0 ו- A1 משמשות לזיהוי הפרעות לייזר. סיכה אנלוגית A2 מחוברת באמצעות כפתור לחיצה המשמש לחימוש שעון העצר.

שלושה נגדים, שני 4.7K ואחד 10K הם נגדים נפתחים שמסייעים לסיכות קלט להישאר נמוכות.

פוטנציומטר 10K מסופק להתאמת ניגודיות במודול LCD לצורך ראות מיטבית.

המעגל המוצע תוכנן עם מנגנון גילוי תקלות עבור לייזרים. אם אחד מהלייזר תקול או שאינו מיושר כראוי עם LDR, הוא מציג הודעת שגיאה בתצוגת LCD.

· אם לייזר START אינו פועל, הוא מציג 'הלייזר' התחל 'אינו פועל'

· אם לייזר STOP אינו פועל, הוא מציג 'הלייזר 'עצור' אינו פועל'

· אם שני הלייזרים לא מתפקדים, מוצג 'שני הלייזרים לא עובדים'

· אם שני הלייזרים מתפקדים כראוי, מוצג 'שני הלייזרים עובדים בסדר'

הודעת השגיאה מופיעה עד שמודול הלייזר קבוע או יישור נעשה כראוי עם LDR.

ברגע שלב זה נקי מבעיות, המערכת עוברת למצב המתנה ומציגה '-המתנה מערכת-'. בשלב זה המשתמש יכול לחמש את ההתקנה על ידי לחיצה על כפתור הלחיצה בכל עת.

אחת כפתור הלחיצה נלחץ המערכת מוכנה לזהות תנועה מהמשתמש ומציגה 'המערכת מוכנה'.

הרץ עשוי להיות כמה סנטימטרים מהלייזר 'התחל'.

אם הלייזר 'התחל' מופרע הזמן מתחיל להיספר והתצוגות 'הזמן מחושב ……' הזמן מחושב בקרקע האחורית.

הזמן שחלף לא יוצג עד שהרץ יגיע / יפריע ללייזר ה'עצור '. הסיבה לכך היא שהצגת הזמן החולף על גבי LCD כפי שעושה שעון עצר מסורתי, מחייבת ביצוע מספר הוראות נוספות במיקרו-בקר, מה שמדרדר את דיוק ההתקנה באופן משמעותי.

הערה: לחץ על כפתור האיפוס ב- arduino כדי לנקות את הקריאות.

כיצד להגדיר את המעגל על ​​מסלול ריצה:

אנא השתמש בחוטים עבים לחיבור בין LDR למעגל ארדואינו מכיוון שהמרחק בין שני אלה עשוי להיות זה מזה כמה מטרים, והמתח לא יכול לרדת משמעותית. המרחק בין 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 LDRs נוספים למדידת זמן הפיצול של רץ הסולו. ישנם 6 LDRs בסך הכל את כולם ניתן למקם במסלול הריצה עם מרחק אחיד ביניהם או בהתאם לנסיבות ולבחירת המשתמש.

רוב החומרה נשמרת ללא שינוי למעט תוספת של 4 LDR, אך הקוד עבר שינוי עצום.

תרשים סכמטי המציג זמן מפוצל:

המעגל הנ'ל מורכב ממספר רכיבים וידידותי למתחילים. אין צורך בהסבר נוסף, רק חוט לפי תרשים המעגל.

כיצד לחבר LDR:

LDR 2 מוצג בתרשים המעגל הראשי חבר 4 LDRs נוספים במקביל כמוצג בתרשים לעיל.

דיאגרמת פריסה:

האמור לעיל הוא הסדר הבסיסי כיצד למקם את הלייזר. שים לב שהמרחק בין 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-------//

כיצד להפעיל שעון עצר אוטומטי זה:

• עם ההתקנה שהושלמה, הפעל תחילה את הלייזרים ואז הפעל את מעגל הארדואינו בהמשך.
• אם כל הלייזרים מיושרים כראוי עם LDR, התצוגה לא תנחה הודעות שגיאה. אם יש, אנא יישר אותם כראוי.
• כעת המעגל מציג 'המערכת במצב המתנה'. כעת לחץ על כפתור 'התחל' והוא יציג 'המערכת מוכנה'.
• בשלב זה כאשר נגן הסולו קוטע את קרן האור LDR 1, הטיימר מתחיל והוא מציג 'הזמן מחושב ...'.
• ברגע שהנגן מגיע לנקודת הסיום כלומר LDR 6, הטיימר נעצר והוא מציג את 5 הזמן המפוצל שנרשם על ידי המעגל.
• המשתמש צריך ללחוץ על כפתור האיפוס בארדואינו כדי לאפס את הטיימר.
מדוע שעון עצר אוטומטי זה אינו יכול להציג תזמון חי בתצוגה כפי שעושה שעון עצר מסורתי (אלא הוא מציג טקסט סטטי 'הזמן מחושב ....')?
כדי להציג את העיתוי בזמן אמת, על ארדואינו לבצע הוראות נוספות לתצוגת LCD. זה יוסיף כמה מיקרו-שניות לעיכוב של כמה אלפיות השנייה לפיסת הקוד העיקרית בזמן, מה שיוביל לתוצאות לא מדויקות.

אם יש לך שאלות נוספות, אנא הביע באמצעות קטע התגובה.