Bitte um Hilfe bei DS1307 Problem

[Dominik G. (moondryl)]

Hallo,
nachdem ich I2C nun doch noch zum Laufen gebracht habe, sitze ich nun 
wieder vor einem Problem:

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <uart.h>
#include <avr/interrupt.h>
#include <i2cmaster.h>

#define UART_BAUD_RATE 9600

#define DS1307  0xD0

unsigned char buffer;
char seconds;


char decToBcd(char val)
{
  return ((val / 10 * 16) + (val % 10));
}

// Convert binary coded decimal to normal decimal numbers
char bcdToDec(char val)
{
  return ((val / 16 * 10) + (val % 16));
}

int main(void)
{
  sei();
  DDRB = (1 << PB0);
  
  
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); //uart initialisieren
  i2c_init(); //i2c initialisieren
  
  //schreibe CH-Bit
  i2c_start_wait(DS1307+I2C_WRITE);
  i2c_write(0x81);
  i2c_stop();
  //*schreibe CH Bit
  
  //CH Bit gesetzt?
  i2c_start_wait(DS1307+I2C_WRITE);
  i2c_write(0x00);
  i2c_rep_start(DS1307+I2C_READ);
  buffer = i2c_readNak();
  i2c_stop();
  
  if ((buffer & 0x80)) //Falls CH Bit gesetzt ==> löschen
  {
    i2c_start_wait(DS1307+I2C_WRITE);
    i2c_write(0x00);
    i2c_write((buffer & 0x7F));
    i2c_stop();
    uart_puts("CH Bit gelöscht\n");
  }
      
  
    while(1)
    {
        PORTB ^= ( 1 << PB0 );  // Toggle PB0 
    
        i2c_start_wait(DS1307+I2C_WRITE);
        i2c_write(0x00); //Seconds Register
        i2c_rep_start(DS1307+I2C_READ);
        buffer = i2c_readNak(); // read seconds
        i2c_stop();
  
        seconds = bcdToDec((buffer & 0x7F));
      
        _delay_ms(500); 
    }
}

(1) Obwohl ich Anfang im Seconds Register zwangsweise das CH-Bit setze, 
scheint das Programm nicht in die If-Abfrage reinzugehen, um das Bit 
wieder zu löschen.

(2) In seconds sollen ja jetzt die Sekunden stehen. So wie ich Peter 
Fleury's UART-Library verstanden habe, kann ich seconds ja nicht einfach 
uart_puts(); übergeben. Kann ich das nun in einen String umwandeln?

Hoffe, ihr könnt mir einen Tipp geben.

Grüße

Dominik

[Karl H. (kbuchegg)]

Dominik Gebhardt schrieb:

> (2) In seconds sollen ja jetzt die Sekunden stehen. So wie ich Peter
> Fleury's UART-Library verstanden habe, kann ich seconds ja nicht einfach
> uart_puts(); übergeben. Kann ich das nun in einen String umwandeln?

FAQ gleich der erste Punkt

[Karl H. (kbuchegg)]

Die Überlegung, die dich zu diesem Code gebracht hat

  //schreibe CH-Bit
  i2c_start_wait(DS1307+I2C_WRITE);
  i2c_write(0x81);
  i2c_stop();
  //*schreibe CH Bit

ist mit unklar.

Nachdem du den Slave adressiert hast, ist das erste Byte, welches da auf 
den Weg bringst, die Register Adresse. Das wäre bei dir 0x81. Das ist 
aber nicht das, was du willst. Du willst ja das Register 0 adressieren 
und dort die 0x81 (also BCD-01 plus gesetztes CH-Bit) einschreiben.
Also müsste das lauten

//schreibe CH-Bit
  i2c_start_wait(DS1307+I2C_WRITE);
  i2c_write(0x00);
  i2c_write(0x81);
  i2c_stop();
  //*schreibe CH Bit

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:
> Dominik Gebhardt schrieb:
>
>> (2) In seconds sollen ja jetzt die Sekunden stehen. So wie ich Peter
>> Fleury's UART-Library verstanden habe, kann ich seconds ja nicht einfach
>> uart_puts(); übergeben. Kann ich das nun in einen String umwandeln?
>
> FAQ gleich der erste Punkt


