Nullstellenunterdrückung bei 7 Segment

[Tommy (Gast)]

Hallo!!
Hab da eine Frage.Vielleicht kann mir wer weiter helfen.

Hab eine Anzeige mit 7 segmentanzeigen zusammengestellt die mir Tage 
anzeigen soll.Das tut sie auch.Aber bin nur im stande die erst "0" zu 
unterdrücken. Denn Nullen vor der Zahl kann ich nicht gebrauchen.Also 
kein "0001" oder "0156". Da die erste Null schon wegfällt zeigt sie mir 
eh nur noch "_001"
"_002 .,._010 " an.wie bekomme ich dass mit den beiden anderen Nullen 
auch hin.

Select Case Bcd_aus

    Case 1 : Ausgang = Lookup(1 , Segmentfolge)             'Tag - 9999
    Case 2 : Ausgang = Lookup(2 , Segmentfolge)             'Tag - 999
    Case 3 : Ausgang = Lookup(3 , Segmentfolge)             'Tag - 99
    Case 4 : Ausgang = Lookup(4 , Segmentfolge)             'Tag - 9
    Case 5 : Ausgang = Lookup(5 , Segmentfolge)
    Case 6 : Ausgang = Lookup(6 , Segmentfolge)
    Case 7 : Ausgang = Lookup(7 , Segmentfolge)
    Case 8 : Ausgang = Lookup(8 , Segmentfolge)
    Case 9 : Ausgang = Lookup(9 , Segmentfolge)
    Case 0 And Temp_ziffer = 1 : Ausgang = Lookup(10 , Segmentfolge) 
'Nullstellenunterdrückung  bei der ersten Ziffer
    Case 0 And Temp_ziffer > 1 : Ausgang = Lookup(0 , Segmentfolge)



Danke schon mal im Vorraus!

[Jens G. (jensig)]

Man klappert einfach von links nach rechts die dargestellten Digit-Werte 
ab, und wenn der 0 ist, wird dieses Digit abgeschaltet. Das macht man 
mit jedem weiteren Digit so, bis ein Digit dann mal >0 hat - dann 
aufhören mit abklappern.

[Tommy (Gast)]

Und wie schaut das dan aus? :)

[Tommy (Gast)]

Danke,ich habs!


    Case 1 : Ausgang = Lookup(1 , Segmentfolge)
    Case 2 : Ausgang = Lookup(2 , Segmentfolge)
    Case 3 : Ausgang = Lookup(3 , Segmentfolge)
    Case 4 : Ausgang = Lookup(4 , Segmentfolge)
    Case 5 : Ausgang = Lookup(5 , Segmentfolge)
    Case 6 : Ausgang = Lookup(6 , Segmentfolge)
    Case 7 : Ausgang = Lookup(7 , Segmentfolge)
    Case 8 : Ausgang = Lookup(8 , Segmentfolge)
    Case 9 : Ausgang = Lookup(9 , Segmentfolge)
    Case 0 And Temp_ziffer = 1 : Ausgang = Lookup(10 , Segmentfolge)
    Case 0 And Temp_ziffer = 1 And Temp_ziffer = 2 : Ausgang = Lookup(10
Segmentfolge)

    Case 0 And Temp_ziffer = 1 And Temp_ziffer = 2 And Temp_ziffer = 3 : 
Ausgang = Lookup(10 , Segmentfolge)

    Case 0 And Temp_ziffer > 1 : Ausgang = Lookup(0 , Segmentfolge)

[Peter D. (peda)]

Tommy schrieb:
> Temp_ziffer = 1 And Temp_ziffer = 2

Die Logik mußt Du mir mal erklären.
Wie kann Temp_ziffer 1 und 2 gleichzeitig sein?

Üblicher Weise macht man die Vornullenunterdrückung bei der Zerlegung 
der Zahl in Ziffern.

[oldmax (Gast)]

Hi
Oooch PeDa, ist doch ganz klar die Logik für die Konstante "0"

gruß oldmax

[Christoph db1uq K. (christoph_kessler)]

FRÜHER (TM) hat man das so gemacht (Aus dem Datenblatt zum 74LS47 von 
ti.com)
Der Decoder hat einen "ripple blanking input" RBI und einen ...output 
RBO.
Wird eine Vornullenunterdrückung gewünscht, dann legt man den 
höchstwertigen RBI auf low und verbindet die RBO jeweils mit dem RBI der 
nächst niedrigeren Stelle.

[oldmax (Gast)]

Hi
Sorry, korrigiere -  Konstante "false".
Gruß

[Tommy (Gast)]

nein,so funst es eh nicht.da is mir ein fehler unterlaufen.i hab es 
schon richtig gehabt.weiss aber nicht mehr wie ich das gemacht hab.
ich weiss nicht mehr weiter . :)

[Wolfgang (Gast)]

Tommy schrieb:
> i hab es schon richtig gehabt.weiss aber nicht mehr wie ich das
> gemacht hab.
Das ist doch schon eine wertvolle Erkenntnis. Dann hast du jetzt 
gelernt, wozu bei der Softwareentwicklung eine Versionsverwaltung gut 
ist, nämlich damit du jederzeit auf eine ältere Version zurückgehen und 
nachvollziehen kannst, welche Ursachen z.B. so ein Fehlverhalten hat.

[Jörg W. (dl8dtl) (Moderator)]

sprintf(puffer, "%4d", tage);

;-)

void zerlege_tage(char buf[4], unsigned int tage)
{
  if (tage > 9999)
    return; /* Überlauf: raus hier */
  memset(buf, ' ', 4); /* Leerzeichen füllen */
  int i = 3;           /* von hinten beginnend ... */
  while (tage > 0)     /* solange noch was zu tun ist */
  {
    unsigned int stelle = tage % 10; /* aktuelle Stelle: Tage modulus 10 */
    buf[i] = stelle + '0';  /* in Zeichen wandeln */
    tage = tage / 10;       /* Rest für nächste Stelle */
    i--;                    /* eine Stelle nach vorn */
  }
}

In BASIC musst du dir den Algorithmus aber selbst umschreiben.

[Tommy (Gast)]

Kann mir wer helfen??



' µC Deklarationen
$regfile = "m8def.DAT" 
'ATmega48-Deklarationen
$crystal = 3686400


' Variablen
Dim Temp_ziffer As Byte                                     'welche 
ziffer soll bearbeitet werden
Dim Bcd_aus As Byte                                         'enthält den 
Wert der dez zahl die ausgegeben werden soll

Dim Ausgang As Byte 
'Segmentfolge die Ausgegeben wird aus Segmentcode - Tabelle
Dim Sek_blink As Bit                                        'Blinkt im 
Sekunden Takt

Dim Zl_sekunde As Byte                                      'Zeit 
Variablen
Dim Zl_minute As Byte                                       'enthalten 
die Uhrzeit
Dim Zl_stunde As Byte
Dim Zl_tag As Byte
Dim Zl_tag99 As Byte
Dim Zh_sekunde As Byte                                      'Zl-... => 
Low Wert der Zeit                                      'Zh-... => High 
Wert der Zeit
Dim Zh_minute As Byte
Dim Zh_stunde As Byte
Dim Zh_tag As Byte
Dim Zh_tag99 As Byte



' Ein-/Ausgänge
Config Portb = Output                                       '7 Sekment
Config Portc.0 = Input
Config Portc.1 = Input
Config Portc.2 = Input
Config Portc.3 = Input
Config Portc.4 = Output
Config Portc.5 = Output

Ddrd = &B11111111                                           '1 Ausgang, 
0 Eingang
'Portd = &B00000000                                          '1 = PullUp 
aktiviert Eingang (Taster gegen Masse)
Portc = &B00001111
'Ausgänge:
Segment_a Alias Portb.0
Segment_b Alias Portb.1
Segment_c Alias Portb.2
Segment_d Alias Portb.3
Segment_e Alias Portb.4
Segment_f Alias Portb.5
Segment_g Alias Portc.4
Dezimalpunkt Alias Portc.5
Ziffer_1 Alias Portd.0                                      't
Ziffer_2 Alias Portd.1                                      't
Ziffer_3 Alias Portd.2                                      't
Ziffer_4 Alias Portd.3                                      't
Ziffer_5 Alias Portd.4                                      'St h
Ziffer_6 Alias Portd.5                                      'St l
Ziffer_7 Alias Portd.6                                      'Min h
Ziffer_8 Alias Portd.7                                      'Min l

