Voltmeter Software!

Volti Gast #1931577
Lesenswert?
• ▲
▼ 
Hallo Leute,

ich habe ein Problem und zwar meine Voltmeter Software läuft nicht 
wirklich gut!


meine Anzeige blinkt immer aber Zeigt nicht wirklich einen Wert an
Ich habe noch nichts an meinen AD Wandler angeschlossen ich habe eine 0 
erwartet!

Kann mir jemand helfen?

Schaltbild im Anhang.






$regfile = "m88def.dat"

$hwstack = 32

$swstack = 10

$framesize = 40

Config Portb = Output
Config Portc.0 = Input
Config Portd = Output

Config Adc = Single , Prescaler = Auto

Config Timer0 = Timer , Prescale = 256
Enable Timer0
Enable Interrupts
On Timer0 Displayinterrupt

Dim Disp(4) As Byte
Dim Help As Byte
Dim Help2 As Byte

Dim Modenvara As Long
Dim Modenvarb As Long
Dim Modenvarc As Long
Dim Modenvard As Long
Dim Modenvare As Long
Dim Modenvarf As Long
Dim I As Integer
Dim A As Double


Do
   I = Getadc(0)
   A = I / 1024
   I = A * 500
   Modenvara = I
   Gosub Moden
Loop




Displayinterrupt:
For Help = 1 To 4
   Portd = Lookup(disp(help) , Siebensegmentchartab)
   Help2 = Help - 1
   Set Portb.help2
   Waitms 3
Next
Portb = &H00
Return


Moden:
   If Modenvara > -999 And Modenvara < 9999 Then
      Modenvard = 100000
      For Modenvare = 1 To 4
         Modenvarf = Modenvard / 10
         Modenvarb = Modenvara Mod Modenvard
         Modenvarc = Modenvara Mod Modenvarf
         Modenvarc = Modenvarb - Modenvarc
         Disp(modenvare) = Modenvarc / Modenvarf
         Modenvard = Modenvard / 10
      Next
   End If
Return


Siebensegmentchartab:
Data &B00001000                                             '0
Data &B01101101                                             '1
Data &B00100010                                             '2
Data &B00100100                                             '3
Data &B01000101                                             '4
Data &B00010100                                             '5
Data &B00010000                                             '6
Data &B00101101                                             '7
Data &B00000000                                             '8
Data &B00000100                                             '9
Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Karl H. #1931612
Lesenswert?
• ▲
▼ 
Funktioniert denn die Ausgabe, wenn du einfach mal eine konstanten Wert 
ausgeben lässt?


1
Displayinterrupt:

2
For Help = 1 To 4

3
   Portd = Lookup(disp(help) , Siebensegmentchartab)

4
   Help2 = Help - 1

5
   Set Portb.help2

6
   Waitms 3

7
Next

8
Portb = &H00

9
Return


das macht man anders.
Bei jedem Aufruf der INterrupt Funktion wird die nächste Ziffer 
ausgegeben. Nach 4 Interrupt Aufrufen sind dann alle 4 Ziffern durch und 
das Spiel beginnt wieder von vorne. Dann brauchst du in der Interrupt 
Funktion auch nicht warten.
Ausserdem wäre es ganz gut, wenn du bei der jeweils nächsten Ziffer die 
vorhergehende Ziffernanzeige abschalten würdest.

( Das geht in BASCOM?
  Set Portb.help2
  Interessant. Wusste ich gar nicht
)

1
Displayinterrupt:

2
  Set Portb.help2                  ' jetzige Anzeige ausschalten

3


4
  help2 = help2 + 1                ' welches ist die nächste Anzeige

5
  if help2 = 4 then help2 = 0

6


7
                                   ' das zu dieser Anzeige gehörende Bitmuster 

8
                                   ' ausgeben

9
  Portd = Lookup(disp(help2 + 1) , Siebensegmentchartab)

10


11
  Reset Portb.help2                ' und die Anzeige einschalten

12
Return
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1931628
Lesenswert?
• ▲
▼ 
Das hier
1
Moden:

2
   If Modenvara > -999 And Modenvara < 9999 Then

3
      Modenvard = 100000

4
      For Modenvare = 1 To 4

5
         Modenvarf = Modenvard / 10

6
         Modenvarb = Modenvara Mod Modenvard

