Choix lib RTC

Bonjour à tous,

Le gentil facteur vient de me livrer les shields RTC (DS3231 AT24C32 IIC) forcément, je joue avec.

Pour l'instant, tout se passe bien, mise à jour de l'heure, lecture de l'heure courante, lecture de la t°...

J'utilise par défaut la lib RTC by Makuna qui était proposée dans l'EDI Arduino. Mais je trouve que pour ne faire presque rien, mon Uno est déjà bien chargé (21% de l'espace de stockage programmes, 20% pour les variables)

Je me demande donc si vous aviez l'habitude d'utiliser d'autres bibliothèques ou si celle ci convenait

Mes besoins sont:

  • Support du uno et de l'ESP-12e
  • DS3231
  • Pourquoi pas introduction de la classe DateTime et gestion des alarmes comme le fait la Makuna

Merci d'avance

C’est bien le coté qui blesse avec les bibliothèques qui font tout, même ce dont tu n’as pas besoin.
Elles créent des tonnes de variables dont tu n’as pas forcément besoin, des tonnes de #define machin truc qui peuvent (?) bouffer de la flash ou de la ram (je ne suis pas très clair sur le sujet des #define, donc s’il existe des analyses fiables je suis preneur).

Si tu n’a que des besoins simples tu peux faire l’effort de lire :

  • la datasheet du circuit intégré DS3231 et si tu compte te servir de l’eeprom celle de AT24C32 .
  • une bibliothèque existante pour t’en inspirer et ne pas réinventer la roue
    et faire ta propre bibliothèque avec uniquement ce dont tu as besoin.

Je ne sais pas comment l’IDE Wiring/arduino compile les bibliothèque des tierce parties.
Les siennes il les compile en “bibliothèque statique” → toute fonction non utilisée est virée par le compilateur et n’occupe pas de place inutile en flash, mais, comme elles ne sont pas placée au même endroit, en est de même pour les bibliothèques utilisateur ?

Comme simplification on pourrait par exemple virer tout ce qui concerne la mise à l’heure : le module ayant une pile de sauvegarde c’est inutile.
S’il faut remettre le module à l’heure une fois par an ce sera bien plus simple à faire à partir d’un tout petit programme qui ne fera que cela.

A titre personnel j’estime qu’avec des micro-contrôleurs qui n’ont pas beaucoup de mémoire les bibliothèques qui font tout sont une erreur, c’est de l’ <> à la microsoft pour qui il faut toujours des processeurs plus puissants.
J’ajoute qu’en modifiant et élaguant des bibliothèques monstrueuses (quand c’était possible, j’ai eu des échecs) j’ai appris des points de programmation que j’ignorais → cela demande des efforts mais après c’est tout bénéfice.

Bonjour,

Je suis dans le même cas que toi.
Je viens de recevoir le même composant. DS3231 + 24CN32.

J'ai téléchargé deux libs pour l'instant:
Lib Rodan

et une autre dont j'ai perdu le lien et qui s'appelle "DS3231-Simple".

J'ai commencé à regarder les sources, rien qui me convienne complètement.
Je vais donc, comme le suggère 68tjs et comme à mon habitude, faire le tri et ajouter/modifier moi même ce qu'il me faut.

Je sais cela ne t'avance pas trop, mais bon..

Au contraire, merci pour vos réponses
Si tous le monde est d’accord pour dire que les lib ne sont pas au top, je vais aussi me coller au nettoyage

D’un autre coté, depuis tout à l’heure je décortique les fichiers .h et .cpp de la lib et je n’ai pas encore bien vu de quoi retirer.

Je vais peut etre me passer de toute la gestion d’alarme pour faire comme dans les tutos, comparer la date courante avec celle du déclenchement prévu… Un peu bourrin coté cpu mais plus léger coté taille du code à compiler

Bonjour

Moi aussi il y a longtemps que j'ai décidé de me passer de la RTClib que l'on trouve partout.
J'ai mis le fruit de mon travail ici

A vous de voir si elle peut correspondre à vos besoins.

C'est une version assez minimaliste d'accès au RTC, réduite à la lecture/écriture de l'horloge, pour les cas d'usages simples.
Donc elle n'embarque pas la gestion des accès à la NVRAM personnalisable, ni les alarmes, ni la gestion de l'eeprom qui accompagne souvent un DS1307 sur un tinyRTC.

Par contre je l'ai un poil réalourdie par une fonctionnalité qui me semblait indispensable et que l'on ne trouve pas dans les lib RTC : la gestion automatique des changements d'heure été/hiver.

A toutes fins utiles, voici un exemple ultra minimal d'accès en lecture/écriture à un RTC.

const uint8_t adresseRTC = 0x68; //Adresse du circuit RTC sur le bus I2C

uint8_t bin2dcb(uint8_t bin) {return bin + 6 * (bin / 10);} //conversion binaire en dcb
uint8_t dcb2bin(uint8_t dcb) {return dcb - 6 * (dcb >> 4);} //conversion dcb en binaire

bool ecrireRTC(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t heure, uint8_t minute, uint8_t seconde)
{
  Wire.beginTransmission(adresseRTC);
  Wire.write((uint8_t)0);
  Wire.write(bin2dcb(seconde));
  Wire.write(bin2dcb(minute));
  Wire.write(bin2dcb(heure));
  Wire.write(1); //joursem non géré
  Wire.write(bin2dcb(jour));
  Wire.write(bin2dcb(mois));
  Wire.write(bin2dcb(annee));
  return (Wire.endTransmission() == 0); //retourne true si transmission ok
}

bool lireRTC(uint8_t *annee, uint8_t *mois, uint8_t *jour, uint8_t *heure, uint8_t *minute, uint8_t *seconde)
{
  Wire.beginTransmission(adresseRTC);
  Wire.write((uint8_t)0);
  bool accesOK = (Wire.endTransmission() == 0);
  if (accesOK) accesOK = (Wire.requestFrom(adresseRTC, (uint8_t) 7) == 7);
  if (accesOK)
  {
    *seconde   = dcb2bin(Wire.read());
    *minute    = dcb2bin(Wire.read());
    *heure     = dcb2bin(Wire.read());
    Wire.read(); //joursem non géré
    *jour      = dcb2bin(Wire.read());
    *mois      = dcb2bin(Wire.read());
    *annee     = dcb2bin(Wire.read());
  }
  return accesOK;
}

bricoleau:
J'ai mis le fruit de mon travail ici

A vous de voir si elle peut correspondre à vos besoins.

Merci beaucoup.

Je vais partir de là pour faire ma propre librairie.
En effet, mon besoin est celui d'avoir un scheduler qui déclenche selon l'heure et le jour de la semaine (mise en marche arret de chauffage)

Je vais donc faire une classe correspondant à un déclenchement (jour de la semaine, heure, minute) et une classe gestionnaire de déclenchement (tableau de déclenchements, ajouter/supprimer un déclenchement à la liste, renvoyer le prochaine déclenchement....)

Merci encore

D'ailleurs, pour écrire des bibliothèques ou autres croquis, vous utilisez l'EDI Arduino ?
Je le trouve plutot faible. Travaillant avec VS, j'ai l'habitude de l'autocompletion et de l'analyse de code en temps réel...

Je me demande si je ne vais pas utiliser ce dernier et garder l'EDI Arduino uniquement pour compiler téléverser et deboguer....

perso je code tout sous codeblocks ;D

C’est clair que la gestion d’un programmateur journalier est un cas d’usage fréquent dans les montages arduino.

J’avais d’ailleurs commencé à écrire quelque chose là-dessus, mais pas fini / pas publié.

L’idée était bêtement de transposer les fonctionnalités d’un programmateur horaire classique (ceux électroniques, où on règle les jours de la semaine, l’heure de début et l’heure de fin).

à utiliser en complément du simpleRTC

Le voici “as is”, même pas sûr que ça compile

const uint8_t DIMANCHE = 0b0000001;
const uint8_t LUNDI    = 0b0000010;
const uint8_t MARDI    = 0b0000100;
const uint8_t MERCREDI = 0b0001000;
const uint8_t JEUDI    = 0b0010000;
const uint8_t VENDREDI = 0b0100000;
const uint8_t SAMEDI   = 0b1000000;

const uint8_t SEMAINE  = LUNDI | MARDI | MERCREDI | JEUDI | VENDREDI;
const uint8_t WEEKEND  = SAMEDI | DIMANCHE;

const uint8_t TOUSLESJOURS = SEMAINE | WEEKEND;

typedef void (*fonctionVoid)();//correspond à toute fonction du style "void ma_fonction()"

class progJournalier
{
  public :

    //Constructeur : fournir les fonctions à appeler lors de la mise en marche et lors de l'arret
    progJournalier(fonctionVoid marche, fonctionVoid arret);

    //Paramètres de programmation journalière
    void reglerDebut(uint8_t heure, uint8_t minute);
    void reglerFin(uint8_t heure, uint8_t minute);
    void reglerJours(uint8_t jours); //utiliser les constantes ci-dessus, par exemple LUNDI | MARDI

    //Evaluation incluant l'appel éventuel aux fonctions de mise en marche ou d'arrêt
    //Valeurs en entrées fournies par un RTC
    //joursem : 0=dim, 1=lun, ... 6=sam
    //retourne true si changement d'état
    bool actualiser(uint8_t joursem, uint8_t heure, uint8_t minute);

    //Méthodes constantes d'accès aux propriétés du programme journalier
    bool estActif() const;
    void debut(uint8_t *heure, uint8_t *minute) const;
    void fin(uint8_t *heure, uint8_t *minute) const;
    uint8_t jours() const;
    bool estActifLe(uint8_t joursem) const;

  private :
    fonctionVoid on, off;
    uint16_t deb, fin;
    uint8_t jrs;
    bool actif;
};

progJournalier::progJournalier(fonctionVoid marche, fonctionVoid arret)
{
  this->on = marche;
  this->off = arret;
  this->deb = 0;
  this->fin = 0;
  this->jrs = TOUSLESJOURS;
  this->actif = false;
}

void progJournalier::reglerDebut(uint8_t heure, uint8_t minute)
{
  this->deb = heure;
  this->deb *= 60;
  this->deb += minute;
}

void progJournalier::reglerFin(uint8_t heure, uint8_t minute)
{
  this->fin = heure;
  this->fin *= 60;
  this->fin += minute;
}

void progJournalier::reglerJours(uint8_t jours)
{
  this->jrs = jours;
}

bool progJournalier::actualiser(uint8_t joursem, uint8_t heure, uint8_t minute)
{
  if (this->jrs & (1 << joursem))
  {
    uint16_t maintenant = heure;
    maintenant *= 60;
    maintenant += minute;
    if (deb <= maintenant && maintenant <fin)
    {
      if (!this->actif)
      {
        this->on();
        this->actif = true;
        return true;
      }
    }
    else
    {
      if (this->actif)
      {
        this->off();
        this->actif = false;
        return true;
      }
    }
  }
  return false;
}

bool progJournalier::estActif() const {return this->actif;}

void progJournalier::debut(uint8_t *heure, uint8_t *minute) const
{
  *minute = this->deb % 60;
  *heure  = this->deb / 60;
}

void progJournalier::fin(uint8_t *heure, uint8_t *minute) const
{
  *minute = this->fin % 60;
  *heure  = this->fin / 60;
}

uint8_t progJournalier::jours() const {return this->jrs;}

bool progJournalier::estActifLe(uint8_t joursem) const {return !!(this->jrs & (1 << joursem));}

Une fois de plus, merci :wink:

Codeblocks gère l'analyse en tps reel et l'autocomplétion ?