Sistem Arduino Automatic School / College Bell

În acest post vom construi un sistem automat de clopote școlare / clopote universitare folosind Arduino, afișaj 16 x 2 și modul de ceas în timp real. Puteți programa acest proiect pentru a suna de 16 ori pe zi la ora și minutul preferat. Lungimea soneriei poate fi programată în câteva secunde.

Căutați o versiune mai simplă fără codificare? Ia-l AICI

Prezentare generală

S-au dus vremurile, când un buion dintr-o școală a sunat la clopot „tin tin tin” și elevii au fugit cu ușurință de la intrarea școlii. Unii s-ar putea să devină și mai fericiți când bionul a sunat cu ultimul clopot cu câteva minute mai devreme.

Acesta a fost scenariul în urmă cu 15-20 de ani, dar acum toate școlile și colegiile sunt strict legate de timp, iar clopotele sunt automatizate.

Autorul rapid al copilăriei / adolescenței amintește:

În timpul școlii primare și secundare, ceasul digital pe care l-am purtat a fost sincronizat cu sistemul de clopote al școlii cu o precizie de 1 secundă.

Aș striga „clopotul va suna în 5 secunde” după ce a sunat clopotul, toți elevii se uită la mine surprinși, acest lucru se întâmplă aproape în fiecare zi. Într-o zi, eu și prietenii mei apropiați începem să numărăm 10, 9, 8, 7 ... înainte de ultimul clopot.

Toți prietenii mei spun că este un ceas de mână magic, dar nu și-au dat seama de faptul că clopotul școlii a fost automatizat. LAUGH OUT LOUD!!

Vom face un astfel de clopot de școală / colegiu folosind Arduino.

Afișare la conexiunea Arduino

Afișajul la conexiunile Arduino este ușor diferit de ceea ce le conectăm de obicei, pinii 9, 8, 7, 6, 5 și 4 utilizați aici. PIN-urile 2 și 3 sunt utilizate ca întrerupere hardware prin apasa butoanele .

Folosiți 10K potențiometru pentru ajustarea contrastului pentru afişa .

Informații detaliate cu privire la conexiunile clopotului și releului:

ACTUALIZARE: A5 la SCL și A4 la SDA (Nu A4 la SCK)

Modul ceas în timp real

Ceas în timp real modulul ține evidența timpului chiar și după o întrerupere îndelungată. Un releu de 9V este prevăzut pentru pornirea și oprirea clopotului.

Vă rugăm să conectați o diodă 1N4007 în polarizare inversă a releului (ceea ce nu este prezentat în schemă), care va absorbi EMF de înaltă tensiune nocivă din releu.

Alimentați circuitul folosind un Adaptor de perete de 9V / 500mA .

Sunt furnizate trei butoane pentru acționarea manuală a clopotului în anumite situații. Apăsarea butonului „ieșire” va opri soneria după ce a sunat manual.

„Butonul de dezactivare a soneriei” va dezactiva soneria pentru totdeauna. Pentru a reactiva soneria, apăsați butonul „Exit”.

Cum setați ora la modulul RTC:

Descărcați biblioteca RTC:
Link: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Descărcare timeLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Încărcați programul

Încărcați programul de mai jos, care va seta ora la 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
}
//----------------------------------------------------//

După încărcarea codului, deschideți monitorul serial, va spune că ora este setată.
Odată ce pasul de mai sus este realizat, treceți la următorul.
Acum încărcați codul de mai jos pe Arduino.

Codul programului principal:

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

După încărcarea codului de mai sus, ar trebui să vedeți ora în ore pe afișaj.

Aceasta încheie codul programului.

Cum se folosește acest sistem automat de sonerie:

Faceți acest lucru cu configurarea hardware finalizată.

1. Încărcați mai întâi codul „setare oră” și deschideți monitorul serial.
2. În programul principal setați ora la care trebuie declanșat releul aici.

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

• Setați h1 în ore de la 1 la 23 de ore și m1 în minute de la 0 la 59.
• La fel pentru h1 la h16 și m1 la m16.
• Dacă doriți să dezactivați câteva clopote, lăsați valoarea h = 0 și m = 0, de exemplu: h5 = 0 și m5 = 0, zero va dezactiva clopotul respectiv.

3. Setați lungimea timpului de pornire și oprire a clopotului, aici:

// --------------- lungimea sunetului soneriei în secunde ------- //
const int Lungime = 3 // în secunde

În mod implicit, valoarea este setată pentru 3 secunde. Când sosește ora stabilită releu va fi pornit timp de 3 secunde și oprit. Schimbați acest lucru dacă aveți nevoie.

4. Încărcați codul modificat în Arduino.
5. Pentru a dezactiva soneria, apăsați „butonul de dezactivare a soneriei”. Pentru a reactiva apăsați butonul „Exit”.
6. Pentru a suna soneria manual, apăsați „comutatorul manual al soneriei” și pentru a opri soneria apăsați „exit”.

Aceasta încheie proiectul, dacă aveți întrebări cu privire la acest proiect, nu ezitați să exprimați în secțiunea de comentarii.