mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Voltmeter Software!


Autor: Volti (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht 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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Funktioniert denn die Ausgabe, wenn du einfach mal eine konstanten Wert 
ausgeben lässt?

Displayinterrupt:
For Help = 1 To 4
   Portd = Lookup(disp(help) , Siebensegmentchartab)
   Help2 = Help - 1
   Set Portb.help2
   Waitms 3
Next
Portb = &H00
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
)
Displayinterrupt:
  Set Portb.help2                  ' jetzige Anzeige ausschalten

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

                                   ' das zu dieser Anzeige gehörende Bitmuster 
                                   ' ausgeben
  Portd = Lookup(disp(help2 + 1) , Siebensegmentchartab)

  Reset Portb.help2                ' und die Anzeige einschalten
Return

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das hier
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

erscheint mir unmässig kompliziert.
 Moden:
   If Modenvara > -999 And Modenvara < 9999 Then
      For Modenvare = 1 To 4
        Disp(modenvare) = Modenvara Mod 10
        Modenvara = Modenvara / 10
      Next
   End If
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.

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nur mal so zum querlesen:
'************************** VOLTMETER-TEST 
$regfile = "atTiny24.dat"                                   'ATTiny24-Deklarationen
$crystal = 1000000                                          'Interner Takt benutzt

Dim Bimu(12) As Byte                                        'Bitmuster für Zeichen
Dim Dimu(3) As Byte                                         'Digit-Bitmuster
Dim Zeichen(3)as Byte                                       'Bitmuster zur Ausgabe
Dim Messwert As Long                                        'kumulativer Messwert
Dim Messwert2 As Long                                       'Zwischenwert zum Ermitteln der Ziffern
Dim Digit As Byte                                           'Index auf Ausgabeposition
Dim Ziffer As Byte                                          'temp. Index auf Zeichenbitmuster
Dim I As Byte                                               'Schleifenzähler

On Adc Onadc                                                'Adc -interrupt

Ddra = &B11111110                                           'Alles Ausgang ausser PA0
Porta = &B00000000                                          'Ziehwiderstand an PA0 ausschalten
Didr0 = &B00000001                                          'Digitalteil abschalten
Ddrb = &B00000111                                           'PB0,1,2 als Ansteuerung der Segmenttreiber
Admux = &B10000000                                          'Aref=VCC, Rechtsbündig, ADC0 auswählen
Adcsra = &B11101011                                         'ADC freilaufend mit Interrupt ein, VT 8
!sei                                                        'Interrupts global erlauben

Restore Bitmuster                                           'Pointer Auf Anfang Flash-Tabelle
For I = 1 To 12
   Read Ziffer                                              'Ziffern-Bitmuster
   Bimu(i) = Ziffer                                         'ins Array kopieren
Next I
Restore Digitmuster                                         'Pointer Auf Anfang Flash-Tabelle
For I = 1 To 3
   Read Ziffer                                              'Digitschalt-Bitmuster
   Dimu(i) = Ziffer                                         'ins Array kopieren
Next I

'******************************Hauptschleife************************************
Do
'   Messwert2 = Messwert * 125                               'Messwert für 5V skalieren
'   Messwert2 = Messwert * 250                               'Messwert für 10V skalieren
   Messwert2 = Messwert * 275                               'Messwert für 1 skalieren, interne Referenz 1,1V
   'Überlauf prüfen
   If Messwert2 > 256000 Then
      Zeichen(1) = Bimu(11)
      Zeichen(2) = Bimu(11)
      Zeichen(3) = Bimu(11)
   Else
      'linke Ziffer ermitteln
      Ziffer = 0                                               'Zwischenwert (Index auf Bitmuster) löschen
      Do                                                       'linke Ziffer ermitteln (Index
         Incr Ziffer                                           'hoch und Stellenwert
         Messwert2 = Messwert2 - 25600                         'Subtrahieren)
      Loop Until Messwert2 < 0                                 'bis zum Unterlauf,
      Messwert2 = Messwert2 + 25600                            'Unterlauf korregieren
      Zeichen(3) = Bimu(ziffer)                                'und zugehöriges Bitmuster aus Array holen
      'mittlere Ziffer ermitteln
      Ziffer = 0                                               'Index auf 0
      Do
         Incr Ziffer                                           'Index hoch,
         Messwert2 = Messwert2 - 2560                          'Wertigkeit abziehen
      Loop Until Messwert2 < 0                                 'bis zum Unterlauf
      Messwert2 = Messwert2 + 2560                             'Unterlauf-Korrektur
      Zeichen(2) = Bimu(ziffer)                                'Bitmuster holen
      'rechte Ziffer ermitteln
      Ziffer = 0                                               'index auf 0
      Do
         Incr Ziffer                                           'Index hoch
         Messwert2 = Messwert2 - 256                           'Wertigkeit abziehen
      Loop Until Messwert2 < 0                                 'bis zum Unterlauf
      Zeichen(1) = Bimu(ziffer)                                'Bitmuster zuweisen

   End If
