Pointer oder was?

[RTC (Gast)]

Aufgrund eines anderen Beitrags 
(Beitrag "RTC Inbetriebnahme STM32F4") der etwas abgeschweift 
ist, verfasse ich mal einen neuen mit passenderem Betreff.


"Nun verzweifel ich eher an der Rückgabe der Werte die per CAN versendet
werden sollen....
da ich mit Pointern arbeiten muss ist mir das alles noch nicht so ganz
klar."

Aufrufendes C File:

extern int *TimeStamp[3]={0,0,0};

  if (RxMessage.StdId == ID && d[0] == 0x54 && d[1] == 0x47){ //Anfrage mit ID und TG im Datenfeld Ruft Zeitstempel ab
    
      CanTxMsg TxMessage;
    
      ur_sh_get_rtc();
    
    
      TxMessage.StdId = ID;            //Standart Identifier
      TxMessage.RTR = CAN_RTR_DATA;       //Data frame
      TxMessage.IDE = CAN_ID_STD;         //Standart Identifier
      TxMessage.DLC = 3;                  //length of the frame
        
      TxMessage.Data[0] = *TimeStamp[0];
      TxMessage.Data[1] = *TimeStamp[1];
      TxMessage.Data[2] = *TimeStamp[2];
    
      CAN_Transmit(CAN2, &TxMessage);
  }

Aufgerufenes C File:

int* TimeStamp[3]={0,0,0};

void ur_sh_get_rtc(){
  RTC_TimeTypeDef RTC_TimeStructure;
  
  RTC_GetTime(RTC_Format_BCD, &RTC_TimeStructure);
  *TimeStamp[0] = RTC_TimeStructure.RTC_Hours;
  *TimeStamp[1] = RTC_TimeStructure.RTC_Minutes;
  *TimeStamp[2] = RTC_TimeStructure.RTC_Seconds;

  //RTC_GetTime(RTC_Format_BCD,);

  }

"Leider weigert sich der Compiler mit der Antwort das "TimeStamp" 
doppelt
deklariert sei.
Aber das ist es doch normalerweise durch "extern" nicht oder habe ich da
was falsch verstanden?"

[ttl (Gast)]

extern int *TimeStamp[];

nicht 2mal initialisieren

[Stefan F. (Gast)]

Wie genau stehen die beiden C File in Beziehung zueinander?

Ich frage, weil man nur Funktionen aufrufen kann, nicht Dateien. Die 
Beziehung zwischen der Datei mit der aufrufenden Funktion und der Datei 
mit der aufgerufenen Funktion stellt man üblicherweise mit Header 
Dateien her. Und darin befinden sich üblicherweise #ifdef Ausdrücke, die 
doppelte Definition verhindern.

Also wäre jetzt ganz interessant, die Include Statements in den 
betroffenen *.c dateien zu sehen, sowie den Inhalt der relevanten *.h 
Dateien.

[RTC (Gast)]

includieren tue ich nur die dateien die ich brauche von der 
stdperiphlib.
Alles andere trage ich immer händisch ein, zb so in der main:

#include "main.h"
#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_tim.h"
#include "misc.h"
#include "stm32f4xx_it.h"
#include "stm32f4xx_eeprom.h"
#include "stm32f4xx_flash.h"

uint32_t deviceserial0; 
void led_init(void);
void button_init(void);
void pwm_init(void);
void LED_An(void);
void LED_Aus(void);
void pwm_activate(void);
void pwm_deactivate(void);
void enable_on(void);
void enable_off(void);
void can_init(void);
void blac(void);
void delay_init(void);
int getid();
void delid(void);
void rtc_init(void);
void set_rtc();
int ur_sh_get_rtc();
int Done=0;
int Count=0;
int reset=0;

int main usw usw...

[Rufus Τ. F. (rufus)]

RTC schrieb:
> Alles andere trage ich immer händisch ein, zb so in der main:

Das solltest Du Dir wieder abgewöhnen.

[Stefan F. (Gast)]

Versuche mal, die Initialisierung weg zu nehmen, so das sie nicht 
doppelt vorkommt:

vorher: extern int *TimeStamp[3]={0,0,0};
nachher: extern int *TimeStamp[3];

[RTC (Gast)]

Hab es jetzt umgebaut und direkt reingestopft, da die Funktion nicht so 
wollte wie ich, auch die änderung der doppelten initialisierung hat 
leider nicht weitergeholfen.