'Eingänge:
T_min_stellen Alias Pinc.0
T_h_stellen Alias Pinc.1
T_t_stellen Alias Pinc.2
T_reset Alias Pinc.3

' Sonstiges
Const Load_timer1 = 57600                                   'Konstande 
auf die der Timer1 geladen wird
'4MHz = 62755 | 62760 etwas zu langsam <> 62750 etwas zu schnell! 
Weniger ist Schneller
'$crystal = 3686400 = 57600


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Timer0 für Multiplexausgabe
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++

On Timer0 7segment 
'Interrupt-Routine für Timer0-Overflow
Config Timer0 = Timer , Prescale = 8                        'Takt: 
Quarz/Prescale  (möglich: 1, 8, 64, 256, 1024)
Enable Timer0 
'Timer0-Overflow-Interrupt einschalten


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Timer 1 als Zeitbasis
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++

On Timer1 Sekunde_plus 
'Interrupt-Routine für Timer1-Overflow
Config Timer1 = Timer , Prescale = 1                        'Takt: 
Quarz/Prescale  (möglich: 1, 8, 64, 256, 1024)
Enable Timer1 
'Timer0-Overflow-Interrupt einschalten
Enable Interrupts                                           'Interrupts 
global zulassen
Load Timer1 , Load_timer1                                   'Lädt den 
Timer auf einen wert vor


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Hauptprogramm
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++


Do


                                                     'Start 
Hauptschleife

' ### Uhren Code ###
' Es wird für jede Ziffer einzelnd gezählt, das ermöglicht eine 
einfacher ausgabe
' auf den 7segmentanzeigen. Der Zählvorgang funktioniert ím prinzip wie 
z.B.
' bei einem normalen Logik Zähler-IC

If Zl_sekunde = 10 Then                                     'Wenn der 
Sekunden Low Wert = 10
Zl_sekunde = 0                                              'wird er auf 
0 gesetzt
Incr Zh_sekunde                                             'und der 
High Wert um eins erhöht
   If Zh_sekunde = 6 Then                                   'Ist der 
High Wert 6 (entspricht 60 Sekunden)
   Zh_sekunde = 0                                           'wird er auf 
0 gesetzt
   Incr Zl_minute                                           'und der 
Minuten Low Wert um eins erhöht
   End If
End If


If Zl_minute = 10 Then
   Zl_minute = 0
   Incr Zh_minute
End If


If Zh_minute = 6 Then
   Zh_minute = 0
   Incr Zl_stunde
End If


If Zl_stunde = 10 Then
   Zl_stunde = 0
   Incr Zh_stunde
End If





If Zh_stunde = 2 And Zl_stunde = 4 Then
   Zl_stunde = 0
   Zh_stunde = 0
   Incr Zl_tag
End If

If Zl_tag = 10 Then
   Zl_tag = 0
   Incr Zh_tag
End If

If Zh_tag = 10 Then
   Zh_tag = 0
   Incr Zl_tag99
End If
    If Zl_tag99 = 10 Then
    Zl_tag99 = 0
    Incr Zh_tag99
    End If






' ### Uhr stellen ###
' Wird der Taster "T_min_stellen" betätigt werden die Minuten um eins 
erhöht.
' Wird der Taster "T_h_stellen" betätigt werden die Stunden um eins 
erhöht.
' Werden beide gleichzeitig betätigt werden Stunden und Minuten auf Null 
gesetzt.
' Wird einer der Taster länger betätigt (> 150ms) gibt es einen 
schnellvorlauf

If T_min_stellen = 0 Then                                   'Wird 
"T_min_stellen" betätigt und ist es eine pos. Flanke
   Waitms 150                                               'Entprellen
   If T_min_stellen = 0 Then                                'Ist der 
Taster immer noch betätigt
   Incr Zl_minute                                           'wird Minute 
um eins erhöht
   Zl_sekunde = 0                                           'Sekunden 
auf Null setzen
   Zh_sekunde = 0
   End If
End If

                                                                   'betätigt, 
wird das Bit 0 von Variable "Flanke" auf 0 gesetzt
If T_h_stellen = 0 Then
    Waitms 150
    If T_h_stellen = 0 Then
    Incr Zl_stunde
    Zl_sekunde = 0
    Zh_sekunde = 0
    End If
End If

If T_t_stellen = 0 Then                                     'Wird 
"T_min_stellen" betätigt und ist es eine pos. Flanke
   Waitms 150                                               'Entprellen
   If T_t_stellen = 0 Then                                  'Ist der 
Taster immer noch betätigt
   Incr Zl_tag                                              'wird Minute 
um eins erhöht

   End If
End If


If T_reset = 0 Then


    Zl_tag = 0                                              'dann werden 
Minuten und Stunden auf 0 gestzt
    Zh_tag = 0
    Zl_tag99 = 0
    Zh_tag99 = 0

End If






If T_min_stellen = 0 And T_h_stellen = 0 Then
    Zl_sekunde = 0
    Zh_sekunde = 0                                          'Wenn 
"T_Min_stellen" und "T_H_stellen" gleichzeitig betätigt
    Zl_minute = 0                                           'dann werden 
Minuten und Stunden auf 0 gestzt
    Zh_minute = 0
    Zl_stunde = 0
    Zh_stunde = 0                                           'wird Minute 
um eins erhöht
End If


Loop                                                        'Ende 
Hauptschleife

End                                                         'Programm 
Ende


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Interrupt-Routine für Ziffer ausgabe im 7 Segmentcode
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Bei jedem Aufruf wir nur eine Ziffer ausgegeben, d.h nur eine Anzeige 
wird
' angesteuert. Die anderen bleiben dunkel. Bei jedem Aufruf wird eine 
Anzeige
' weitergeschaltet.
'
' Anzeigen anordnung
'
' 1111  2222   3333  4444
' 1  1  2  2   3  3  4  4
' 1111  2222   3333  4444
' 1  1  2  2   3  3  4  4
' 1111o 2222o  3333o 4444o
'
'                        ^-- Dezimalpunkt
'                      ^---- 4. Ziffer | Minute Low Wert  | Variable 
Zl_minute
'                ^---------- 3. Ziffer | Minute High Wert | Variable 
Zh_minute
'         ^----------------- 2. Ziffer | Stunde Low Wert  | Variable 
Zl_stunde
'   ^----------------------- 1. Ziffer | Stunde High Wert | Variable 
Zh_stunde


7segment:

If Temp_ziffer = 4 Then Temp_ziffer = 0                     'bestimmt 
die auszugebende Ziffer (1 bis 4)
Incr Temp_ziffer                                            'bei jedem 
aufruf des Lable wir eine andere Ziffer ausgegeben


Portb = &B11111111
Portc = &B00111111                                          'Alle 
Ziffern aus, ansonsten gibt es "Geister" Anzeigen


Select Case Temp_ziffer
                                     'welche Ziffer soll angesteuert 
