Arduino Automatic School / College Bell System

W tym poście zamierzamy zbudować automatyczny system dzwonka szkolnego / dzwonka uniwersyteckiego przy użyciu Arduino, wyświetlacza 16 x 2 i modułu zegara czasu rzeczywistego. Możesz zaprogramować ten projekt tak, aby dzwonił do 16 razy dziennie o preferowanej godzinie i minucie. Długość dzwonka można zaprogramować w sekundach.

Szukasz prostszej wersji bez kodowania? Zdobyć TUTAJ

Przegląd

Dawno minęły czasy, kiedy peon w szkole zadzwonił dzwonkiem „blaszana puszka” i uczniowie śpiewająco wybiegli z wejścia do szkoły. Niektórzy mogą być jeszcze szczęśliwsi, gdy peon zadzwonił ostatnim dzwonkiem kilka minut wcześniej.

Tak było od 15 do 20 lat temu, ale teraz wszystkie szkoły i uczelnie są ściśle ograniczone czasowo, a dzwony są zautomatyzowane.

Szybkie dzieciństwo / nastolatka autora pamiętaj:

W szkole podstawowej i średniej zegarek cyfrowy, który nosiłem, był synchronizowany ze szkolnym systemem dzwonków z dokładnością do 1 sekundy.

Wrzeszczałem „dzwonek zadzwoni za 5 sekund” po tym, jak zadzwonił dzwonek, wszyscy uczniowie patrzą na mnie ze zdziwieniem, zdarza się to prawie codziennie. Pewnego dnia ja i moi bliscy przyjaciele zaczynamy odliczać 10, 9, 8, 7… ..przed ostatnim dzwonkiem.

Wszyscy moi przyjaciele mówią, że to magiczny zegarek na rękę, ale nie zdawali sobie sprawy z jednego prostego faktu, że dzwonek szkolny był zautomatyzowany. LOL!!

Zamierzamy wykonać jeden taki dzwonek szkolny / uniwersytecki za pomocą Arduino.

Połączenie wyświetlacza z Arduino

Wyświetlacz do połączeń Arduino różni się nieco od tego, z czym zwykle je podłączamy, używanymi tutaj pinami 9, 8, 7, 6, 5 i 4. Piny numer 2 i 3 są używane jako przerwanie sprzętowe za pośrednictwem wciskać przyciski .

Użyj 10K potencjometr do regulacji kontrastu dla pokaz .

Szczegółowe informacje dotyczące połączeń dzwonka i przekaźnika:

AKTUALIZACJA: A5 do SCL i A4 do SDA (nie A4 do SCK)

Moduł zegara czasu rzeczywistego

Plik Zegar czasu rzeczywistego Moduł śledzi czas nawet po długiej przerwie w zasilaniu. Przekaźnik 9 V służy do włączania i wyłączania dzwonka.

Proszę podłączyć diodę 1N4007 w odwrotnym polaryzacji do przekaźnika (co nie jest pokazane na schemacie), która będzie absorbować szkodliwe wysokie napięcie z powrotem EMF z przekaźnika.

Zasil obwód za pomocą Adapter ścienny 9V / 500mA .

Trzy przyciski służą do ręcznej obsługi dzwonka w niektórych sytuacjach. Naciśnięcie przycisku „exit” spowoduje zatrzymanie dzwonka po ręcznym zadzwonieniu.

„Przycisk wyłączania dzwonka” wyłącza dzwonek na zawsze. Aby ponownie włączyć dzwonek, naciśnij przycisk „Wyjście”.

Jak ustawić czas do modułu RTC:

Pobierz bibliotekę RTC:
Link: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Czas pobieraniaLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Prześlij program

Prześlij poniższy program, który ustawi czas na 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
}
//----------------------------------------------------//

Po wgraniu kodu otwórz monitor szeregowy, powie, że czas jest ustawiony.
Po pomyślnym wykonaniu powyższego kroku przejdź do następnego.
Teraz prześlij poniższy kod do Arduino.

Główny kod programu:

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

Po wgraniu powyższego kodu na wyświetlaczu powinna pojawić się godzina w godzinach.

Na tym kończy się kod programu.

Jak korzystać z tego automatycznego systemu dzwonka:

Zrób to po zakończeniu konfiguracji sprzętu.

1. Prześlij najpierw kod „ustawienia czasu” i otwórz monitor szeregowy.
2. W programie głównym ustaw tutaj czas, w którym przekaźnik ma zostać wyzwolony.

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

• Ustaw h1 w godzinach od 1 do 23 godzin i m1 w minutach od 0 do 59.
• To samo dotyczy h1 do h16 i m1 do m16.
• Jeśli chcesz wyłączyć jakąś wartość opuszczania dzwonka h = 0 im = 0, na przykład: h5 = 0 i m5 = 0, zero wyłączy ten konkretny dzwonek.

3. Ustaw czas, przez jaki dzwonek ma być włączany i wyłączany, tutaj:

// --------------- długość dzwonka w sekundach ------- //
const int Lenght = 3 // w sekundach

Domyślnie wartość jest ustawiona na 3 sekundy. Gdy nadejdzie ustalony czas przekaźnik zostanie włączony na 3 sekundy i wyłączy się. Zmień to, jeśli potrzebujesz.

4. Prześlij zmodyfikowany kod do Arduino.
5. Aby wyłączyć dzwonek, naciśnij „przycisk wyłączania dzwonka”. Aby ponownie włączyć, naciśnij przycisk „Exit”.
6. Aby ręcznie zadzwonić do dzwonka, naciśnij „ręczny przełącznik dzwonka”, a aby zatrzymać dzwonek, naciśnij „wyjście”.

Na tym kończy się projekt, jeśli masz jakiekolwiek pytania dotyczące tego projektu, możesz je wyrazić w sekcji komentarzy.