Loop                                                        'nochmal

'****************************ADC Interrupt**************************************
Onadc:
   Messwert = Adcd                                          'ADC einlesen
'   Portb = 0                                                'alle Digits aus (g. Kathode)
   Portb = 7                                                'alle Digits aus (g. Anode)
   Incr Digit                                               'Digit hochzählen
   If Digit = 4 Then Digit = 1                              'und begrenzen
   Porta = Zeichen(digit)                                   'Bitmuster ausgeben
   Portb = Dimu(digit)                                      'Digit einschalten
Return                                                      'fertig...

'****************************Konstanten*****************************************
Bitmuster:                                                  'Low-aktive Segmente an PA1..PA7
Data &H80 , &H9E , &H50 , &H12 , &H0E , &H22 , &H20 , &H96 , &H00 , &H02 , &H7E , &HFE

Digitmuster:                                                'Low-aktive Digit-Treiber (PNP)
Data 3 , 5 , 6 , 7
'gerade Anzahl der Elemente wegen der Ordnung

...

Autor: Volti (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann mir jemand die Software mal umstellen wie ihr das meint?
Wenn ich die Einfüge und Complementiere kommen nur fehler :(
ich stege da nicht mehr durch...
Am besten in Assembler...

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
In Assembler?

Na gut:
;Voltmeter mit Tiny24 und dreistelliger Lichtschacht-Anzeige mit 
;gemeinsamer Anode je Ziffer und PNP-Transistoren als Digit-Treiber.

.include "tn24def.inc"  ;Portnamen

.equ skalier=125        ;Skalierfaktor
.equ bremse=50          ;Anzeigebremse (verlangsamt Berechnung)

.dseg                   ;SRAM
.org sram_start         ;Anfang
bimu:       .byte 24    ;Bitmuster für Zeichensatz (16-Bit)
    ;12 Segment-Bitmuster für PortB (0..11)
    ;12 Segment-Bitmuster für PortA (12..23)

zeichen:    .byte 12    ;Zeichen- und Digit-Bitmuster der 3 Stellen
    ;3 Digit-Bitmuster für PortB (0..2)
    ;3 Digit-Bitmuster für PortA (3..5)
    ;3 Segment-Bitmuster für PortB (6..8)
    ;3 Segment-Bitmuster für PortA (9..11)

.def null=r3            ;immer 0
.def srsk=r4            ;SREG-Kopie
.def mwn=r5             ;Messwert / Mittelwert Nachkomma
.def mwl=r6             ;Messwert / Mittelwert Low
.def mwh=r7             ;Messwert / Mittelwert High
.def scheibe=r8         ;Zeitscheibe
.def sfl=r9             ;Skalierfaktorzähler Low
.def sfh=r10            ;Skalierfaktorzähler High
.def ausa=r11           ;Bitmuster Digits aus PortA
.def ausb=r12           ;Bitmuster Digits aus PortB

.def wert1=r16          ;Low-Byte Zwischenwert zur Skalierung
.def wert2=r17          ;Mid-Byte
.def wert3=r18          ;High-Byte

.def digit=r21          ;Digit-Zähler für Anzeige-Multiplexing
.def iwl=r22            ;ISR-Working L
.def iwh=r23            ;ISR-Working H
.def wl=r24             ;Working L
.def wh=r25             ;Working H

.cseg
.org 0
 rjmp RESET         ;Reset Handler
 rjmp nix;EXT_INT0      ;IRQ0 Handler
 rjmp nix;PCINT0        ;PCINT0 Handler
 rjmp nix;PCINT1        ;PCINT1 Handler
 rjmp nix;WATCHDOG      ;Watchdog Interrupt Handler
 rjmp nix;TIM1_CAPT     ;Timer1 Capture Handler
 rjmp nix;TIM1_COMPA    ;Timer1 Compare A Handler
 rjmp nix;TIM1_COMPB    ;Timer1 Compare B Handler
 rjmp nix;TIM1_OVF      ;Timer1 Overflow Handler
 rjmp nix;TIM0_COMPA    ;Timer0 Compare A Handler
 rjmp nix;TIM0_COMPB    ;Timer0 Compare B Handler
 rjmp nix;TIM0_OVF      ;Timer0 Overflow Handler
 rjmp nix;ANA_COMP      ;Analog Comparator Handler
 rjmp ADCC          ;ADC Conversion Handler
 rjmp nix;EE_RDY        ;EEPROM Ready Handler
 rjmp nix;USI_STR       ;USI STart Handler
 rjmp nix;USI_OVF       ;USI Overflow Handler
nix:
 rjmp nix
;
RESET:
 ldi wl,low(RAMEND)         ;Stackpointer-Init
 out SPL,wl
 clr null                   ;immer 0
 clr mwn                    ;Messwert 
 clr mwl                    ;erstmal
 clr mwh                    ;auf 0
 
 out porta,null             ;alle Ports
 out portb,null             ;auf L-Pegel,
 ldi wl,$fe                 ;alle Portpins 
 out ddra,wl                ;außer 
 ldi wl,7                   ;PA0
 out ddrb,wl                ;als Ausgang
 sbi didr0,0                ;Digitalteil vom ADC-Port trennen

 ldi zl,low(charset*2)      ;Bitmuster
 ldi zh,high(charset*2)     ;im Flash
 ldi yl,bimu                ;Array 
 clr yh                     ;im SRAM
reset1:
 lpm r0,z+                  ;Segment-Bits für PortA
 std y+12,r0                ;in obere Array-Hälfte kopieren
 lpm r0,z+                  ;Segment-Bits für PortB
 st y+,r0                   ;in untere Array-Hälfte kopieren
 cpi yl,bimu+12             ;alle 12 Werte fertig?
 brne reset1                ;nein, nochmal...

 ldi zl,low(stelle*2)       ;Bitmuster für Digits
 ldi zh,high(stelle*2)      ;im Flash
 ldi yl,zeichen             ;Array für Zeichen und Digits im SRAM
 lds wh,bimu+12             ;Bitmuster für 0 PortA
 lds wl,bimu                ;und PortB holen
reset2:
 std y+9,wh                 ;Startwert PortA in oberes Array-Viertel
 std y+6,wl                 ;Startwert PortB in drittes Array-Viertel
 lpm r0,z+                  ;Digit-Bits für PortA
 std y+3,r0                 ;in zweites Array-Viertel kopieren
 lpm r0,z+                  ;Digit-Bits für PortB
 st y+,r0                   ;in unteres Array-Viertel kopieren
 cpi yl,zeichen+3           ;alle 3 Werte fertig?
 brne reset2                ;nein, nochmal...
 lpm ausa,z+                ;Bitmuster für Digits aus
 lpm ausb,z+                ;holen
; ldi wl,(1<<refs1)+0        ;ADC0 (PA0) gegen interne 1,1V
 ldi wl,0                   ;ADC0 (PA0) gegen Vcc (5V)
 out admux,wl               ;rechtsbündig messen
 ldi wl,(1<<aden)|(1<<adsc)|(1<<adate)|(1<<adie)+3 ;ADC freilaufend mit 
 out adcsra,wl              ;Interrupt und Vorteiler 8 (125kHz) starten
 ldi yl,zeichen             ;Startwert für Display-Multiplexing in der ISR
 ldi zh,0                   ;für Mainloop vorbereiten
 ldi wl,low(skalier+257)    ;Startwert
 mov sfl,wl                 ;für
 ldi wl,high(skalier+257)   ;Skalierung (Kumulation)
 mov sfh,wl                 ;des Messwertes
 ldi wl,1<<se               ;Sleep-Mode IDLE 
 out mcucr,wl               ;vobereiten
 sei                        ;Enable interrupts

mainloop:       ;Hauptschleife
 tst scheibe                ;Zeitscheibe auf 0?
 breq machwert              ;ja, Wert machen...

 sleep                      ;bis zum nächsten Interrupt pennen
 rjmp mainloop              ;nochmal...

machwert:       ;Job der Hauptschleife, gibt Messwert an Anzeige
 ldi wl,-bremse             ;Startwert Anzeigebremse
 mov scheibe,wl             ;setzen
 dec sfl                    ;Rundenzähler L runter
 brne machwert4             ;unten? - nein, weiter sammeln...
 dec sfh                    ;ja, H-Byte auch
 brne machwert4             ;unten? - nein, weiter sammeln...
 ;Zähler unten angekommen, Wert ausgeben
 
 ldi wh,high(1000)          ;Kopie für CPC
 cpi wert2,low(1000)        ;Wert über 999?
 cpc wert3,wh
 brlo machwert1             ;nein, berechnen...
 lds wh,bimu+10+12          ;Bitmuster für '-' (PortA)
 lds wl,bimu+10             ;(PortB) holen
 ldi zl,zeichen+3           ;für alle 3 Stellen
 std z+0,wl                 ;Minuszeichen
 std z+1,wl                 ;eintragen
 std z+2,wl
 std z+3,wh
 std z+4,wh
 std z+5,wh
 rjmp mainloop              ;fertig...
machwert1:
 ldi zl,bimu-1              ;Z-Pointer auf 1 Adresse unter Ziffer 0
machwert2:
 inc zl                     ;Index (Hunderter) hoch,
 subi wert2,low(100)        ;Hundert
 sbci wert3,high(100)       ;wegnehmen
 brsh machwert2             ;schon unter 0? - nein, nochmal...
 ldd wh,z+12                ;ja, Ziffer-Bitmuster PoertA
 ldd wl,z+0                 ;und PortB holen
 ldi zl,zeichen             ;und
 std z+6,wl                 ;in linke Stelle PortB
 std z+9,wh                 ;und PortA speichern
 subi wert2,low(-100)       ;Unterlauf
 sbci wert3,high(-100)      ;korregieren
 ldi zl,bimu-1              ;Z-Pointer auf 1 Adresse unter Ziffer 0
machwert3:
 inc zl                     ;Index (Zehner) hoch,
 subi wert2,low(10)         ;Zehn wegnehmen
 brsh machwert3             ;schon unter 0? - nein, nochmal...
 ldd wh,z+12                ;ja, Ziffer-Bitmuster PoertA
 ldd wl,z+0                 ;und PortB holen
 ldi zl,zeichen             ;und
 std z+7,wl                 ;in mittlere Stelle PortB
 std z+10,wh                ;und PortA speichern
 subi wert2,low(-10)        ;Unterlauf korregieren
 ldi zl,bimu                ;Z-Pointer auf Adresse Ziffer 0
 add zl,wert2               ;Rest dazu
 ldd wh,z+12                ;ja, Ziffer-Bitmuster PoertA
 ldd wl,z+0                 ;und PortB holen
 ldi zl,zeichen             ;und
 std z+8,wl                 ;in rechte Stelle PortB
 std z+11,wh                ;und PortA speichern
 clr wert1                  ;Kumulation
 clr wert2                  ;wieder bei 0
 clr wert3                  ;beginnen
 ldi wl,low(skalier+257)    ;Startwert
 mov sfl,wl                 ;für
 ldi wl,high(skalier+257)   ;Skalierung (Kumulation)
 mov sfh,wl                 ;des Messwertes
 
machwert4:  ;Sammeln der Messwerte
 add wert1,mwl              ;Low-Byte Mittelwert addieren
 adc wert2,mwh              ;High-Byte mit Übertrag
 adc wert3,null             ;Null mit Übertrag
 rjmp mainloop              ;fertig...


adcc:           ;ISR, ADC-Messung fertig
 in srsk,sreg               ;SREG sichern
 out porta,ausa             ;alle Segmente an PortA
 out portb,ausb             ;und PortB erstmal aus
 ldd iwl,y+9                ;Segmente für PortA holen,
 ldd iwh,y+3                ;Digits für PortA holen,
 or iwl,iwh                 ;Digit.Bits einkopieren (mixen)
 out porta,iwl              ;und ausgeben,
 ldd iwl,y+6                ;Segmente für PortB holen,
 ld iwh,y+                  ;Digits für PortB holen und Pointer hoch
 or iwl,iwh                 ;Digit.Bits einkopieren (mixen)
 out portb,iwl              ;und ausgeben,
 cpi yl,zeichen+3           ;alle 3 Werte fertig?
 brne adcc1                 ;nein...
 ldi yl,zeichen             ;ja, von vorn beginnen
adcc1:
 sub mwn,mwl                ;1/256
 sbc mwl,mwh                ;des Mittelwert-Inhaltes
 sbc mwh,null               ;rausnehmen und wegwerfen,
 in iwl,adcl                ;ADC-Wert
 in iwh,adch                ;einlesen
 add mwn,iwl                ;1/256 des neuen Messwertes
 adc mwl,iwh                ;in den Mittelwert
 adc mwh,null               ;reinlegen
 inc scheibe                ;Zeitscheibe weiterdrehen
 ldi iwl,(1<<aden)|(1<<adsc)|(1<<adate)|(1<<adie)+3 ;ADC freilaufend mit 
; out adcsra,wl              ;Interrupt und Vorteiler 8 (125kHz) starten
; out sreg,srsk              ;SREG wiederherstellen
 reti                       ;fertig und zurück...


charset:;Zeichensatz L-aktiv, 
;            I   RML    ;I=Eingang, RML=rechts/mitte/links
;     gcbfade.          ;Segmente
.db 0b10000000,0b000    ;0
.db 0b10011110,0b000    ;1
.db 0b01010000,0b000    ;2
.db 0b00010010,0b000    ;3
.db 0b00001110,0b000    ;4
.db 0b00100010,0b000    ;5
.db 0b00100000,0b000    ;6
.db 0b10010110,0b000    ;7
.db 0b00000000,0b000    ;8
.db 0b00000010,0b000    ;9
.db 0b01111110,0b000    ;-
.db 0b11111110,0b000    ;Leer

stelle: ;Digit 
;            I   RML    ;I=Eingang, RML=rechts/mitte/links
.db 0b00000000,0b110    ;links
.db 0b00000000,0b101    ;mitte
.db 0b00000000,0b011    ;rechts
.db 0b11111110,0b111    ;aus



/*
charset:;Zeichensatz L-aktiv, 
;            I   RML    ;I=Eingang, RML=rechts/mitte/links
;     gfedcba           ;Segmente
.db 0b10000000,0b000    ;0
.db 0b11110010,0b000    ;1
.db 0b01001000,0b000    ;2
.db 0b01100000,0b000    ;3
.db 0b00110010,0b000    ;4
.db 0b00100100,0b000    ;5
.db 0b00000100,0b000    ;6
.db 0b11110000,0b000    ;7
.db 0b00000000,0b000    ;8
.db 0b00100000,0b000    ;9
.db 0b01111110,0b000    ;-
.db 0b11111110,0b000    ;Leer

stelle: ;Digit 
;            I   RML    ;I=Eingang, RML=rechts/mitte/links
.db 0b00000000,0b110    ;links
.db 0b00000000,0b101    ;mitte
.db 0b00000000,0b011    ;rechts
.db 0b11111110,0b111    ;aus

*/


/*
charset:;Zeichensatz L-aktiv, IN = Eingang, L, M, R = Digits
;(A7=IN A6=G A5=B A4=R A3=M A2=F A1=A A0=L B2=C B1=D B0=E)
;     I  RM  L          ;I=Eingang, RML=rechts/mitte/links
;     .gb..fa.   cde    ;Segmente
.db 0b01000000,0b000    ;0
.db 0b01000110,0b011    ;1
.db 0b00000100,0b100    ;2
.db 0b00000100,0b001    ;3
.db 0b00000010,0b011    ;4
.db 0b00100000,0b001    ;5
.db 0b00100000,0b000    ;6
.db 0b01000100,0b011    ;7
.db 0b00000000,0b000    ;8
.db 0b00000000,0b001    ;9
.db 0b00100110,0b111    ;-
.db 0b01100110,0b111    ;Leer

stelle: ;Digit (links=A0 mitte=A3 rechts=A4, H-aktiv)
;     I  RM  L          ;I=Eingang, RML=rechts/mitte/links
.db 0b00000001,0b000    ;links
.db 0b00001000,0b000    ;mitte
.db 0b00010000,0b000    ;rechts
.db 0b01111111,0b111    ;aus
*/

Autor: Volti (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie gebe ich denn einen konstanten Wert aus ?
Schaltplan ist am Anfang!

Wie mache ich das ?

Autor: Bitte einen Namen eingeben (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Wie mache ich das ?
Das hat Karl heinz Buchegger oben bereits geschildert, also: Lesen!

@Hannes Lux
DAS ist wenigstens verständlich! Immer dieses Bascomgewusel...

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht 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... ;-)

...

Autor: MWS (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das sollte mal die grundsätzliche Gedankenverschlingung lösen :D
Displayinterrupt:
  Incr help
    Portb = 0   ' leds vor dem Umschalten austasten
    Portd = Lookup(disp(help) , Siebensegmentchartab)
      Help2 = Help - 1
        Set Portb.help2
          If help > 3 Then help = 0
Return

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.