werden
   Case 1 : Ziffer_1 = 1                                    '1. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 0
            Ziffer_4 = 0
            Ziffer_5 = 0
            Ziffer_6 = 0
            Ziffer_7 = 0
            Ziffer_8 = 0
            Bcd_aus = Zh_tag99

   Case 2 : Ziffer_1 = 0                                    '2. Ziffer
            Ziffer_2 = 1
            Ziffer_3 = 0
            Ziffer_4 = 0
            Ziffer_5 = 0
            Ziffer_6 = 0
            Ziffer_7 = 0
            Ziffer_8 = 0
            Bcd_aus = Zl_tag99

   Case 3 : Ziffer_1 = 0                                    '3. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 1
            Ziffer_4 = 0
            Ziffer_5 = 0
            Ziffer_6 = 0
            Ziffer_7 = 0
            Ziffer_8 = 0
            Bcd_aus = Zh_tag

   Case 4 : Ziffer_1 = 0                                    '4. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 0
            Ziffer_4 = 1
            Ziffer_5 = 0
            Ziffer_6 = 0
            Ziffer_7 = 0
            Ziffer_8 = 0
            Bcd_aus = Zl_tag

   Case 5 : Ziffer_1 = 0                                    '3. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 0
            Ziffer_4 = 0
            Ziffer_5 = 1
            Ziffer_6 = 0
            Ziffer_7 = 0
            Ziffer_8 = 0
            Bcd_aus = Zh_stunde

   Case 6 : Ziffer_1 = 0                                    '4. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 0
            Ziffer_4 = 0
            Ziffer_5 = 0
            Ziffer_6 = 1
            Ziffer_7 = 0
            Ziffer_8 = 0
            Dezimalpunkt = Sek_blink
            Bcd_aus = Zl_stunde

   Case 7 : Ziffer_1 = 0                                     '3. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 0
            Ziffer_4 = 0
            Ziffer_5 = 0
            Ziffer_6 = 0
            Ziffer_7 = 1
            Ziffer_8 = 0
            Bcd_aus = Zh_minute

   Case 8 : Ziffer_1 = 0                                    '4. Ziffer
            Ziffer_2 = 0
            Ziffer_3 = 0
            Ziffer_4 = 0
            Ziffer_5 = 0
            Ziffer_6 = 0
            Ziffer_7 = 0
            Ziffer_8 = 1
            Bcd_aus = Zl_minute


End Select


'Ermittelt aus der Segmentfolge-Tabelle den 7 Segmentcode für die 
auszugebende Zahl
Select Case Bcd_aus




    Case 1 : Ausgang = Lookup(1 , Segmentfolge)             'Ziffer Tag 
- 9---

                               '1 Anzeigen wenn 1 gewünscht

    Case 2 : Ausgang = Lookup(2 , Segmentfolge)             'Ziffer Tag 
- -9--

                               '2 Anzeigen wenn 2 gewünscht

    Case 3 : Ausgang = Lookup(3 , Segmentfolge)             'Ziffer Tag 
- --9-

                               '3 Anzeigen wenn 3 gewünscht

    Case 4 : Ausgang = Lookup(4 , Segmentfolge)             'Ziffer Tag 
- ---9

                               '4 Anzeigen wenn 4 gewünscht

    Case 5 : Ausgang = Lookup(5 , Segmentfolge)

                               '5 Anzeigen wenn 5 gewünscht

    Case 6 : Ausgang = Lookup(6 , Segmentfolge)

                               '6 Anzeigen wenn 6 gewünscht

    Case 7 : Ausgang = Lookup(7 , Segmentfolge)

                               '7 Anzeigen wenn 7 gewünscht

    Case 8 : Ausgang = Lookup(8 , Segmentfolge)

                               '8 Anzeigen wenn 8 gewünscht

    Case 9 : Ausgang = Lookup(9 , Segmentfolge)

                               '9 Anzeigen wenn 9 gewünscht

    Case 0 And Temp_ziffer = 1 : Ausgang = Lookup(10 , Segmentfolge) 
'Nullstellenunterdrückung  bei der ersten Ziffer

    Case 0 And Temp_ziffer > 1 : Ausgang = Lookup(0 , Segmentfolge) 
'wenn nicht erste Ziffer Null anzeigen








End Select


'Ausgabe des 7 Segmentcodes (Invertierend [Not] bei Anz. mit gem. Anode)
Segment_a = Not Ausgang.0                                   'Segment A
Segment_b = Not Ausgang.1                                   'Segment B
Segment_c = Not Ausgang.2                                   'Segment C
Segment_d = Not Ausgang.3                                   'Segment D
Segment_e = Not Ausgang.4                                   'Segment E
Segment_f = Not Ausgang.5                                   'Segment F
Segment_g = Not Ausgang.6                                   'Segment G


Return


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Interrupt-Routine für Timer1 / Zeitbasis
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++

Sekunde_plus:


Load Timer1 , Load_timer1                                   'Lädt den 
Timer auf einen wert vor

Incr Zl_sekunde                                             'Erhöht den 
Low Wert der Sekunde um eins

Toggle Sek_blink                                            'Ändert sich 
jede Sek., 1sec an 1sec aus


Return



'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' 7 Segmentcode - Tabelle
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
'
' --A--
' |   |
' F   B
' |   |
' --G--
' |   |
' E   C
' |   |
' --D--


Segmentfolge:                                               'GFEDCBA / 
"1" Segment AN


Data &B0111111                                              '0
Data &B0000110                                              '1
Data &B1011011                                              '2
Data &B1001111                                              '3
Data &B1100110                                              '4
Data &B1101101                                              '5
Data &B1111101                                              '6
Data &B0000111                                              '7
Data &B1111111                                              '8
Data &B1101111                                              '9

Data &B0000000                                              'leeres Feld 
(zur Nullstellenunterdrückung)

[Karl H. (kbuchegg)]

(Wahnsinn, ist das kompliziert.)


Aber wo ist denn bei dir das Problem?
Du hast 2 stellige Zahlen und willst eine führende 0 unterdrücken. Das 
ist doch nun wirklich nicht schwer:
  Wenn die Zehnerstelle 0 ist, dann gibst du statt dessen halt ein
  leeres Feld aus und sonst das Muster für die Ziffer an dieser
  Zehner-Stelle.
  Bei der Einer-Stelle machst du das nicht und gibst jede Ziffer so wie
  sie ist aus.
  Fertig ist die Unterdrückung der führenden 0




Es ist sowieso Unsinn die ganze Zerlegung und umkodierung in die 
7-Segment Codes jedes mal wieder in der Interrupt Routine zu machen.

Dafür hätte das weiterschalten der Sekunden zu Minuten zu Stunden zu 
Tagen in die Timer Interrupt Routine gehört.

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:

> Aber wo ist denn bei dir das Problem?
> Du hast 2 stellige Zahlen und willst eine führende 0 unterdrücken. Das
> ist doch nun wirklich nicht schwer:
>   Wenn die Zehnerstelle 0 ist, dann gibst du statt dessen halt ein
>   leeres Feld aus und sonst das Muster für die Ziffer an dieser
>   Zehner-Stelle.
>   Bei der Einer-Stelle machst du das nicht und gibst jede Ziffer so wie
>   sie ist aus.
>   Fertig ist die Unterdrückung der führenden 0

Entschuldigung. Deine Tage sind ja 4-stellig.
Aber sie sind immer 4-stellig. Was mit den Zehnern geht, geht auch mit 
den Hundertern und den Tausendern.

Solange du das nicht allgemein für beliebige Zahlen brauchst, ist das 
doch kein Problem.

[Karl H. (kbuchegg)]

Und PS (ich kann das nicht länger sehen)

Was ist der Unterschied zwischen

Select Case Bcd_aus




    Case 1 : Ausgang = Lookup(1 , Segmentfolge)             'Ziffer Tag 
- 9---

                               '1 Anzeigen wenn 1 gewünscht

    Case 2 : Ausgang = Lookup(2 , Segmentfolge)             'Ziffer Tag 
- -9--

                               '2 Anzeigen wenn 2 gewünscht

  .... etc. etc.

und

     Ausgang = Lookup( Bcd, Segmentfolge )

richtig. Du brauchst 3 Seiten Code für etwas, was man in 1 Zeile 
ausdrücken kann.
Und das was du da mit den ganzen Ziffern_x Variablen aufgeführt hast, 
kann man ähnlich kompakt machen.

[Tommy (Gast)]

ja aber ist egal wie ich dass schreibe,irgendwas passt immer nicht.
sobald ich die '0' unterdrückt hab ist diese auf der ziffer immer 
weg.das heisst dann  _ _ 1 - _ _ 99 dann steht wieder  1_0 - _999.


ich brauch doch nur an den beiden zeilen rumschreiben,oder??



    Case 0 And Temp_ziffer = 1 : Ausgang = Lookup(10 , Segmentfolge)
'Nullstellenunterdrückung  bei der ersten Ziffer

    Case 0 And Temp_ziffer > 1 : Ausgang = Lookup(0 , Segmentfolge)
'wenn nicht erste Ziffer Null anzeigen

[Karl H. (kbuchegg)]

Ganz ehrlich.

Schreibs noch mal neu.
Das ist alles deutlich zu kompliziert und unübersichtlich.

