Sistema Arduino Automatic School / College Bell

Sistema Arduino Automatic School / College Bell

En aquest post anem a construir un sistema automàtic de campanes escolars / campanes universitàries mitjançant Arduino, pantalla de 16 x 2 i mòdul de rellotge en temps real. Podeu programar aquest projecte per tocar fins a 16 vegades al dia a la vostra hora i minut preferits. La longitud del timbre es pot programar en segons.



Cerqueu una versió més senzilla sense codificar? Aconsegueix-ho AQUÍ

Visió general

S’han acabat els temps en què un peó d’una escola tocava la campana “tin tin tin” i els estudiants van sortir corrents de l’entrada de l’escola. Alguns poden ser encara més feliços quan el peó va tocar el darrer timbre uns minuts abans.





Aquest era l’escenari de fa 15 a 20 anys, però ara totes les escoles i col·legis estan estrictament lligats al temps i les campanes estan automatitzades.

La caputxa ràpida de la infància / adolescència de l'autor recorda:



Durant la meva escola primària i secundària, el rellotge digital que portava es sincronitzava amb el sistema de campanes de l’escola amb precisió d’1 segon.

Cridaria: 'la campana sonarà en 5 segons' després que sonés la campana, tots els estudiants em miraven amb sorpresa, això passa gairebé tots els dies. Un dia, jo i els meus amics íntims comencem el compte enrere 10, 9, 8, 7 ... abans de l’última campana.

Tots els meus amics diuen que és un rellotge màgic, però no es van adonar del simple fet que la campana de l’escola estava automatitzada. LOL!!

Farem una campana d’aquestes escoles / universitats amb Arduino.

Connexió de pantalla a Arduino

Les connexions de pantalla a Arduino són lleugerament diferents del que normalment les fem, els pins 9, 8, 7, 6, 5 i 4 que s’utilitzen aquí. Els pins número 2 i 3 s’utilitzen com a interrupció de maquinari mitjançant polsadors .

Utilitzeu el 10K potenciòmetre per ajustar el contrast per a visualització .

LCD de campana escolar Arduino

Sistema automàtic de campanes escolars / universitàries que utilitza Arduino

Informació detallada sobre les connexions de campana i relé:

circuit de temporitzadors de campanes escolars amb Arduino

ACTUALITZACIÓ: A5 a SCL i A4 a SDA (no A4 a SCK)

Mòdul de rellotge en temps real

El Rellotge en temps real El mòdul manté el seguiment del temps fins i tot després d'un llarg tall de corrent. Es proporciona un relé de 9V per encendre i apagar la campana.

Si us plau, connecteu un díode 1N4007 en polarització inversa a través del relé (que no es mostra a l’esquema) que absorbeixi el CEM de tornatge d’alta tensió perjudicial.

Alimentar el circuit mitjançant un Adaptador de paret de 9V / 500mA .

Es proporcionen tres polsadors un per accionar manualment la campana durant alguna situació. En prémer el botó 'sortir' s'aturarà la campana després de tocar la campana manualment.

El 'botó de desactivació de la campana' desactivarà la campana per sempre. Per tornar a activar la campana, premeu el botó 'Surt'.

Com es configura l'hora al mòdul RTC:

Descarregueu la biblioteca RTC:
Enllaç: github.com/PaulStoffregen/DS1307RTC

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

Pengeu el programa

Carregueu el programa que apareix a continuació, que configurarà l'hora a 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
}
//----------------------------------------------------//

Després de penjar el codi, obriu el monitor sèrie, dirà que l'hora està establerta.
Un cop realitzat el pas anterior, passeu al següent.
Ara pengeu el codi següent a Arduino.

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

Després de penjar el codi anterior, heu de veure el temps en hores a la pantalla.

D’aquesta manera es conclou el codi del programa.

Com s'utilitza aquest sistema de campanes automàtiques:

Feu això amb la configuració de maquinari completa.

1. Carregueu primer el codi de 'configuració de l'hora' i obriu el monitor sèrie.
2. Al programa principal, establiu aquí el moment en què cal activar el relé.

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

• Estableix h1 en hores d’1 a 23 hores i m1 en minuts de 0 a 59.
• El mateix per a h1 a h16 i m1 a m16.
• Si voleu desactivar una campana, deixeu el valor h = 0 i m = 0 per exemple: h5 = 0 i m5 = 0, zero desactivarà la campana en particular.

3. Establiu aquí la durada del període d’activació i desactivació de la campana:

// --------------- Durada del timbre en segons ------- //
const int Llarg = 3 // en segons

Per defecte, el valor s'estableix durant 3 segons. Quan s'arriba l'hora establerta, relleu s'encén durant 3 segons i s'apaga. Canvieu-ho si ho necessiteu.

4. Pengeu el codi modificat a Arduino.
5. Per desactivar la campana, premeu el botó de desactivació de la campana. Per tornar a activar-lo, premeu el botó 'Surt'.
6. Per tocar la campana manualment, premeu el 'interruptor manual de campana' i, per aturar la campana, premeu 'sortir'.

Això conclou el projecte, si teniu cap pregunta sobre aquest projecte, no dubteu a expressar-ho a la secció de comentaris.




Anterior: Construeix aquest ratpenat de mosquit sense bateria Següent: Com fer un sistema d’assistència basat en RFID