R8C: Variablen spinnen

OP #1502205
Lesenswert?

Desöfteren habe ich bereits Prjekte mit dem R8C Elektor Board 
realisiert, welche bisher auch einwandfrei funktionieren.
Jetzt stehe ich jedoch vor einem Problem, das mich schon mehrere Tage 
beschäftigt.

Im Grunde soll das Projekt eine simple Uhr darstellen, die mithilfe von 
vier 7-Segmentanzeigen die Uhrzeit anzeigen soll (Stunde und Minute).

Nun hier mal die grundlegenden, dafür zuständigen Codeausschnitte:

Variablen:
1
#define SEG1_sperren p0_4
2
#define SEG2_sperren p0_5  
3
#define SEG3_sperren p0_6
4
#define SEG4_sperren p0_7
5

6
int Stunde_Zehner = 0;
7
int Stunde_Einer = 0;
8
int Minute_Zehner = 0;
9
int Minute_Einer = 0;
10
int Sekunde_Zehner = 0;
11
int Sekunde_Einer = 0;
12
int Sekunde = 0;
13

14
int SEG1_neu = 0;
15
int SEG1_alt = 0;
16
int SEG2_neu = 0;
17
int SEG2_alt = 0;
18
int SEG3_neu = 0;
19
int SEG3_alt = 0;
20
int SEG4_neu = 0;
21
int SEG4_alt = 0;


Funktionen:
1
void SEG1_Ausgabe(int Wert1)
2
{
3
  SEG1_neu = Wert1;
4
  
5
  if(SEG1_neu != SEG1_alt)
6
  {    
7
    SEG1_sperren = FALSE;  // Sperre SEG1 aufheben
8
    BCD_Ausgabe(Wert1);  // BCD Wert ausgeben
9
    SEG1_sperren = TRUE;  // Sperre SEG1 aktivieren
10
      
11
    SEG1_alt = Wert1;
12
  }
13
}
14
  
15
void SEG2_Ausgabe(int Wert2)
16
{
17
  SEG2_neu = Wert2;
18
    
19
  if(SEG2_neu != SEG2_alt)
20
  {
21
    SEG2_sperren = FALSE;
22
    BCD_Ausgabe(Wert2);
23
    SEG2_sperren = TRUE;
24
      
25
    SEG2_alt = Wert2;
26
  }
27
}
28
  
29
void SEG3_Ausgabe(int Wert3)
30
{
31
  SEG3_neu = Wert3;
32
    
33
  if(SEG3_neu != SEG3_alt)
34
  {    
35
    SEG3_sperren = FALSE;
36
    BCD_Ausgabe(Wert3);
37
    SEG3_sperren = TRUE;
38
      
39
    SEG3_alt = Wert3;
40
  }
41
}
42
  
43
void SEG4_Ausgabe(int Wert4)
44
{
45
        SEG4_neu = Wert4;
46
    
47
  if(SEG4_neu != SEG4_alt)
48
  {    
49
    SEG4_sperren = FALSE;
50
    BCD_Ausgabe(Wert4);
51
    SEG4_sperren = TRUE;
52
      
53
    SEG4_alt = Wert4;
54
  }
55
}


Wenn ich nun in der Main folgendes aufrufe...
1
while(1)
2
{    
3
  SEG1_Ausgabe(1);
4
  SEG2_Ausgabe(2);
5
  SEG3_Ausgabe(3);
6
  SEG4_Ausgabe(4);
7
}
...funktioniert alles perfekt.
Auch bei anderen Werten die ich direkt (ohne Variable) der Funktion 
übergebe.

Nun zum Problem:
wenn ich die übergegebenen Werte testweise durch meine Variablen 
ersetze...
1
while(1)
2
{    
3
  SEG1_Ausgabe(1);
4
  SEG2_Ausgabe(2);
5
  SEG3_Ausgabe(Minute_Zehner);
6
  SEG4_Ausgabe(Minute_Einer);
7
}
...in der bereits die richtigen Werte stehen, wird immer der Wert vom 
vorhergehenden Element übernommen.

