Arduino Automatic School / College Bell System

Arduino Automatic School / College Bell System

I dette indlæg skal vi konstruere et automatisk skoleklokke / college klokke-system ved hjælp af Arduino, 16 x 2-skærm og realtidsur-modul. Du kan programmere dette projekt til at ringe op til 16 gange om dagen på dit foretrukne time og minut. Længden af ​​klokkeringen kan programmeres i sekunder.



Leder du efter en enklere version uden kodning? Få det HER

Oversigt

Borte er de dage, hvor en peon i en skole ringede på klokken 'tin tin tin' og eleverne løb ud af skolens indgang med flyvende farver. Nogle kan blive endnu lykkeligere, da peon ringede til den sidste klokke få minutter tidligere.





Dette var scenariet for 15 til 20 år siden, men nu er alle skoler og gymnasier strengt tidsbundne, og klokkerne automatiseres.

Forfatterens hurtige barndom / teenage hætte husk:



Under min grundskole og gymnasium blev det digitale ur, som jeg havde på, synkroniseret med skolens klokkesystem med 1 sekunders præcision.

Jeg råber 'klokken ringer om 5 sekunder' efter klokken ringede alle studerende med overraskelse på mig, dette sker næsten hver dag. En dag begynder jeg og mine nære venner at tælle ned 10, 9, 8, 7… .. før den sidste klokke.

Alle mine venner siger, at det er et magisk armbåndsur, men de indså ikke en simpel kendsgerning, at skoleklokken var automatiseret. LOL !!

Vi skal lave en sådan skole / college klokke ved hjælp af Arduino.

Display til Arduino-forbindelse

Skærmen til Arduino-forbindelser er lidt forskellige fra det, vi tilslutter dem normalt, benene 9, 8, 7, 6, 5 og 4, der bruges her. Pin nummer 2 og 3 bruges som hardware afbrydelse via trykknapper .

Brug 10K potentiometer til justering af kontrasten til Skærm .

Arduino skoleklokke LCD

Automatisk skole / college klokke system ved hjælp af Arduino

Detaljerede oplysninger om klokke- og relæforbindelser:

skole klokke timer kredsløb med Arduino

OPDATERING: A5 til SCL og A4 til SDA (ikke A4 til SCK)

Realtids urmodul

Det Realtidsur modul holder styr på tiden selv efter lang strømafbrydelse. Der er et 9V-relæ til at tænde og slukke for klokken.

Tilslut en 1N4007-diode i omvendt forspænding på tværs af relæet (som ikke er vist i skemaet), som absorberer skadelig højspændings-EMF fra relæet.

Tænd for kredsløbet ved hjælp af en 9V / 500mA vægadapter .

Der er tilvejebragt tre trykknapper til manuel betjening af klokken under en situation. Ved at trykke på “exit” -knappen stoppes klokken efter manuelt ringetone.

'Bell disable button' deaktiverer klokken for evigt. For at genaktivere klokken skal du trykke på “Afslut” -knappen.

Sådan indstilles tid til RTC-modul:

Download RTC-biblioteket:
Link: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Download timeLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Upload programmet

Upload programmet nedenfor, som indstiller tiden til 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 uploaden af ​​koden skal du åbne den serielle skærm, den vil sige, at tiden er indstillet.
Når ovenstående trin er gennemført, skal du gå videre til næste.
Upload nu nedenstående kode til Arduino.

Hovedprogram Kode:

//------------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 uploaden af ​​ovenstående kode skal du se tiden i timer på displayet.

Det afslutter programkoden.

Sådan bruges dette automatiske klokkesystem:

Gør dette med afsluttet hardwareopsætning.

1. Upload først 'tidsindstilling' -koden, og åbn den serielle skærm.
2. I hovedprogrammet indstilles det tidspunkt, hvor relæet skal udløses her.

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

• Indstil h1 i timer fra 1 til 23 timer og m1 i minutter fra 0 til 59.
• Samme for h1 til h16 og m1 til m16.
• Hvis du f.eks. Vil deaktivere en værdi, der forlader klokken h = 0 og m = 0: h5 = 0 og m5 = 0, deaktiverer nul den pågældende klokke.

3. Indstil tidslængden for klokken, der skal tændes og slukkes, her:

// --------------- klokke ring længde i sekunder ------- //
const int Længde = 3 // i sekunder

Som standard er værdien indstillet til 3 sekunder. Når den indstillede tid er ankommet, relæ tændes i 3 sekunder og slukkes. Skift dette, hvis du har brug for det.

4. Upload den ændrede kode til Arduino.
5. For at deaktivere klokken skal du trykke på 'bell disable button'. For at genaktivere skal du trykke på “Exit” -knappen.
6. For at ringe klokken manuelt skal du trykke på “manuel klokkekontakt” og stoppe klokken ved at trykke på “exit”.

Det afslutter projektet, hvis du har spørgsmål vedrørende dette projekt, er du velkommen til at udtrykke det i kommentarsektionen.




Forrige: Byg denne myggestang uden batteri Næste: Sådan oprettes et RFID-baseret tilstedeværelsessystem