Arduino automaatne kooli / kolledži kellasüsteem

Selles postituses ehitame Arduino, 16 x 2 kuvari ja reaalajas kella mooduli abil automaatse koolikella / kolledži kellasüsteemi. Saate selle projekti programmeerida kella helistama kuni 16 korda päevas teie eelistatud kellaajal ja minutil. Kellamängu pikkuse saab programmeerida sekundites.

Kas otsite lihtsamat versiooni ilma kodeerimiseta? Saage see kätte SIIN

Ülevaade

Möödas on ajad, kui pojeng koolis helistas “plekist plekkplekist” ja õpilased jooksid kooli sissepääsu juurest värviliselt välja. Mõni võib veelgi õnnelikumaks minna, kui pojeng paar minutit varem viimast kella helistas.

See oli stsenaarium 15–20 aastat tagasi, kuid nüüd on kõik koolid ja kolledžid rangelt ajaliselt seotud ja kellad on automatiseeritud.

Autori kiire lapsepõlve / teismelise kapuuts mäletab:

Põhi- ja keskkooli ajal sünkroniseeriti minu kantud digitaalne kell 1 sekundi täpsusega kooli kellasüsteemiga.

Ma hüüaksin, et „kell hakkab helisema 5 sekundi pärast“, pärast seda, kui kõik kõlasid, vaatasid mind üliõpilased mind üllatunult, see juhtub peaaegu iga päev. Mõnel päeval hakkan mina ja mu lähedased sõbrad loendama 10, 9, 8, 7 ... enne viimast kella.

Kõik mu sõbrad ütlevad, et see on maagiline käekell, kuid nad ei mõistnud üht lihtsat fakti, et koolikell oli automatiseeritud. LOL !!

Me teeme ühe sellise kooli / kolledži kellu, kasutades Arduino.

Kuva Arduino ühendusse

Arduino ühenduste kuvamine erineb veidi sellest, mida me tavaliselt ühendame, siin kasutatavad tihvtid 9, 8, 7, 6, 5 ja 4. Tihvtinumbreid 2 ja 3 kasutatakse riistvaralise katkestusena nupud .

Kasutage 10K potentsiomeeter kontrasti seadistamiseks kuva .

Üksikasjalik teave kella ja relee ühenduste kohta:

UUENDAMINE: A5 - SCL ja A4 - SDA (mitte A4 - SCK)

Reaalajas kellamoodul

The Reaalajas kell moodul jälgib aega ka pärast pikka voolukatkestust. Kella sisse- ja väljalülitamiseks on ette nähtud 9V relee.

Palun ühendage 1N4007 diood vastupidises eelrõhus üle relee (mida pole skeemil näidatud), mis neelab releelt kahjuliku kõrgepinge tagasi EMF-i.

Toite vooluahelat, kasutades a 9V / 500mA seinaadapter .

Kolm nuppu on varustatud kellaga käsitsi juhtimiseks. Nupu “exit” vajutamine peatab kellu pärast kella käsitsi helistamist.

Kella keelamise nupp keelab kella igaveseks. Kella uuesti lubamiseks vajutage nuppu “Välju”.

RTC mooduli aja määramine:

Laadige alla RTC teek:
Link: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Allalaadimise aegLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Laadige programm üles

Laadige üles allpool olev programm, mis määrab aja RTC-ks