7
         Modenvarc = Modenvara Mod Modenvarf

8
         Modenvarc = Modenvarb - Modenvarc

9
         Disp(modenvare) = Modenvarc / Modenvarf

10
         Modenvard = Modenvard / 10

11
      Next

12
   End If

13
Return


erscheint mir unmässig kompliziert.

1
 Moden:

2
   If Modenvara > -999 And Modenvara < 9999 Then

3
      For Modenvare = 1 To 4

4
        Disp(modenvare) = Modenvara Mod 10

5
        Modenvara = Modenvara / 10

6
      Next

7
   End If

8
Return



Deine Variablennamen sind ..... bescheiden gewählt. Man muss höllisch 
aufpassen, dass man sie nicht durcheinanderbringt. 9 Buchstaben und dann 
unterscheiden sie sich nur im letzten Buchstaben. Ts, ts.


Aber wie gesagt: bring das Schrittweise zum laufen!
Zuerst muss die Ausgabe funktionieren. Dazu schreibst du in disp(1) bis 
disp(4) entsprechende Ziffern und siehst nach, ob die auch so auf der 
7_Seg Anzeige auftauchen.

Wenn das funktioniert, gehst du weiter und zerlegst einen Integer in die 
einzelnen Ziffern, die du in disp(1) bis disp(4) schreibst. Ein 
Testprogramm könnte zb in einer For-Next Schleife alle Zahlen von 0 is 
9999 durchgehen und die in die Zerlegung schicken (die sie dann wieder 
über den bereits getesten Mechanismus der Ausgabe zur Anzeige bringt)

Und erst dann nimmst du deinen ADC in Betrieb.

Es hat keinen Sinn, wenn du 3 Funktionsblöcke gleichzeitig in Betrieb 
nehmen willst. Bei einem Fehler weißt du nie, in welchem 
Funktionsbereich du mit Suchen anfangen musst. Daher geht man 
schrittweise vor. Man beginnt mit den grundlegenden Bausteinen und 
arbeitet sich dann schrittweise nach oben vor, wobei die 
darüberliegenden Schritte die bereits getesten Schichten benutzen 
können. Da sie getestet sind, funktionieren sie auch zumindest so 
einigermassen leidlich.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Hannes L. #1931701
Lesenswert?
• ▲
▼ 
Nur mal so zum querlesen:

1
'************************** VOLTMETER-TEST 

2
$regfile = "atTiny24.dat"                                   'ATTiny24-Deklarationen

3
$crystal = 1000000                                          'Interner Takt benutzt

4


5
Dim Bimu(12) As Byte                                        'Bitmuster für Zeichen

6
Dim Dimu(3) As Byte                                         'Digit-Bitmuster

7
Dim Zeichen(3)as Byte                                       'Bitmuster zur Ausgabe

8
Dim Messwert As Long                                        'kumulativer Messwert

9
Dim Messwert2 As Long                                       'Zwischenwert zum Ermitteln der Ziffern

10
Dim Digit As Byte                                           'Index auf Ausgabeposition

11
Dim Ziffer As Byte                                          'temp. Index auf Zeichenbitmuster

12
Dim I As Byte                                               'Schleifenzähler

13


14
On Adc Onadc                                                'Adc -interrupt

15


16
Ddra = &B11111110                                           'Alles Ausgang ausser PA0

17
Porta = &B00000000                                          'Ziehwiderstand an PA0 ausschalten

18
Didr0 = &B00000001                                          'Digitalteil abschalten

19
Ddrb = &B00000111                                           'PB0,1,2 als Ansteuerung der Segmenttreiber

20
Admux = &B10000000                                          'Aref=VCC, Rechtsbündig, ADC0 auswählen

21
Adcsra = &B11101011                                         'ADC freilaufend mit Interrupt ein, VT 8

22
!sei                                                        'Interrupts global erlauben

23


24
Restore Bitmuster                                           'Pointer Auf Anfang Flash-Tabelle

25
For I = 1 To 12

26
   Read Ziffer                                              'Ziffern-Bitmuster

27
   Bimu(i) = Ziffer                                         'ins Array kopieren

28
Next I

29
Restore Digitmuster                                         'Pointer Auf Anfang Flash-Tabelle

30
For I = 1 To 3

31
   Read Ziffer                                              'Digitschalt-Bitmuster