Beginne damit, dass du dir erst mal ein Array aus 8 Byte machst, die du 
in der Interrupt Routine reihum ausgibst.  Nicht mehr. Die Interrupt 
Routine soll sich nicht mehr darum kümmern, was diese Bytes bedeutet. 
Für die Interrupt Rouine sind das einfach nur noch die Codes, welche 
Segmente der 7-Segment Anzeige gerade leuchten sollen oder nicht. Für 
jede Stelle der 7-Segment gibt es 1 Byte in diesem Array. In der 
Interrupt Routine werden die reihum einfach nur noch ausgegeben.

Dass dann daraus lesbare Zahlen entstehen, dafür sorgt derjenige, der 
die entsprechenden Codes in dieses Array schreibt. Wer auch immer das 
ist (spielt jetzt noch keine Rolle) und was auch immer der da 
reinschreibt.


Das ist dein erstes Zwischenziel.
(Die Uhr ist momentan noch völlig egal. Die kommt später)

[Tommy (Gast)]

die Uhr braucht auch keiner mehr.hab den code einer Uhr umgeschrieben da 
ich ja einen Tageszähler brauch.die uhr fällt komplett weg. habs nur 
noch im code stehen lassen.der code muss doch so zu bearbeiten sein,das 
die '0' vor der zahl vaschwindn.das kann doch nicht sein.  :)

[Karl H. (kbuchegg)]

Es ist auch ziemmlich simpel.

Nur ist der ganze Code verbockt und gehört erst mal korrigiert und in 
vernünftige Bahnen gebracht. So wie er jetzt ist, ist es wahnsinnig 
umständlich das nachzurüsten.

Wenn du die Uhr sowieso nicht brauchst, dann fang neu an und machs 
diesmal ordentlich. Und deine Probleme lösen sich nahezu in Luft auf. 
Das ganze Konzept, wie der Code zur Zeit ist, ist ganz einfach nicht 
tragfähig und flexibel genug. Das ist ja kein Vorwurf an den, der den 
Code geschrieben hat.

[Karl H. (kbuchegg)]

Probier mal diesen Code aus.
Mir geht es jetzt erst mal darum, ob ich deine Hardware richtig aus dem 
Code rausgelesen habe.
Das Programm müsste dir auf den 8 Stellen der Anzeige die Folge 76543210 
anzeigen. Stimmt das?

' µC Deklarationen
$regfile = "m8def.DAT"
$crystal = 3686400
$hwstack = 32                                               ' default use 32 for the hardware stack
$swstack = 10                                               ' default use 10 for the SW stack
$framesize = 40                                             ' default use 40 for the frame space




'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Timer0 für Multiplexausgabe
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

On Timer0 7segment
'Interrupt-Routine für Timer0-Overflow
Config Timer0 = Timer , Prescale = 8
Tcnt0 = 0
Enable Timer0
'Timer0-Overflow-Interrupt einschalten


Config Portd = Output                                       ' Stellentreiber
Config Portb = Output
Config Portc.4 = Output

Segment_a Alias Portb.0
Segment_b Alias Portb.1
Segment_c Alias Portb.2
Segment_d Alias Portb.3
Segment_e Alias Portb.4
Segment_f Alias Portb.5
Segment_g Alias Portc.4


Dim Ausgabestelle As Byte
Dim Ausgang As Byte
Dim Stelle As Byte

Dim Code(8) As Byte


Code(1) = Lookup(0 , Segmentfolge)
Code(2) = Lookup(1 , Segmentfolge)
Code(3) = Lookup(2 , Segmentfolge)
Code(4) = Lookup(3 , Segmentfolge)
Code(5) = Lookup(4 , Segmentfolge)
Code(6) = Lookup(5 , Segmentfolge)
Code(7) = Lookup(6 , Segmentfolge)
Code(8) = Lookup(7 , Segmentfolge)

Enable Interrupts

Do
Loop

End

7segment:

  Portd = 0                                                 ' alles aus

  Ausgabestelle = Ausgabestelle + 1
  If Ausgabestelle = 8 Then
    Ausgabestelle = 0
  End If

  Ausgang = Code(ausgabestelle + 1)
  'Ausgabe des 7 Segmentcodes (Invertierend [Not] bei Anz. mit gem. Anode)
  Segment_a = Not Ausgang.0
  Segment_b = Not Ausgang.1
  Segment_c = Not Ausgang.2
  Segment_d = Not Ausgang.3
  Segment_e = Not Ausgang.4
  Segment_f = Not Ausgang.5
  Segment_g = Not Ausgang.6

  Stelle = Lookup(ausgabestelle , Digitcode )

  Portd = Stelle

Return

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' 7 Segmentcode - Tabelle
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'
' --A--
' |   |
' F   B
' |   |
' --G--
' |   |
' E   C
' |   |
' --D--


Segmentfolge:                                               'GFEDCBA / "1" Segment AN


Data &B0111111                                              '0
Data &B0000110                                              '1
Data &B1011011                                              '2
Data &B1001111                                              '3
Data &B1100110                                              '4
Data &B1101101                                              '5
Data &B1111101                                              '6
Data &B0000111                                              '7
Data &B1111111                                              '8
Data &B1101111                                              '9

Data &B0000000                                              'leeres Feld (zur Nullstellenunterdrückung)

Digitcode:
Data &B00000001
Data &B00000010
Data &B00000100
Data &B00001000
Data &B00010000
Data &B00100000
Data &B01000000
Data &B10000000

[Tommy (Gast)]

ja das tut es! toll,und danke dass du dich damit auseinand setzt.find 
ich toll.
76543210
wobei die 4567 nicht nötig sind.ausser mann könnte auch die uhr über 
tasterdruck auslesen und einstellen dass diese im hintergrund mitläuft 
um eben gewährleisten zu können,dass der tageszähler um 0.00 uhr um eins 
weiterzählt.

[Karl H. (kbuchegg)]

Tommy schrieb:
> ja das tut es!

Gut.

Jetzt hast du erst mal einen einfachen Multiplex.

jetzt geht es darum eine Funktkion zu schreiben, die eine Zahl in die 
einzelnen Stellen zerlegt und dabei gleich die führenden 0-en 
unterdrückt.

> wobei die 4567 nicht nötig sind.

Wurscht

> ausser mann könnte auch die uhr über
> tasterdruck auslesen und einstellen dass diese im hintergrund mitläuft
> um eben gewährleisten zu können,dass der tageszähler um 0.00 uhr um eins
> weiterzählt.

Was jetzt?
Uhr oder nicht Uhr?

[Tommy (Gast)]

nein,wie gesagt,ich gebe mich auch ohne Uhr Zufriedn.
Find ich echt super,dass du dich so einsetzt.danke nochmal.schön das es 
in diesem Forum noch Tüftler gib wie dich!!

[Karl H. (kbuchegg)]

Gut. Müsste funktionieren. Der Code zählt in der Variablen Zahl einen 
Zähler von 0 beginnend durch.

Studier den Code.
Insbesondere die Sub 'Show'.
Dort steckt das Geheimnis drinnen, wie führende 0-en unterdrückt werden.

Show gibt eine maximal 4-stellige Zahl aus, indem es die Zahl in die 
einzelnen Stellen zerlegt und entscheidet, ob die Stelle überhaupt 
angezeigt werden muss, oder ob an dieser Stelle nicht eigentlich schon 
eine führende 0 sein sollte, die mit dem 10.ten Zeichen in der 
'Code-Tabelle' dargestellt wird.

' µC Deklarationen
$regfile = "m8def.DAT"
$crystal = 3686400
$hwstack = 32                                               ' default use 32 for the hardware stack
$swstack = 10                                               ' default use 10 for the SW stack
$framesize = 40                                             ' default use 40 for the frame space




'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Timer0 für Multiplexausgabe
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

On Timer0 7segment
'Interrupt-Routine für Timer0-Overflow
Config Timer0 = Timer , Prescale = 8
Tcnt0 = 0
Enable Timer0
'Timer0-Overflow-Interrupt einschalten


Config Portd = Output                                       ' Stellentreiber
Config Portb = Output
Config Portc.4 = Output

Segment_a Alias Portb.0
Segment_b Alias Portb.1
Segment_c Alias Portb.2
Segment_d Alias Portb.3
Segment_e Alias Portb.4
Segment_f Alias Portb.5
Segment_g Alias Portc.4