Obwohl.
Bei dir gehts viel einfacher. Genau das ist ja der springende Punkt, 
warum die Uhr überhaupt in BCD zählt. Eben weil man dann ganz trivial 
eine Textrepräsentierung der Zahl erzeugen kann, ohne viel rechnen zu 
müssen.

        ....

        buffer = i2c_readNak(); // read seconds
        i2c_stop();
  
        char num[3];
        num[0] = (( buffer & 0x7F ) >> 4 ) + '0';
        num[1] = (( buffer & 0x0F ) + '0';
        num[2] = '\0';

        uart_puts( num );
        uart_puts( "\n" );

        ....

[Dominik G. (moondryl)]

Asche auf mein Haupt!
Weiter unten immer darauf geachtet, dass ich erst die Adresse schreibe 
und dann das Byte und dort vergessen; peinlich.

Danke dir, Karl Heinz. Funktioniert nun so, wie es soll.

Vielen Dank euch beiden für die sehr schnelle Hilfe! :)

Viele Grüße

Dominik

Edit: Gerade nochmal den die verlinkten FAQ angesehen. Mit itoa(); hatte 
ich es probiert. Allerdings stand in meiner Variablen Müll drin, 
weswegen ich es wieder verworfen hatte. Dann war ich ja doch auf der 
richtigen Fährte und meine Umrechnung stimmt doch nicht.

[Karl H. (kbuchegg)]

Dominik Gebhardt schrieb:

> weswegen ich es wieder verworfen hatte. Dann war ich ja doch auf der
> richtigen Fährte und meine Umrechnung stimmt doch nicht.

Was mir als allererstes aufgefallen ist.

Wenn du in deinem Code mit 'Bytes' operierst, dann ist der Datentyp 
dafür ein 'unsigned char' oder noch besser ein 'uint8_t'. Aber 'char' 
ist nicht der Datentyp, den du für Arbeiten mit Bytes benutzen willst. 
Bei 'char' ist nicht festgelegt, ob der ein Vorzeichen hat oder nicht. 
Du willst kein Vorzeichen und zwar willst du das ganz sicher nicht. 
Daher willst du dich auch nicht deinem Compilerbauer ausliefern, wie er 
das für char festgelegt hat. An dieser Stelle bist du lieber explizit 
und verlangst einen uint8_t

D.h. das hier

char decToBcd(char val)
{
  return ((val / 10 * 16) + (val % 10));
}

ist besser als

uint8_t decToBcd(uint8_t val)
{
  return ((val / 10 * 16) + (val % 10));
}

(und die Umkehrung genauso.)

Und genauso willst du einen

uint8_t seconds;

und keinen char. Denn Sekunden sind nun mal nicht negativ.

[Karl H. (kbuchegg)]

Dominik Gebhardt schrieb:


> Edit: Gerade nochmal den die verlinkten FAQ angesehen. Mit itoa(); hatte
> ich es probiert.

itoa      für einen int oder int8_t. Also etwas mit Vorzeichen
utoa      für einen unsigned int oder uint8_t. Also etwas ohne 
Vorzeichen


Es obligt deiner Verantwortung, die richtige Funktion zu benutzen! itoa 
bzw. utoa ist das wurscht! Die Funktion schnappt sich die übergebenen 
Bytes und interpretiert sich diese Bytes als mit/ohne Vorzeichen, je 
nach Funktion.

[Karl H. (kbuchegg)]

Dominik Gebhardt schrieb:
> Asche auf mein Haupt!
> Weiter unten immer darauf geachtet, dass ich erst die Adresse schreibe
> und dann das Byte und dort vergessen; peinlich.

Jetzt weißt du, warum man sich für alles mögliche Funktionen schreibt 
:-)

[Dominik G. (moondryl)]

Oh man, immer wenn ich denke, ich kann jetzt einen Schritt vorwärts 
gehen, habe ich das Gefühl, dass ich doch wieder zwei zurück gehe. :D

> itoa      für einen int oder int8_t. Also etwas mit Vorzeichen
> utoa      für einen unsigned int oder uint8_t. Also etwas ohne
> Vorzeichen

Genau, hatte halt den Fehler gemacht char statt unsigned char zu 
verwenden. Deswegen hatte ich noch itoa(); genutzt.


> Jetzt weißt du, warum man sich für alles mögliche Funktionen schreibt
> :-)

Damit man nicht einmal den Fehler, obwohl man es sonst immer richtig 
gemacht hat. Gleich mal eine Funktion geschrieben, in der man explizit 
Adresse, Adressregister und Inhalt übergeben muss. :)