32
   Dimu(i) = Ziffer                                         'ins Array kopieren

33
Next I

34


35
'******************************Hauptschleife************************************

36
Do

37
'   Messwert2 = Messwert * 125                               'Messwert für 5V skalieren

38
'   Messwert2 = Messwert * 250                               'Messwert für 10V skalieren

39
   Messwert2 = Messwert * 275                               'Messwert für 1 skalieren, interne Referenz 1,1V

40
   'Überlauf prüfen

41
   If Messwert2 > 256000 Then

42
      Zeichen(1) = Bimu(11)

43
      Zeichen(2) = Bimu(11)

44
      Zeichen(3) = Bimu(11)

45
   Else

46
      'linke Ziffer ermitteln

47
      Ziffer = 0                                               'Zwischenwert (Index auf Bitmuster) löschen

48
      Do                                                       'linke Ziffer ermitteln (Index

49
         Incr Ziffer                                           'hoch und Stellenwert

50
         Messwert2 = Messwert2 - 25600                         'Subtrahieren)

51
      Loop Until Messwert2 < 0                                 'bis zum Unterlauf,

52
      Messwert2 = Messwert2 + 25600                            'Unterlauf korregieren

53
      Zeichen(3) = Bimu(ziffer)                                'und zugehöriges Bitmuster aus Array holen

54
      'mittlere Ziffer ermitteln

55
      Ziffer = 0                                               'Index auf 0

56
      Do

57
         Incr Ziffer                                           'Index hoch,

58
         Messwert2 = Messwert2 - 2560                          'Wertigkeit abziehen

59
      Loop Until Messwert2 < 0                                 'bis zum Unterlauf

60
      Messwert2 = Messwert2 + 2560                             'Unterlauf-Korrektur

61
      Zeichen(2) = Bimu(ziffer)                                'Bitmuster holen

62
      'rechte Ziffer ermitteln

63
      Ziffer = 0                                               'index auf 0

64
      Do

65
         Incr Ziffer                                           'Index hoch

66
         Messwert2 = Messwert2 - 256                           'Wertigkeit abziehen

67
      Loop Until Messwert2 < 0                                 'bis zum Unterlauf

68
      Zeichen(1) = Bimu(ziffer)                                'Bitmuster zuweisen

69


70
   End If

71
Loop                                                        'nochmal

72


73
'****************************ADC Interrupt**************************************

74
Onadc:

75
   Messwert = Adcd                                          'ADC einlesen

76
'   Portb = 0                                                'alle Digits aus (g. Kathode)

77
   Portb = 7                                                'alle Digits aus (g. Anode)

78
   Incr Digit                                               'Digit hochzählen

79
   If Digit = 4 Then Digit = 1                              'und begrenzen

80
   Porta = Zeichen(digit)                                   'Bitmuster ausgeben

81
   Portb = Dimu(digit)                                      'Digit einschalten

82
Return                                                      'fertig...

83


84
'****************************Konstanten*****************************************

85
Bitmuster:                                                  'Low-aktive Segmente an PA1..PA7

86
Data &H80 , &H9E , &H50 , &H12 , &H0E , &H22 , &H20 , &H96 , &H00 , &H02 , &H7E , &HFE

87


88
Digitmuster:                                                'Low-aktive Digit-Treiber (PNP)

89
Data 3 , 5 , 6 , 7

90
'gerade Anzahl der Elemente wegen der Ordnung


...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1931720
Lesenswert?
• ▲
▼ 
Volti schrieb:
> Kann mir jemand die Software mal umstellen wie ihr das meint?

Ich schlage vor, das machst du mal selber.

Durch nichts lernst du soviel, wie durch die kleinen Fehler die du 
selber machst. Einen prinzipiellen Fahrplan, in welcher Reihenfolge du 
was in Betrieb nimmst, hab ich dir ja schon zusammengestellt.