Dim Ausgabestelle As Byte
Dim Ausgang As Byte
Dim Stelle As Byte
Dim Digit As Byte
Dim I As Byte
Dim Zahl As Word
Dim Code(8) As Byte

Declare Sub Clear7Seg()
Declare Sub Show(byval Nr As Word )

Enable Interrupts

Call Clear7seg()

Zahl = 0
Do
  Call Show(zahl)
  Wait 1
  Zahl = Zahl + 1
  If Zahl = 10000 Then
    Zahl = 0
  End If
Loop

End

Sub Clear7seg()
  For I = 1 To 8
    Code(I) = Lookup(10 , Segmentfolge)
  Next I
End Sub

Sub Show(byval Nr As Word )
  For I = 1 To 4
    Digit = Nr Mod 10
    If I = 1 Or Nr > 0 Then
      Code(i) = Lookup(digit , Segmentfolge)
    Else
      Code(i) = Lookup(10 , Segmentfolge)
    End If
    Nr = Nr / 10
  Next I
End Sub

7segment:

  Portd = 0                                                 ' alles aus

  Ausgabestelle = Ausgabestelle + 1
  If Ausgabestelle = 8 Then
    Ausgabestelle = 0
  End If

  Ausgang = Code(ausgabestelle + 1)
  'Ausgabe des 7 Segmentcodes (Invertierend [Not] bei Anz. mit gem. Anode)
  Segment_a = Not Ausgang.0
  Segment_b = Not Ausgang.1
  Segment_c = Not Ausgang.2
  Segment_d = Not Ausgang.3
  Segment_e = Not Ausgang.4
  Segment_f = Not Ausgang.5
  Segment_g = Not Ausgang.6

  Stelle = Lookup(ausgabestelle , Digitcode )

  Portd = Stelle

Return

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' 7 Segmentcode - Tabelle
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'
' --A--
' |   |
' F   B
' |   |
' --G--
' |   |
' E   C
' |   |
' --D--


Segmentfolge:                                               'GFEDCBA / "1" Segment AN


Data &B0111111                                              '0
Data &B0000110                                              '1
Data &B1011011                                              '2
Data &B1001111                                              '3
Data &B1100110                                              '4
Data &B1101101                                              '5
Data &B1111101                                              '6
Data &B0000111                                              '7
Data &B1111111                                              '8
Data &B1101111                                              '9

Data &B0000000                                              'leeres Feld (zur Nullstellenunterdrückung)

Digitcode:
Data &B00000001
Data &B00000010
Data &B00000100
Data &B00001000
Data &B00010000
Data &B00100000
Data &B01000000
Data &B10000000

[Karl H. (kbuchegg)]

Tommy schrieb:
> nein,wie gesagt,ich gebe mich auch ohne Uhr Zufriedn.

Klar kann man auch eine Uhr ausgeben. Oder jede andere Zahl, die du 
willst. Alles was du tun musst, ist an das entsprechende Array-Element 
'Code' den Wert zuzuweisen, den du mit dem Lookup kriegst.

Soll an die 6.te Stelle eine 7 dargestellt werden, dann eben

   Code(6) = Lookup( 7, segmentfolge )

Oder eben dann auch mit Variablen. Je nachdem was du halt brauchst.

Du kannst auch was anderes darstellen. Zb ein -
Du musst nur an Code, an der betreffenden Stelle, das LED-Muster 
einschreiben, derjenigen LED die leuchten sollen. Fertig.
Die Multiplexroutine kümmert sich um den Rest, so dass dieses Muster 
dann auch an dieser Stelle angezeigt wird.

[Tommy (Gast)]

Fehlermeldung:


:(

[Karl H. (kbuchegg)]

Tommy schrieb:
> Fehlermeldung:
>

Entweder ist dir beim Rauskopieren was passiert, oder mir beim 
Reinkopieren.
Ich häng noch mal das File so an, wie es ist

[Tommy (Gast)]

Hier in Bascom

[Tommy (Gast)]

keine ahnung was da los is. de fehlmeldunge werden mehr.

[Tommy (Gast)]

nach mehrmaligen versuchen wieder die selben fehler. beim kopiere ist 
mir nix passiert.

[Karl H. (kbuchegg)]

Starte BASCOM mal neu.
Meines hat das nicht.

[Tommy (Gast)]

immer noch das selbe.kannst mir ein Screenshot machen?
zum vergleich.

[Tommy (Gast)]

jetz hau ich mich mal nieder.morgen ist doch auch noch ein tag.aber 
nochmal
ein grosses dankeschön für deine mithilfe.meld mich morgen wieder.

[Jörg W. (dl8dtl) (Moderator)]

Karl Heinz Buchegger schrieb:
> Starte BASCOM mal neu.
> Meines hat das nicht.

Du schreckst auch vor nichts zurück, oder? :-)

[Tommy (Gast)]

Jörg Wunsch schrieb:
> Karl Heinz Buchegger schrieb:
>> Starte BASCOM mal neu.
>> Meines hat das nicht.
>
> Du schreckst auch vor nichts zurück, oder? :-)

Wer??  :)  :)

[Karl H. (kbuchegg)]

Jörg Wunsch schrieb:
> Karl Heinz Buchegger schrieb:
>> Starte BASCOM mal neu.
>> Meines hat das nicht.
>
> Du schreckst auch vor nichts zurück, oder? :-)

Man muss ja auch der Jugend mal zeigen, wie es richtig geht.
Ich kann zwar BASCOM nicht, aber das was er da ursprünglich abgeliefert 
hat, das geht doch auf keine Kuhhaut. Das kann sogar ich als 
Nicht-BASCOM Programmierer sehen, dass er sich da komplett verlaufen hat 
und jetzt bildlich gesprochen sich nicht traut aus der Sackgasse erst 
mal wieder rauszukommen, in die er sich da manövriert hat.
Gehört auch zum Lernprozess dazu, dass man mal über seinen Schatten 
springt und nicht an dem klebt was man schon hat, sondern Code auch mal 
verwirft wenn man so einfach nicht mehr weiter kommt.


Was sein BASCOM da allerdings hat, kann ich auch nicht sagen. Am Code 
liegts nicht, ich schätze mal das hat irgendwas mit der Installation 
oder den Projekt-Einstellungen zu tun.
Eventuell könnte es noch was mit den HW-Stack, SW-Stack bzw. 
Frameeinstellungen ganz am Anfang des COdes zu tun haben. Aber da kenn 
ich mich nicht aus, die hab ich auch einfach von anderem Code 
übernommen.

[Tommy (Gast)]

das mein code nicht die feinste ware ist,weiss ich ja.
aber aus hobbyprogrammierer und nicht elektroniker ist das eigendlich 
nicht so schlecht,denn es funktioniert ja.auch wenns der volle horor 
ist.
ich werd am  Karl Heinz seinem cod natürlich dran bleibm den der gefällt 
mir sowiso besser. und da bedanke ich mich nochmal für die mühe.
 HW-Stack, SW-Stack bzw.
Frameeinstellungen ist eine möglichkeit.auch das werde ich 
versuchen.danke!!  :)

[Jörg W. (dl8dtl) (Moderator)]

Tommy schrieb:
> HW-Stack, SW-Stack bzw.
> Frameeinstellungen ist eine möglichkeit.

Hast du das BASCOM denn gekauft?  Dann solltest du doch Support dafür
haben, der einem Fragen nach solcherart Fehlermeldungen beantworten
kann, oder?  Vielleicht führt das ja schneller zum Ziel als
Herumprobieren.

[Karl H. (kbuchegg)]

Jörg Wunsch schrieb:
> Tommy schrieb:
>> HW-Stack, SW-Stack bzw.
>> Frameeinstellungen ist eine möglichkeit.
>
> Hast du das BASCOM denn gekauft?

Nö. Demo-Download
gestern noch schnell von MCS geholt, installiert und Programm 
geschrieben. Hab ein bischen gebraucht, bis ich raus hatte, warum im 
Simulator keine Timer laufen (diese Funktionalität muss extra aktiviert 
werden), aber dann liefs eigentlich ganz gut.

  Dann solltest du doch Support dafür
