kostenloser Webspace werbefrei: lima-city


Programmierproblem Assembler

lima-cityForumProgrammiersprachenSonstige Programmiersprachen

  1. Autor dieses Themas

    s******n

    Hallo Leute

    ich habe ein kleines Problem und zwar muss ich in Assembler einen Temperatursensor Programmieren.
    Meine Idee war es den Wert des Sensors einzulesen. Ein 2 byte Pointer enthält die Look-up-table mit allen Werten. Der Pointer wird um den ADC_Wert erhöht und zeigt auf den Temperaturwert. Leider gibt es mir irgendwelche Zahlen zwischen 0-255 aus. Die LCD Routine funktioniert, nur die Look-up-table wird glaube ich nicht richtig eingelesen.Ich finde den Fehler einfach nicht. Ich hoffe jemand kann mir helfen.

    Mein Code lautet bis jetzt wie folgt:

    ___________________________________________________________________________________
    Temperatur_1
                    
                    ldhx    Pointer_Temp                          ; Pointer auf dem meine Look_up_Table gespeichert ist
                    lda     0,X                                      ; Erstes Byte des Pointers (Pointer = 2Byte)
                    add     ADC_Wert_PB0                      ; Erhöht um ADC_Wert von PortB 0
                    ;tax
                    sthx    Pointer_Temp                          ; Speichert neuen Wert auf Pointer Temp               
                    lda     1,X                                               ; Lade 2tes Byte vom Pointer
                    add     ADC_Wert_PB0                      ; erhöhe um ADC_Wert von PortB 0
                    ;tax
                    sthx    Pointer_Temp+1T                   ; Speicher auf 2tes Byte vom Pointer
    
                  
                    
    Ausgabe_Temp
    
                    ldhx    #Text                                          ; Diese Zeilen kopieren einfach den "Start-Text"
                    sthx    SourcePointer                          ; in das LCD-Buffer in der RAM
                    ldhx    #LCD_Oben
                    sthx    DestPointer
                    lda     #32T                                           ; Insgesamt 32 Zeichen (2 Zeilen á 16 Zeichen)
                    sta     TextLenght              
                    jsr     CopyText
                    
                    ldhx    Pointer_Temp                         
                    lda     0,x
                    ldhx    #LCD_Unten;+10T                 ;Schreibe Wert an Stelle 10 des Displays
                    sthx    DestPointer
                    jsr      DezimalBCD
                    
                    ldhx    Pointer_Temp
                    lda     1,x
                    ldhx    #LCD_Unten+12T
                    sthx    DestPointer                
                    jsr      DezimalBCD
    
    Laden                                                                                         ; Lade Look_up_Table auf Pointer
                    ldhx    #Ausgabe_Temp_Muster
                    sthx    Pointer_Temp 
                    rts  
                    
    Text                  
                    dc.b            'Temperatur:  , C'
                    dc.b            '                '

  2. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

  3. hackyourlife

    Moderator Kostenloser Webspace von hackyourlife

    hackyourlife hat kostenlosen Webspace.

    Assembler ≠ Assembler, du wirst also sagen müssen welchen Prozessor / Microcontroller du verwendest, falls du wirklich Hilfe bekommen möchtest.
  4. Autor dieses Themas

    s******n

    hackyourlife schrieb:
    Assembler ? Assembler, du wirst also sagen müssen welchen Prozessor / Microcontroller du verwendest, falls du wirklich Hilfe bekommen möchtest.


    Entschuldigung, habe ich vergessen
    FREESCALE SEMICONDUCTOR - MC9S08AW32CPUE - IC, 8BIT MCU 32K FLASH, SMD, LQFP64

    Danke für die Info
  5. Hallo,

    wenn du einen 2-byte-Pointer hast - irgendwo anders war das so - musst du das lowbyte und das highbyte andersherum reinladen?!
    Nur so eine Idee am Rande.
  6. Autor dieses Themas

    s******n

    mathesoft schrieb:
    Hallo,

    wenn du einen 2-byte-Pointer hast - irgendwo anders war das so - musst du das lowbyte und das highbyte andersherum reinladen?!
    Nur so eine Idee am Rande.



    Letztes Jahr in der Schule haben wir ebenfalls mit einem Pointer ein Lauflicht bzw. 2 Lauflichter ausgegeben und der code war wie folgt:

    Cool_Blinklicht
    
                    lda     Counter               ;Realtime_Zeitverzögerung
                    add     #1T                   
                    sta     Counter               
                    cmpa    #DELAY    
                    bne     Exit_Lauflicht
                    lda     #0T
                    sta     Counter
    
                    ldhx    Pointer               ;Lädt Muster auf Lauflicht
                    lda     0,X		      ;Pointer für PORTD auf Position 0
                    sta     PORTD
                    lda     1,X		      ;Pointer für PORTD auf Position 0
                    sta     PORTF
                    aix     #2T		      ;add immediate Value -> zählt 2 weiter bei Pointer (da 2ausgaben sind)
                    sthx    Pointer
                    cphx    #Muster_Fertig
                    beq     Laden
    
    Exit_Lauflicht
                    rts                           ;Zurück zum Hauptloop
                                                  
    
    Laden                                        
                    ldhx    #Muster               ;Speicher Muster im Pointer
                    sthx    Pointer
                    rts


    Ps. Dieses Programm hat Funktioniert

    Beitrag zuletzt geändert: 18.3.2013 0:22:04 von seppelin
  7. seppelin schrieb:
    Mein Code lautet bis jetzt wie folgt:

    ___________________________________________________________________________________
    Temperatur_1
                    
                    ldhx    Pointer_Temp                          ; Pointer auf dem meine Look_up_Table gespeichert ist
                    lda     0,X                                      ; Erstes Byte des Pointers (Pointer = 2Byte)
                    add     ADC_Wert_PB0                      ; Erhöht um ADC_Wert von PortB 0
                    ;tax
                    sthx    Pointer_Temp                          ; Speichert neuen Wert auf Pointer Temp               
                    lda     1,X                                               ; Lade 2tes Byte vom Pointer



    ich meine, wenn du es so rum probierst:
    Temperatur_1
                    
                    ldhx    Pointer_Temp                          ; Pointer auf dem meine Look_up_Table gespeichert ist
                    lda     1,X                                      ; Erstes Byte des Pointers (Pointer = 2Byte)
                    ;tax
                    sthx    Pointer_Temp                          ; Speichert neuen Wert auf Pointer Temp               
                    lda     0,X                                               ; Lade 2tes Byte vom Pointer
                    add     ADC_Wert_PB0                      ; Erhöht um ADC_Wert von PortB 0


    Oder aber...

    sthx    Pointer_Temp+1T


    ist das STHX nicht schon eine 16-Bit-Zuweisung (also 2Byte)? Was macht da dann das +1T ?
    oder heißt das "Store High eXtended", gibts auch ein "Store Low eXtended" STLX.

    Ich kenn den Prozessor nicht, aber gewisse Ähnlichkeiten sind schon da zu den 80x86.
    Vielleicht schreibe ich auch nur Müll 8-D
  8. Autor dieses Themas

    s******n


    ist das STHX nicht schon eine 16-Bit-Zuweisung (also 2Byte)? Was macht da dann das +1T ?
    oder heißt das "Store High eXtended", gibts auch ein "Store Low eXtended" STLX.


    sthx ist eine 2Byte Zuweisung, das +1T sollte nur dazu dienen das der 1Byte große Wert auf das 2te Byte geschrieben wird. Somit ist das erste Byte meine ganzzahliger Temperaturwert (zB. 25°C) und das 2te Byte für die Nachkommazahlen (zB. ...,5°C)

    sthx= Store H:X (2Byte Zuweisung ins hx-Register)
    sta=Store Accumulator in Memory (1Byte Zuweisung ins a-Register)

    Das vertauschen hat nichts geholfen, aber danke für die schnelle Antwort
  9. Hallo seppelin,

    so ganz verstehe ich den Code noch nicht. Ich würde als naheliegenstes mal fogendes versuchen:
    ldhx    Pointer_Temp    ; Lade (Pointer_Temp:Pointer_Temp+1) -> H:X
    lda     0, X            ; Lade H:X[0] -> A
    add     ADC_Wert_PB0    ; Addiere PB0 zu A
    sta     0, X            ; Speichere A -> H:X[0]
    lda     1, X            ; Lade H:X[1] -> A
    add     ADC_Wert_PB0    ; Addiere PB0 zu A
    sta     1, X            ; Speichere A -> H:X[1]
    sthx    Pointer_Temp    ; Speichere H:X -> (Pointer_Temp:Pointer_Temp+1)
    Allerdings kenne ich jetzt die MCU nicht und das Datenblatt ist auch nicht sehr ausführlich, was die Befehle angeht. Ich bin davon Ausgegangen, dass Pointer_Temp ein Lable bzw. eine Adresse darstellt und ADC_Wert_PB0 ein 8-Bit Wert ist. Nachdem ich jetzt aber nicht weis, wie deine Lookup-Table aussieht erschließt sich mir nicht, inwiefern das Addieren des ADC-High-Bytes sowohl zum niederwertigen als auch zum höherwertigen Byte ein sinnvolles Ergebnis liefern soll. Ich vermute jetzt einfach mal, das Du eigentlich eher eine Addition mit Übertrag (with Carry) benötigst um den Zeiger auf die Lookup-Table korrekt zu erhöhen.
    Desweiteren sieht es so aus, als ob Du ständig den Zeiger erhöhst, d.h. Du summierst die ADC-Werte immer weiter auf, was eigentlich irgenwann zu einem Überlauf führen müsste.
    Ich vermute weiter, dass Du eigentlich sowas haben willst:
    <Zeiger auf Text> = <Basisadresse>+<ADC-Wert>
    Dann könnte es vielleicht so aussehen:
    ldhx    lookup_base     ; Lade Basisadresse der LUT -> H:X
    lda     0, X            ; Lade H:X[0] -> A
    add     ADC_Wert_PB0    ; Addiere PB0 zu A
    sta     0, X            ; Speichere A -> H:X[0]
    lda     1, X            ; Lade H:X[1]
    adc     #0T             ; Addiere Übertrag zu A
    sta     1, X            ; Speichere A -> H:X[1]
    sthx    text_address    ; Speichere H:X -> Text Adresse
    Das ist jetzt unter der Annahme, dass lda 0,X das niederwertige Byte lädt, ansonsten musst Du erst lda 1,X und als zweites lda 0,X schreiben. Desweiteren darf das Carry-Flag durch die Lade und Speicher Befehle nicht geändert werden, sonst funktioniert es nicht.


  10. Autor dieses Themas

    s******n

    Danke darkpandemic

    Es stimmt, der ADC hat einen 8-Bit Wert. Im Pointer habe ich die Werte der LUT gespeichert.

    Ausgabe_Temp_Muster
    
              dc.b	10,0
              dc.b	9,9
              dc.b	9,8
              dc.b	9,7
              dc.b	9,6
              dc.b	9,5
              dc.b	9,4
              dc.b	9,3
              dc.b	9,2
              dc.b	9,1
              dc.b	9,0
              dc.b	8,9
              dc.b	7,2
              dc.b	6,9
              dc.b	6,7
              dc.b	6,5
              dc.b	6,2
              dc.b	6,0
              dc.b	5,8
              dc.b	5,5
              dc.b	5,3
              dc.b	5,1
              dc.b	4,8
              dc.b	4,6
              dc.b	4,4
              dc.b	4,1
              dc.b	3,9
              dc.b	3,6
              dc.b	3,4
              dc.b	3,2
              dc.b	2,9
              dc.b	2,7
              dc.b	2,5
              dc.b	2,2
              dc.b	2,0
              dc.b	1,8
              dc.b	1,5
              dc.b	1,3
              dc.b	1,1
              dc.b	0,8
              dc.b	0,6
              dc.b	0,4
              dc.b	0,1
              dc.b	0,1
              dc.b	0,4
              dc.b	0,6
              dc.b	0,8
              dc.b	1,1
              dc.b	1,3
              dc.b	1,5
              dc.b	1,8
              dc.b	2,0
              dc.b	2,2
              dc.b	2,5
              dc.b	2,7
              dc.b	2,9
              dc.b	3,2
              dc.b	3,4
              dc.b	3,6
              dc.b	3,9
              dc.b	4,1
              dc.b	4,4
              dc.b	4,6
              dc.b	4,8
              dc.b	5,1
              dc.b	5,3
              dc.b	5,5
              dc.b	5,8
              dc.b	6,0
              dc.b	6,2
              dc.b	6,5
              dc.b	6,7
              dc.b	6,9
              dc.b	7,2
              dc.b	7,4
              dc.b	7,6
              dc.b	7,9
              dc.b	8,1
              dc.b	8,4
              dc.b	8,6
              dc.b	8,8
              dc.b	9,1
              dc.b	9,3
              dc.b	9,5
              dc.b	9,8
              dc.b	10,0
              dc.b	10,2
              dc.b	10,5
              dc.b	10,7
              dc.b	10,9
              dc.b	11,2
              dc.b	11,4
              dc.b	11,6
              dc.b	11,9
              dc.b	12,1
              dc.b	12,4
              dc.b	12,6
              dc.b	12,8
              dc.b	13,1
              dc.b	13,3
              dc.b	13,5
              dc.b	13,8
              dc.b	14,0
              dc.b	14,2
              dc.b	14,5
              dc.b	14,7
              dc.b	14,9
              dc.b	15,2
              dc.b	15,4
              dc.b	15,6
              dc.b	15,9
              dc.b	16,1
              dc.b	16,4
              dc.b	16,6
              dc.b	16,8
              dc.b	17,1
              dc.b	17,3 
              dc.b	17,5
              dc.b	17,8 
              dc.b	18,0   
              dc.b	18,2 
              dc.b	18,5 
              dc.b	18,7 
              dc.b	18,9 
              dc.b	19,2 
              dc.b	19,4 
              dc.b	19,6 
              dc.b	19,9 
              dc.b	20,1 
              dc.b	20,4 
              dc.b	20,6 
              dc.b	20,8 
              dc.b	21,1 
              dc.b	21,3 
              dc.b	21,5 
              dc.b	21,8 
              dc.b	22,0   
              dc.b	22,2 
              dc.b	22,5 
              dc.b	22,7 
              dc.b	22,9 
              dc.b	23,2 
              dc.b	23,4 
              dc.b	23,6 
              dc.b	23,9 
              dc.b	24,1 
              dc.b	24,4 
              dc.b	24,6 
              dc.b	24,8 
              dc.b	25,1 
              dc.b	25,3 
              dc.b	25,5 
              dc.b	25,8 
              dc.b	26,0   
              dc.b	26,2 
              dc.b	26,5 
              dc.b	26,7 
              dc.b	26,9 
              dc.b	27,2 
              dc.b	27,4 
              dc.b	27,6 
              dc.b	27,9
              dc.b	28,1
              dc.b	28,4
              dc.b	28,6
              dc.b	28,8
              dc.b	29,1
              dc.b	29,3
              dc.b	29,5 
              dc.b	29,8 
              dc.b	30,0
              dc.b	30,2 
              dc.b	30,5 
              dc.b	30,7 
              dc.b	30,9 
              dc.b	31,2 
              dc.b	31,4 
              dc.b	31,6 
              dc.b	31,9 
              dc.b	32,1 
              dc.b	32,4 
              dc.b	32,6 
              dc.b	32,8 
              dc.b	33,1
              dc.b	33,3 
              dc.b	33,5 
              dc.b	33,8 
              dc.b	34,0   
              dc.b	34,2 
              dc.b	34,5 
              dc.b	34,7 
              dc.b	34,9
              dc.b	35,2 
              dc.b	35,4 
              dc.b	35,6 
              dc.b	35,9 
              dc.b	36,1 
              dc.b	36,4 
              dc.b	36,6 
              dc.b	36,8 
              dc.b	37,1 
              dc.b	37,3 
              dc.b	37,5 
              dc.b	37,8 
              dc.b	38,0   
              dc.b	38,2 
              dc.b	38,5 
              dc.b	38,7 
              dc.b	38,9 
              dc.b	39,2 
              dc.b	39,4 
              dc.b	39,6 
              dc.b	39,9 
              dc.b	40,1 
              dc.b	40,4 
              dc.b	40,6 
              dc.b	40,8 
              dc.b	41,1 
              dc.b	41,3 
              dc.b	41,5 
              dc.b	41,8 
              dc.b	42,0   
              dc.b	42,2 
              dc.b	42,5 
              dc.b	42,7 
              dc.b	42,9 
              dc.b	43,2 
              dc.b	43,4 
              dc.b	43,6 
              dc.b	43,9 
              dc.b	44,1 
              dc.b	44,4 
              dc.b	44,6 
              dc.b	44,8 
              dc.b	45,1 
              dc.b	45,3 
              dc.b	45,5 
              dc.b	45,8 
              dc.b	46,0   
              dc.b	46,2 
              dc.b	46,5 
              dc.b	46,7 
              dc.b	46,9 
              dc.b	47,2 
              dc.b	47,4 
              dc.b	47,6 
              dc.b	47,9 
              dc.b	48,1 
              dc.b	48,4 
              dc.b	48,6 
              dc.b	48,8 
              dc.b	49,1 
              dc.b	49,3 
              dc.b	49,5 
              dc.b	49,8 
              dc.b	50,0
    
    Muster_Fertig


    Der Temperaturbereich liegt zwischen -10 bis 50 °C, das minus Vorzeichen muss ich noch Programmieren (also das es von -10 bis 0°C anzeigt)
    Ich habe eben versucht das 1te Byte des Pointers für die ersten 2 zahlen zu verwenden und das 2te Byte des Pointers für die Nachkommastellen.
    Da der ADC_Wert relativ Konstant bleibt kann ich mit einem ADC_Wert beide Werte getrennt (auch wenn sie am Ende ein Ergebnis ergeben) ausgeben.

    Danke das Ihr so schnell Antwortet, ich hoffe meine Idee ist verständlicher.
  11. Hallo seppelin,

    dann ist es eher Lösungsansatz Nummer 2. Allerdings hat eine Speicherstelle bei Dir 2 Byte, weshalb man den ADC Wert mit 2 Multiplizieren müsste. Also gilt:
    <Adresse des Zahlenpaares> = <Basisadresse> + 2 * <ADC Wert>
    Nachdem die Multiplikation das X Register verwendet, in welchem wir die Basisaddresse haben, und der Akkumulator nur 8-Bit groß ist schreiben wir das lieber zu:
    <Adresse des Zahlenpaares> = <Basisadresse> + <ADC Wert> + <ADC Wert>
    um ;-)
    Könnte dann in etwa so aussehen:
    ldhx    Ausgabe_Temp_Muster     ; Lade Basisadresse -> H:X
    
    ; 1. Addition:
    lda     0, X                    ; Lade H:X[0] -> A
    add     ADC_Wert_PB0            ; Addiere PB0 zu A
    sta     0, X                    ; Speichere A -> H:X[0]
    lda     1, X                    ; Lade H:X[1] -> A
    adc     #0T                     ; Addiere Überhang
    sta     1, X                    ; Speichere A -> H:X[1]
    
    ; 2. Addition:
    lda     0, X                    ; Lade H:X[0] -> A
    add     ADC_Wert_PB0            ; Addiere PB0 zu A
    sta     0, X                    ; Speichere A -> H:X[0]
    lda     1, X                    ; Lade H:X[1] -> A
    adc     #0T                     ; Addiere Überhang
    sta     1, X                    ; Speichere A -> H:X[1]
    
    sthx    Pointer_Temp            ; Speichere H:X -> (Pointer_Temp:Pointer_Temp+1)
    Allerdings bin ich mir jetzt nicht ganz sicher, ob ich die Befehle ldhx, sthx und vor allem das lda *, X bzw. sta *,X richtig interpretiere. Aber ich hoffe die Grundidee ist klar.

    Edit: Falsch kopiert.



    Beitrag zuletzt geändert: 18.3.2013 22:25:54 von darkpandemic
  12. Autor dieses Themas

    s******n

    Derzeit wird 255,255 ausgegeben egal welchen ADC_Wert vorhanden ist. Ich verstehe nur nicht wieso es 2 Additionen benötigt und diese gleich aussehen.
  13. seppelin schrieb:
    Derzeit wird 255,255 ausgegeben egal welchen ADC_Wert vorhanden ist. Ich verstehe nur nicht wieso es 2 Additionen benötigt und diese gleich aussehen.


    Hm.. der Messfühler ist aber nicht kaputt / falsch gepolt? Bzw. du liest den korrekten Port aus? Nur so ein anderer Gedanke..
  14. Autor dieses Themas

    s******n

    Also ich hab den Sensor noch nicht angeschlossn. Habe meinen Sensor von 0-5V angepasst und änder den Wert über einen Trimmer. Allerdings Funktioniert es auch nicht wenn ich stat den ADC-Wert irgend welche Zahlen dazu zähle.

    Das ist eben ein Teil meiner Abschlussarbeit und ich komme einfach nicht weiter!
  15. Hallo seppelin,

    zuerst zur Frage, warum man den ADC-Wert mit Zwei multiplizieren muss:
    Dazu muss man sich anschauen, wie Deine Wertetabelle im Speicher abgelegt ist.
    Der Ausdruck dc.b sagt dem Assembler, dass er es hier mit Byte-Werten zu tun bekommt. Danach kannst Du entweder eine einzelne Zahl oder eine durch Kommas getrennte Liste von Zahlen angeben, welche im Speicher der Reihe nach als 1-Byte große Werte abgelegt werden. Wenn danach eine neue Zeile mit einem weiteren dc.b kommt, dann werden diese Werte einfach dahinter abgelegt. Die ersten fünf Einträge Deiner Lookup-Table erzeugen daher folgende Byte-Reihenfolge im Speicher:
    +------+---+---+---+---+---+---+---+---+---+---+
    |Offset|  0|  1|  2|  3|  4|  5|  6|  7|  8|  9|
    +------+---+---+---+---+---+---+---+---+---+---+
    |Wert  | 10|  0|  9|  9|  9|  8|  9|  7|  9|  6|
    +------+---+---+---+---+---+---+---+---+---+---+
    |Type  |  G|  N|  G|  N|  G|  N|  G|  N|  G|  N|
    +------+---+---+---+---+---+---+---+---+---+---+
           ^
           |
           Basisadresse = #Ausgabe_Temp_Muster
    Hierbei ist steht unter Offset der Abstand zur Basisadresse, unter Wert der Wert des Bytes an der Adresse <Basisadresse> + <Offset> und Type gibt an, ob es sich um den Ganzzahlanteil (G) oder den Nachkommaanteil (N) handelt.
    Wenn der ADC-Wert z.B. 3 ist, dann willst Du als Ausgabe ja den Wert 9.7 erzeugen. Wenn Du jetzt in obige Tabelle schaust, dann siehst Du, dass der zugehörige Ganzzahlanteil bei Offset 6 und der Nachkommastellenanteil bei Offset 7 zu finden ist, weil ja jedes Zahlenpaar 2 Byte im Speicher belegt.
    Daher gilt:
    <Adresse Ganzzahlanteil> = <Basisadresse> + 2 * <ADC-Wert>
    und
    <Adresse Nachkommastelle> = <Basisadresse> + 2 * <ADC-Wert> + 1

    Und jetzt zurück zum Code:
    Ich habe noch ein bisschen herumgesucht und dabei hat sich mein ungutes Gefühl bestätigt :scared:
    Man muss hier wohl Syntaktisch sehr aufpassen, wann man es mit einer Adresse und wann mit dem eigentlichen Wert zu tun hat.
    Soweit ich es verstanden habe würde z.B. folgendes:
    ldhx    Ausgabe_Temp_Muster
    die ersten beiden Bytes aus der Lookup-Table in das Registerpaar H:X laden. Um die Basisadresse zu laden hätte man
    ldhx    #Ausgabe_Temp_Muster
    schreiben müssen. Also war die erste Zeile schon einmal Quatsch.
    Die Idee wäre ja gewesen die Basisadresse nach H:X zu laden und dann den 8-Bit ADC-Wert dazu zu addieren. Die Zeile
    lda 0, X
    lädt aber nicht das X-Register in den Akkumulator sondern das Byte, das im Speicher an der Position H:X+0 steht. Also nicht das was man eigentlich will. Im Datasheet habe ich gesehen, dass es die Befehle tax und txa gibt mit denen man zumindest das X-Register in den Akkumulator kopieren und den Akkumulator wieder in das X-Register befördern kann. Leider gibt es sowas für das H-Register nicht. Also wenn man sowas wie
    mov A, H
    bzw.
    mov H, A
    nicht schreiben kann, dann führt der Weg über das H:X Register nicht zum Ziel und man muss stattdessen über den Speicher gehen.
    Also der nächste Versuch, der vielleicht nicht mehr ganz so falsch ist:
    Variable für die berechnete Adresse:
    LUT_POINTER
    	ds.w 1
    Der (vielleicht etwas richtigere) Code:
    ldhx    #Ausgabe_Temp_Muster    ; Lade Basisadresse -> H:X
    sthx    LUT_POINTER             ; Speichere Basisadresse -> LUT_POINTER
    ldhx    #LUT_POINTER            ; Lade Adresse von LUT_POINTER -> H:X
    
    ; 1. Addition:
    lda     0, X                    ; Lade LUT_POINTR[0] -> A
    add     ADC_Wert_PB0            ; Addiere PB0 zu A
    sta     0, X                    ; Speichere A -> LUT_POINTER[0]
    lda     1, X                    ; Lade LUT_POINTER[1] -> A
    adc     #0                      ; Addiere Überhang
    sta     1, X                    ; Speichere A -> LUT_POINTER[1]
    
    ; 2. Addition:
    lda     0, X                    ; Lade LUT_POINTR[0] -> A
    add     ADC_Wert_PB0            ; Addiere PB0 zu A
    sta     0, X                    ; Speichere A -> LUT_POINTER[0]
    lda     1, X                    ; Lade LUT_POINTER[1] -> A
    adc     #0                      ; Addiere Überhang
    sta     1, X                    ; Speichere A -> LUT_POINTER[1]
    
    ldhx    LUT_POINTER             ; Lade berechnete Adresse -> H:X
    lda     0, X                    ; Ganzzahlanteil -> A
    lda     1, X                    ; Nachkommaanteil -> A
    Hierbei wurde wieder angenommen, dass die Adresse Little-Endian ist. Ansonsten muss beim Addieren erst das erste und danach das nullte Byte geladen werden.

    Edit: Variablendeklaration korrigiert.


    Beitrag zuletzt geändert: 19.3.2013 21:33:52 von darkpandemic
  16. Autor dieses Themas

    s******n

    Danke für die Versuche darkpandemic, es funktioniert auf dese Weise immer noch nicht. Allerdings habe ich es auf eine andere Weise gelöst. Ich habe 2 LUT verwendet (eine für die Ganzzahlen und eine für die Nachkommazahlen)

    Jetzt muss ich nur noch das Problem mit dem Vorzeichenwechsel lösen
    :thumb:
  17. Hallo seppelin,

    freut mich, dass es mit 2 LUTs funktioniert (spart Dir die 16-Bit Addition).
    Aber rein aus Neugirde, hast Du es auch mit umgekehrter Reihenfolge der Bytes beim Addieren versucht?
    Also zwei mal:
    lda     1, X                    ; Lade LUT_POINTR[1] -> A
    add     ADC_Wert_PB0            ; Addiere PB0 zu A
    sta     1, X                    ; Speichere A -> LUT_POINTER[1]
    lda     0, X                    ; Lade LUT_POINTER[0] -> A
    adc     #0                      ; Addiere Überhang
    sta     0, X                    ; Speichere A -> LUT_POINTER[0]

    Und weil mir das Rumraten gerade solchen Spaß macht, noch ein (vielleicht mieser) Vorschlag:
    lda     ADC_Wert_PB0    ; Lade ADC-Wert -> A
    cmp     #43             ; Vergleiche mit 43
    blo     ADD_SIGN        ; Wenn kleiner springe zu ADD_SIGN
    <normale Ausgabe>       ; sonst normale Ausgabe




    Beitrag zuletzt geändert: 20.3.2013 22:48:23 von darkpandemic
  18. Autor dieses Themas

    s******n

    darkpandemic schrieb:
    Aber rein aus Neugirde, hast Du es auch mit umgekehrter Reihenfolge der Bytes beim Addieren versucht?



    Ja habe ich auch gemacht, allerdings könnte es auch sein das ich sonst irgend einen kleinen Fehler gemacht habe :wall:
    Allerdings hat mein Lehrer gesagt die Grundidee stimmpt, aber er weiß auch nicht genau was fehlt



    Und weil mir das Rumraten gerade solchen Spaß macht, noch ein (vielleicht mieser) Vorschlag:


    Danke für dein Rumraten :prost:
  19. Naja, wenn Dein Lehrer den Fehler auch nicht sieht, dann fühle ich mich gleich besser :prost:
  20. Autor dieses Themas

    s******n

    Das ist eben eine art Abschlussarbeit. Noch das Vorzeichen Programmieren, Feuchtigkeitssensor (gleiche Routine mit anderer LUT) und :pissed: den Telit GL865 Programmieren (SMS versenden)

    :wall::wall::wall:
  21. ...und zuletzt das Projekt dann opensource auf www.sf.net legen, damit auch andere noch was davon haben...:wave:

    Beitrag zuletzt geändert: 23.3.2013 1:33:39 von mathesoft
  22. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

Dir gefällt dieses Thema?

Über lima-city

Login zum Webhosting ohne Werbung!