Mittlerweile sieht es so aus:

  if (RxMessage.StdId == ID && d[0] == 0x54 && d[1] == 0x47){ //Anfrage mit ID und TG im Datenfeld Ruft Zeitstempel ab
  
      RTC_TimeTypeDef RTC_TimeStructure;
      CanTxMsg TxMessage;
    
      TxMessage.StdId = ID;            //Standart Identifier
      TxMessage.RTR = CAN_RTR_DATA;       //Data frame
      TxMessage.IDE = CAN_ID_STD;         //Standart Identifier
      TxMessage.DLC = 3;                  //length of the frame
    
      RTC_GetTime(RTC_Format_BCD, &RTC_TimeStructure);
      TxMessage.Data[0] = RTC_TimeStructure.RTC_Hours;
      TxMessage.Data[1] = RTC_TimeStructure.RTC_Minutes;
      TxMessage.Data[2] = RTC_TimeStructure.RTC_Seconds;
    
      CAN_Transmit(CAN2, &TxMessage);
  }

Leider ändert das nichts daran das die Uhr nur kurze Zeit richtig läuft 
und dann plötzlich um 20 Minuten hinterherhinkt und dann auf einmal 
wieder eine halbe stunde voraus....
Ich schätze mal das liegt an dem komischen BCD Format.
Ich rechne die Zeit immer vom Hexadezimalen ins Dezimale System um.
Bin ich da auf dem Holzweg?
Leider komme ich der Funktionalität der RTC noch nicht ganz auf die 
Schliche...

[holger (Gast)]

>Ich schätze mal das liegt an dem komischen BCD Format.

Dann nimm halt RTC_Format_BIN.

[Karl H. (kbuchegg)]

RTC schrieb:

> Ich schätze mal das liegt an dem komischen BCD Format.
> Ich rechne die Zeit immer vom Hexadezimalen ins Dezimale System um.
> Bin ich da auf dem Holzweg?


Wenn die Umrechnung richtig programmiert ist, dann nicht.
Aber ohne Code lässt sich das schwer sagen.

[DirkB (Gast)]

http://cdecl.org/ sagt zu int *TimeStamp[3] : declare TimeStamp as array 
3 of pointer to int

Willst du wirklich drei Zeiger auf int haben?
Und warum initialisierst du diese mit 0? (und nicht mit NULL)

[RTC (Gast)]

Gegenfrage (da ich im Programmieren noch nicht allzusehr bewandert bin 
:) )
Warum nicht als int?
Und 0 ist doch dasselbe wie NULL, ich dachte ob man das mit Buchstaben 
oder Zahlen macht ist ja eigentlich wurschtegal, bedeuten tut es ja 
dasselbe oder nicht?

[Karl H. (kbuchegg)]

RTC schrieb:
> Und 0 ist doch dasselbe wie NULL, ich dachte ob man das mit Buchstaben
> oder Zahlen macht ist ja eigentlich wurschtegal, bedeuten tut es ja
> dasselbe oder nicht?

Ja, es bedeutet dasselbe.
Aber die Verwendung von NULL ist ein Hinweis an den geneigten Leser des 
Codes, dass man es hier mit einem Pointer zu tun hat. Die Verwendung von 
NULL anstelle von 0 (und auch von '\0' anstelle von 0 in einem 
char-Kontext) ist eine Lesehilfe für diejenigen, die dann die Programme 
derjenigen korrigieren sollen, die sie selber mangels Überblick nicht 
mehr gebacken bekommen.

Merke: Ja, man kann in C optisch sehr dicht programmieren. Die Sprache 
lässt das zu. Aber ob das programmierstrategisch schlau ist, ist eine 
ganz andere Frage.

Zeit bei der Programmentwicklung spart man nicht dadurch, dass man sich 
3 Tastendrücke einspart. Jede Programmzeile wird ein mal geschrieben und 
vielleicht noch ein paar mal verändert. Aber sie wird im Laufe eines 
Programmlebens viele Zig-mal gelesen. Es ist daher schlauer, sich Code 
so zurecht zu legen, dass er gut gelesen werden kann. Und zwar so, dass 
man nicht ständig 300 Millionen Querverweise im Kopf haben muss und auch 
nicht so, dass man ständig im Code rumscrollen muss. Sondern so, dass 
man möglichst viel Information aus dem Code selber entnehmen kann. Je 
einfacher und schneller man eine Codezeile erfassen kann (in möglichst 
vielen Details), desto schneller und zuverlässiger geht das.

[Karl H. (kbuchegg)]

RTC schrieb:
> Gegenfrage (da ich im Programmieren noch nicht allzusehr bewandert bin
> :) )
> Warum nicht als int?