> Wenn ich die Einfüge und Complementiere kommen nur fehler :(

das heist compilieren (vom englischen "to compile" [ kompeil ] - 
zusammenstellen, erarbeiten, übersetzen)

Und nein: Aus dem Code vom Hannes kannst du dir Ideen holen, aber 
einfach ausschneiden und einsetzen ist nicht.


> ich stege da nicht mehr durch...

Dann fang noch mal von vorne an. Neues Programm.
So schwer ist das nicht.
Aber schreib diesmal nicht alles in einem Rutsch, sondern arbeite 
schrittweise. Zuerst die 7-Seg, dann Zahlen zerlegen, dann ADC
Aber um Himmels willen nicht alles auf einmal, sondern eines nach dem 
anderen. Zahlen zerlegen kommt erst drann, wenn 7-Seg funktioniert und 
getestet ist.

> Am besten in Assembler...

Genau. Kein weiterer Kommentar dazu
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Hannes L. #1931734
Lesenswert?
• ▲
▼ 
In Assembler?

Na gut:

1
;Voltmeter mit Tiny24 und dreistelliger Lichtschacht-Anzeige mit 

2
;gemeinsamer Anode je Ziffer und PNP-Transistoren als Digit-Treiber.

3


4
.include "tn24def.inc"  ;Portnamen

5


6
.equ skalier=125        ;Skalierfaktor

7
.equ bremse=50          ;Anzeigebremse (verlangsamt Berechnung)

8


9
.dseg                   ;SRAM

10
.org sram_start         ;Anfang

11
bimu:       .byte 24    ;Bitmuster für Zeichensatz (16-Bit)

12
    ;12 Segment-Bitmuster für PortB (0..11)

13
    ;12 Segment-Bitmuster für PortA (12..23)

14


15
zeichen:    .byte 12    ;Zeichen- und Digit-Bitmuster der 3 Stellen

16
    ;3 Digit-Bitmuster für PortB (0..2)

17
    ;3 Digit-Bitmuster für PortA (3..5)

18
    ;3 Segment-Bitmuster für PortB (6..8)

19
    ;3 Segment-Bitmuster für PortA (9..11)

20


21
.def null=r3            ;immer 0

22
.def srsk=r4            ;SREG-Kopie

23
.def mwn=r5             ;Messwert / Mittelwert Nachkomma

24
.def mwl=r6             ;Messwert / Mittelwert Low

25
.def mwh=r7             ;Messwert / Mittelwert High

26
.def scheibe=r8         ;Zeitscheibe

27
.def sfl=r9             ;Skalierfaktorzähler Low

28
.def sfh=r10            ;Skalierfaktorzähler High

29
.def ausa=r11           ;Bitmuster Digits aus PortA

30
.def ausb=r12           ;Bitmuster Digits aus PortB

31


32
.def wert1=r16          ;Low-Byte Zwischenwert zur Skalierung

33
.def wert2=r17          ;Mid-Byte

34
.def wert3=r18          ;High-Byte

35


36
.def digit=r21          ;Digit-Zähler für Anzeige-Multiplexing

37
.def iwl=r22            ;ISR-Working L

38
.def iwh=r23            ;ISR-Working H

39
.def wl=r24             ;Working L

40
.def wh=r25             ;Working H

41


42
.cseg

43
.org 0

44
 rjmp RESET         ;Reset Handler

45
 rjmp nix;EXT_INT0      ;IRQ0 Handler

46
 rjmp nix;PCINT0        ;PCINT0 Handler

47
 rjmp nix;PCINT1        ;PCINT1 Handler

48
 rjmp nix;WATCHDOG      ;Watchdog Interrupt Handler

49
 rjmp nix;TIM1_CAPT     ;Timer1 Capture Handler

50
 rjmp nix;TIM1_COMPA    ;Timer1 Compare A Handler

51
 rjmp nix;TIM1_COMPB    ;Timer1 Compare B Handler

52
 rjmp nix;TIM1_OVF      ;Timer1 Overflow Handler

53
 rjmp nix;TIM0_COMPA    ;Timer0 Compare A Handler

54
 rjmp nix;TIM0_COMPB    ;Timer0 Compare B Handler

55
 rjmp nix;TIM0_OVF      ;Timer0 Overflow Handler

56
 rjmp nix;ANA_COMP      ;Analog Comparator Handler

57
 rjmp ADCC          ;ADC Conversion Handler

58
 rjmp nix;EE_RDY        ;EEPROM Ready Handler

59
 rjmp nix;USI_STR       ;USI STart Handler

60
 rjmp nix;USI_OVF       ;USI Overflow Handler

61
nix:

62
 rjmp nix

63
;

64
RESET:

65
 ldi wl,low(RAMEND)         ;Stackpointer-Init

66
 out SPL,wl

67
 clr null                   ;immer 0

68
 clr mwn                    ;Messwert 

69
 clr mwl                    ;erstmal

70
 clr mwh                    ;auf 0

71
 

72
 out porta,null             ;alle Ports

73
 out portb,null             ;auf L-Pegel,

74
 ldi wl,$fe                 ;alle Portpins 

75
 out ddra,wl                ;außer 

76
 ldi wl,7                   ;PA0

77
 out ddrb,wl                ;als Ausgang

78
 sbi didr0,0                ;Digitalteil vom ADC-Port trennen

79


80
 ldi zl,low(charset*2)      ;Bitmuster

81
 ldi zh,high(charset*2)     ;im Flash

82
 ldi yl,bimu                ;Array 

83
 clr yh                     ;im SRAM

84
reset1:

85
 lpm r0,z+                  ;Segment-Bits für PortA

86
 std y+12,r0                ;in obere Array-Hälfte kopieren

87
 lpm r0,z+                  ;Segment-Bits für PortB

88
 st y+,r0                   ;in untere Array-Hälfte kopieren

89
 cpi yl,bimu+12             ;alle 12 Werte fertig?

90
 brne reset1                ;nein, nochmal...

91


92
 ldi zl,low(stelle*2)       ;Bitmuster für Digits

93
 ldi zh,high(stelle*2)      ;im Flash

94
 ldi yl,zeichen             ;Array für Zeichen und Digits im SRAM

95
 lds wh,bimu+12             ;Bitmuster für 0 PortA

96
 lds wl,bimu                ;und PortB holen

97
reset2:

98
 std y+9,wh                 ;Startwert PortA in oberes Array-Viertel

99
 std y+6,wl                 ;Startwert PortB in drittes Array-Viertel

100
 lpm r0,z+                  ;Digit-Bits für PortA

101
 std y+3,r0                 ;in zweites Array-Viertel kopieren

102
 lpm r0,z+                  ;Digit-Bits für PortB

103
 st y+,r0                   ;in unteres Array-Viertel kopieren

104
 cpi yl,zeichen+3           ;alle 3 Werte fertig?

105
 brne reset2                ;nein, nochmal...

106
 lpm ausa,z+                ;Bitmuster für Digits aus

107
 lpm ausb,z+                ;holen

108
; ldi wl,(1<<refs1)+0        ;ADC0 (PA0) gegen interne 1,1V

109
 ldi wl,0                   ;ADC0 (PA0) gegen Vcc (5V)

110
 out admux,wl               ;rechtsbündig messen

111
 ldi wl,(1<<aden)|(1<<adsc)|(1<<adate)|(1<<adie)+3 ;ADC freilaufend mit 

112
 out adcsra,wl              ;Interrupt und Vorteiler 8 (125kHz) starten

113
 ldi yl,zeichen             ;Startwert für Display-Multiplexing in der ISR

114
 ldi zh,0                   ;für Mainloop vorbereiten

115
 ldi wl,low(skalier+257)    ;Startwert

116
 mov sfl,wl                 ;für

117
 ldi wl,high(skalier+257)   ;Skalierung (Kumulation)

118
 mov sfh,wl                 ;des Messwertes

119
 ldi wl,1<<se               ;Sleep-Mode IDLE 

120
 out mcucr,wl               ;vobereiten

121
 sei                        ;Enable interrupts

122


123
mainloop:       ;Hauptschleife

124
 tst scheibe                ;Zeitscheibe auf 0?

125
 breq machwert              ;ja, Wert machen...

126


127
 sleep                      ;bis zum nächsten Interrupt pennen

128
 rjmp mainloop              ;nochmal...

129


130
machwert:       ;Job der Hauptschleife, gibt Messwert an Anzeige

131
 ldi wl,-bremse             ;Startwert Anzeigebremse

132
 mov scheibe,wl             ;setzen

133
 dec sfl                    ;Rundenzähler L runter

134
 brne machwert4             ;unten? - nein, weiter sammeln...

135
 dec sfh                    ;ja, H-Byte auch

136
 brne machwert4             ;unten? - nein, weiter sammeln...

137
 ;Zähler unten angekommen, Wert ausgeben

138
 

139
 ldi wh,high(1000)          ;Kopie für CPC

140
 cpi wert2,low(1000)        ;Wert über 999?

141
 cpc wert3,wh

142
 brlo machwert1             ;nein, berechnen...

143
 lds wh,bimu+10+12          ;Bitmuster für '-' (PortA)

144
 lds wl,bimu+10             ;(PortB) holen

145
 ldi zl,zeichen+3           ;für alle 3 Stellen

146
 std z+0,wl                 ;Minuszeichen

147
 std z+1,wl                 ;eintragen

148
 std z+2,wl

149
 std z+3,wh

150
 std z+4,wh

151
 std z+5,wh

152
 rjmp mainloop              ;fertig...

153
machwert1:

154
 ldi zl,bimu-1              ;Z-Pointer auf 1 Adresse unter Ziffer 0

155
machwert2:

156
 inc zl                     ;Index (Hunderter) hoch,

157
 subi wert2,low(100)        ;Hundert

158
 sbci wert3,high(100)       ;wegnehmen

159
 brsh machwert2             ;schon unter 0? - nein, nochmal...

160
 ldd wh,z+12                ;ja, Ziffer-Bitmuster PoertA

161
 ldd wl,z+0                 ;und PortB holen

162
 ldi zl,zeichen             ;und

163
 std z+6,wl                 ;in linke Stelle PortB

164
 std z+9,wh                 ;und PortA speichern

165
 subi wert2,low(-100)       ;Unterlauf

166
 sbci wert3,high(-100)      ;korregieren

167
 ldi zl,bimu-1              ;Z-Pointer auf 1 Adresse unter Ziffer 0

168
machwert3:

169
 inc zl                     ;Index (Zehner) hoch,

170
 subi wert2,low(10)         ;Zehn wegnehmen

171
 brsh machwert3             ;schon unter 0? - nein, nochmal...

172
 ldd wh,z+12                ;ja, Ziffer-Bitmuster PoertA

173
 ldd wl,z+0                 ;und PortB holen

174
 ldi zl,zeichen             ;und

175
 std z+7,wl                 ;in mittlere Stelle PortB

176
 std z+10,wh                ;und PortA speichern

177
 subi wert2,low(-10)        ;Unterlauf korregieren

178
 ldi zl,bimu                ;Z-Pointer auf Adresse Ziffer 0

179
 add zl,wert2               ;Rest dazu

180
 ldd wh,z+12                ;ja, Ziffer-Bitmuster PoertA

181
 ldd wl,z+0                 ;und PortB holen

182
 ldi zl,zeichen             ;und

183
 std z+8,wl                 ;in rechte Stelle PortB

184
 std z+11,wh                ;und PortA speichern

185
 clr wert1                  ;Kumulation

186
 clr wert2                  ;wieder bei 0

187
 clr wert3                  ;beginnen

188
 ldi wl,low(skalier+257)    ;Startwert

189
 mov sfl,wl                 ;für

190
 ldi wl,high(skalier+257)   ;Skalierung (Kumulation)

191
 mov sfh,wl                 ;des Messwertes

192
 

193
machwert4:  ;Sammeln der Messwerte

194
 add wert1,mwl              ;Low-Byte Mittelwert addieren

195
 adc wert2,mwh              ;High-Byte mit Übertrag

196
 adc wert3,null             ;Null mit Übertrag

197
 rjmp mainloop              ;fertig...

198


199


200
adcc:           ;ISR, ADC-Messung fertig

201
 in srsk,sreg               ;SREG sichern

202
 out porta,ausa             ;alle Segmente an PortA

203
 out portb,ausb             ;und PortB erstmal aus

204
 ldd iwl,y+9                ;Segmente für PortA holen,

205
 ldd iwh,y+3                ;Digits für PortA holen,

206
 or iwl,iwh                 ;Digit.Bits einkopieren (mixen)

207
 out porta,iwl              ;und ausgeben,

208
 ldd iwl,y+6                ;Segmente für PortB holen,

209
 ld iwh,y+                  ;Digits für PortB holen und Pointer hoch

210
 or iwl,iwh                 ;Digit.Bits einkopieren (mixen)

211
 out portb,iwl              ;und ausgeben,

212
 cpi yl,zeichen+3           ;alle 3 Werte fertig?

213
 brne adcc1                 ;nein...

214
 ldi yl,zeichen             ;ja, von vorn beginnen

215
adcc1:

216
 sub mwn,mwl                ;1/256

217
 sbc mwl,mwh                ;des Mittelwert-Inhaltes

218
 sbc mwh,null               ;rausnehmen und wegwerfen,

219
 in iwl,adcl                ;ADC-Wert

220
 in iwh,adch                ;einlesen

221
 add mwn,iwl                ;1/256 des neuen Messwertes

222
 adc mwl,iwh                ;in den Mittelwert

223
 adc mwh,null               ;reinlegen

224
 inc scheibe                ;Zeitscheibe weiterdrehen

225
 ldi iwl,(1<<aden)|(1<<adsc)|(1<<adate)|(1<<adie)+3 ;ADC freilaufend mit 

226
; out adcsra,wl              ;Interrupt und Vorteiler 8 (125kHz) starten

227
; out sreg,srsk              ;SREG wiederherstellen

228
 reti                       ;fertig und zurück...

229


230


231
charset:;Zeichensatz L-aktiv, 

232
;            I   RML    ;I=Eingang, RML=rechts/mitte/links

233
;     gcbfade.          ;Segmente

234
.db 0b10000000,0b000    ;0

235
.db 0b10011110,0b000    ;1

236
.db 0b01010000,0b000    ;2

237
.db 0b00010010,0b000    ;3

238
.db 0b00001110,0b000    ;4

239
.db 0b00100010,0b000    ;5

240
.db 0b00100000,0b000    ;6

241
.db 0b10010110,0b000    ;7

242
.db 0b00000000,0b000    ;8

243
.db 0b00000010,0b000    ;9

244
.db 0b01111110,0b000    ;-

245
.db 0b11111110,0b000    ;Leer

246


247
stelle: ;Digit 

248
;            I   RML    ;I=Eingang, RML=rechts/mitte/links

249
.db 0b00000000,0b110    ;links

250
.db 0b00000000,0b101    ;mitte

251
.db 0b00000000,0b011    ;rechts

252
.db 0b11111110,0b111    ;aus

253


254


255


256
/*

257
charset:;Zeichensatz L-aktiv, 

258
;            I   RML    ;I=Eingang, RML=rechts/mitte/links

259
;     gfedcba           ;Segmente

260
.db 0b10000000,0b000    ;0

261
.db 0b11110010,0b000    ;1

262
.db 0b01001000,0b000    ;2

263
.db 0b01100000,0b000    ;3

264
.db 0b00110010,0b000    ;4

265
.db 0b00100100,0b000    ;5

266
.db 0b00000100,0b000    ;6

267
.db 0b11110000,0b000    ;7

268
.db 0b00000000,0b000    ;8

269
.db 0b00100000,0b000    ;9

270
.db 0b01111110,0b000    ;-

271
.db 0b11111110,0b000    ;Leer

272


273
stelle: ;Digit 

274
;            I   RML    ;I=Eingang, RML=rechts/mitte/links

275
.db 0b00000000,0b110    ;links

276
.db 0b00000000,0b101    ;mitte

277
.db 0b00000000,0b011    ;rechts

278
.db 0b11111110,0b111    ;aus

279


280
*/

281


282


283
/*

284
charset:;Zeichensatz L-aktiv, IN = Eingang, L, M, R = Digits

285
;(A7=IN A6=G A5=B A4=R A3=M A2=F A1=A A0=L B2=C B1=D B0=E)

286
;     I  RM  L          ;I=Eingang, RML=rechts/mitte/links

287
;     .gb..fa.   cde    ;Segmente

288
.db 0b01000000,0b000    ;0

289
.db 0b01000110,0b011    ;1

290
.db 0b00000100,0b100    ;2

291
.db 0b00000100,0b001    ;3

292
.db 0b00000010,0b011    ;4

293
.db 0b00100000,0b001    ;5

294
.db 0b00100000,0b000    ;6

295
.db 0b01000100,0b011    ;7

296
.db 0b00000000,0b000    ;8

297
.db 0b00000000,0b001    ;9

298
.db 0b00100110,0b111    ;-

299
.db 0b01100110,0b111    ;Leer

300


301
stelle: ;Digit (links=A0 mitte=A3 rechts=A4, H-aktiv)

302
;     I  RM  L          ;I=Eingang, RML=rechts/mitte/links

303
.db 0b00000001,0b000    ;links

304
.db 0b00001000,0b000    ;mitte

305
.db 0b00010000,0b000    ;rechts

306
.db 0b01111111,0b111    ;aus

307
*/
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1931877
Lesenswert?
• ▲
▼ 
Volti schrieb:
> Wie gebe ich denn einen konstanten Wert aus ?
> Schaltplan ist am Anfang!
>
> Wie mache ich das ?


Sieht so aus als ob du noch weiter bei den Basics anfangen müsstest, als 
ich zunächst angenommen habe.

Vergiss fürs erste dass du 4 7-Segment Anzeigen hast.
Was musst du tun, damit auf LED1 etwas leuchtet und alle anderen dunkel 
sind?

Konzentrier dich im Moment einfach nur auf LED1.

Dazu muss der Transistor T1 durchschalten, damit die Anzeige mit + 
verbunden wird und alle anderen Transistoren müssen sperren.

Dieser NPN Transistor ist dann durchgeschaltet, wenn an seiner Basis 
eine 1 anliegt. Bei einer 0 an der Basis sperrt er.

D.h. du musst T1 durch ausgeben eines 1 Bits durchschalten (alle anderen 
bekommen eine 0) und du musst natürlich auf den 7 Segmentleitungen 
diejenigen auf 0 setzen, deren Segmente leuchten sollen.
Dies deshalb, weil du ja aus Sicht des jeweiligen Segments einen 
geschlossenen Stromkreis brauchst: Von + kommt der Strom über den 
durchgeschalteten Transistor, geht durch die jeweilige LED und muss über 
den µC abfliessen können. Dazu muss aber der jeweilige µC Pin auf 0 
sein.


Deine erste Aufgabe:
 Teilaufgabe 1:
    An LED1 gezielt einzelne Segmente zum Aufleuchten bringen.
 Teilaufgabe 2:
    AN LED1 diejenigen Segmente aufleuchten lassen, so dass sich
    eine 1, 2, 3 etc ergibt.
 Teilaufgabe 3:
    Das ganze so gestalten, dass du die auszugebende Ziffer in einer
    Variablen hast, und dein Code dann die dazu passende Segmentbelegung
    zb aus einer Tabelle zusammensucht und auf LED1 ausgibt.


Edit: Korrektur - hatte mich im Schaltplan verschaut. Sind ja NPN 
Transistoren und keine PNP. Die jetzt beschriebene Bitausgabe an die 
Transistorbasen ist die richtige.
Aber eigentlich sollten diese NPN Transistoren überhaupt PNP sein. D.h. 
da ist die Schaltung ebenfalls schon Murks.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Hannes L. #1931940
Lesenswert?
• ▲
▼ 
> Aber eigentlich sollten diese NPN Transistoren überhaupt PNP sein. D.h.
> da ist die Schaltung ebenfalls schon Murks.

Kann man nicht so pauschal sagen. Wenn man Anzeigen mit geringer 
Flussspannung verwendet, macht es durchaus Sinn, die Treiber als 
Emitterfolger (Kollektorschaltung) zu schalten. Denn da stört der 
zusätzliche Spannungsabfall nicht. Bei Verwendung von blauen Anzeigen 
geht das natürlich nicht. Und größere Anzeigen mit mehreren LEDs in 
Reihe brauchen sowiso eine separate, höhere Versorgungsspannung und auch 
open-Coll.-Treiber für die Segmente.

Aber Volti sollte wirklich erstmal versuchen, nacheinander die Ziffern 
von 0 bis 9 einzeln auf ein Digit der Anzeige auszugeben. Dann im 
nächsten Schritt eine mehrstellige Konstante über alle Digits 
(Schwerpunkt: Zerlegung der Zahl in Ziffern und Anzeige deren Bitmuster 
im Multiplex). Danach kann er sich dann Gedanken über die Skalierung des 
Messwertes machen.

Es gibt viel zu tun, schauen wir weg... ;-)

...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
MWS Gast #1932038
Lesenswert?
• ▲
▼ 
Das sollte mal die grundsätzliche Gedankenverschlingung lösen :D

1
Displayinterrupt:

2
  Incr help

3
    Portb = 0   ' leds vor dem Umschalten austasten

4
    Portd = Lookup(disp(help) , Siebensegmentchartab)

5
      Help2 = Help - 1

6
        Set Portb.help2

7
          If help > 3 Then help = 0

8
Return
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren