Arduino Automatic School / College Bell System

In diesem Beitrag werden wir ein automatisches Schulglocken- / College-Klingelsystem mit Arduino, 16 x 2-Display und Echtzeituhrmodul erstellen. Sie können dieses Projekt so programmieren, dass es bis zu 16 Mal am Tag zu Ihrer bevorzugten Stunde und Minute klingelt. Die Länge des Klingels kann in Sekunden programmiert werden.

Suchen Sie eine einfachere Version ohne Codierung? Kapiert HIER

Überblick

Vorbei sind die Zeiten, in denen ein Peon in einer Schule die Glocke „Zinn Zinn Zinn“ läutete und die Schüler mit Bravour aus dem Schuleingang rannten. Einige werden vielleicht noch glücklicher, wenn der Peon einige Minuten zuvor die letzte Glocke geläutet hat.

Dies war das Szenario vor 15 bis 20 Jahren, aber jetzt sind alle Schulen und Hochschulen streng zeitgebunden und die Glocken sind automatisiert.

Die schnelle Kindheit / Jugend des Autors erinnert sich:

Während meiner Grund- und Sekundarschule wurde die Digitaluhr, die ich trug, mit einer Genauigkeit von 1 Sekunde mit dem Klingelsystem der Schule synchronisiert.

Ich würde schreien 'Die Glocke wird in 5 Sekunden läuten', nachdem die Glocke geläutet hat. Alle Schüler starren mich überrascht an. Dies passiert fast jeden Tag. Eines Tages zählen ich und meine engen Freunde 10, 9, 8, 7 ... vor der letzten Glocke herunter.

Alle meine Freunde sagen, es sei eine magische Armbanduhr, aber sie haben keine einfache Tatsache erkannt, dass die Schulglocke automatisiert war. LOL !!

Wir werden eine solche Schul- / College-Glocke mit Arduino herstellen.

Anzeige zur Arduino-Verbindung

Die Anzeige zu Arduino-Verbindungen unterscheidet sich geringfügig von dem, was wir normalerweise verdrahten, den hier verwendeten Pins 9, 8, 7, 6, 5 und 4. Die Pin-Nummern 2 und 3 werden als Hardware-Interrupt über verwendet Drück Knöpfe .

Verwenden Sie die 10K Potentiometer zum Einstellen des Kontrasts für die Anzeige .

Detaillierte Informationen zu Glocken- und Relaisanschlüssen:

UPDATE: A5 zu SCL und A4 zu SDA (nicht A4 zu SCK)

Echtzeituhr-Modul

Das Echtzeituhr Das Modul verfolgt die Zeit auch nach langem Stromausfall. Zum Ein- und Ausschalten der Glocke ist ein 9-V-Relais vorgesehen.

Bitte schließen Sie eine 1N4007-Diode in Sperrrichtung über das Relais an (was im Schaltplan nicht gezeigt ist), die schädliche Hochspannungs-Gegen-EMK vom Relais absorbiert.

Versorgen Sie den Stromkreis mit a 9V / 500mA Wandadapter .

Drei Druckknöpfe dienen zum manuellen Betätigen der Glocke in bestimmten Situationen. Durch Drücken der Taste „Beenden“ wird die Glocke nach manuellem Klingeln gestoppt.

Die „Klingeltaste“ deaktiviert die Glocke für immer. Um die Glocke wieder zu aktivieren, drücken Sie die Taste „Beenden“.

So stellen Sie die Zeit für das RTC-Modul ein:

Laden Sie die RTC-Bibliothek herunter:
Link: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Laden Sie timeLib.h herunter:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Laden Sie das Programm hoch

Laden Sie das folgende Programm hoch, mit dem die Uhrzeit auf RTC eingestellt wird

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

Öffnen Sie nach dem Hochladen des Codes den seriellen Monitor. Dort wird angezeigt, dass die Uhrzeit eingestellt ist.
Sobald der obige Schritt erfolgreich abgeschlossen wurde, fahren Sie mit dem nächsten fort.
Laden Sie nun den folgenden Code auf Arduino hoch.

Hauptprogrammcode:

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

Nach dem Hochladen des obigen Codes sollte die Uhrzeit in Stunden auf dem Display angezeigt werden.

Damit ist der Programmcode abgeschlossen.

So verwenden Sie dieses automatische Klingelsystem:

Tun Sie dies mit abgeschlossenem Hardware-Setup.

1. Laden Sie zuerst den Code für die Zeiteinstellung hoch und öffnen Sie den seriellen Monitor.
2. Stellen Sie hier im Hauptprogramm den Zeitpunkt ein, zu dem das Relais ausgelöst werden muss.

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

• Stellen Sie h1 in Stunden von 1 bis 23 Stunden und m1 in Minuten von 0 bis 59 ein.
• Gleiches gilt für h1 bis h16 und m1 bis m16.
• Wenn Sie einen Klingelwert deaktivieren möchten, lassen Sie beispielsweise h = 0 und m = 0: h5 = 0 und m5 = 0, Null deaktiviert diese bestimmte Glocke.

3. Stellen Sie hier die Zeitdauer für das Ein- und Ausschalten der Glocke ein:

// --------------- Klingellänge in Sekunden ------- //
const int Lenght = 3 // in Sekunden

Standardmäßig ist der Wert auf 3 Sekunden eingestellt. Wenn die eingestellte Zeit erreicht ist, wird die Relais wird für 3 Sekunden eingeschaltet und ausgeschaltet. Ändern Sie dies bei Bedarf.

4. Laden Sie den geänderten Code auf Arduino hoch.
5. Um die Glocke zu deaktivieren, drücken Sie die Taste „Glockendeaktivierung“. Zum erneuten Aktivieren drücken Sie die Taste „Beenden“.
6. Um die Glocke manuell zu läuten, drücken Sie den „manuellen Klingelschalter“ und um die Glocke zu stoppen, drücken Sie „exit“.

Damit ist das Projekt abgeschlossen. Wenn Sie Fragen zu diesem Projekt haben, können Sie diese gerne im Kommentarbereich ausdrücken.