Die Frage ist nicht 'int oder nicht int'. Die Frage ist: 'Pointer oder 
nicht Pointer'!

Man verwendet keine Pointer, wenn man nicht muss. Du hast zwar im OT nur 
sehr wenig Umgebung gezeigt, aber aus dem Gezeigten erschliesst sich 
erst mal nicht, warum man hier Pointer einsetzen müsste. Ganz im 
Gegenteil sieht das hier

int* TimeStamp[3]={0,0,0};

void ur_sh_get_rtc(){
  RTC_TimeTypeDef RTC_TimeStructure;
  
  RTC_GetTime(RTC_Format_BCD, &RTC_TimeStructure);
  *TimeStamp[0] = RTC_TimeStructure.RTC_Hours;
  *TimeStamp[1] = RTC_TimeStructure.RTC_Minutes;
  *TimeStamp[2] = RTC_TimeStructure.RTC_Seconds;
...

erst mal nach einem Fehler aus. Denn die 3 Pointer zeigen ins nirgendwo. 
Dort kann man so erst mal keine int speichern.

Grundsätzlich: Eine Pointer Variable wie zb

  int * pI;

ist erst mal nur eine Variable, in der man die Adresse ablegen kann, wo 
man einen int speichern könnte. Aber der Speicher, in dem dann der int 
tatsächlich gespeichert werden kann, der existiert dadurch noch nicht. 
Das ist ein bischen so, wie der Unterschied zwischen deinem 
Telefon-Adressbuch und der realen Person. Im Adressbuch steht, wo die 
Person wohnt. Aber das ist was anderes, wie das Haus in dem die Person 
dann tatsächlich wohnt.

   pI
  +---------+
  | NULL    |
  +---------+

Bis jetzt existiert nur die Pointer Variable. Dort wird eine Adresse 
gespeichert.

  int * pI = NULL;
  int   dieVariable = 5;

   pI
  +---------+
  | NULL    |
  +---------+

                          dieVariable
                          +----------+
                          |     5    |
                          +----------+

 Zum Beispiel die Adresse einer int Variablen

  int * pI = NULL;
  int   dieVariable = 5;

  pI = &dieVariable;

   pI
  +---------+
  |   o     |
  +---|-----+
      |
      |                   dieVariable
      |                   +----------+
      +------------------>|    5     |
                          +----------+

in der dann der gewünschte Wert tatsächlich abgelegt werden kann

  int * pI = NULL;
  int   dieVariable = 5;

  pI = &dieVariable;
  *pI = 8;

   pI
  +---------+
  |   o     |
  +---|-----+
      |
      |                   dieVariable
      |                   +----------+
      +------------------>|    8     |
                          +----------+

Gibt es aber keine Speicherfläche, in der ein int abgelegt wird, zeigt 
der Pointer daher irgendwohin in den Speicher

  int * pI;
  int   dieVariable = 5;

  *pI = 8;

   pI
  +---------+
  |   o     |
  +---|-----+
      +------------------------------------->  8
                          dieVariable
                          +----------+
                          |    5     |
                          +----------+

dann schreibst du irgendwo in den Speicher. Wo genau hängt vom Zufall 
und dem genauen Programmablauf ab. Aber auf jeden Fall ist das kein 
Speicher, der in irgendeiner Form zur gezielten Verwendung für dein 
Programm reserviert wurde. Dort im Speicher kann alles mögliche liegen. 
zb. auch andere Variablen, die dann magisch urplötzlich ihren Wert 
ändern. zb. auch wichtige Systeminformationen, wie zb Stackwerte, die 
das Programm benötigt, um aus Funktionen wieder zum Aufrufer 
zurückzufinden. Was genau da im Speicher überbügelt wird, kann man nur 
mittels aufwändigen Analysen herausfinden. Es ist im Grunde aber egal, 
denn Fehler ist Fehler und so etwas ist nun mal ein schwerwiegender 
Fehler.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Zeit bei der Programmentwicklung spart man nicht dadurch, dass man sich
> 3 Tastendrücke einspart. Jede Programmzeile wird ein mal geschrieben und
> vielleicht noch ein paar mal verändert. Aber sie wird im Laufe eines
> Programmlebens viele Zig-mal gelesen. Es ist daher schlauer, sich Code
> so zurecht zu legen, dass er gut gelesen werden kann. Und zwar so, dass
> man nicht ständig 300 Millionen Querverweise im Kopf haben muss und auch
> nicht so, dass man ständig im Code rumscrollen muss. Sondern so, dass
> man möglichst viel Information aus dem Code selber entnehmen kann. Je
> einfacher und schneller man eine Codezeile erfassen kann (in möglichst
> vielen Details), desto schneller und zuverlässiger geht das.

Aus dem gleichen Grund ist auch

  if (RxMessage.StdId == ID &&
      d[0] == 'T' && d[1] == 'G' ) {
   ...

um Welten besser als

  if (RxMessage.StdId == ID && d[0] == 0x54 && d[1] == 0x47){ //Anfrage mit ID und TG im Datenfeld Ruft Zeitstempel ab

Dass dieses 'TG' in deinem Kommentar ernst zu nehmen ist und was es 
bedeutet, hab ich erst rausgefunden, als ich probehalber 0x54 und 0x47 
in einer ASCII Tabelle nachgeschlagen habe.
Völlig sinnlos.
Wenn du 'T' meinst, dann schreib auch 'T' und nicht 0x54!

[RTC (Gast)]

Hallo Karl Heinz,
vielen Dank für die Super Erklärung!
Endlich hab auch ich das mal mit den Pointern kapiert! :)

if (RxMessage.StdId == ID &&
      d[0] == 'T' && d[1] == 'G' ) {
   ...

Wäre mir eigentilch auch lieber, nur leider reagiert der Mikrocontroller 
dann nicht wenn ich ihm die entsprechenden Datenpakete über CAN schicke, 
da ich in der Software nur HEX Werte versenden kann.

Mittlerweile habe ich dank der Tipps die RTC auch zum laufen gebracht 
mit plausiblen Werten, nur leider läuft sie etwas zu schnell, obwohl die 
Prescaler laut Datenblatt richtig gesetzt wurden.
Ist die Abweichung erfahrungsgemäß wirklich so groß, dass bei der Wahl 
des LSI Taktes die RTC nach einer Minute schon 4 Sekunden zu schnell 
ist?
Da ich das erste mal mit der RTC arbeite, kann ich die Abweichungen noch 
nicht wirklich einschätzen.

void ur_sh_rtc_init(void){

  RTC_InitTypeDef  RTC_InitStructure;
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);

  PWR_BackupAccessCmd(ENABLE);

  RCC_BackupResetCmd(ENABLE);
  RCC_BackupResetCmd(DISABLE);

  RCC_LSICmd(ENABLE);

  while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)  { }

  RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);

  RCC_RTCCLKCmd(ENABLE);

  RTC_WaitForSynchro();

  //Prescaler wählen
  //LSI = 32 kHz    127      249      1Hz
  RTC_InitStructure.RTC_AsynchPrediv = 127;
  RTC_InitStructure.RTC_SynchPrediv  = 249;    // (32KHz / 128) - 1 = 249
  RTC_InitStructure.RTC_HourFormat   = RTC_HourFormat_24;
  RTC_Init(&RTC_InitStructure);

}