> haben, der einem Fragen nach solcherart Fehlermeldungen beantworten
> kann, oder?  Vielleicht führt das ja schneller zum Ziel als
> Herumprobieren.


Wie gesagt: Bei meiner Installation hab ich das Problem nicht. Meines 
compiliert und simuliert einwandfrei

[Tommy (Gast)]

Jörg Wunsch schrieb:


> Hast du das BASCOM denn gekauft?

nein,ich hab die 4kb frei version.
probiern ist ja nichts schlechtes.nur so hab ich es überhaupt geschafft 
soweit zu kommen!geduld ist auch genug vorhanden :)
doch irgendwann ist auch die vorbei.überhaupt wenn es dann an so 
kleinigkeiten scheitert.

[Peter D. (peda)]

Bevor man anfängt, unüberschaubare Codemonster hinzuklotzen, sollte man 
das hier verinnerlichen:

Divide et impera
(Teile und herrsche)

Also einfach jede Aufgabe in kleine Teile aufspalten, bis es nicht mehr 
kleiner geht. Sinnvoll zusammenfassen kann man hinterher immer noch.

Hier wären die Teile:
1. Zerlegung der Zahl in Ziffern
2. Umwandlung der Ziffern in 7-Segment-Code
3. Nullunterdrückung.

Da ich kein Bascom kann, hier als Beispiel in C:

#define _A      0x01
#define _B      0x02
#define _C      0x04
#define _D      0x08
#define _E      0x10
#define _F      0x20
#define _G      0x40

#define _0      _A+_B+_C+_D+_E+_F
#define _1         _B+_C
#define _2      _A+_B+   _D+_E+   _G
#define _3      _A+_B+_C+_D+      _G
#define _4         _B+_C+      _F+_G
#define _5      _A+   _C+_D+   _F+_G
#define _6      _A+   _C+_D+_E+_F+_G
#define _7      _A+_B+_C
#define _8      _A+_B+_C+_D+_E+_F+_G
#define _9      _A+_B+_C+_D   +_F+_G
#define BLANK   0

uint8_t TABLE_7S[] = { _0, _1, _2, _3, _4, _5, _6, _7, _8, _9 };

uint8_t display_mem[8];         // 8 digits, MSD first


// convert 16bit value to n digits
// Input:   val: 16bit value
//        start: start digit in display_mem
//            n: number of digits to convert
void val_digits( uint16_t val, uint8_t start, uint8_t n )
{
  start += n;                   // convert LSD first
  do{
    display_mem[--start] = val % 10;
    val /= 10;
  }while( --n );
}

// convert digits to 7-segment
// Input: start: start digit in display_mem
//            n: number of digits to convert
void digits_7segment( uint8_t start, uint8_t n )
{
  do{
    display_mem[start] = TABLE_7S[display_mem[start]];
    start++;
  }while( --n );
}

// suppress leading zero
// Input: start: start digit in display_mem
//            n: number of digits to convert
void digits_blank( uint8_t start, uint8_t n )
{
  do{
    if( display_mem[start] != _0 )
      break;
    display_mem[start] = BLANK;
    start++;
  }while( --n > 0 );            // except on LSD
}

Die Funktionen wurden so geschrieben, daß man sie für Tage, Stunden, 
Minuten nutzen kann, deshalb die Start- und Längenangabe.

[Tommy (Gast)]

danke peda!! auch diesn code werden heute mal probieren.bis später!

[Jörg W. (dl8dtl) (Moderator)]

Karl Heinz Buchegger schrieb:
>> Hast du das BASCOM denn gekauft?
>
> Nö. Demo-Download

Ich meinte ja eher Tommy.

Tommy schrieb:
> auch diesn code werden heute mal probieren.

Dann solltest du dir aber vorher einen C-Compiler installieren. ;-)

[Tommy (Gast)]

Jörg Wunsch schrieb

> Dann solltest du dir aber vorher einen C-Compiler installieren. ;-)

Hab ich ja eh auch !  :)

[Vlad T. (vlad_tepesch)]

ich hatte mir ganz am Anfang meiner µC-Experimente mal eine 
Ascii-zu-7segment-Look-Up-Tabelle erstellt, falls gewünscht, such ich 
die nochmal raus. Dem Prinzip der Sache ist natürlich geschuldet, dass 
einige Zeichen nur aus dem textuellen Kontext zu erschließen sind, aber 
man konnte die Ausgaben verstehen.

[Tommy (Gast)]

Vlad Tepesch schrieb:
 falls gewünscht, such ich die nochmal raus.

für jede kleinigkeit bin ich jeden sehr dankbar. :)

[Karl H. (kbuchegg)]

Vlad Tepesch schrieb:
> ich hatte mir ganz am Anfang meiner µC-Experimente mal eine
> Ascii-zu-7segment-Look-Up-Tabelle erstellt, falls gewünscht, such ich
> die nochmal raus. Dem Prinzip der Sache ist natürlich geschuldet, dass
> einige Zeichen nur aus dem textuellen Kontext zu erschließen sind, aber
> man konnte die Ausgaben verstehen.

Ja, daran wäre ich auch interessiert.
Denn ein vollständiger 'ASCII-Zeichensatz' für 7-Segment Anzeigen ist 
alles andere als einfach bzw. schnell gemacht, wenn das ganze halbwegs 
lesbar sein soll.

[Vlad T. (vlad_tepesch)]

Karl Heinz Buchegger schrieb:
> Ja, daran wäre ich auch interessiert.
> Denn ein vollständiger 'ASCII-Zeichensatz' für 7-Segment Anzeigen ist
> alles andere als einfach bzw. schnell gemacht, wenn das ganze halbwegs
> lesbar sein soll.

vollständig ist er nicht. Zahlen und Buchstaben hatte ich gemacht, wobei 
bei den Buchstaben auch keine Unterscheidung zwischen groß und klein 
ist. Da wurde das genommen, was am ehesten zu interpretieren ist. Ich 
suchs heut abend mal raus.

[Vlad T. (vlad_tepesch)]

Hier. Das ganze ist integriert in eine kleine lib für 4x7seg.
Das ganze ist als eins der ersten Übungen mit µCs entstanden, als nix 
allumfassendes erwarten
Wie aus dem Gedächtnis angedeutet: nur die Ziffern und Buchstaben sind 
darstellbar. Sorry KHB, wenn ich damit deine Hoffnung Enttäusche

Entscheident für ascii->7seg ist die Routine
uint8_t SevenSeg_getCharData(uint8_t i_input);

die anderen kümmern sich um die Initialisierung und Darstellung eines 
Scrolltextes und kümmern ich um das Multiplexing.

Edit:
Das ganze passt allerdings eigentlich überhaupt nicht in den thread.

[Tommy (Gast)]

Karl Heinz Buchegger schrieb:

> Entweder ist dir beim Rauskopieren was passiert, oder mir beim
> Reinkopieren.
> Ich häng noch mal das File so an, wie es ist

ach du scheisse,ist das geil!!  :)

hab ein update gemacht beim bascomavr. jetzt funzts vom feinsten.
hab den code sofort und in innerhalb von 10min. nach meinen bedürfnissen
angepasst gehabt. nochmal ein riessen dank karl!!! bist echt spitze!!

[Tommy (Gast)]

Karl Heinz darf ich doch noch mal sigant sein?
ein taster gehört noch rein,mit dem man die zahl voreinstellen kann.
if portc.2 = 0 then

???

[Uwe (de0508)]

Nein,

suche mal nach dem Stichwort Tasterentprellung, die 100.000 Antworten 
weisen Dir den Weg.

[Tommy (Gast)]

Do



  Call Show(zahl)
  Waitms 51350                                              'waitms 
51300=1 min    im sekundentakt
  Zahl = Zahl - 1                                           '1tag sind 
86400 sek.
  If Zahl = 00001 Then                                      '10000
    Zahl = 0
  End If



If T_plus_stellen = 0 Then                                  'Wird 
"T_min_stellen" betätigt und ist es eine pos. Flanke
   Waitms 150                                               'Entprellen
   If T_plus_stellen = 0 Then                               'Ist der 
Taster immer noch betätigt
                                               'wird Minute um eins 
erhöht
   Zahl = Zahl + 1

   End If
   End If



