Sistema automatico di campanello per scuola / college Arduino

In questo post costruiremo un sistema automatico di campanelli scolastici / universitari utilizzando Arduino, display 16 x 2 e modulo orologio in tempo reale. Puoi programmare questo progetto per suonare il campanello fino a 16 volte al giorno all'ora e al minuto che preferisci. La durata del suono del campanello può essere programmata in pochi secondi.

Cerchi una versione più semplice senza codifica? Prendilo QUI

Panoramica

Sono finiti i tempi, quando un peone in una scuola suonava il campanello 'latta latta latta' e gli studenti correvano fuori dall'ingresso della scuola a pieni voti. Alcuni potrebbero essere ancora più felici quando il peone ha suonato l'ultimo campanello pochi minuti prima.

Questo era lo scenario da 15 a 20 anni fa, ma ora tutte le scuole e le università sono strettamente vincolate nel tempo e le campane sono automatizzate.

La rapida infanzia / adolescenza dell'autore ricorda:

Durante la mia scuola primaria e secondaria, l'orologio digitale che indossavo era sincronizzato con il campanello della scuola con una precisione di 1 secondo.

Urlavo 'la campana suonerà tra 5 secondi' dopo che la campana ha suonato tutti gli studenti mi fissano con sorpresa, questo accade quasi ogni giorno. Un giorno io ei miei amici più stretti iniziamo il conto alla rovescia 10, 9, 8, 7 ... prima dell'ultima campana.

Tutti i miei amici dicono che è un orologio da polso magico, ma non si sono resi conto di un semplice fatto che la campana della scuola era automatizzata. LOL !!

Realizzeremo una di queste campane scolastiche / universitarie usando Arduino.

Connessione display ad Arduino

Le connessioni del display ad Arduino sono leggermente diverse da quelle che normalmente colleghiamo, i pin 9, 8, 7, 6, 5 e 4 usati qui. I pin numero 2 e 3 vengono utilizzati come interrupt di processo tramite premi i pulsanti .

Usa il 10K potenziometro per regolare il contrasto per Schermo .

Informazioni dettagliate sui collegamenti della sirena e del relè:

AGGIORNAMENTO: da A5 a SCL e da A4 a SDA (non da A4 a SCK)

Modulo orologio in tempo reale

Il Orologio in tempo reale il modulo tiene traccia del tempo anche dopo una lunga interruzione di corrente. È previsto un relè da 9V per l'accensione e lo spegnimento del campanello.

Collegare un diodo 1N4007 con polarizzazione inversa attraverso il relè (che non è mostrato nello schema) che assorbe il dannoso EMF ad alta tensione dal relè.

Alimentare il circuito utilizzando un Adattatore da parete 9V / 500mA .

Tre pulsanti sono forniti uno per azionare manualmente la campana in alcune situazioni. Premendo il pulsante 'esci' si arresta il campanello dopo aver suonato manualmente il campanello.

Il 'pulsante di disattivazione del campanello' disabiliterà il campanello per sempre. Per riattivare la suoneria premere il pulsante “Esci”.

Come impostare l'ora sul modulo RTC:

Scarica la libreria RTC:
Collegamento: github.com/PaulStoffregen/DS1307RTC

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

Carica il programma

Carica il programma sottostante che imposterà l'ora su 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
}
//----------------------------------------------------//

Dopo aver caricato il codice, apri il monitor seriale, dirà che l'ora è impostata.
Una volta completato con successo il passaggio precedente, passare a quello successivo.
Ora carica il codice seguente su Arduino.

Codice programma principale:

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

Dopo aver caricato il codice sopra, dovresti vedere l'ora in ore sul display.

Questo conclude il codice del programma.

Come utilizzare questo sistema di campanello automatico:

Fallo con l'installazione hardware completata.

1. Carica prima il codice “time setting” e apri il monitor seriale.
2. Nel programma principale impostare qui l'ora in cui il relè deve essere attivato.

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

• Impostare h1 in ore da 1 a 23 ore e m1 in minuti da 0 a 59.
• Lo stesso per h1-h16 e m1-m16.
• Se si desidera disabilitare un campanello, lasciare il valore h = 0 em = 0 ad esempio: h5 = 0 e m5 = 0, zero disabiliterà quel particolare campanello.

3. Impostare la durata del periodo di attivazione e disattivazione della campana, qui:

// --------------- durata del campanello in secondi ------- //
const int Lenght = 3 // in secondi

Per impostazione predefinita, il valore è impostato per 3 secondi. Quando l'ora impostata è arrivata il relè si accenderà per 3 secondi e si spegnerà. Cambia questo se necessario.

4. Carica il codice modificato su Arduino.
5. Per disabilitare la suoneria, premere il 'pulsante di disabilitazione campana'. Per riattivare premere il pulsante 'Esci'.
6. Per suonare il campanello manualmente premere il “pulsante campanello manuale” e per fermare il campanello premere “esci”.

Questo conclude il progetto, se hai domande su questo progetto sentiti libero di esprimere nella sezione commenti.