„Arduino“ automatinė mokyklos / kolegijos varpų sistema

Šiame įraše mes sukursime automatinę mokyklos varpų / kolegijų varpų sistemą, naudodami „Arduino“, 16 x 2 ekraną ir realaus laiko laikrodžio modulį. Galite užprogramuoti šį projektą skambinti iki 16 kartų per dieną jūsų norima valanda ir minute. Varpo skambučio ilgį galima užprogramuoti sekundėmis.

Ieškote paprastesnės versijos be kodavimo? Paimk ČIA

Apžvalga

Seniai praėjo tie laikai, kai bijūnas mokykloje paskambindavo varpeliu „alavo skardos skarda“, o mokiniai iš mokyklos įėjimo išbėgo skraidančiomis spalvomis. Kai kurie gali tapti dar laimingesni, kai bijūnas paskambino paskutiniuoju varpu keliomis minutėmis anksčiau.

Tai buvo scenarijus prieš 15–20 metų, tačiau dabar visos mokyklos ir kolegijos griežtai laikosi laiko, o varpai yra automatizuoti.

Greitas autoriaus vaikystės / paauglių gobtuvas prisimena:

Pradinės ir vidurinės mokyklos laikais skaitmeninis laikrodis, kurį dėvėjau, 1 sekundės tikslumu buvo suderintas su mokyklos varpų sistema.

Aš šaukčiau: „varpas skambės per 5 sekundes“, po to, kai skambėjo visi studentai, nustebę spokso į mane, tai vyksta beveik kiekvieną dieną. Vieną dieną aš ir mano artimi draugai pradedame skaičiuoti 10, 9, 8, 7 ... prieš paskutinį skambutį.

Visi mano draugai sako, kad tai stebuklingas rankinis laikrodis, tačiau jie nesuvokė vieno paprasto fakto, kad mokyklos varpas buvo automatizuotas. DAUG JUOKO!!

Mes ketiname pagaminti vieną tokį mokyklos / kolegijos varpą naudodami „Arduino“.

Ekranas prie „Arduino“ ryšio

„Arduino“ jungčių ekranas šiek tiek skiriasi nuo to, kurį mes juos paprastai laiduojame, čia naudojami kaiščiai 9, 8, 7, 6, 5 ir 4. Kaiščių skaičius 2 ir 3 naudojami kaip aparatūros pertraukimas per mygtukai .

Naudokite 10K potenciometras pritaikyti kontrastą ekranas .

Išsami informacija apie skambučių ir relių jungtis:

ATNAUJINIMAS: A5 - SCL ir A4 - SDA (Ne A4 - SCK)

Realaus laiko laikrodžio modulis

The Realaus laiko laikrodis modulis stebi laiką net po ilgo elektros energijos tiekimo nutraukimo. 9V relė yra skirta varpui įjungti ir išjungti.

Prijunkite 1N4007 diodą atvirkštiniu būdu per relę (kuri nerodoma schemoje), kuris sugers žalingą aukštos įtampos atgalinį EMF iš relės.

Maitinkite grandinę naudodami a 9V / 500mA sieninis adapteris .

Trys mygtukai yra skirti rankiniam varpo valdymui tam tikroje situacijoje. Paspaudus mygtuką „Išeiti“, varpas bus sustabdytas, nuskambėjus rankiniu būdu.

„Varpo išjungimo mygtukas“ išjungs varpą visam laikui. Norėdami vėl įjungti varpą, paspauskite mygtuką „Išeiti“.

Kaip nustatyti laiką iki RTC modulio:

Atsisiųskite RTC biblioteką:
Nuoroda: github.com/PaulStoffregen/DS1307RTC

-------------------------------------------------- ---------------
Atsisiųsti timeLib.h:
github.com/PaulStoffregen/Time
-------------------------------------------------- ----------------

Įkelkite programą

Įkelkite žemiau esančią programą, kurioje bus nustatytas laikas iki 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
}
//----------------------------------------------------//

Įkėlę kodą atidarykite nuoseklųjį monitorių, jis pasakys, kad laikas nustatytas.
Kai aukščiau nurodytas žingsnis bus atliktas, pereikite prie kito.
Dabar įkelkite žemiau esantį kodą į „Arduino“.

Pagrindinis programos kodas:

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

Įkėlę aukščiau nurodytą kodą, ekrane turėtumėte pamatyti laiką valandomis.

Tai užbaigia programos kodą.

Kaip naudotis šia automatine varpų sistema:

Tai atlikite atlikę aparatūros sąranką.

1. Pirmiausia įkelkite „laiko nustatymo“ kodą ir atidarykite nuoseklųjį monitorių.
2. Pagrindinėje programoje nustatykite laiką, kada reikia suaktyvinti 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

• Nustatykite h1 valandomis nuo 1 iki 23 valandų ir m1 per kelias minutes nuo 0 iki 59.
• Tas pats ir nuo h1 iki h16, ir nuo m1 iki m16.
• Jei norite išjungti kai kurias varpelio reikšmes h = 0 ir m = 0, pavyzdžiui: h5 = 0 ir m5 = 0, nulis išjungs tą konkretų varpą.

3. Čia nustatykite varpo įjungimo ir išjungimo trukmę:

// --------------- varpo skambėjimo ilgis sekundėmis ------- //
const int Ilgis = 3 // per sekundes

Pagal numatytuosius nustatymus vertė nustatoma 3 sekundėms. Atėjus nustatytam laikui, estafetė bus įjungtas 3 sekundėms ir išsijungs. Pakeiskite, jei jums reikia.

4. Įkelkite pakeistą kodą į „Arduino“.
5. Norėdami išjungti varpą, paspauskite „varpo išjungimo mygtuką“. Norėdami vėl įjungti, paspauskite mygtuką „Išeiti“.
6. Norėdami skambinti varpeliu rankiniu būdu, paspauskite „rankinį varpo jungiklį“ ir, norėdami sustabdyti varpą, paspauskite „išeiti“.

Tuo projektas baigtas, jei turite kokių nors klausimų dėl šio projekto, nedvejodami išsakykite komentarų skyriuje.