Conectarea ceasului în timp real ds1302 la Arduino. Ceas pe Arduino fără a utiliza un modul RTC

Ceas în timp real - un modul care stochează data curentași nu îl resetează când alimentarea este oprită datorită bateriei încorporate. Poate ați auzit despre ceasuri bazate pe cipul DS1307. Acest cip are o precizie extrem de scăzută a ceasului. O întârziere de o oră pe zi este prea mare. Recomand folosirea unui modul bazat pe un cip DS3231 de înaltă precizie, care este echipat cu un termometru pentru a regla frecvența ceasului în funcție de temperatură. Precizia ceasului acestui cip este la un nivel bun ceas de mânăși este de 2 ppm la temperatură mediu inconjurator 0°-40°. În același timp, modulul este compatibil cu toate bibliotecile scrise pentru modul bazat pe cipul DS1307. Articolul vorbește despre conectarea modulului la Arduino și interacțiunea cu ele folosind biblioteca Time. Puteți cumpăra un astfel de modul de la un vânzător pe care l-am verificat.

Conexiune ceas în timp real

Ceasul este conectat folosind protocolul I2C cu doar două fire. Este necesar să strângeți suplimentar bornele la care ceasul este conectat la șina de alimentare folosind rezistențe de 2 KΩ. Ieșirile ceasului arată astfel:

Pinii 32K și SQW pot fi ignorați. Scopul lor nu este discutat în acest articol. SCL și SDA sunt pinii interfeței I2C. Acestea trebuie conectate la controler. VCC și GND sunt +5V și, respectiv, masă.

SCL și SDA activate diferite placi situate pe diferiți pini:

Uno, Nano A4 (SDA), A5 (SCL)
Mega2560 20 (SDA), 21 (SCL)
Leonardo 2 (SDA), 3 (SCL)

Pinul SDA al ceasului este conectat la pinul SDA al controlerului. Ceasul SDL, respectiv, la controlerul SDL. După conectarea firelor, ar trebui să obțineți următoarea imagine:

Cel mai convenabil mod de a lucra cu modulul de ceas în timp real este utilizarea bibliotecii. Cel mai convenabil în acest sens se numește: Timp ( Engleză timp).
Biblioteca este un „înveliș” pentru o altă bibliotecă populară pentru lucrul cu modulul de ceas: DS1307RTC. În ciuda faptului că biblioteca a fost dezvoltată pentru cipul DS1307, funcționează perfect cu DS3231, deoarece protocoalele de comunicare sunt compatibile.

Descărcați ambele biblioteci.

După descărcare, plasați conținutul arhivelor în folderul biblioteci, care se află în folderul de mediu Dezvoltare Arduino. Alerga Mediul Arduino IDE și deschis exemplu standard biblioteci: Exemple->Timp->TimeRTC
Sau doar copiați acest cod:

#include #include #include void setup() ( Serial.begin(9600); while (!Serial) ; // așteptați până când Arduino Serial Monitor deschide setSyncProvider(RTC.get); // funcția pentru a obține ora de la RTC if(timeStatus()! = timeSet) Serial.println("Nu se poate sincroniza cu RTC"); else Serial.println("RTC a setat ora sistemului"); ) void loop() ( if (timeStatus() == timeSet) ( digitalClockDisplay( ); ) else ( Serial.println("Ora nu a fost setată. Vă rugăm să rulați Ora"); Serial.println("Exemplu TimeRTCSet sau exemplu DS1307RTC SetTime."); Serial.println(); delay(4000) ; ) delay(1000); ) void digitalClockDisplay())( // Afișarea ceasului digital al orei Serial.print(hour()); printDigits(minute()); printDigits(second()); Serial.print(" " ); Serial.print(day()); Serial.print(" "); Serial.print(luna()); Serial.print(" "); Serial.print(an()); Serial.println( ) ; ) void printDigits(int digits)( // funcția de utilitate pentru afișarea ceasului digital: afișează două puncte înainte și 0 Serial.print(":"); if(cifre)< 10) Serial.print("0"); Serial.print(digits); }