Eine Frage zu deiner Berechnung habe ich aber gerade noch:

char num[3];
        num[0] = (( buffer & 0x7F ) >> 4 ) + '0'; 
        num[1] = (( buffer & 0x0F ) + '0';
        num[2] = '\0';

Die Bitmasken sind klar und die Bitverschiebung bei num[0] ist auch 
klar. Aber wozu das +'0'? Hat das eine ähnliche Funktion wie '\0'? ('\0' 
bezeichnet ja das Stringende).

Grüße und nochmals Danke für die ganzen Informationen!

[Uwe (de0508)]

Hallo,

num[0] und num[1] enthält dann die Dezimalzahl, derer vorher in BCD 
repräsentierten Zahl.

Somit enthält num[] einen C-String mit der BCD-Zahl als String.

[Karl H. (kbuchegg)]

Dominik Gebhardt schrieb:


> Die Bitmasken sind klar und die Bitverschiebung bei num[0] ist auch
> klar. Aber wozu das +'0'?

Weil am anderen Ende deiner UART ein Terminal sitzt. Und das will ASCII 
Codes sehen, damit es was auf den Monitor hinpinselt.

Nach dem Ausmaskieren und Verschieben hast du bereits numerische Ziffern 
von 0 bis 9. Die sind gut, kannst sie aber noch nicht gebrauchen. Damit 
das Terminal das Zeichen '0' hinpinselt, musst du ihm den ASCII Code für 
'0' schicken und nicht die Zahl 0. Damit es eine '1' hinpinselt, musst 
du ihm den ASCII Code für '1' schicken und nicht die Zahl 1. Damit ....

Glücklicherweise sind im ASCII Code die Codes für die Ziffernzeichen 
genau so angeordnet, dass sie hintereinander kommen. D.h. wenn du zum 
ASCII Code von '0' noch 5 dazuzählst, kriegst du den ASCII Code des 
Zeichens '5'.

Und da uns das zu fad ist, uns selber aus einer ASCII Tabelle 
rauszusuchen, welches der ASCII Code für '0' ist (der wäre 0x30), lassen 
wir das den Compiler machen. Der kann das genausogut, indem ich ihm 
einfach das Zeichen hinschreibe und ich muss mich nicht mit 
irgendwelchen Hex-Codes als ASCII Codes rumplagen. Wenn ich in c

   char c;

den ASCII Code des Zeichens 'p' haben will, dann schreibe ich auch

    c = 'p';

und nicht

    c = 0x70;

oder gar

    c = 112;

obwohl technisch gesehen alle 3 Varianten genau dasselbe machen. Für die 
Maschine mag das dasselbe sein (nämlich ein immer gleiches Bitmuster in 
den Character c zu laden), aber für mich als Mensch macht das einen 
gewaltigen Unterschied. Bei  c = 'p' sehe ich auf einen Blick was Sache 
ist. Bei c = 112 seh ich erst mal gar nichts, sondern muss eine ASCII 
Tabelle zu Hilfe nehmen, um zu wissen welchen ASCII Code ich da gerade 
in c gespeichert habe.


In der EDV sind alles Zahlen! Auch Zeichen sind Zahlen. Wenn dein 
Terminal ein 'A' auf den Bildschirm malt, dann deswegen, weil es ein 
Byte mit dem Wert 0x41 bekommen hat und das laut ASCII Tabelle der Code 
für 'A' ist.

[Dominik G. (moondryl)]

Bis zu dem Punkt, dass in num[x] dann die einzelnen Zahlen für Zehner 
und Einser stehen, hatte ich es verstanden. Aber dass das '0' also 
ASCII-Code addiert wird und mann dann auf den ASCII-Code für z.B. 5 
kommt, war mir nicht klar.

Vielen Dank für die asuführliche Erklärung und für eure Geduld mit mir!
Nun ist aber alles klar!
Konnte jetzt auch meine Berechnungsfunktion korrekt über den UART 
ausgeben. Nun weiß ich auch, warum da vorher Murks drin stand. Deine 
Berechnung für BCD ist aber durchaus eleganter und hier auch 
einleuchtender als meins und werde es deshalb auch beibehalten. Wollte 
nur wissen, ob ich jetzt alles richtig verstanden habe und es auch mit 
dem alten Code zum Laufen bekomme. Dank eurer Hilfe ist dem jetzt so! :)

Vielen Dank und viele Grüße

Dominik