Loop

sooooo???? Geht aber nicht

[Tommy (Gast)]

Hoppala so meinte ich natürlich!!jetz geht das wieder nicht.ist doch zum 
verzweifen!



' µC Deklarationen
$regfile = "m8adef.DAT"
$crystal = 3686400
$hwstack = 100
$swstack = 100
$framesize = 100




'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' Timer0 für Multiplexausgabe
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++

On Timer0 7segment

Config Timer0 = Timer , Prescale = 8
Tcnt0 = 0
Enable Timer0



Config Portd = Output                                       ' 
Stellentreiber
Config Portb = Output
Config Portc.4 = Output
Config Pinc.1 = Input
Config Pinc.2 = Input
Portc = &B00000110

T_plus_stellen Alias Pinc.1
T_minus_stellen Alias Pinc.2


Segment_a Alias Portb.0
Segment_b Alias Portb.1
Segment_c Alias Portb.2
Segment_d Alias Portb.3
Segment_e Alias Portb.4
Segment_f Alias Portb.5
Segment_g Alias Portc.4


Dim Ausgabestelle As Byte
Dim Ausgang As Byte
Dim Stelle As Byte
Dim Digit As Byte
Dim I As Byte
Dim Zahl As Word
Dim Code(8) As Byte

Declare Sub Clear7Seg()
Declare Sub Show(byval Nr As Word )

Enable Interrupts

Call Clear7seg()

Zahl = 0

Do

  Call Show(zahl)
  Waitms 51350
  Zahl = Zahl - 1
  If Zahl = 00001 Then
    Zahl = 0
  End If



If T_plus_stellen = 0 Then
   Waitms 150
   If T_plus_stellen = 0 Then

   Zahl = Zahl + 1

   End If
   End If



Loop

End

Sub Clear7seg()
  For I = 1 To 8
    Code(I) = Lookup(10 , Segmentfolge)
  Next I
End Sub

Sub Show(byval Nr As Word )
  For I = 1 To 4
    Digit = Nr Mod 10
    If I = 1 Or Nr > 0 Then
      Code(i) = Lookup(digit , Segmentfolge)
    Else
      Code(i) = Lookup(10 , Segmentfolge)
    End If
    Nr = Nr / 10
  Next I
End Sub





7segment:

  Portd = 0                                                 ' alles aus

  Ausgabestelle = Ausgabestelle + 1
  If Ausgabestelle = 4 Then                                 '8
    Ausgabestelle = 0
  End If




  Ausgang = Code(ausgabestelle + 1)
  'Ausgabe des 7 Segmentcodes (Invertierend [Not] bei Anz. mit gem. 
Anode)
  Segment_a = Not Ausgang.0
  Segment_b = Not Ausgang.1
  Segment_c = Not Ausgang.2
  Segment_d = Not Ausgang.3
  Segment_e = Not Ausgang.4
  Segment_f = Not Ausgang.5
  Segment_g = Not Ausgang.6

  Stelle = Lookup(ausgabestelle , Digitcode )

  Portd = Stelle




Return

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
' 7 Segmentcode - Tabelle
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
++++++++
'
' --A--
' |   |
' F   B
' |   |
' --G--
' |   |
' E   C
' |   |
' --D--


Segmentfolge:                                               'GFEDCBA / 
"1" Segment AN


Data &B0111111                                              '0
Data &B0000110                                              '1
Data &B1011011                                              '2
Data &B1001111                                              '3
Data &B1100110                                              '4
Data &B1101101                                              '5
Data &B1111101                                              '6
Data &B0000111                                              '7
Data &B1111111                                              '8
Data &B1101111                                              '9

Data &B0000000                                              'leeres Feld 
(zur Nullstellenunterdrückung)

Digitcode:
Data &B00000001
Data &B00000010
Data &B00000100
Data &B00001000
Data &B00010000
Data &B00100000
Data &B01000000
Data &B10000000

[Gerhard K. (mikros)]

Tommy schrieb:
> Dim Zahl As Word

> Zahl = 0

Tommy schrieb:
> Zahl = Zahl - 1
>   If Zahl = 00001 Then
>     Zahl = 0
>   End If

Dir fehlen die elementarsten Grundkenntnisse!


Du hast da oben 51 Sek Wartezeit drin.
Du pollst den Taster.

Versuch Dir aus diesen beiden Sätzen einen Reim zu machen.

Die Entprellzeit von 150mS ist auch viel zu lang.
30mS sollten genügen

MfG

[Tommy (Gast)]

Gerhard K. schrieb:


> Dir fehlen die elementarsten Grundkenntnisse!

 das ist schon richtig!

>Du hast da oben 51 Sek Wartezeit drin.

 51 sek. hab ich zum test eingestellt.das soll ein tageszähler werden.

> Zahl = Zahl - 1
>   If Zahl = 00001 Then
>     Zahl = 0
>   End If

weiss ich doch,hab vagessn wieder zurückzustellen.

[Karl H. (kbuchegg)]

Tommy schrieb:
> Gerhard K. schrieb:
>
>
>> Dir fehlen die elementarsten Grundkenntnisse!
>
>  das ist schon richtig!
>
>>Du hast da oben 51 Sek Wartezeit drin.
>
>  51 sek. hab ich zum test eingestellt.das soll ein tageszähler werden.

Das ist doch Quatsch.
Kurze Zeiten kann man noch mit Wait machen. Aber alles was länger ist, 
braucht einen Timer, der parallel zur CPU dann das Zählen übernimmt.

Denn: weährend der µC im Wait hängt, macht er in seinem eigentlichen 
Programm nichts anderes mehr. Insbesondere kann er dann keine Tasten 
abfragen.

Das ich einen Wait benutzt habe, ist dem Umstand geschuldet, dass ich 
beim Herzeigen des Multiplexings die Sache nicht zu kompliziert machen 
wollte. Aber es ist überhaupt kein Probem, in die bereits vorhandene 
Interrupt Routine noch zusätzlich eine Uhr mit einzubauen. Es gibt keine 
Regel, nach der eine Interrupt Funktion lediglich eine einzige Aufgabe 
machen darf.


Der Befehl zum Abfragen einer Taste heißt 'debounce'.

Ich empfehle dir dringend, dir ein BASCOM Tutorial im Web zu suchen. 
Ein/Ausgabe bzw. Auswerten von Tasten sind Basis-Fähigkeiten. Die muss 
jeder Programmierer im Schlaf beherrschen.

[Karl H. (kbuchegg)]

Und noch was.
Exzessiv viele Leerzeilen .... ziehen einen Code lediglich in die Länge, 
machen ihn aber nicht übersichtlicher. Alles was du tust ist, dafür zu 
sorgen, dass man den Überblick verliert.

Wenn dir etwas so wichtig ist, dass du meinst da müssten jetzt 5 
Leerzeilen hintereinander anzeigen, dass hier etwas neues beginnt, oder 
das hier ein neuer Gedankengang beginnt, dann mach 1 Leerzeile und einen 
Kommentar rein. Das hilft dir in späterer Folge und zieht den Code nicht 
so in die Länge. Denn grundsätzlich sollte man Code mit dem kleinen 
Sichtfenster, welches der Editor darstellt überblicken können. Musst du 
ständig rauf und runter scrollen um die Zusammenhänge zu sehen, dann 
werden die Dinge aber nicht übersichtlicher und leichter erfassbar.

[Tommy (Gast)]

so in etwa??  :)
des geht so vom allerfeinstn!!


 '*** Tageszähler mit Atmega8A und 7 Segmente zur Anzeige 
*****************************

 '*** Hardware 
*****************************************************************
$regfile = "m8adef.dat"
$crystal = 3686400                                          '3,6864 Mhz

'*** Ports 
konfigurieren********************************************************

Ddrb = &B00111111
Ddrc = &B00010000
Ddrd = &B11111111

Config Pinc.0 = Input                                       'Taster 
T_reset
Config Pinc.1 = Input                                       'Taster 1er 
und 10er einst.
Config Pinc.2 = Input                                       'Taster 
100er und 1000er einst.

Portc.0 = 1                                                 'pullup
Portc.1 = 1                                                 'pullup
Portc.2 = 1                                                 'pullup

'Sekundentakt erzeugen