[Rufus Τ. F. (rufus)]

RTC schrieb:
> wäre mir eigentilch auch lieber, nur leider reagiert der Mikrocontroller
> dann nicht wenn ich ihm die entsprechenden Datenpakete über CAN schicke,
> da ich in der Software nur HEX Werte versenden kann.

Du hast da, so glaube ich, was grundlegendes noch nicht verstanden.

0x54 ist dasselbe wie 'T'.

Der Compiler erzeugt exakt denselben Binärcode, ob da in Deinem 
Quelltext nun das eine oder das andere steht.

[RTC (Gast)]

Doch habe ich, vielleicht habe ich mich falsch ausgedrückt.
Da ich nur Hex Werte über meine CAN Schnittstelle jagen kann, ist es 
(zumindest momentan) übersichtlicher wenn man sieht was man gerade 
versendet und wo es im Code sitzt.
Sorry dafür.

[RTC (Gast)]

Aber ihr habt recht, der Übersichtlichkeit halber werde ich das später 
mit den Buchstaben trotzdem umsetzen.

Hat noch jemand einen Tipp zwecks der Einstellung des Prescalers, denn 
die Uhr läuft immernoch zu schnell und was ich bemerkt habe, sie startet 
urplötzlich wieder von 00:00:00 ab, ohne das eine veränderung 
meinerseits erfolgt ist.

[ter oder (Gast)]

>Da ich nur Hex Werte über meine CAN Schnittstelle jagen kann, ist es

Das ist grober Unsinn.

"Hex Werte" gibt es nur in der String-Darstellung!

[Rufus Τ. F. (rufus)]

Vermutlich (hoffentlich) meint er eine Einschränkung der Software, mit 
denen er die CAN-Telegramme erzeugt, vielleicht ist das ja so etwas wie 
das "Terminalprogramm" hTerm.