Modul ceas RTC PCF8563, interfata I2C, 1.0-5.5V, alarma si temporizator, suport baterie moneda

In acest tutorial folosim placa Arduino Uno R3. Modulul ceas PCF8563 este un ceas de timp real (RTC) cu interfata I2C. El tine ora si data chiar si cand placa de dezvoltare este oprita, atat timp cat are o baterie de rezerva in suport. Il folositi in jurnale de date cu marca de timp, alarme, ceasuri digitale, automatizari programate si orice proiect care trebuie sa stie cat e ceasul dupa o repornire.

Modulul are circuitul PCF8563 in capsula SO8, un cristal de 32.768 kHz (Y1) si un suport pentru baterie tip moneda. Pe marginea placii este un conector J1 cu 6 pini, marcati INT, COT, SCL, SDA, GND si VCC. Placa nu are butoane, potentiometre, jumperi sau LED-uri, deci tot ce reglati se face din program.

Cum functioneaza:

Cristalul de 32.768 kHz oscileaza de 32768 de ori pe secunda, adica de 2 la puterea 15. Circuitul imparte aceasta frecventa pana la 1 Hz si la fiecare impuls al acestuia incrementeaza contorul de secunde. Din contorul de secunde se obtin minutele, orele, ziua, ziua saptamanii, luna si anul, toate pastrate in registre interne.

Valorile din registre sunt in format BCD. Fiecare cifra zecimala ocupa 4 biti, deci secunda 45 se citeste ca 0x45 si nu ca 0x2D. Programul converteste din BCD in zecimal cu formula (v >> 4) * 10 + (v AND 0x0F) si invers cu ((v / 10) << 4) OR (v MOD 10).

Registrul 0x02 (secunde) are in bitul 7 indicatorul VL (voltage low). Daca este 1, tensiunea de alimentare a scazut prea mult sau oscilatorul s-a oprit, iar ora nu mai este garantata. Scriind secundele cu bitul 7 egal cu 0 indicatorul se sterge. Registrul 0x07 (luna) are in bitul 7 bitul de secol, pe care circuitul il comuta la trecerea anului de la 99 la 00. In program consideram ca valoarea 0 inseamna anii 20xx.

Circuitul mai are alarma, temporizator si o iesire de ceas programabila pe pinul COT (CLKOUT), cu frecventele 32.768 kHz, 1.024 kHz, 32 Hz sau 1 Hz, setata din registrul de la adresa 0x0D. Pinul INT este iesire de intrerupere, open-drain, activa pe nivel jos. In acest tutorial citim doar ora si data, deci COT si INT raman neconectate.

Precizia depinde doar de cristal, pentru ca circuitul nu face compensare de temperatura. Un cristal cu abatere de 20 ppm (valoare data ca exemplu) inseamna aproximativ 20 x 86400 / 1000000 = 1.7 secunde pe zi, adica circa 50 de secunde pe luna. Pentru un jurnal de date este mult mai mult decat suficient, pentru un ceas de precizie ar trebui o sincronizare periodica.

Adresa I2C pe 7 biti este 0x51. In documentatia circuitului apar adresele de 8 biti A2h pentru scriere si A3h pentru citire, iar biblioteca Wire din Arduino lucreaza cu adresa pe 7 biti, adica 0x51.

Conectare:

Alimentati modulul din pinul 5V al placii Arduino Uno. Circuitul PCF8563 functioneaza intre 1.0 si 5.5 V, deci 5 V este potrivit, iar nivelurile logice ale magistralei I2C sunt compatibile cu cele ale placii Uno, deci nu aveti nevoie de convertor de nivel. Daca folositi o placa de 3.3 V, alimentati modulul din 3.3 V. Placa Arduino se alimenteaza de la calculator prin cablul USB A-B. Montati bateria tip moneda in suport cu polaritatea corecta, verificand tipul inscriptionat pe suport.

Pe placa Arduino Uno R3 pinii SDA si SCL de langa AREF sunt aceleasi semnale ca A4 si A5, deci ii puteti folosi in locul lor. Cand conectati pinii de la conector, tineti cont ca ordinea de sus in jos pe placa este INT, COT, SCL, SDA, GND, VCC. Atentie la SDA si SCL, sunt in ordine inversa fata de multe module. Pentru o magistrala I2C stabila, folositi fire scurte.

