Arduino Automatic School / College Bell System

I det här inlägget ska vi bygga ett automatiskt skolklocka / college bell-system med Arduino, 16 x 2 display och realtidsklockmodul. Du kan programmera det här projektet så att det ringer upp till 16 gånger om dagen vid önskad timme och minut. Klockringens längd kan programmeras på några sekunder.

Letar du efter en enklare version utan kodning? Förstår HÄR

Översikt

Borta är de dagar då en peon i en skola ringde klockan ”tenn tenn” och eleverna sprang ut ur skolans entré med glans. Vissa kan bli ännu lyckligare när peonen ringde den sista klockan några minuter tidigare.

Detta var scenariot för 15 till 20 år sedan, men nu är alla skolor och högskolor strikt tidsbundna och klockorna automatiseras.

Författarens snabba barndom / tonårshatt kom ihåg:

Under min grundskola och gymnasiet synkroniserades den digitala klockan som jag bar med skolans klocksystem med 1 sekunders precision.

Jag skulle skrika 'klockan kommer att ringa om 5 sekunder' efter att klockan ringde alla elever stirrar på mig med förvåning, detta händer nästan varje dag. En dag börjar jag och mina nära vänner räkna ner 10, 9, 8, 7 ... .. före den sista klockan.

Alla mina vänner säger att det är ett magiskt armbandsur, men de insåg inte ett enkelt faktum att skolklockan var automatiserad. LOL!!

Vi ska göra en sådan skola / högskoleklocka med Arduino.

Display till Arduino-anslutning

Displayen till Arduino-anslutningar skiljer sig något från vad vi brukar ansluta dem vanligtvis, stiften 9, 8, 7, 6, 5 och 4 som används här. Stift nummer 2 och 3 används som hårdvaruavbrott via trycka på knappar .

Använd 10K potentiometer för att justera kontrasten för visa .

Detaljerad information om klock- och reläanslutningar:

UPPDATERING: A5 till SCL och A4 till SDA (inte A4 till SCK)

Realtidsklockmodul

De Riktig tids klocka modulen håller reda på tiden även efter lång strömavbrott. Ett 9V-relä finns för att slå på och av klockan.

Anslut en 1N4007-diod i omvänd förspänning över reläet (vilket inte visas i schemat) som absorberar skadlig högspännings-EMF från reläet.

Slå på kretsen med en 9V / 500mA väggadapter .

Tre tryckknappar finns en för manuell manövrering av klockan under vissa situationer. Genom att trycka på 'exit' -knappen stoppas klockan efter att man ringt klockan manuellt.

'Bell disable button' kommer att inaktivera klockan för alltid. För att återaktivera klockan trycker du på “Avsluta” -knappen.

Så här ställer du in tid till RTC-modul:

Ladda ner RTC-biblioteket:
Länk: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Ladda ner timeLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Ladda upp programmet

Ladda upp programmet nedan som ställer in tiden till RTC

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

Efter att ha laddat upp koden, öppna den seriella bildskärmen, den kommer att säga att tiden är inställd.
När steget ovan har uppnåtts framgångsrikt går du vidare till nästa.
Ladda nu upp koden nedan till Arduino.

Huvudprogramkod:

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

Efter att ha laddat upp ovanstående kod bör du se tiden i timmar på displayen.

Det avslutar programkoden.

Hur man använder detta automatiska klocksystem:

Gör detta med slutförd hårdvaruinstallation.

1. Ladda upp koden 'tidsinställning' först och öppna den seriella bildskärmen.
2. Ställ in den tid då reläet måste utlösas i huvudprogrammet här.

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

• Ställ in h1 i timmar från 1 till 23 timmar och m1 i minuter från 0 till 59.
• Samma för h1 till h16 och m1 till m16.
• Om du vill inaktivera ett visst värde för klockan lämnar h = 0 och m = 0 till exempel: h5 = 0 och m5 = 0, kommer noll att inaktivera just den klockan.

3. Ställ in tidslängden för att klockan ska slås på och av, här:

// --------------- klockans ringlängd i sekunder ------- //
const int Längd = 3 // i sekunder

Som standard är värdet inställt på 3 sekunder. När den inställda tiden har anlänt relä slås på i tre sekunder och stängs av. Ändra detta om du behöver.

4. Ladda upp den modifierade koden till Arduino.
5. För att inaktivera klockan, tryck på “bell disable button”. För att återaktivera, tryck på “Avsluta” -knappen.
6. För att ringa klockan manuellt trycker du på “manuell klockomkopplare” och för att stoppa klockan trycker du på “avsluta”.

Det avslutar projektet, om du har några frågor angående detta projekt är du välkommen att uttrycka i kommentarsektionen.