Uhr RV3029 programmieren

[Mauer (Gast)]

HAllo,
ich brauche dringend Hilfe. Ich will die RV3029 Uhr benutzen, dazu 
brauche ich Ansätze.

Ich benutze bereits ein I2C Modul, mit einem EEprom, über den I2C 
ZUgriff, nun befindet sich auch eine RV3029 auf der Platine. fürs erste 
will ich die Uhrzeit setzen und lesen können und das Datum setzen und 
lesen können.

Ich hab gedacht, erst brauche ich folgende funktionen:

#define RV3029C2_W_SEC        0x08
#define RV3029C2_W_MINUTES    0x09
#define RV3029C2_W_HOURS      0x0A
#define RV3029C2_W_DATE       0x0B
#define RV3029C2_W_DAYS       0x0C
#define RV3029C2_W_MONTHS     0x0D
#define RV3029C2_W_YEARS      0x0E
#define RV3029C2_LEN          0x07


+/* eeprom data section */
#define RV3029C2_E2P_EEDATA1  0x28
#define RV3029C2_E2P_EEDATA2  0x29


struct time {
  int sec;
  int min;
  int hour;
}
                       //Adresse sec,min,hour //zugriff sec,min..  //Länge
unsigned int time_set(unsigned char Address, struct time *tm, unsigned int RV3029C2_LEN)
unsigned int time_read(unsigned char Address, struct time *tm, unsigned int RV3029C2_LEN)

ist der Ansatz schonmal in ordnung, am besten wärs wenn jemand mir 
zeigen könnte wie der zugriff aud die Uhr durchgeführt wird. Danke.

[Mauer (Gast)]

Hallo
wollt mal fragen ob mir jemand zu meinem Problem helfen kann.
Ich habe zwar das schreiben von sek, min, und das lesen an den Adressen 
anliegenden Daten hinbekommen, jedoch solls ja so sein, dass man eine 
Startaddresse vorgibt z.B. die von der sek, dann pa minuten später erst, 
die Uhr ablesen tut und es muss dir richtige Uhrzeit angegeben werden,
wie genau konfiguriere ich die funktion read:

mein beispiel:

//base=base addresse, Address=Addressen der Uhrzeit, Data=Daten, Len=Länge der Daten-Bytes

