16 bit berekening met een PIC

maar later word doe potensiometer vervangen door een waarde die va uart binnenkomt en dit is een 8 bit waarde.

Dus zo simpel is het nog niet :(
Nog eens even voor de zekerheid (ik ben niet zeker meer)

als er in w 180 staat en je telt daar 200 bij op den heb je 380 wat staat er dan in het W register ? 124?

[Bericht gewijzigd door nonkel_dw op (36%)]

als er in w 180 staat en je telt daar 200 bij op den heb je 380 wat staat er dan in het W register ? 124?

Ja, dat klopt. Bij > 255 vindt er gewoon een roll-over plaats. (255 -> 0 -> 1 -> 2, enz...)

dan ga ik eens een opzet proberen te schrijven

Hey ik weet niet of je er wat aan hebt maar hier word een beetje uitgelegd over vermenigvuldigen in asm.

Of je kan gebruik maken van een lookuptable.

Dit kost dan wel 256512bytes geheugen, maar het scheelt heel wat rekenwerk ;-)


A/D	result
0	0
1	8
2	16
3	24
4	31
---snip---
30	235
31	243
32	251
33	259
34	267
---snip---
98	769
99	776
100	784
101	792
102	800
---snip---
251	1969
252	1976
253	1984
254	1992
255	2000

Waarbij ik dit in excel heb gebruikt om deze tabel te maken:
=AFRONDEN((2000/255) * A257;0)
(ja ik weet het, nederlandse office..... blame my ex girlfriend)

hoi,

Nu ik deze avond wat tijd heb, ben ik begonnen aan het berekenen van men 16 Bit waarde.
Maar ik loop tegen een probleem aan...
Ik dacht de opzet zo te maken:
aantal pulsen: totaal van de pulsen in Voorbeeld 2000
totaal: de uitkomst van de vermenigvuldiging
Waarde: waarde van de byte

Lus:
aantal pulsen tel op in totaal
zet weg in totaal
trek 1 af van waarde
waarde niet gelijk aan 0
terug naar lus
wel gelijk aan 0 verdoen met programma ...

Het probleem dat ik heb is het volgende:
Laten we er van uitgaan dat er in aantalpulsenH 10 staat en in aantalpulsenL 200 staat.

als ik nu de lus maak
dan zou er in aantalpulsenH 20 staan
en in aantalpulsenL 400 dus daar loopt het mis...

Ik begrijp eerlijk gezegd hiet hoe je van 10:200 na de loop op 20:400 zou kunnen komen.
Maar los daarvan is 2000 in 16 bit geen 10:200, maar 7:208 (0x07D0 hex)

Ik zou gewoon op en of andere manier
de aantal pulsen x de waarde moeten kunnen uitrekenen.

en dit dan delen door 255

Het simpelste is het om de math routines te downloaden van Microchip. (AN544 en nog een paar)

Voor 8 bit heb ik net wat geschreven.
Dit is zo al wat de opzet


LUS
	MOVF	AANTALPULS,W
	ADDWF	TOTAALL,F
	BTFSC	STATUS,C
	INCF	TOTAALH,F
	DECFSZ	WAARDE,F
	GOTO	LUS

Alleen zie ik nog niet zo direct een oplossing voor die met 16 bit te doen :(

Alleen zie ik nog niet zo direct een oplossing voor die met 16 bit te doen

Daarom zei ik ook: geebruik de math libraries van Microchip. Waarom opnieuw het wiel uitvinden?...

Oke

ik heb nu dus weer de tijd gehad om van alles wat uit te testen en zo ...
Nu heb ik een code die 16x16bit doet dit werkt alleen is de uitkomst groter dan 16 bit.
Maar hier vind ik niet direct een code voor bij microchip.
Heb ik er over gekeken? Of is dit wel opnieuw het wiel uitvinden?

Nou ik heb voor mezelf eigenlijk ook het wiel opnieuw uitgevonden zoals sommigen hier beweren. Ik vind dat zelf niet erg, maar juist leerzaam. Dat is voor mij de voornaamste reden dat ik deze hobby heb.

Sommige stukken code vanuit de AN's van microchip zijn voor mij soms gewoon onleesbaar. Ik heb immers geen/amper elctronica en sofware lessen gehad op school. Dus heb zelf wat gemaakt wat ik soms domweg gewoon kan invoegen als subroutine. Misschien dat je er wat aan hebt en belang bij hebt. Alleen een stukje om te vermenigvuldigen ontbreekt nog. Daar heb ik nog geen tijd voor/zin in gehad.

Het zijn 16-16 naar 16 bit berekingen.

Groetjes,
Lampie

We kan me er bij helpen?
Bij dit te ontwikkelen.


LUS
MOVF	TELLERH,W
SUBWF	UITH,F
BTFSC	STATUS,C
INCF	UITZ,F

MOVF	TELLERL,W
SUBWF	UITL,F
BTFSC	STATUS,C
INCF	UITH,F
MOVWF	UITL
INCFSZ	TELLER,W
GOTO LUS

zou dit kunnen werken om gewoon op te tellen?

[Bericht gewijzigd door nonkel_dw op (70%)]

Na een avond proberen krijg ik nog altijd zeer rare zaken als uitkomst
Dit is een code om 24bit*24bit = 24 bit te doen

echter krijg ik deze niet juist aan de praat


MULTIPLY_24x24
;Multiplier EQU Product3
        ; preload values to test

      	MOVLW   d'0'

        MOVWF   Multipland

        MOVLW   d'0'

        MOVWF   Multipland1
	
       	MOVLW   d'2'

        MOVWF   Multipland2

 	

       	MOVLW   d'0'

       	MOVWF   Multiplier

        MOVLW   d'0'

        MOVWF   Multiplier1

      	MOVLW   d'20'

        MOVWF   Multiplier2

 

        ; these values should generate the reply = 0x6651AF33BC6C

;24 x 24 Multiplication

;Input:

; Multiplier - 3 bytes (shared with Product)

; Multiplicand - 3 bytes (not modified)

;Temporary:

; Bitcount

;Output:

; Product - 6 bytes

 

        CLRF    Product         ; clear destination

        CLRF    Product1

        CLRF    Product2

 

        

        MOVLW   D'24'

        MOVWF   BitCount        ; number of bits

 

        RRF     Product3,F     ; shift out to carry

        RRF     Product4,F     ; next multiplier bit

        RRF     Product5,F

 

ADD_LOOP_24x24

 

        BTFSS   STATUS,C        ; if carry is set we must add multipland

                                ; to the product

          GOTO  SKIP_LOOP_24x24 ; nope, skip this bit

                

        MOVF    Multipland2,W  ; get LSB of multiplicand

        ADDWF   Product2,F     ; add it to the lsb of the product

  

        MOVF    Multipland1,W  ; middle byte

        BTFSC   STATUS,C        ; check carry for overflow

        INCFSZ  Multipland1,W  ; if carry set we add one to the source 

        ADDWF   Product1,F     ; and add it  (if not zero, in

                                ; that case mulitpland = 0xff->0x00 )

        

        MOVF    Multipland,W    ; MSB byte

        BTFSC   STATUS,C        ; check carry

        INCFSZ  Multipland,W

        ADDWF   Product,F       ; handle overflow

 

SKIP_LOOP_24x24

        RRF     Product,F

        RRF     Product1,F

        RRF     Product2,F

        RRF     Product3,F

        RRF     Product4,F

        RRF     Product5,F

 

        DECFSZ  BitCount,F

        GOTO    ADD_LOOP_24x24

        RETURN

Niemand die kan helpen?