#include

#include

#include

void setup() (

Serial. începe(9600);

în timp ce (! Serial ) ; // așteptați până când se deschide Arduino Serial Monitor

setSyncProvider(RTC.get); // funcția pentru a obține ora de la RTC

if (timeStatus() != timeSet)

Serial. println("Nu se poate sincroniza cu RTC");

altfel

Serial. println("RTC a setat ora sistemului");

buclă goală ()

dacă (timeStatus() == timeSet) (

digitalClockDisplay();

) altfel (

Serial. println( „Ora nu a fost setată. Vă rugăm să rulați Ora”) ;

Serial. println( „Exemplu TimeRTCSet sau exemplu DS1307RTC SetTime.”) ;

Serial. println();

întârziere (4000);

întârziere (1000);

void digitalClockDisplay() (

// Afișarea ceasului digital al orei

Serial. print(ora());

printDigits(minut());

printDigits(second());

Serial. imprimare (" " ) ;

Serial. print(ziua());

Serial. imprimare (" " ) ;

Serial. print(luna());

Serial. imprimare (" " ) ;

Serial. print(an());

Serial. println();

void printDigits(int digits) (

// funcția de utilitate pentru afișarea ceasului digital: afișează două puncte înainte și 0 înainte

Serial. imprimare(":");

dacă (cifre< 10 )

Serial. print("0");

Serial. print(cifre);

După ce ați încărcat schița pe placă, lansați monitorul portului (Tools->port monitor). Veți vedea mesaje din bibliotecă. Ora afișată va fi incorectă sau biblioteca se va plânge că ceasul nu este configurat. Pentru a seta ceasul, încărcați un exemplu din biblioteca „SetTime” DS1307RTC pe placă (Exemple->DS1307RTC->SetTime). Încărcați acest exemplu în tabloul dvs. După descărcare, ceasul va fi setat la timpul de compilare a schițelor. Întârziere între compilare și complet încărcat va fi destul de puțin, ceea ce va fi suficient pentru un ceas fin reglat. Dar dacă deconectați și reconectați alimentarea plăcii, chiar și după câteva ore, ora ceasului va fi totuși resetată la momentul compilării și va fi incorectă. Prin urmare, utilizați acest exemplu numai pentru configurare, după configurare, opriți ceasul sau încărcați o altă schiță pe tablă.

Trebuia să fac ceva mai mare cumva. Ceas de perete cu luminozitate automată.

Acest ceas este perfect pentru spații mari, de exemplu, un hol de birou sau un apartament mare.

Realizarea unui ceas de perete atât de mare nu este foarte dificilă folosind aceste instrucțiuni.


Pentru a estima dimensiunea ceasului, puteți presupune că un segment al ceasului va fi de dimensiunea hârtiei A4, ceea ce va facilita utilizarea ramelor foto de dimensiunea corespunzătoare.

Pasul 1. Componentele unui ceas de perete mare.

Fire, lipit, fier de lipit, bandă LED Arduino Nano Convertor DC-DC LM2596
4 metri bandă LED WS2811 senzor de lumina ceas în timp real DS3231
microîntrerupătoare

Ce am folosit pentru acest proiect:

Pasul 8. Programați ceasul.

După ce m-am jucat, am reușit să-mi iau un ceas care mi-a satisfăcut complet nevoile. Sunt sigur că te poți descurca mai bine decât mine.

Codul este bine comentat și nu vă va fi greu să îl înțelegeți; mesajele de depanare sunt și ele foarte bine comentate.

Dacă trebuie să schimbați culoarea ceasului de perete folosită, trebuie să schimbați variabila pe linia 22 ( int ledColor = 0x0000FF; // Culoarea folosită (în hex)). Puteți găsi o listă de culori și codurile lor hexadecimale pe pagina: https://github.com/FastLED/FastLED/wiki/Pixel-refe…

Dacă aveți probleme la descărcare, utilizați oglinda: http://bit.ly/1Qjtgg0

Schița mea finală poate fi descărcată.

Pasul 9. Faceți numere folosind polistiren.

Baza tăietorului Corpul de lucru al tăietorului Forma generală tăietor
Rezultatul tăietorului

Tăiați fiecare segment în șablonul imprimat la început.
Polistirenul poate fi tăiat cu un cuțit ascuțit, ceea ce este destul de dificil, sau cu un dispozitiv simplu din sârmă de nicrom sau coarde de chitară și mai multe bucăți de placă OSB.

Puteți vedea cum am făcut-o în imaginile de mai sus.

Pentru a alimenta tăietorul am folosit o sursă de alimentare de 12v.

Ca rezultat al tăierii, ar trebui să obțineți patru segmente pentru ceas mare, dintre care unul este prezentat în fotografie.

Pasul 10. Lipiți numerele și acoperiți totul cu un difuzor. Ultimul ceas de perete mare.

Străluciți în timpul zilei Străluciți noaptea

După ce ați tăiat toate cele patru numere și puncte ale ceasului de perete, lipiți-le pe toate împreună pe carton Benzi LED(Am folosit bandă cu două fețe pentru a ușura procesul)

Pentru a risipi greu lumina LED Am folosit două coli de hârtie deasupra numerelor de polistiren. Pentru comoditate și estetică, am folosit hârtie de dimensiune A2 împăturită în jumătate.

După ce am finalizat toți acești pași, am plasat ansamblul mare de ceas de perete rezultat într-o ramă foto mare potrivită.

Acest ceas sa dovedit a fi foarte impresionant și atrăgător. Cred că un ceas de perete atât de mare va decora perfect multe camere.

In contact cu

Unul dintre primele proiecte pe care începătorii le construiesc folosind o placă Arduino este ceas simplu, numărătoarea inversă. Practic, astfel de ceasuri se bazează pe un modul RTC (Real Time Clock) conectat la Arduino. Pe piață astăzi componente electronice disponibil diferite modele RTC-uri care variază ca precizie și preț. Modelele comune includ DS1302, DS1307, DS3231.



Dar puteți face un ceas pe Arduino fără a utiliza un RTC, mai ales dacă nu puteți obține astfel de module. Desigur, precizia este în acest caz, va fi mic, așa că proiectul ar trebui mai degrabă considerat ca un proiect de formare.


Principiul de funcționare al unor astfel de ceasuri este destul de simplu. De fiecare dată când porniți acest ceas Arduino, va trebui să îl setați la ora curentă, la fel ca oricare ceas analogic. Cu siguranță este mai bine să nu folosiți astfel de ceasuri la dvs Viata de zi cu zi dacă sunt active pentru o lungă perioadă de timp fără repornire și configurare ulterioară, de la desincronizare cu ora curentăîn timpul funcționării pe termen lung poate fi semnificativă.


Acest ceas poate fi asamblat folosind un obișnuit panou, deoarece nu necesită multe componente. Linkul nostru principal aici va fi taxa Arduino Uno. Pentru a afișa ora, puteți lua un afișaj LCD 16x2. Pentru a modifica setările de timp, trebuie să conectați două butoane (pentru ore și minute). Butoanele sunt conectate la Aduino prin rezistențe de 10KΩ. Pentru a schimba luminozitatea afișajului veți avea nevoie de un potențiometru de 10 kOhm. Schema de conectare a tuturor acestor componente la Placa Arduino Uno este prezentat mai jos.



Acum trebuie să programați Arduino. Un cod simplu (schiță) care vă permite să afișați ora pe ecranul LCD este prezentat mai jos.


#include LCD cristal lichid(12,11,5,4,3,2); int h=12; int m; int s; int steag; int TIME; const int hs=8; const int ms=9; int stare1; int stare2; void setup() ( lcd.begin(16,2); ) void loop() ( lcd.setCursor(0,0); s=s+1; lcd.print("TIME:"); lcd.print(h ); lcd.print(":"); lcd.print(m); lcd.print(":"); lcd.print(e); if(steagul<12)lcd.print("AM"); if(flag==12)lcd.print("PM"); if(flag>12)lcd.print("PM"); dacă(steagul==24)steagul=0; întârziere (1000); lcd.clear(); if(s==60)( s=0; m=m+1; ) if(m==60) (m=0; h=h+1; flag=flag+1; ) if(h==13 ) ( h=1; ) lcd.setCursor(0,1); lcd.print("O ZI FRUMOĂ"); //-------Timp // setare-------// state1=digitalRead(hs); dacă(stare1==1) (h=h+1; steag=steag+1; dacă(steagul<12)lcd.print("AM"); if(flag==12)lcd.print("PM"); if(flag>12)lcd.print("PM"); dacă(steagul==24)steagul=0; dacă(h==13)h=1; ) stare2=digitalRead(ms); dacă(starea2==1)( s=0; m=m+1; ) )

   Vă mulțumim pentru interesul acordat proiect de informare site-ul web.
   Dacă vrei interesant și materiale utile a apărut mai des și a fost mai puțină publicitate,
   Puteți susține proiectul nostru donând orice sumă pentru dezvoltarea lui.

Acest articol discută un exemplu de creare a unui ceas în timp real. Indicatorul va afișa ora exactă, iar colonul de pe acesta va clipi o dată pe secundă. Timpul exact va fi instalat automat în timpul compilării firmware-ului.

Descrierea componentelor

Ceas în timp real

Folosim modulul de ceas în timp real de la Seeed Studio. Se bazează pe cipul DS1307 de la Maxim Integrated. Dintre elementele de fixare, necesită trei rezistențe, un ceas cuarț și o baterie, care sunt deja disponibile pe acest modul. Modulul are următoarele proprietăți:

    Timpul de numărare (secunde, minute, ore), data (an, lună, zi), ziua săptămânii

    Interfață I²C cu două fire

Esența unui ceas în timp real este că, dacă există o baterie, aceasta poate funcționa chiar dacă dispozitivul principal este dezactivat. Întâlnim constant astfel de ceasuri în laptopuri sau camere digitale. Dacă scoateți bateria de pe aceste dispozitive și le puneți înapoi după un timp, ora nu se va reseta. Acest lucru se datorează ceasului în timp real, Real Time Clock (RTC).

Toate bibliotecile necesare pot fi descărcate de pe site-ul oficial.

Indicator

Folosim un indicator cu patru cifre de la Seeed Studio. Principalul lucru din indicator este cipul TM1637, care este un driver pentru biți individuali cu 7 segmente. Acest modul folosește 4 biți. Modulul are următoarele proprietăți:

    8 nivele de luminozitate

    Interfață de operare cu două fire (CLK, DIO)

Folosim acest modul pentru a afișa timpul: ore și minute. Comoditatea modulului este că este conectat prin doar două fire și nu necesită implementare software afișaj dinamic, deoarece totul este deja implementat în interiorul modulului.

Indicarea dinamică este un proces în care indicatorii din modulul nostru se aprind secvenţial. Dar nu vedem pâlpâire, deoarece ochiul uman are o mare inerție. Aceasta metoda vă permite să salvați foarte bine numărul de conexiuni dintre indicatoare și controler:

    Afișaj static: 4 cifre × 7 segmente = 28 conexiuni.

    Indicatie dinamica: 7 segmente + 4 anozi sau catozi comuni = 11 conexiuni.

    Chip TM1637: 2 conexiuni.

Beneficiul este evident.

Conexiune

Modulul ceasului în timp real trebuie conectat la pinii SCL/SDA aferenti magistralei I²C. De asemenea, este necesar să conectați liniile de alimentare (Vcc) și de masă (GND).

Liniile SDA/SCL au propriii pini separati pe Arduino, dar în interior sunt conectate cumva la pini scop general. Dacă ne uităm la Arduino Uno, linia SDA corespunde pinului A4, iar linia SCL corespunde A5.

Modulul vine cu un cablu cu contacte femele, care sunt mai convenabile de conectat la Troyka Shield. Cu toate acestea, pinii SDA și SCL separati nu sunt afișați pe el, așa că ne-am conectat direct prin pinii A5 și A4.

În ceea ce privește conectarea indicatorului, totul este mult mai simplu. Pinii CLK și DIO pot fi conectați la orice pin digital. În acest caz, se folosesc al 12-lea și, respectiv, al 11-lea pini.

Scrierea firmware-ului

Funcția de configurare ar trebui să inițialeze ceasul și indicatorul în timp real și să înregistreze timpul de compilare în memorie interna ceas în timp real. Întreaga acțiune, sau mai degrabă, citirea timpului de la RTC și afișarea acesteia pe indicator, va fi efectuată în funcția de buclă.

Codul pentru aceasta arată astfel:

rtc.ino #include #include // Clasele TM1637 și DS1307 sunt declarate în ele ceas ; void setup() ( ceas .begin () ; ceas ceas .setTime () ; ) void loop() ( int8_t timeDisp[ 4 ] ; //Solicitați ora de la ceas] = ceas .minut % 10 ; afisare.punct (ceas .secunda % 2 ? POINT_ON : POINT_OFF) ; ) //Conținutul funcției este explicat mai jos char getInt(const char * șir, int startIndex) ( return int (șir[ startIndex] - "0" ) * 10 + int (șir[ startIndex+ 1 ] ) - "0" ; )

Acum încărcăm acest cod în mediul de dezvoltare, compilăm și încărcăm. Ne uităm la afișaj - bingo! Ora de pe afișaj este timpul de compilare.

Funcția getInt explicată

În primul rând, trebuie să înțelegeți de unde vine timpul în matricea compileTime. Apare în această linie:

caracter nesemnat compileTime = __TIME__;

Compilatorul înlocuiește __TIME__ cu un șir care conține timpul de compilare sub forma __TIME__ = "hh:mm:ss" , unde hh este ore, mm este minute, ss este secunde.

Să revenim la codul care trebuie explicat:

char getInt(const char * șir, int startIndex) ( return int (șir[ startIndex] - "0" ) * 10 + int (șir[ startIndex+ 1 ] ) - "0" ; )

În matricea de șiruri transmisă ca parametru funcției getInt, obținem caracterul de la index startIndex și cel care îl urmează să ajungă cu un întreg de două cifre. Cu toate acestea, inițial acesta nu este un număr, ci o pereche personaje. Pentru a obține un număr dintr-un simbol, trebuie să scădem simbolul zero („0”) din acest simbol: la urma urmei, în Tabel ASCII toate simbolurile cu cifre vin unul după altul, începând cu simbolul zero. Prin urmare, codul int(șir) - "0"), literalmente, face următoarele: "Ia numărul caracterului startIndex , scădeți caracterul zero din el și convertiți-l într-un tip întreg".

Probleme

Da, acest cod funcționează și ceasul va rula. Cu toate acestea, dacă opriți alimentarea și porniți-l câteva minute mai târziu, atunci după ce o porniți, timpul va deveni din nou același ca în timpul compilării.

Acest lucru se întâmplă deoarece după pornirea alimentării, codul găsit în funcția de configurare este executat din nou. Și el scrie valoarea de timp veche pe ceasul în timp real.

Pentru a evita acest lucru, trebuie să mai modificăm puțin codul. De fiecare dată în funcția de configurare, va fi calculat un „hash” al timpului de compilare - se va calcula numărul de secunde care au trecut de la 00:00:00 la timpul de compilare. Și acest hash va fi comparat cu hash-ul din EEPROM. Să vă reamintim că EEPROM este o memorie care nu se resetează atunci când alimentarea este oprită.

Dacă valorile hashului calculat și salvat anterior coincid, aceasta înseamnă că nu este nevoie să rescrieți ora în modulul ceas: acest lucru a fost deja făcut. Dar dacă această verificare nu trece, atunci timpul este suprascris în RTC.

Pentru a scrie/citi un număr de tip int nesemnat în/din EEPROM, doi funcții suplimentare EEPROMWriteInt și EEPROMReadInt . Sunt adăugate deoarece funcțiile EEPROM.read și EEPROM.write pot citi și scrie doar date char.

rtc-eeprom.ino #include #include #include „TM1637.h” #include „DS1307.h” //Matrice care conține timpul de compilare char compileTime = __TIME__; //Numărul de pini Arduino la care este conectat indicatorul#define DISPLAY_CLK_PIN 12 #define DISPLAY_DIO_PIN 13 //Pentru a lucra cu cipul de ceas și indicatorul, folosim biblioteci Afișare TM1637(DISPLAY_CLK_PIN, DISPLAY_DIO_PIN) ; ceas DS1307 ; void setup() ( //Activați și configurați indicatorul display.set(); display.init(); //Porniți ceasul în timp real ceas.begin(); //Obține un număr dintr-un șir, cunoscând numărul primului caracter octet ora = getInt(compileTime, 0); byte minute = getInt(compileTime, 3); octet secundă = getInt(compileTime, 6); //Hash de timp improvizat //Conține numărul de secunde de la începutul zilei unsigned int hash = oră * 60 * 60 + minut * 60 + secundă; //Verificați dacă noul hash nu se potrivește cu hash-ul din EEPROM dacă (EEPROMReadInt(0) != hash) ( //Salvați noul hash EEPROMWriteInt(0, hash) ; //Pregătiți ore, minute, secunde pentru înregistrarea în RTC ceas .fillByHMS (oră, minut, secundă) ; //Scrieți aceste date în memoria internă a ceasului. //Din acest moment încep să numere timpul de care avem nevoie clock.setTime(); ) ) void loop() ( //Valori de afișat pe fiecare dintre cele 4 cifre int8_t timeDisp[ 4 ] ; //Solicitați ora de la ceas] = ceas .minut % 10 ; //... și apoi afișați-l pe ecran display.display(timeDisp); //nu avem cifre separate pentru secunde, deci //vom activa și opri două puncte în fiecare secundă afisare.punct (ceas .secunda % 2 ? POINT_ON : POINT_OFF) ; ) char getInt(const char * șir, int startIndex) ( return int (șir[ startIndex] - "0" ) * 10 + int (șir[ startIndex+ 1 ] ) - "0" ; ) //Scrieți un număr de doi octeți în memorie void EEPROMWriteInt(adresă int, valoare int) ( ​​EEPROM.write (adresă, lowByte (valoare) ) ; EEPROM.write (adresă + 1 , highByte (valoare) ) ; ) //Citirea unui număr din memorie unsigned int EEPROMReadInt(adresă int) (byte lowByte = EEPROM.read (adresă) ; octet highByte = EEPROM.read (adresă + 1) ; return (highByte)<< 8 ) | lowByte; }

Concluzie

Acest articol a arătat un exemplu de lucru cu cip-ul de ceas în timp real RTC DS1307 și cip-ul driver-ului indicator TM1637; am învățat, de asemenea, cum să obținem data și ora în etapa de compilare. Acum, dacă setați ora dorită pe ceas și apoi opriți alimentarea timp de cel puțin câteva ore, atunci după ce o porniți, ora va fi din nou precisă. Verificat!

Totul a început cu faptul că, întâmplător, m-am dovedit a fi proprietarul unui ecran LCD cu text BTHQ 22005VSS (2 rânduri a câte 20 de caractere fiecare) și al unei plăci de ceas electronic DS1302. Să spun adevărul, fac primii pași în Arduino Engineering, așa că prețul accesibil și posibilitatea de livrare rapidă au jucat un rol decisiv în achiziționarea acestor piese. La urma urmei, adesea nu există timp să așteptați ca „dispozitivul” să sosească din Regatul Mijlociu, după ce a călătorit aproape „jumătate din lume” și pur și simplu nu doriți.

De ce ceasuri? Într-o perioadă în care există o mulțime de ceasuri diferite la vânzare, prețul celor mai simple este comparabil cu o cutie de suc. Dar lucrul este că de multe ori este necesar nu numai să cunoști ora exactă (și data, care este și uneori necesar), ci și să operezi cu acest timp. De exemplu, păstrați jurnalele schimbărilor de temperatură (umiditate, presiune, lumină etc.) care indică ora exactă la care au avut loc aceste modificări. Aici ARDUINO, echipat cu un ceas, va oferi un serviciu minunat. Și, în plus, este frumos când dispozitivul arată și ora. La urma urmei, chiar și atunci când lucrăm pe un computer personal, aruncăm ocazional o privire în colțul din dreapta jos, ce se întâmplă dacă este deja timpul pentru prânz sau a venit sfârșitul zilei de lucru sau poate că a sosit deja?

Inima acestui proiect a fost ARDUINO UNO, care este destul de ușor de achiziționat - asta, desigur, dacă doriți să cumpărați ceva de înaltă calitate și rapid. Puteți, desigur, să-l găsiți mai ieftin, dar din nou trebuie să așteptați, iar eu nu am vrut să aștept. Arduinka și-a clipit vesel LED-ul, a făcut tot ce i s-a cerut, dând mesaje simple prin portul serial și, în general, m-a făcut fericit. Dar să revenim la ceas. Problemele au început, ca întotdeauna, pe neașteptate. Nu a fost posibil să găsesc articole cu sens și orice altceva nici pe ecran, nici ore întregi la miting. Pe alte ecrane - există, pe alte ceasuri - cât îți place, dar pe ceea ce ai în mâinile tale - aproape nimic. Dar când nu există nimic, „aproape” este, de asemenea, mult.

Să începem cu ecranul. BTHQ 22005VSS s-a dovedit a fi un ecran LCD banal de 20x2 (adică are 2 linii a câte 20 de caractere fiecare); în schimb, este foarte posibil să se folosească, de exemplu, un ecran - deși are „doar” 16 caractere în fiecare linie, dar pentru majoritatea proiectelor acest lucru este mai mult decât suficient. Acest ecran are un conector cu 16 pini, deși nu un singur rând, ci un rând dublu (2x8), dacă țineți dispozitivul cu ecranul îndreptat spre tine și conectorul din dreapta, atunci primul pin va fi stânga jos, al doilea dreapta jos, al treilea deasupra primului, al patrulea deasupra celui de-al doilea etc. Stânga sus (15) va fi anodul, dreapta sus (16) va fi catodul. Dacă aveți cunoștințe de engleză și curiozitate, puteți citi descrierea tehnică. Dacă există foarte puțin din primul, iar curiozitatea este mult mai slabă decât dorința de a experimenta, așa am conectat-o:

Ecran de contact Contact Arduino Notă
1 GND Acesta este „minus” sau „sol”.
2 +5V
3 GND Dacă aveți nevoie de semne luminoase.
4 4
5 GND Numai pentru a „scrie”.
6 5
7 -- Nu a folosit
8 -- Nu a folosit
9 -- Nu a folosit
10 -- Nu a folosit
11 10
12 11
13 12
14 13
A(15) +5V M-am conectat printr-un rezistor de 500 ohmi
K(16) GND

În unele surse, „pinout-ul” de pe partea Arduino este diferit, dar a fost mai convenabil pentru mine în acest fel. De asemenea, conectarea ceasului nu a cauzat probleme:

Ceas DS1302 Arduino Notă
VCC +5V
GND GND Aici l-am conectat printr-un rezistor de 10 kOhm.
CLK 0 A nu se confunda cu GND!!! Pinul se mai numește și SCLK
DAT 1 Contactul se mai numește și IO
RST 3 Contactul se mai numește și CE

Îl poți conecta cu fire sau un cablu; eu personal l-am asamblat pe o placă.

Problemele au început când demosketch-ul a fost încărcat și ceasul a început să funcționeze. Adevărat, au arătat anul 2165, luna 45, săptămâna 85... Probabil că asta este după calendarul „Uranian” sau „Neptun”... Dar nu voi trăi pe Pământ și nici nu voi merge. la Uranus și Neptun încă. În general, trebuie făcut ceva. Lipirea unui rezistor de 10 kOhm în circuitul GND->GND nu a ajutat. Problema s-a dovedit a fi o bibliotecă incorectă. Voi spune imediat că biblioteca corectă poate fi luată. Acesta este pentru ceas. Micul ecran folosește cu succes biblioteca de la set standard, care se numește LiquidCrystal.h.

Problema #2. De fiecare dată când pornește ceasul, începe să numere de la ora care este „cusută” în program. Există o soluție complexă pentru această problemă. Creați un hash, scrieți-l în memoria ceasului, apoi, la pornire, citiți-l de acolo, comparați-l... În general, pentru un începător în ingineria Arduino, este puțin complicat. După cum se dovedește, există o soluție simplă. sau mai degrabă foarte simplu. Și anume, flash-o de 2 ori. Prima dată - afișează-l cu setarea datei și orei, a doua oară îl afișează, după ce a „comentat” anterior (punând un semn // chiar la începutul rândului) liniile cu setarea acestei date.

De fapt, schița:

// DS1302_LCD (C)2010 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
// O demonstrație rapidă despre cum să folosesc biblioteca mea DS1302 pentru a face un rapid
// ceas folosind un DS1302 și un LCD 20x2.
// Corespondență între pinii ceasului și ecranul Arduino pinpm.
// DS1302: pin CE -> Arduino Digital 3
// Pin I/O -> Arduino Digital 1
// Pin SCLK -> Arduino Digital 0
// LCD: DB7 -> Arduino Digital 13
// DB6 -> Arduino Digital 12
// DB5 -> Arduino Digital 11
// DB4 -> Arduino Digital 10
// E -> Arduino Digital 5
// RS -> Arduino Digital 4

#include // Conectarea bibliotecii de ecran.
#include // Conectarea bibliotecii de ceasuri.

// Inițializați pinii ceasului
DS1302 rtc(3, 1, 0);
// Inițializați pinii ecranului
LiquidCrystal lcd (4, 5, 10, 11, 12, 13);

void setup()
{
// Porniți ceasul
rtc.halt(fals);
rtc.writeProtect(false);

// Lansează un ecran care indică numărul de caractere și linii
lcd.begin(20, 2);

// Cele trei linii de jos sunt necomentate pentru prima dată; în ele indicăm data și ora curentă. A doua oară - să comentăm.
//rtc.setDOW(JOI); // Ziua săptămânii, dacă este vineri, atunci nu scrie VINERI în rusă!
//rtc.setTime(11, 41, 0); // Ore, minute, secunde în format de 24 de ore.
//rtc.setDate(13, 6, 2013); // Data de. IN NUMERE!!! Nu trebuie să puneți un zero în fața unei singure cifre!
}

buclă goală ()
{
// Afișează ora centrată pe linia de sus
lcd.setCursor(6, 0); // Setați cursorul pentru a imprima ora în linia de sus
lcd.print(rtc.getTimeStr()); // Tipăriți ora

// Afișează prescurtat Ziua săptămânii în colțul din stânga jos
lcd.setCursor(0, 1); // Setați cursorul în stânga jos pentru a imprima ziua săptămânii
lcd.print(rtc.getDOWStr(FORMAT_LONG)); // Imprimați ziua săptămânii în întregime, deoarece ecranul o permite.

// Afișează data în colțul din dreapta jos
lcd.setCursor(9, 1); // Setați cursorul pentru a imprima data
lcd.print(rtc.getDateStr()); // Tipăriți data

// Așteptați o secundă înainte de a repeta
întârziere (1000); // Faceți o pauză de 1 secundă și începeți din nou!
}