ja ik snap wat je wil zeggen

maar dan heb je nog altijd maar een waarde van 1 byte.
Terwijl het voor een word moet gedaan worden.
Zoals het er al eerder stond.

sorry, was mijn bericht aan het uitbreiden (=slechte eigenschap) heb er wat aan toegevoegd.

ja oke

dan moet ik zoals zweetvoetje zegt zien op te lossen.
Dit gaat nog niet zo simpel zijn denk ik

jazeker wel, supersimpel:

'tellerH * waarde' levert resultaat1H + resultaat1L
'tellerL * waarde' levert resultaat2H + resultaat2L

dan heb je 2 keer een 16 bits getal, dan zeg je:

byte0 = resultaat2L
byte1 = resultaat2H + resultaat1L
byte2 = resultaat1H + (eventueel teveel in byte1)

[bad habit edit mode]
overigens werken veel assembler commando's met carry bits, deze bewaren het 9e bit als je bijvoorbeeld 200 + 200 doet, dan krijg je een getal wat niet meer in 1 byte past, en dan bevat het carrybit (C) je 9e bit. Als je dan daarna weer het optelcommando gebruikt, dan neemt hij dit bit mee, voorbeeld volgens bovenstaande tekst:

resultaat2L = 200
resultaat2H = 150
resultaat1L = 130
resultaat1H = 250

byte0 = 200
byte1 = 150 + 130 = 260 = 4 + carrybit
byte2 = 250 + carrybit = 251

[/bad habit edit mode]

[Bericht gewijzigd door Martijn Berntsen op (48%)]

Nu heb ik wat gevonden alleen zit er nog een fout in :(
Als ik dit simuleer met pic simultor




	list	P=16F628a
	#INCLUDE <P16F628a.INC>
	__CONFIG    _CP_OFF & _MCLRE_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC


CBLOCK 0X20		
 TELLER
 PULS 
 PULSH 
 TELLER2
 TELLER2H
PP0 
PP0H
PP1
PP1H 
PP2 
PP2H
PP3 
PP3H 
PP6H 
ENDC                 

	ORG	00h
	GOTO	init	;Initialize PIC
;-------------------------------------------

 init
	movlw	d'200'
	movwf	TELLER
	movlw	d'100'
	movwf	PULSH
	movwf	PULS
; teller 2 staat de uitkomt teller2L teller2h
        goto MAIN

MAIN

	Clrf PP3H
	Movf TELLER,W
	Movwf PP3
	Movf PULSH,W
	Movwf PP1H
	Movf PULS,W
	Movwf PP1
	Call m@py
	Movwf TELLER2
	Movf PP2H,W
	Movwf TELLER2H

	Movf TELLER2H,W
	Movwf PP0H
	Movf TELLER2,W
	Movwf PP0
	Clrf PP1H
	Movlw d'255'
	Movwf PP1
	Call d@vd
	Movwf TELLER2
	Movf PP0H,W
	Movwf TELLER2H

	Goto MAIN




d@vd clrf PP2H
	clrf PP2

d@vd2 movlw 16
	movwf PP3
	rlf PP0H,w
	rlf PP2,f
	rlf PP2H,f
	movfw PP1
	subwf PP2,f
	movfw PP1H
	skpc
	incfsz PP1H,w
	subwf PP2H,f
	skpnc
	goto $ + 8
	movfw PP1
	addwf PP2,f
	movfw PP1H
	skpnc
	incfsz PP1H,w
	addwf PP2H,f
	clrc
	rlf PP0,f
	rlf PP0H,f
	decfsz PP3,f
	goto $ - 21
	movfw PP0
	goto i@nt

m@py movlw 16
	movwf PP6H
	clrf PP0H
	clrf PP0
	rrf PP3H,f
	rrf PP3,f
	skpc
	goto $ + 7
	movfw PP1
	addwf PP0,f
	movfw PP1H
	skpnc
	incfsz PP1H,w
	addwf PP0H,f
	rrf PP0H,f
	rrf PP0,f
	rrf PP2H,f
	rrf PP2,f
	decfsz PP6H,f
	goto $ - 15
	movfw PP2
	goto i@nt
i@nt bcf 3,7
i@nt2 bcf 3,5
	bcf 3,6
	nop
	return


	END

Wil iemand hier even mee op kijken?


i@nt bcf 3,7
i@nt2 bcf 3,5
	bcf 3,6
	nop
	return

dit stukje is me voorlopig ook nog een raadsel voor wat dit mag zijn.

Als je een grotere nauwkeurigheid wil ontkom je er niet aan met meer bits te gaan werken.

Dus moet er een 16x8 multiply worden gedaan.
Hiervoor kun je zo een kant en klare subroutine plukken van www.piclist.com
Je krijgt dan een 24 bits getal als uitkomst.

Om het geheel te kunnen begrijpen: Wat heeft de analoge ingang met het verhaal te maken? De puls-counter op de ketting is zo te zien digitaal?

een potensiometer

waar ik de de byt waarde kan mee instellen

dit moet latere met wat extra code de takel omhoog en omlaag sturen.
maar eerst het rekenwerk werkende krijgen

Ah,

Dat is al een stuk duidelijker...
Je wilt dus dat de potmeterstand <min> gelijk is aan '0', en <max> gelijk is aan 2000...
Over dit probleem hebben we het geloof ik al eerder over gehad. Als je de A/D converter zo instelt, dat het aantal pulsen er door deelbaar is, wordt alles veel simpeler en nauwkeuriger.
Als de ketting totaal 2000 pulsen geeft, dan A/D op max. 500 of 1000 zetten.
Je hoeft dan alleen de A/D waarde met 2 of 4 te vermenigvuldigen. (Kan het nog simpeler? :) )

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?