Placa si biblioteci:

In Arduino IDE selectati Tools > Board > Arduino AVR Boards > Arduino Uno. Pachetul Arduino AVR Boards vine odata cu Arduino IDE, deci nu trebuie adaugata nicio adresa in File > Preferences. Selectati apoi portul placii din Tools > Port.

Programul foloseste doar biblioteca Wire, care vine cu Arduino IDE, deci nu trebuie instalata nicio biblioteca. Vorbim direct cu registrele circuitului, ca sa intelegeti exact ce se citeste si ce se scrie.

Codul:

Programul seteaza ceasul din ora de compilare daca ora nu a fost setata niciodata sau daca bateria a fost scoasa, apoi afiseaza data si ora in fiecare secunda.

/*
  PCF8563 RTC module test
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Board package: Arduino AVR Boards (comes with the Arduino IDE)
  Libraries: none to install, the Wire library comes with the Arduino IDE
  Wiring:
    RTC VCC -> Arduino 5V
    RTC GND -> Arduino GND
    RTC SDA -> Arduino A4
    RTC SCL -> Arduino A5
    RTC INT and COT are not connected
  The program sets the clock from the compile time when the time was never
  set or the backup battery was lost, then prints the date and time every second.
*/
#include <Wire.h>
const uint8_t RTC_ADDRESS = 0x51;      // 7-bit I2C address of the PCF8563
const uint8_t REG_CONTROL_1 = 0x00;    // first register, control and status 1
const uint8_t REG_SECONDS = 0x02;      // seconds register, bit 7 is the VL flag
const bool FORCE_SET_TIME = false;     // set to true to rewrite the time at every start
const char *dayNames[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
// Convert a decimal number (0 - 99) to BCD
uint8_t decToBcd(uint8_t value) {
  return ((value / 10) << 4) | (value % 10);
}
// Convert a BCD number to decimal
uint8_t bcdToDec(uint8_t value) {
  return ((value >> 4) * 10) + (value & 0x0F);
}
// Day of the week from the date, 0 = Sunday
uint8_t dayOfWeek(uint16_t year, uint8_t month, uint8_t day) {
  static const uint8_t offsets[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
  if (month < 3) {
    year -= 1;
  }
  return (year + year / 4 - year / 100 + year / 400 + offsets[month - 1] + day) % 7;
}
// Check if the module answers on the I2C bus
bool rtcPresent() {
  Wire.beginTransmission(RTC_ADDRESS);
  return Wire.endTransmission() == 0;
}
// Read several consecutive registers starting at startReg
bool readRegisters(uint8_t startReg, uint8_t *buffer, uint8_t length) {
  Wire.beginTransmission(RTC_ADDRESS);
  Wire.write(startReg);
  if (Wire.endTransmission() != 0) {
    return false;
  }
  if (Wire.requestFrom(RTC_ADDRESS, length) != length) {
    return false;
  }
  for (uint8_t i = 0; i < length; i++) {
    buffer[i] = Wire.read();
  }
  return true;
}
// Write the compile date and time into the clock
void setTimeFromCompileTime() {
  const char *dateText = __DATE__;   // format: "Mmm dd yyyy"
  const char *timeText = __TIME__;   // format: "hh:mm:ss"
  const char *months = "JanFebMarAprMayJunJulAugSepOctNovDec";
  char monthName[4] = {dateText[0], dateText[1], dateText[2], 0};
  uint8_t month = (strstr(months, monthName) - months) / 3 + 1;
  uint8_t day = ((dateText[4] == ' ') ? 0 : (dateText[4] - '0')) * 10 + (dateText[5] - '0');
  uint16_t year = atoi(dateText + 7);
  uint8_t hour = (timeText[0] - '0') * 10 + (timeText[1] - '0');
  uint8_t minute = (timeText[3] - '0') * 10 + (timeText[4] - '0');
  uint8_t second = (timeText[6] - '0') * 10 + (timeText[7] - '0');
  Wire.beginTransmission(RTC_ADDRESS);
  Wire.write(REG_CONTROL_1);                          // start at control register 1
  Wire.write((uint8_t)0x00);                          // control 1: clock running
  Wire.write((uint8_t)0x00);                          // control 2: no alarm or timer flags
  Wire.write(decToBcd(second));                       // seconds, bit 7 = 0 clears the VL flag
  Wire.write(decToBcd(minute));                       // minutes
  Wire.write(decToBcd(hour));                         // hours
  Wire.write(decToBcd(day));                          // day of the month
  Wire.write(dayOfWeek(year, month, day));            // day of the week
  Wire.write(decToBcd(month));                        // month, century bit 0 means 20xx
  Wire.write(decToBcd(year % 100));                   // year (00 - 99)
  Wire.endTransmission();
}
void setup() {
  Serial.begin(9600);
  Wire.begin();
  if (!rtcPresent()) {
    Serial.println("PCF8563 not found, check the wiring");
    while (true) {
      delay(1000);
    }
  }
  Serial.println("PCF8563 found at address 0x51");
  uint8_t secondsRegister = 0;
  readRegisters(REG_SECONDS, &secondsRegister, 1);
  bool vlFlag = (secondsRegister & 0x80) != 0;        // 1 = time is not guaranteed
  if (vlFlag || FORCE_SET_TIME) {
    Serial.println("Time lost or forced, setting it from compile time");
    setTimeFromCompileTime();
  }
}
void loop() {
  uint8_t data[7];
  if (!readRegisters(REG_SECONDS, data, 7)) {
    Serial.println("Read error");
    delay(1000);
    return;
  }
  bool vlFlag = (data[0] & 0x80) != 0;
  uint8_t second = bcdToDec(data[0] & 0x7F);          // mask the VL bit
  uint8_t minute = bcdToDec(data[1] & 0x7F);
  uint8_t hour = bcdToDec(data[2] & 0x3F);
  uint8_t day = bcdToDec(data[3] & 0x3F);
  uint8_t weekday = data[4] & 0x07;
  uint8_t month = bcdToDec(data[5] & 0x1F);           // mask the century bit
  uint16_t year = 2000 + bcdToDec(data[6]);
  char buffer[40];
  snprintf(buffer, sizeof(buffer), "%04u-%02u-%02u %02u:%02u:%02u ",
           (unsigned int)year, (unsigned int)month, (unsigned int)day,
           (unsigned int)hour, (unsigned int)minute, (unsigned int)second);
  Serial.print(buffer);
  Serial.print(dayNames[weekday]);
  if (vlFlag) {
    Serial.print("  WARNING: time is not guaranteed");
  }
  Serial.println();
  delay(1000);                                        // one reading per second
}

Cum functioneaza codul:

La inceput sunt definitiile. RTC_ADDRESS este adresa I2C pe 7 biti a circuitului, adica 0x51. REG_CONTROL_1 este primul registru (0x00), iar REG_SECONDS este registrul secundelor (0x02), al carui bit 7 este indicatorul VL. Constanta FORCE_SET_TIME, daca o puneti pe true, rescrie ora la fiecare pornire. Tabloul dayNames contine numele zilelor, in ordinea in care le numeroteaza programul, de la 0 pentru duminica.

Functiile decToBcd si bcdToDec convertesc intre numarul zecimal si formatul BCD folosit de registre. Functia dayOfWeek calculeaza ziua saptamanii din data, pentru ca ceasul nu o deduce singur si trebuie sa o scriem noi. Functia rtcPresent trimite o transmisie goala la adresa 0x51 si intoarce true daca modulul raspunde.

Functia readRegisters trimite adresa registrului de start, apoi cere length octeti cu Wire.requestFrom si ii pune in buffer. Circuitul incrementeaza singur adresa registrului, deci o singura cerere citeste toate valorile de la secunde la an.

Functia setTimeFromCompileTime extrage data si ora din macrourile __DATE__ si __TIME__, calculeaza luna dupa pozitia numelui in sirul months si scrie in ordine registrele de la 0x00 la 0x08. Secundele se scriu cu bitul 7 egal cu 0, ceea ce sterge indicatorul VL, iar bitul de secol din luna ramane 0.

In setup pornim portul serial la 9600 baud si magistrala I2C cu Wire.begin. Daca rtcPresent intoarce false, programul afiseaza un mesaj de eroare si se opreste. Altfel citim registrul secundelor, iar daca vlFlag este 1 sau FORCE_SET_TIME este true, apelam setTimeFromCompileTime.

In loop citim 7 registre de la 0x02 in tabloul data. Din fiecare valoare mascam bitii care nu fac parte din numar (0x7F pentru secunde si minute, 0x3F pentru ore si zi, 0x1F pentru luna) si convertim din BCD. Anul se obtine ca 2000 plus valoarea din registrul anilor. Linia se formateaza cu snprintf, se afiseaza impreuna cu numele zilei si, daca vlFlag este 1, cu un avertisment. La final, delay(1000) da o citire pe secunda.

Rezultat:

Deschideti Serial Monitor din Tools si setati viteza la 9600 baud. La prima pornire apar mesajele despre modul gasit si despre setarea orei, apoi o linie pe secunda cu data, ora si ziua saptamanii. La urmatoarele porniri ora nu se mai seteaza, atat timp cat bateria este in suport.

PCF8563 found at address 0x51
Time lost or forced, setting it from compile time
2025-03-14 10:22:31 Friday
2025-03-14 10:22:32 Friday
2025-03-14 10:22:33 Friday
2025-03-14 10:22:34 Friday
2025-03-14 10:22:35 Friday
2025-03-14 10:22:36 Friday

Probleme frecvente:

Pe monitorul serial apare mesajul PCF8563 not found. Cauza este de obicei o conectare gresita sau o alimentare lipsa. Verificati ca SDA merge la A4 si SCL la A5, tinand cont ca pe conector SCL este deasupra lui SDA, si ca VCC este la 5V iar GND la GND.

Nu apare nimic pe monitorul serial sau apar caractere ciudate. Cauza este o viteza gresita. Setati in Serial Monitor viteza de 9600 baud si verificati ca portul selectat este cel al placii Arduino Uno.

Ora este gresita dupa fiecare oprire a alimentarii. Cauza este lipsa sau descarcarea bateriei din suport, ori montarea ei cu polaritatea inversata. Montati o baterie corecta, apoi puneti FORCE_SET_TIME pe true, incarcati programul o data si readuceti-l pe false.

Apare avertismentul time is not guaranteed. Indicatorul VL este 1, deci tensiunea de alimentare a scazut prea mult sau oscilatorul s-a oprit. Setati din nou ora, iar daca avertismentul revine, schimbati bateria.

Ora seteaza ora de compilare, dar cu cateva secunde intarziere. Cauza este timpul dintre compilare si incarcarea programului in placa. Pentru o ora exacta, setati ceasul dintr-o sursa externa, de exemplu de la calculator sau de la un server de timp.

Ceasul se abate cu cateva secunde pe luna. Este normal, pentru ca precizia depinde de cristal si circuitul nu face compensare de temperatura. Sincronizati periodic ceasul daca aveti nevoie de o precizie mai buna.

Limitari si sfaturi:

Ceasul functioneaza intre 1.0 si 5.5 V, dar pentru comunicatia I2C la 400 kHz alimentarea trebuie sa fie de minimum 1.8 V. Precizia este data de cristalul de 32.768 kHz si variaza cu temperatura, deci nu inlocuieste un ceas cu compensare de temperatura acolo unde conteaza fractiunile de secunda pe luna.

Modulul tine ora doar atat timp cat in suport este o baterie in stare buna, iar consumul in regim de rezerva este foarte mic, tipic 0.25 µA la 3.0 V si 25 °C. Cand folositi iesirile INT si COT, adaugati rezistente de pull-up, pentru ca ambele sunt open-drain.

Mai departe puteti folosi alarma si temporizatorul circuitului, cu iesirea INT conectata la o intrare de intrerupere, ca sa treziti placa dintr-un mod de consum redus. Puteti folosi si iesirea COT la 1 Hz ca baza de timp pentru alte circuite, sau puteti construi un jurnal de date cu marca de timp pe card SD.