Kurz:
Übergebe ich von 1 nach 4 zum Beispiel 5, 6, Variable1, Variable2
steht auf den Segmenten 5666

Oder:
Übergebe ich von 1 nach 4 zum Beispiel 3, Variable1, Variable2, 6
steht auf den Segmenten 3336

Zu geringe Umschaltzeiten an den Segmenten konnte ich bereits 
ausschließen-

Es ist etwas schwer auszudrücken, aber ich hoffe ihr versteht mein 
Problem.
Hat jemand eine Idee?
#1502211
Lesenswert?

Sven B. schrieb:

> Es ist etwas schwer auszudrücken, aber ich hoffe ihr versteht mein
> Problem.

Nicht wirklich.
Woher weiß eigentlich BCD_Ausgabe, was es zu tun hat?


(Ist das ganze ein Multiplex? Wenn ja, wie sieht die Funktion dazu aus? 
Auch scheint mir, dass da ein paar volatile fehlen, aber ohne kompletten 
Code ist das schwer zu sagen)
OP #1502216
Lesenswert?

BCD_Ausgabe regelt nur die ausgebenden Pins
1
void BCD_Ausgabe(int BCD)    // BCD Werte übergeben
2
{
3
  if(BCD == 0)
4
  {
5
    BCD1 = 0;               // BCD A p1_0
6
    BCD2 = 0;               // BCD B p1_1
7
    BCD3 = 0;               // BCD C p1_2
8
    BCD4 = 0;               // BCD D p1_3
9
  }
10

11
        .
12
        .  geht so von 0 bis 9
13
        .
14
  
15
  if(BCD == 9)
16
  {
17
    BCD1 = 1;
18
    BCD2 = 0;
19
    BCD3 = 0;
20
    BCD4 = 1;
21
  }
22
}


Gemultiplext wird zum jetzigen Zeitpunkt noch nichts.
Ich möchte lediglich, dass die Segmente ersteinmal mit den Variablen 
richtig funktionieren.
#1502223
Lesenswert?

Aha.
Dann wird das Mulitplexing hierdurch erledigt

while(1)
{
  SEG1_Ausgabe(1);
  SEG2_Ausgabe(2);
  SEG3_Ausgabe(Minute_Zehner);
  SEG4_Ausgabe(Minute_Einer);
}

Da frage ich mich allerdings, warum du erwartest, dass du überhaupt 
etwas passiert. Schliesslich machst du die Ausgabe ja nur dann


  SEG3_neu = Wert3;

  if(SEG3_neu != SEG3_alt)


Wenn sich die Stelle geändert hat.

Lass diese Neu/Alt Optimierung mal weg. Zum momentanen Zeitpunkt bist du 
darauf angewiesen, dass wenn du SEG3_Ausgabe aufrufst, auch tatsächlich 
eine Ausgabe auf das Segment 3 gemacht wird.
Gast #1502358
Lesenswert?

Mal eine bloeder Frage, aber du hast doch einen
Sourceleveldebugger. Warum geht du nicht einfach mal
mit Singlestep durch dein Program, schaust dir dabei
gleichzeitig den Inhalt deiner Variablen an, und kuckst
ob dein Programm sich so verhaelt wie es das deiner
Meinung nach sollte?

Olaf
#1502512
Lesenswert?

Probier mal einen Cast, also etwa "SEG3_Ausgabe((int) Minute_Zehner);"
Sollte der Compiler zwar von sich aus wissen, aber ich hatte mit dem 
Renesas Compiler schon ne Menge Probleme in dieser Richtung. Was 
passiert denn, wenn man "SEG3_Ausgabe((int) 3);" oder so schreibt?

Das einem "pd_0 = ...;" ein "prc2 = 1;" vorgestellt werden muss, dürfte 
hier nicht das Problem sein denke ich, sonst würde es ja gar nicht 
funktionieren.
Gast #1503931
Lesenswert?

>> by the way: Warum muss es eigentlich "int" sein? "unsigned char" oder
>> ein anderer 8-bitter würde es sicher auch tun (0...255).

schnell, dann BUS Breite: 16 Bit
sparsam, dann Wertemenge: hier 8 Bit

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren