Sistema Arduino Automatic School / College Bell

Neste artigo, vamos construir um sistema automático de campainhas escolares / universitárias usando Arduino, display 16 x 2 e módulo de relógio em tempo real. Você pode programar este projeto para tocar a campainha até 16 vezes por dia na hora e minuto de sua preferência. A duração do toque da campainha pode ser programada em segundos.

Procurando uma versão mais simples sem codificação? Pegue AQUI

Visão geral

Já se foi o tempo em que um peão em uma escola tocava a campainha “lata de lata” e os alunos corriam para fora da entrada da escola com louvor. Alguns podem ficar ainda mais felizes quando o peão tocou a última campainha alguns minutos antes.

Esse era o cenário de 15 a 20 anos atrás, mas agora todas as escolas e faculdades têm um prazo estrito e os sinos são automatizados.

A infância / adolescência rápida do autor, lembre-se:

Durante minha escola primária e secundária, o relógio digital que usei foi sincronizado com o sistema de campainha da escola com precisão de 1 segundo.

Eu gritava “o sino vai tocar em 5 segundos” depois que o sino tocou todos os alunos me olham com surpresa, isso acontece quase todos os dias. Em algum dia, eu e meus amigos próximos começamos a contagem regressiva 10, 9, 8, 7 ... antes do último sino.

Todos os meus amigos dizem que é um relógio de pulso mágico, mas eles não perceberam o simples fato de que o sino da escola era automatizado. LOL!!

Vamos fazer um sino de escola / faculdade usando o Arduino.

Exibir para conexão do Arduino

As conexões do display com o Arduino são ligeiramente diferentes do que costumamos fazer, os pinos 9, 8, 7, 6, 5 e 4 usados ​​aqui. Os pinos 2 e 3 são usados ​​como interrupção de hardware via Apertar botões .

Use os 10K potenciômetro para ajustar o contraste para o exibição .

Informações detalhadas sobre conexões de campainha e relé:

ATUALIZAÇÃO: A5 para SCL e A4 para SDA (não A4 para SCK)

Módulo de relógio em tempo real

O Relógio de tempo real módulo mantém o controle do tempo mesmo após um longo corte de energia. Um relé de 9 V é fornecido para ligar e desligar a campainha.

Por favor, conecte um diodo 1N4007 em polarização reversa através do relé (que não é mostrado no esquema), que absorverá o EMF de alta tensão prejudicial do relé.

Ligue o circuito usando um Adaptador de parede 9V / 500mA .

São fornecidos três botões, um para operar manualmente a campainha durante algumas situações. Pressionar o botão “sair” irá parar a campainha após tocá-la manualmente.

O “botão para desativar campainha” desativará a campainha para sempre. Para reativar a campainha, pressione o botão “Sair”.

Como definir a hora para o módulo RTC:

Baixe a biblioteca RTC:
Link: github.com/PaulStoffregen/DS1307RTC

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

Faça upload do programa

Faça upload do programa abaixo, que definirá a hora para 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
}
//----------------------------------------------------//

Após fazer o upload do código, abra o monitor serial, ele dirá que a hora está definida.
Depois que a etapa acima for concluída com êxito, passe para a próxima.
Agora carregue o código abaixo para o Arduino.

Código do programa 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------------//

Depois de enviar o código acima, você verá o tempo em horas no visor.

Isso conclui o código do programa.

Como usar este sistema de campainha automática:

Faça isso com a configuração de hardware concluída.

1. Carregue primeiro o código de “configuração de tempo” e abra o monitor serial.
2. No programa principal, defina a hora em que o relé precisa ser disparado aqui.

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

• Defina h1 em horas de 1 a 23 horas e m1 em minutos de 0 a 59.
• O mesmo para h1 a h16 e m1 a m16.
• Se você deseja desativar algum valor de licença de sino h = 0 e m = 0, por exemplo: h5 = 0 e m5 = 0, zero desativará aquele sino específico.

3. Defina o período de tempo para o sino ser ligado e desligado, aqui:

// --------------- comprimento do toque do sino em segundos ------- //
const int Lenght = 3 // em segundos

Por padrão, o valor é definido para 3 segundos. Quando chega a hora definida, retransmissão será ligado por 3 segundos e desliga. Altere isso se precisar.

4. Faça upload do código modificado para o Arduino.
5. Para desativar a campainha, pressione o “botão de desativação da campainha”. Para reativar, pressione o botão “Sair”.
6. Para tocar a campainha manualmente pressione o “interruptor manual da campainha” e para parar a campainha pressione “sair”.

Isso conclui o projeto, se você tiver alguma dúvida em relação a este projeto, sinta-se à vontade para expressar na seção de comentários.