On Timer1 Ontimer1
Config Timer1 = Timer , Prescale = 1024                     '1024 
'3686400/1024 =3600 =1Hz
Enable Timer1

'Multiplexfrequenz erzeugen

On Timer0 Ontimer0
Config Timer0 = Timer , Prescale = 64 
'3686400/256/14400
Enable Timer0

Enable Interrupts

'*** Variablen 
*****************************************************************

Dim Wert As Byte                                            'Ziffer die 
ausgegeben wird
Dim Multiplex As Byte                                       'Stellenwert 
(1,2,4,8,16,32)
Dim Sek_einer As Byte                                       'Ziffer 1 
von Li.nach Re.
Dim Sek_zehner As Byte                                      'Ziffer 2
Dim 1_einer As Byte                                         'Ziffer 3
Dim 2_zehner As Byte                                        'Ziffer 4
Dim 3_einer As Byte                                         'Ziffer 5
Dim 4_zehner As Byte                                        'Ziffer 6

Declare Sub Einer_zehner
Declare Sub Hundert_tausend
Declare Sub T_reset

Multiplex = 1                                               'Startwert
Timer1 = 61936                                              'Für den 
Start der Uhr nach 1 Sekunde

'*** Main (Zeit einstellen) 
****************************************************
Do
   Debounce Pinc.1 , 0 , Einer_zehner , Sub                 'Einer & 
Zehner einstellen
   Debounce Pinc.2 , 0 , Hundert_tausend , Sub              'Hundert & 
Tausend einstellen
   Debounce Pinc.0 , 0 , T_reset , Sub                      'Zähler auf 
0 rückstellen
Loop

'*** Sub-Routinen 
**************************************************************
Sub Einer_zehner
    Incr 1_einer                                            'Einer & 
Zehner erhöhen
    End Sub

Sub Hundert_tausend
    Incr 3_einer                                            'Hudert & 
Tausend erhöhen
    End Sub

Sub T_reset
    1_einer = 0                                             'Alles 
Rückstellen
    2_zehner = 0
    4_zehner = 0
    3_einer = 0
    End Sub


'*** Interrupt-Routinen 
********************************************************
Ontimer1:                                                   'Aufruf im 
Sekundentakt
Timer1 = 61936 
'65536-3600=..weniger ist langsamer 
'dann Sekunde Einer-Stelle Null setzen
Incr Sek_einer                                              'und Sekunde 
Zehner-Stelle hochzählen

If Sek_einer = 86403 Then                                   'Sekunden 
pro Tag angepasst.Soll 86400sek.
      Sek_einer = 0                                         'dann 
Sekunde Einer-Stelle Null setzen
      Incr  1_einer 
'Sek_zehner                                       '          'und 
Sekunde Zehner-Stelle hochzählen
   End If

'Die Stunden-Zehner hochzählen

'If Sek_zehner = 6 And Sek_einer = 0 Then
'         Sek_zehner = 0
'         Sek_einer = 0
'         Incr 1_einer
'   End If

'Die 1-Einer hochzählen

If 1_einer >= 10 Then                                       'usw.
      1_einer = 0
      Incr 2_zehner
   End If

If 2_zehner >= 10 Then
      2_zehner = 0
      Incr 3_einer
   End If

If 3_einer >= 10 Then
      3_einer = 0
      Incr 4_zehner
   End If

If 4_zehner >= 10 Then
         4_zehner = 0
         3_einer = 0
         2_zehner = 0
         1_einer = 0
   End If

Return



Ontimer0:                                                   'Der 
Multiplexer!
   Timer0 = 100                                             '61,5 Hz

   'Hier wird die Umschaltsequenz (Multiplexen) der 6 Segmente erzeugt!

   Multiplex = Multiplex * 2 
'1,2,4,8,16,32,(64)
If Multiplex = 64 Then Multiplex = 4

   '400Hz/6Segmente=> 66Hz. Die kpl. Anzeige wird also mit 66Hz 
gemultiplext!

   Portb = &B00111111                                       'Alle 
Segmente vor dem Umschalten ausschalten
   Portc.4 = 1
   Portd = Multiplex                                        'Das 
anzusteuernde Segment auswählen
                   'Ab hier erfolgt die Zuordnung von Anzeige und Wert
   If Multiplex = 1 Then Wert = Sek_einer
   If Multiplex = 2 Then Wert = Sek_zehner
   If Multiplex = 4 Then Wert = 1_einer
   If Multiplex = 8 Then

If 2_zehner = 0 And 3_einer = 0 And 4_zehner = 0 Then       '0 auf 
Zehner uterdrücken
   Wert = 10                                                '10 bedeutet 
=> kein Segment ist an.
   Else
   Wert = 2_zehner                                          'oder Zahl 
Anzeigen

   End If
   End If

If Multiplex = 16 Then

If 3_einer = 0 And 4_zehner = 0 Then                        '0 auf 
Huderter unterdrücken
   Wert = 10                                                '10 bedeutet 
=> kein Segment ist an.
   Else
   Wert = 3_einer                                           'oder Zahl 
Anzeigen

   End If
   End If

If Multiplex = 32 Then

If 4_zehner = 0 Then                                        '0 auf 
Tausener underdrücken
   Wert = 10                                                '10 bedeutet 
=> kein Segment ist an.
   Else
   Wert = 4_zehner                                          'oder Zahl 
Anzeigen

   End If
   End If

'Hier erfolgt die die Auswahl (Dekodierung) welche Segmente leuchten 
sollen

Select Case Wert

      Case 0                                                'gfedcba
         Portb = &B00000000                                 '0
      Case 1
         Portb = &B00111001                                 '1
      Case 2
         Portb = &B01100100
         Portc.4 = 0                                        '2
      Case 3
         Portb = &B00110000                                 '3
         Portc.4 = 0
      Case 4
         Portb = &B00011001                                 '4
         Portc.4 = 0
      Case 5
         Portb = &B00010010                                 '5
         Portc.4 = 0
      Case 6
         Portb = &B00000010                                 '6
         Portc.4 = 0
      Case 7
         Portb = &B00111000                                 '7
      Case 8
         Portb = &B00000000                                 '8
         Portc.4 = 0
      Case 9
         Portb = &B00010000                                 '9
         Portc.4 = 0
      Case Else
         Portb = &B00111111
         Portc.4 = 1                                        'Anzeige 
dunkel schalten
   End Select
Return

[Falk B. (falk)]

@ Tommy (Gast)

>    IMG_0030.JPG
>    2,3 MB, 0 Downloads
>    IMG_0029.JPG
>    2,4 MB, 0 Downloads

>so in etwa??  :)

NÖ! Wir glauben dir ja, dass du auf deine BASCOM-Lernerfole stolz bist, 
aber auch du solltest dir mal die Themen Netiquette und 
Bildformate reinziehen, wie es so schöna uf neudeutsch heißt. Lange 
Quelltexe gehören in den Anhang.

[Tommy (Gast)]

das hab ich mir gedacht,dass das jetzt kommt! :)

[Sascha W. (arno_nyhm)]

> Wir legen großen Wert auf Sicherheit - 'Unfallfreie Tage: 0'
passt gut, die dateigröße der bilder ist dann wohl das unfall, der den 
reset der tafel hervorrief?

[Tommy (Gast)]

:)

So besser???

[Jörg W. (dl8dtl) (Moderator)]

Tommy schrieb:
> :)
>
> So besser???

Ja, außer dass die Reflektionen des Blitzlichts unschön sind.
Besser mit alternativer Beleuchtung (ohne Blitz) fotografieren
oder irgendwie von der Seite.

So ein längliches Progrämmchen postet man besser als Anhang.  Nicht
nur, dass es dann den Thread weniger „zerdröselt“, es ist für einen
potenziellen Nachnutzer dann auch einfacher runterzuladen.

[Tommy (Gast)]

Jörg Wunsch schrieb:

> So ein längliches Progrämmchen postet man besser als Anhang.  Nicht
> nur, dass es dann den Thread weniger „zerdröselt“, es ist für einen
> potenziellen Nachnutzer dann auch einfacher runterzuladen.

Hast eh Recht.Werd mich in Zukunft bemühen es immer schön und richtig zu 
machen. :)