Système automatique de cloche d'école / collège Arduino

Dans cet article, nous allons construire un système de cloche automatique d'école / collège utilisant Arduino, un écran 16 x 2 et un module d'horloge en temps réel. Vous pouvez programmer ce projet pour sonner la cloche jusqu'à 16 fois par jour à l'heure et à la minute de votre choix. La longueur de la sonnerie peut être programmée en secondes.

Vous recherchez une version plus simple sans codage? Tu piges ICI

Aperçu

Il est révolu le temps, où une personne dans une école a sonné la cloche «boîte de conserve» et les élèves ont couru hors de l'entrée de l'école avec brio. Certains peuvent être encore plus heureux lorsque le péon a sonné la dernière cloche quelques minutes plus tôt.

C'était le scénario il y a 15 à 20 ans, mais maintenant toutes les écoles et collèges sont strictement limités dans le temps et les cloches sont automatisées.

La petite enfance / l'adolescence rapide de l'auteur se souvient:

Pendant mon école primaire et secondaire, la montre numérique que je portais était synchronisée avec le système de sonnerie de l’école avec une précision d’une seconde.

Je criais «la cloche va sonner dans 5 secondes» après que la cloche a sonné tous les élèves me regardent avec surprise, cela arrive presque tous les jours. Un jour, mes amis proches et moi commençons à compter 10, 9, 8, 7… avant la dernière cloche.

Tous mes amis disent que c’est une montre-bracelet magique, mais ils n’ont pas réalisé un simple fait que la cloche de l’école était automatisée. MDR!!

Nous allons fabriquer une telle cloche d'école / collège en utilisant Arduino.

Affichage à la connexion Arduino

L'affichage aux connexions Arduino est légèrement différent de ce que nous les câblons habituellement, les broches 9, 8, 7, 6, 5 et 4 utilisées ici. Les broches 2 et 3 sont utilisées comme interruption matérielle via boutons poussoir .

Utilisez le 10K potentiomètre pour régler le contraste du affichage .

Informations détaillées sur les connexions de sonnerie et de relais:

MISE À JOUR: A5 vers SCL et A4 vers SDA (pas A4 vers SCK)

Module d'horloge en temps réel

Le Horloge temps réel Le module garde la trace de l'heure même après une longue coupure de courant. Un relais 9V est fourni pour allumer et éteindre la sonnerie.

Veuillez connecter une diode 1N4007 en polarisation inverse à travers le relais (ce qui n'est pas montré dans le schéma) qui absorbera les EMF haute tension nocifs du relais.

Alimentez le circuit à l'aide d'un Adaptateur mural 9V / 500mA .

Trois boutons poussoirs sont fournis, un pour actionner manuellement la cloche dans certaines situations. Appuyer sur le bouton «exit» arrêtera la cloche après avoir fait sonner la cloche manuellement.

Le «bouton de désactivation de la cloche» désactivera la cloche pour toujours. Pour réactiver la sonnerie, appuyez sur le bouton «Quitter».

Comment régler l'heure sur le module RTC:

Téléchargez la bibliothèque RTC:
Lien: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Téléchargez timeLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Télécharger le programme

Téléchargez le programme ci-dessous qui définira l'heure sur 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
}
//----------------------------------------------------//

Après avoir téléchargé le code, ouvrez le moniteur série, il dira que l'heure est réglée.
Une fois l'étape ci-dessus accomplie, passez à l'étape suivante.
Téléchargez maintenant le code ci-dessous sur Arduino.

Code du programme 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------------//

Après avoir téléchargé le code ci-dessus, vous devriez voir l'heure en heures sur l'écran.

Cela conclut le code du programme.

Comment utiliser ce système de sonnerie automatique:

Faites-le avec la configuration matérielle terminée.

1. Téléchargez d'abord le code de «réglage de l'heure» et ouvrez le moniteur série.
2. Dans le programme principal, définissez ici l'heure à laquelle le relais doit être déclenché.

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

• Réglez h1 en heures de 1 à 23 heures et m1 en minutes de 0 à 59.
• Idem pour h1 à h16 et m1 à m16.
• Si vous souhaitez désactiver une valeur de congé de sonnerie h = 0 et m = 0 par exemple: h5 = 0 et m5 = 0, zéro désactivera cette cloche particulière.

3. Définissez ici la durée d'activation et de désactivation de la sonnerie:

// --------------- longueur de sonnerie en secondes ------- //
const int Lenght = 3 // en secondes

Par défaut, la valeur est définie sur 3 secondes. Lorsque l'heure réglée est arrivée, le relais s'allume pendant 3 secondes et s'éteint. Changez cela si vous en avez besoin.

4. Téléchargez le code modifié sur Arduino.
5. Pour désactiver la sonnerie, appuyez sur «bouton de désactivation de la sonnerie». Pour réactiver, appuyez sur le bouton «Quitter».
6. Pour faire sonner la cloche manuellement, appuyez sur le «commutateur de sonnerie manuelle» et pour arrêter la cloche, appuyez sur «exit».

Cela conclut le projet, si vous avez des questions concernant ce projet, n'hésitez pas à les exprimer dans la section commentaires.