nsigned int RV3029_read(unsigned long Base, unsigned short Address, unsigned char *Data, unsigned int Len) {
  int i = 0;
  int Retry = I2C_MASTER_MAX_RETRIES;
  unsigned long j;

   retry:
   
  // Start Transmission   
  I2C_StartTX(Base, RV3029_EEPROM_SLAVE_write, 0);

  I2C_Send(Base, Address);
 
  I2C_StartRX(Base, RV3029_EEPROM_SLAVE_read, Data);
  for (i = 1; i < Len; i++) {
    Data[i] = I2C_Read(Base);
  }

  UARTprintf("Uhrzeit: %02d:%02d:%02d\n", 0x08, 0x09, 0x0A);  // Send the stop condition
  I2C_Stop(Base);^

if (Retry--)
    goto retry;
  return i;

Ist das so in orsnung, oder kann man da noch was verbessern.danke.

[Yoghurtmonster (Gast)]

Das go-Konstrukt kann durch eine einfache while-Schleife ersetzt 
werden...

[Yoghurtmonster (Gast)]

s/go/goto

[Mauer (Gast)]

Diese beiden Funktionen waren nur zum lesen und schreiben von rv_3029 
gedacht, der man addresse und daten zuweisen und auskesen kann.
Nun habe ich es erweitert mit den Funktionen um die Zeit zu sétzen und 
lesen.
Nur bin ich mir da nicht so sicher:

unsigned int RV3029_set_time() {

Set_time:
  I2C_StartTX(0, RV3029_EEPROM_SLAVE_write, 0);
  I2C_StartTX(0, RV3029_SEC, 0);
  I2C_StartTX(0, RV3029_MINUTES, 0);
  I2C_StartTX(0, RV3029_HOURS, 0);
  I2C_Stop();

}

unsigned int RV3029_get_time() {

Get_time:
  I2C_StartTX(0, RV3029_EEPROM_SLAVE_write, 0);
  I2C_StartTX(0, RV3029_EEPROM_SLAVE_read, 0);

  I2C_StartRX(0, RV3029_SEC, Data_sec);
  I2C_StartRX(0, RV3029_MINUTES, Data_min);
  I2C_StartRX(0, RV3029_HOURS, Data_hour);
  UARTprintf("Uhrzeit: %02d:%02d:%02d\n", Data_hour, Data_min, Data_sec);
  I2C_Stop();


}

Nur zum verständnis. beim setzen der Zeit muss ich doch erst die 
Startbedingung setzen also I2C start mit der write adresse des RV3029, 
hab ich gemacht aber muss dazu auch die Daten setzen oder, für die 
Addresse RV3029_SEC, 0x05 (5 sekunden) ... usw. Meine I2C Funktionen 
enthalten einmal die Base Adresse des I2c, die Adressen und Daten. Bei 
write hab die Daten noch auf 0 gesetzt.

So beim Get_time versteh ich nicht hab üerall gelesen wird erst 
I2C_Start mit der Write Address initialisiert und dann mit der Read 
Address, warum dass denn.

Soll bei Get_Time der PArameter Data übergeben werden oder nciht, bin da 
irgendwie durcheinander.

Wäre für jede Hilfe dankbar.
Soll

[Mauer (Gast)]

Hallo,
kann mir keiner hier weiterhelfen.Danke.


Gruß

[Peter D. (peda)]

Mauer schrieb:
> struct time {
>   int sec;
>   int min;
>   int hour;
> }

Das ist Verschwendung (eine Minute hat keine 65536 Sekunden usw.).
Nimm unsigned char oder besser uint8_t.

Viele RTC zählen im veralteten BCD-Format, dann muß man noch nach binär 
umwandeln (C rechnet intern nur binär).

Zeit lesen bzw. setzen muß man in einem I2C-Paket machen.
Sonst kann zwischen den Paketen ein Überlauf erfolgen und man hat halb 
neue und halb alte Daten.

Zu dem Code kann ich nichts sagen, da ich weder die RTC noch Deine 
unbekannte I2C-Lib kenne.

Ich erspare mir den ganzen Schrunz mit externer RTC. Ich zähle ganz 
einfach Zeit und Datum im Timerinterrupt.


Peter

[Mauer (Gast)]

Danke für deine Hilfe hab, deine ersten beiden Punkte umgesetzt, was ich 
wissen will ist der Ablauf.

Wie ist denn genau die Reihenfolge, als erstes wird ja die slave+write 
Adresse mit dem I2C eingelesen:

i2c_write(slave_address+write

was genau wird danach eingelesen, die Adressen der Zeitparameter oder 
die Daten für die Zeitparameter,

Auf diesem Link Beitrag "Uhr mit RV-3029-C2" hat schonmal 
einer darüber gefragt, nur habe ich nicht ganz die Reihenfolge 
verstanden, wann werden die Addressen eingelesen wann die Daten und wann 
wird die Zeit gelesen, und muss ich die Reg 0 bbis 3 (control) auch 
einbeziehen.

[Mauer (Gast)]

kurze erläuerung meines I2C Pakets:

I2C_StartTX(unsigned char Slave, unsigned char Data) = Sendet die 
Startkondition, die Slave_address und das erste Datenbyte
I2C_StartRX(unsigned char Slave, unsigned char *Data) = sendet 
Startkondition und Slave_address

I2C_Send(unsigned char Data) = sendet das Daten_byte
I2C_Read(unsigned long Base) = empfängt ein Datenbyte
I2C_Stop(unsigned long Base) = sendet die Stopkondition auf dem Bus


nun meine beiden funktionen sehen so aus, hoffe habe die richtige 
Reihenfolge der Aufrufungen der Funkionen eingehalten.

#define RV3029_EEPROM_SLAVE_write 0xAC
#define RV3029_EEPROM_SLAVE_read 0xAD

#define RV3029_SEC        0x08
#define RV3029_MINUTES    0x09
#define RV3029_HOURS      0x0A

unsigned long RV3029_set_time(unsigned long Base, unsigned char Data) {
 

  I2C_StartTX(Base, RV3029_EEPROM_SLAVE_write, 0);
 
  I2C_Send(Base, RV3029_SEC);
  I2C_Send(Base, 0x09);
  I2C_Send(Base, RV3029_MINUTES);
  I2C_Send(Base, 0x05);
  I2C_Send(Base, RV3029_HOURS);
  I2C_Send(Base, 0x02);

  
  
  I2C_Stop(Base);

}

unsigned long RV3029_get_time(unsigned long Base, unsigned char *Data) {


  I2C_StartTX(Base, RV3029_EEPROM_SLAVE_write, 0);
  I2C_Send(Base, RV3029_SEC);
  I2C_StartRX(Base, RV3029_EEPROM_SLAVE_read, Data);

  Data[0] = I2C_Read(Base);
  Data[1] = I2C_Read(Base);
  Data[2] = I2C_Read(Base);

  UARTprintf("Uhrzeit: %02d:%02d:%02d\n", Data[2], Data[1], Data[0]);

  I2C_Stop();

Ist das so in ordnung, muss nur noch bcd to binary funktion 
hinzufügen.danke

[Mauer (Gast)]

Kann mir jemand sagen, ob die reihefolge, der Aufrufe der register 
richtig ist, oder habe ich da fehler drin.Danke.

[Gerhard G. (g_g)]

Hallo,

hier findest du den Einstieg: 
Beitrag "Re: Uhr mit RV-3029-C2"

1. internen Takt im Control-Register aktivieren
2. Sende Daten zum Stellen der Uhr (Register)
3. Auslesen

Gruß xmega

[Mauer (Gast)]

Muss ich da nicht erst die Write_adresse für die Uhr laden, dann den 
Takt aktivieren, danach die erste Adresse (sekunden) laden und danach 
die Daten für sek, min, und stunde eingeben, laut dem Datenblatt zählt 
er die Adressen ja selber hoch. Nochwas, hab den Beitrag schonmal vorher 
angeschaut den du gelinkt hast, wollt mal fragen, warum hat derjenige 
nicht die daten erst in bcd format umgewandelt, um in die uhr zu laden, 
die uhr kann doch nur das bcd format.Danke.

[Mauer (Gast)]

Hallo,
wollt mal fragen, ist die Startkondition nicht die, dass die 
Write_address initialisiert wird, oder was genau beinhaltet die 
Startkondition des I2C Moduls.Vor der aktivierung des Taktes wird doch 
die Startkondition gesetzt. oder nicht.

[Gerhard G. (xmega)]

Hallo,

bei dem Beispiel wird mit der I2C master library  von Peter Fleury
gearbeitet. Die enthält natürlich die einzelnen I2C-Befehle.

i2c_write(0x00);                       // Startaddresse
i2c_write(0xE9);                       // REG0
i2c_write(0x00);                       // REG1
i2c_stop();                            // Bus stop


Wenn du die Funktion i2c_write(0x00) z.B. aufdröselst, wirst du sehen, 
dass hier alle I2C-Standardbefehle angewandt werden. Das komplette 
Protokoll möchte ich hier nicht aufzählen.

Wenn du deine eigene Lib verwendest, musst du natürlich den richtigen 
Protokoll-Fluß beachten!

Ist jetzt dein Problem das I2C-Protokoll oder das Programmieren der RTC?

Stell das Problem BCD/HEX und umgekehrt mal in den Hintergrund, das ist 
dann, wenn dein Code mal funktioniert kein Problem.


Gruß xmega

[Mauer (Gast)]

Ich denk mal ich habe bisher imm er noch nicht geschafft, die Uhr zu 
aktivieren, bei der Ausgabe, gibt das Programm mir für sekunde, minute 
und stunde den Wert 255 zurück. Ich weiß nicht was ich noch machen soll. 
Brauche dringend Tipps.

Mein Code:

typedef struct {
  uint8_t sec;
  uint8_t min;
  uint8_t hour;
  } MY_BUFFER;

static MY_BUFFER rtc;

unsigned long RV3029_set_time(unsigned long Base) {

  I2C_StartTX(Base, RV3029_EEPROM_SLAVE_write, 0);
  I2C_Send(Base, RV3029_CTRL);
  I2C_Send(Base, 0xE9);
  I2C_Send(Base, 0x00);
  I2C_Stop(Base);

  I2C_StartTX(Base, RV3029_EEPROM_SLAVE_write, 0);
  I2C_Send(Base, RV3029_SEC);
  I2C_Send(Base, 0x09);
  I2C_Send(Base, 0x05);
  I2C_Send(Base, 0x02);
  I2C_Stop(Base);

}

unsigned long RV3029_get_time(unsigned long Base) {

  unsigned char Data[3];
  I2C_StartTX(Base, RV3029_EEPROM_SLAVE_write, 0);
  I2C_Send(Base, RV3029_SEC);
  I2C_Stop(Base);

  I2C_StartRX(Base, RV3029_EEPROM_SLAVE_read, Data);
  rtc.sec = I2C_Read(Base);
  rtc.min = I2C_Read(Base);
  rtc.hour = I2C_Read(Base);

 UARTprintf("Uhrzeit: %02d:%02d:%02d\n", rtc.hour, rtc.min, rtc.sec);

  I2C_Stop();
}

[Peter D. (peda)]

Mauer schrieb:
> unsigned long RV3029_set_time(unsigned long Base) {
Mauer schrieb:
> unsigned long RV3029_get_time(unsigned long Base) {

Wo ist der Returnwert dazu?
Du solltest die Compilermeldungen lesen, der meckert bei sowas.

Was ist Base?

Beim Lesen muß der Master ein ACK senden und nach dem letzten Byte ein 
NACK.


Peter

[Mauer (Gast)]

Was für ein return Wert, im code von Peter Fleury gibt es doch auch 
keinen Rückgabewert in der Funktion.

Base ist die Base Adresse des I2C Bus.

Und wie genau wird ein Acknowledge und Nack gesendet . Kannst du mir das 
am Beispiel von Peter Fleur zeigen.

Habs zwar im Datenblatt vom RV3029 nachgelesen, aber nicht so richtig 
verstanden, wie ich dies zu setzen habe.

Gruß

[Peter D. (peda)]

Mauer schrieb:
> Was für ein return Wert

Wenn Du eine Funktion als "unsigned long" definierst, dann mußt Du Dir 
doch dabei auch was gedacht haben.
Und der Compiler erwartet dann, daß an Ende ein "return irgendwas;" 
steht.

Mauer schrieb:
> Base ist die Base Adresse des I2C Bus.

D.h. also, Dein unbekannter MC hat mehrere I2C, die Deine unbekannte 
Lib für den unbekannten Compiler auswählt.

Es ist sehr unklug, wichtige Basisinformationen wegzulassen. Wenn keiner 
weiß, worum es überhaupt geht, sinkt die Hilfsbereitschaft rapide.

Grundlegende Informationen zur gesamten Entwicklungsumgebung sind nie 
verkehrt. Auch wenn später herauskommen sollte, daß das Problem ähnlich 
auch auf anderen Architekturen besteht.


Mauer schrieb:
> Und wie genau wird ein Acknowledge und Nack gesendet

Da mußt Du die Doku zu Deiner I2C-Lib lesen.
Die Fleury-Lib benutze ich nicht.

Ich benutze fast immer SW-I2C. Solange man I2C nicht als Interrupt 
macht, ist SW-I2C gleich schnell und gleich groß.


Peter

[Mauer (Gast)]

Danke für deine Hilfreiche Info, werd mich drum kümmern und meld mich 
wieder.

[Peter D. (peda)]

Hier mal mein SW-I2C:

Beitrag "Re: SPI und I²C zeitgleich benutzen"


Peter

[Mauer (Gast)]

Hallo,
ALso, ich weiß nicht warum aber die Uhr wird übehaupt nicht 
angesprochen, Die Uhr befindet sich auf einem Stellaris Board, hoffe 
dies sat euch etwas und wenn eigentlich sollte die Uhr ja mit dem Befehl

 I2C_StartTX(Base, RV3029_SLAVE_write, 0);

gestartet werden, aber leider passiert da nichts, Peter haste richtig 
erkannt, der Mc soll mehrere I2C haben, deshalb baue ich den so um, 
deshalb auch die Initialisierung mit der Base Adresse. Ich komm da net 
weiter.
Die Uhr wird net initialisiert, hab einbißchen umgebaut, nun sieht die 
Funktion so aus:

unsigned int RV3029_write(unsigned long Base, struct tm tm) {
    int Err;
    
    I2C_StartTX(Base, RV3029_SLAVE_write, 0);
    I2C_Send(Base, RV3029_CTRL);
    Err = I2C_Send(Base, 0xE9);
    //I2C_Stop(Base);
    if (Err)
      goto error;
    
    Err = I2C_Send(Base, RV3029_SEC);
    // If an error occurred, goto error handler
    if (Err)
      goto error;
    
      // .. keep transmitting data
      Err = I2C_Send(Base, tm.tm_sec);
      Err = I2C_Send(Base, tm.tm_min);
      Err = I2C_Send(Base, tm.tm_hour);

      // on error, goto error handler
      if (Err)
        goto error;
      // increment the Index
      i++;
      
      if ((RV3029_SEC + i) % RV3029_EEPROM_PAGE == 0) {
        break;
      }
    }
    // Send the stop condition
    I2C_Stop(Base);

    return Err;
  }

Wenn er den Err zurückliefert, heißt es, dass er die Uhr nicht 
initialisiert hat. Vielleicht hast du noch ein paar Tipps auf Lager was 
ich noch ausprobieren kann.Danke.