//----------------------------------------------------//
#include
#include
#include
int P=A3 //Assign power pins for RTC
int N=A2
const char *monthName[12] = {
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
}
tmElements_t tm
void setup() {
pinMode(P,OUTPUT)
pinMode(N,OUTPUT)
digitalWrite(P,HIGH)
digitalWrite(N,LOW)
bool parse=false
bool config=false
// get the date and time the compiler was run
if (getDate(__DATE__) && getTime(__TIME__)) {
parse = true
// and configure the RTC with this info
if (RTC.write(tm)) {
config = true
}
}
Serial.begin(9600)
while (!Serial) // wait for Arduino Serial Monitor
delay(200)
if (parse && config) {
Serial.print('DS1307 configured Time=')
Serial.print(__TIME__)
Serial.print(', Date=')
Serial.println(__DATE__)
} else if (parse) {
Serial.println('DS1307 Communication Error :-{')
Serial.println('Please check your circuitry')
} else {
Serial.print('Could not parse info from the compiler, Time='')
Serial.print(__TIME__)
Serial.print('', Date='')
Serial.print(__DATE__)
Serial.println(''')
}
}
void loop() {
}
bool getTime(const char *str)
{
int Hour, Min, Sec
if (sscanf(str, '%d:%d:%d', &Hour, &Min, &Sec) != 3) return false
tm.Hour = Hour
tm.Minute = Min
tm.Second = Sec
return true
}
bool getDate(const char *str)
{
char Month[12]
int Day, Year
uint8_t monthIndex
if (sscanf(str, '%s %d %d', Month, &Day, &Year) != 3) return false
for (monthIndex = 0 monthIndex <12 monthIndex++) {
if (strcmp(Month, monthName[monthIndex]) == 0) break
}
if (monthIndex >= 12) return false
tm.Day = Day
tm.Month = monthIndex + 1
tm.Year = CalendarYrToTm(Year)
return true
}
//----------------------------------------------------//

Pärast koodi üleslaadimist avage jadamonitor, see ütleb, et kellaaeg on määratud.
Kui ülaltoodud samm on edukalt täidetud, liikuge järgmisele.
Nüüd laadige allolev kood Arduinosse üles.

Põhiprogrammi kood:

//------------Program developed by R.GIRISH------------//
#include
#include
#include
#include
#include
LiquidCrystal lcd(9, 8, 7, 6, 5, 4)
int i = 0
int H = 0
int M = 0
int S = 0
int setting_value
const int bell = 10
const int P = A3
const int N = A2
const int setting_address = 0
const int over_ride_off = 11
boolean bell_status = true
boolean Over_ride = true
//------------------- Set Bell Timings from hours 1 to 23 hrs -------------------//
//---- 1st bell ------//
const int h1 = 0 //hours
const int m1 = 0 //Minutes
//---- 2nd bell ------//
const int h2 = 0
const int m2 = 0
//---- 3rd bell ------//
const int h3 = 0
const int m3 = 0
//---- 4th bell ------//
const int h4 = 0
const int m4 = 0
//---- 5th bell ------//
const int h5 = 0
const int m5 = 0
//---- 6th bell ------//
const int h6 = 0
const int m6 = 0
//---- 7th bell ------//
const int h7 = 0
const int m7 = 0
//---- 8th bell ------//
const int h8 = 0
const int m8 = 0
//---- 9th bell ------//
const int h9 = 0
const int m9 = 0
//---- 10th bell ------//
const int h10 = 0
const int m10 = 0
//---- 11th bell ------//
const int h11 = 0
const int m11 = 0
//---- 12th bell ------//
const int h12 = 0
const int m12 = 0
//---- 13th bell ------//
const int h13 = 0
const int m13 = 0
//---- 14th bell ------//
const int h14 = 0
const int m14 = 0
//---- 15th bell ------//
const int h15 = 0
const int m15 = 0
//---- 16th bell ------//
const int h16 = 0
const int m16 = 0
//--------------- bell ring lenght in seconds -------//
const int Lenght = 3 //in seconds
//-------------------------- -------------------------//
void setup()
{
lcd.begin(16, 2)
pinMode(P, OUTPUT)
pinMode(N, OUTPUT)
pinMode(bell, OUTPUT)
pinMode(over_ride_off, INPUT)
digitalWrite(P, HIGH)
digitalWrite(N, LOW)
digitalWrite(over_ride_off, HIGH)
attachInterrupt(0, over_ride, RISING)
attachInterrupt(1, bell_setting, RISING)
if (EEPROM.read(setting_address) != 1)
{
bell_setting()
}
}
void loop()
{
tmElements_t tm
lcd.clear()
if (RTC.read(tm))
{
H = tm.Hour
M = tm.Minute
S = tm.Second
lcd.setCursor(0, 0)
lcd.print('TIME:')
lcd.print(tm.Hour)
lcd.print(':')
lcd.print(tm.Minute)
lcd.print(':')
lcd.print(tm.Second)
lcd.setCursor(0, 1)
lcd.print('DATE:')
lcd.print(tm.Day)
lcd.print('/')
lcd.print(tm.Month)
lcd.print('/')
lcd.print(tmYearToCalendar(tm.Year))
} else {
if (RTC.chipPresent())
{
lcd.setCursor(0, 0)
lcd.print('RTC stopped!!!')
lcd.setCursor(0, 1)
lcd.print('Run SetTime code')
} else {
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Read error!')
lcd.setCursor(0, 1)
lcd.print('Check circuitry!')
}
}
if (EEPROM.read(setting_address) == 1)
{
if (H == 0 && M == 0 && S == 0)
{
digitalWrite(bell, LOW)
}
if (H == h1 && M == m1 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h2 && M == m2 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h3 && M == m3 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h4 && M == m4 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h5 && M == m5 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h6 && M == m6 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h7 && M == m7 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h8 && M == m8 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h9 && M == m9 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h10 && M == m10 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h11 && M == m11 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h12 && M == m12 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h13 && M == m13 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h14 && M == m14 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h15 && M == m15 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
if (H == h16 && M == m16 && S == 0)
{
for (i = 0 i {
digitalWrite(bell, HIGH)
delay(1000)
}
digitalWrite(bell, LOW)
i = 0
}
}
delay(1000)
}
void over_ride()
{
lcd.clear()
while (Over_ride)
{
digitalWrite(bell, HIGH)
lcd.setCursor(0, 0)
lcd.print('Press Exit to')
lcd.setCursor(0, 1)
lcd.print('Stop the bell!!!')
if (digitalRead(over_ride_off) == LOW)
{
Over_ride = false
digitalWrite(bell, LOW)
}
}
Over_ride = true
}
void bell_setting()
{
setting_value = 0
EEPROM.write(setting_address, setting_value)
lcd.clear()
while (bell_status)
{
lcd.setCursor(0, 0)
lcd.print('Bell is Disabled')
lcd.setCursor(0, 1)
lcd.print('Press Exit.')
if (digitalRead(over_ride_off) == LOW)
{
bell_status = false
}
}
bell_status = true
setting_value = 1
EEPROM.write(setting_address, setting_value)
}
//------------Program developed by R.GIRISH------------//

Pärast ülaltoodud koodi üleslaadimist peaksite ekraanil nägema kellaaega tundides.

See lõpetab programmi koodi.

Selle automaatse kellasüsteemi kasutamine:

Tehke seda koos riistvara lõpuleviimisega.

1. Laadige kõigepealt üles „aja seadistamise“ kood ja avage seeriamonitor.
2. Põhiprogrammis määrake aeg, mil siin tuleb relee käivitada.

//---- 1st bell ------//
const int h1 = 0 //hours
const int m1 = 0 //Minutes
//---- 2nd bell ------//
const int h2 = 0
const int m2 = 0
//---- 3rd bell ------//
const int h3 = 0
const int m3 = 0
//---- 4th bell ------//
const int h4 = 0
const int m4 = 0

• Määrake h1 tundides vahemikus 1 kuni 23 tundi ja m1 minutites vahemikus 0 kuni 59.
• Sama h1 kuni h16 ja m1 kuni m16.
• Kui soovite keelata mõne kellaaja lahkumise väärtuse h = 0 ja m = 0, näiteks: h5 = 0 ja m5 = 0, keelab null selle konkreetse kella.

3. Määrake kella sisse- ja väljalülitamise aja pikkus siin:

// --------------- kellahelina pikkus sekundites ------- //
const int Pikkus = 3 // sekundites

Vaikimisi on väärtus seatud 3 sekundiks. Kui määratud aeg on saabunud relee lülitatakse 3 sekundiks sisse ja lülitatakse välja. Vajadusel muutke seda.

4. Laadige muudetud kood Arduinosse üles.
5. Kella keelamiseks vajutage klahvi keelamise nuppu. Uuesti lubamiseks vajutage nuppu “Välju”.
6. Kella käsitsi helistamiseks vajutage “manuaalset kellalülitit” ja kella peatamiseks vajutage “exit”.

Sellega projekt lõpeb, kui teil on selle projektiga seoses küsimusi, võite seda kommentaaride jaotises väljendada.