Hallo

Ik heb volgende vermenigvuldiging in assembly proberen te programmeren:

product(32bit) = factor_1(16bit) * factor_2(16bit)

Dit is de code



        CBLOCK		0x22
	H_fac1				       ;high byte factor 1
	L_fac1				       ;low byte factor 1
	
	H_fac2				       ;high byte factor 2
	L_fac2				       ;low byte factor 2
	
	;product(32bit) = dddddddd cccccccc bbbbbbbb aaaaaaaa
	pdc_d				       ;
	pdc_c				       ;
	pdc_b				       ;
	pdc_a				       ;

	count                                  ;lusteller
	
	ENDC

Mul_16x16
	CLRF		pdc_d
	CLRF		pdc_c
	CLRF		pdc_b
	CLRF		pdc_a
		
	MOVLW		0x10			;W = 16	
	MOVWF		count			;count = 16
		
mulloop	
	BCF		STATUS,C		;C=0
	RRF		H_fac2,F		;LSB factor2 uitschuiven 
	RRF		L_fac2,F		;(C = LSB factor2)
		
	BTFSS		STATUS,C		;carry?
	GOTO		noAdd			;C = '0' niet optellen
	MOVF		L_fac1,W
	ADDWF		pdc_c,F			;add LSB
	MOVF		H_fac1,W	
	ADDWF		pdc_d,F			;add MSB

noAdd						;shift product		
	RRF		pdc_d,F
	RRF		pdc_c,F
	RRF		pdc_b,F		
	RRF		pdc_a,F

	DECFSZ		count,F			;lusteller--
	GOTO		mulloop			;	
	RETLW		0			;einde 

Nu er moet een fout in zitten want bij sommige factoren krijg ik het juiste product en bij anderen niet.

  • Werkend voorbeeld

    bv: 10000000 00000000 * 10000000 00000000 = 01000000 00000000 00000000 00000000
    32768 * 32768 = 1 073 741 842
  • Niet werkend voorbeeld:

    bv: 11111111 11111111 * 11111111 11111111 = 11111110 11111110 00000010 00000001
    65535 * 65535 = 4 294 967 295 (resultaat door mul_16x16 = 4 278 059 521)

Op 17 september 2010 17:01:56 schreef steve04:
bv: 10000000 00000000 * 10000000 00000000 = 01000000 00000000 00000000 00000000
32768 * 32768 = 1 073 741 842

32768 * 32768 = 1 073 741 824

bv: 11111111 11111111 * 11111111 11111111 = 11111110 11111110 00000010 00000001
65535 * 65535 = 4 294 967 295 (resultaat door mul_16x16 = 4 278 059 521)

65535 * 65535 = 4 294 836 225 (dus geen van de twee bovengenoemde)

e: 65535^2 is binair 11111111 11111110 00000000 00000001

De bovenste is wel degelijk juist ik heb een type fout gemaakt:
2^30 = 1 073 741 824

Nu ja, maar dat neemt niet weg dat de twee uitkomsten voor 655352 allebei fout zijn - niet alleen die van jouw routine.

Overigens, ik zie dat 4 294 967 295 = 65535 * 65537. Misschien doet dat een lichtje branden.

mul_16x16 heeft het gewoon helemaal fout. 4 278 059 521 = 47 * 1531 * 59453, ik zie echt geen verband of begrijpelijke fout. :+

Als je eerst eens je beperkt tot getallen die in 15 bits passen. Het zou me niets verbazen als het foutgaat doordat je met signed-16 bits getallen aan het rekenen bent. Dan komen er onverwachte getallen uit die toch blijken te kloppen. Vandaag nog iemand die 8/2 wilde doen en daar kwam geen 4 maar 0x0C uit. Blijkt dat ie 4bits-signed getallen gebruikte, dus 8 was eignelijk -8 en gedeeld door 2 komt daar gewoon 0x0c= -4 uit....

De fout die FET vermoedt, heeft niets te maken met signed of unsigned, voor zover ik kan zien. Ik denk (heb het niet zelf geprobeerd) dat zijn hint wel eens de sleutel kon zijn.

Heb eerst wat eenvoudiger geprobeerd namelijk:

product(16bit) = factor1(8bit) * factor2(8bit)

Heb dit ondertussen met 5 verschillende combinaties van waarden geprobeerd en het komt steeds correct uit. (Overig baseer ik me enkel op unsigned getallen mits deze enkel van toepassing zijn voor wat ik nodig heb)


        CBLOCK		0x22
	fac1						;factor 1
	fac2						;factor 2
	
	;product(16bit) 
	H_pdc						;high byte product			
	L_pdc						;low byte product

	count						;lusteller
	
	ENDC

;product(16bit) = factor 1(8bit) * factor_2(8bit)      

mul_8x8

        CLRF		H_pdc
	CLRF		L_pdc

	MOVLW		0x08		;W = 8
	MOVWF		count		;count = 8
	
	MOVF		fac1,W		;W = fac1
	BCF		STATUS,C	;carry = 0

mulloop	
	RRF		fac2,F		;LSB fac2 uitschuiven
	BTFSC		STATUS,C	;carry '0' of '1' ?
        ADDWF		H_pdc		;carry = '1' optellen
	RRF		H_pdc,F		;bits doorschuiven	
	RRF		L_pdc,F		;bits doorschuiven
	DECFSZ		count,F		;lusteller--
	GOTO		mulloop		;
	RETLW		0

Nu ja, maar dat neemt niet weg dat de twee uitkomsten voor 655352 allebei fout zijn - niet alleen die van jouw routine.

Overigens, ik zie dat 4 294 967 295 = 65535 * 65537. Misschien doet dat een lichtje branden.

mul_16x16 heeft het gewoon helemaal fout. 4 278 059 521 = 47 * 1531 * 59453, ik zie echt geen verband of begrijpelijke fout.

Mijn lampje gaat helaas nog niet branden, heb wat moeite om de hint of boodschap er uit te halen.

[Bericht gewijzigd door steve04 op (19%)]

En na nog wat nadenken snap ik de hint ook niet helemaal, sorry. Ik dacht aan een factor 2 maar het is een opgetelde constante 2. Het is ook alweer een tijdje geleden dat ik met m'n neus in (een andere) assembler zat.

Toch is dit wel de manier om te gaan zoeken. Wat is er anders aan je uitkomst. Is er iets altijd 2 te hoog (zoals FET aangaf), kan het komen door signed versus unsigned (zoals rew aangaf)? Is het altijd dezelfde fout, of verschillende?

Heb wat verder geprobeerd met mul_16x16:

  • Decimaal:
    65535 * 65535 = 4 294 836 225
  • Resultaat binair (correct):
    11111111 11111110 00000000 00000001
  • Resultaat binair (mul_16*16)
    11111101 11111110 00000000 00000001

De code heb ik wat aangepast en stel nu vast dat er 1 bit niet goed staat namelijk deze in het vet.

Het stuk waar ik optel werd aangepast:


Mul_16x16
		
	CLRF		pdc_d
	CLRF		pdc_c
	CLRF		pdc_b
	CLRF		pdc_a
		
	MOVLW		d'16'			;W = 16	
	MOVWF		count			;count = 16
		
mulloop
	BCF		STATUS,C		;C=0
	RRF		H_fac2,F		;LSB factor 2 uitschuiven 
	RRF	        L_fac2,F		;carry = LSB factor 2
		
	BTFSS		STATUS,C		;carry '0' of '1'?
	GOTO		noAdd			;'0' niet optellen
		
	BCF		STATUS,C		;'1' wel optellen
	MOVF		L_fac1,W		
	ADDWF		pdc_c,F			;add low byte factor 1
	BTFSS		STATUS,C		;test op carry out?
	GOTO		no_c			;'0' 
	MOVLW		0x01			;W = 1
	ADDWF		pdc_d,F			;carry meerekenen
no_c	MOVF		H_fac1,W	
	ADDWF		pdc_d,F			;add high byte factor 1

noAdd						;shift product		
	RRF		pdc_d,F
	RRF		pdc_c,F
	RRF		pdc_b,F		
	RRF		pdc_a,F

	DECFSZ		count,F			;lusteller--
	GOTO		mulloop			;	
	RETLW		0			;einde 

Ehm, het was niet echt een hint, sorry.
Ik weet het antwoord niet, ik bedoelde gewoon letterlijk: misschien zegt het jou (TS) wat, dat hij het getal tweemaal extra heeft opgeteld.

Maar ik zie nu dat DIE fout niet van jouw routine kwam, maar van een andere foute berekening.
mul_16x16 is juist jouw routine zie ik, en daarin gaat blijkbaar iets anders fout.

De code kan ik jammer genoeg niet navolgen - die taal ken ik gewoon niet, bedoel ik. Is er ook een soort symbolisch diagram van wat je doet?

Nogmaals, de libraries bestaan al. Waarom het wiel nog eens uitvinden?

Ik baseer me op die libraries maar de code effectief overnemen doe ik niet.
Dit is de flowchart van een vermenigvuldiging waarmee ik mul_16x16 heb opgebouwd. Deze flowchart komt uit een van de PDF's van microchip.

multiplication_flowchart

Hmm.. dat is toch gewoon de klassieke vermenigvuldiging zoals je 'm met de hand ook zou doen (alleen dan met slechts 0 en 1 :)).
Daar kan het haast niet aan liggen.

Als je eens alle tussenresultaten zou uitvoeren? Dan kunnen we zien waar het mis gaat.

Ik heb de fout gevonden het ligt aan een carry die niet meegerekend word.

Stel bv het volgende:



Binaire optelling met carry (normaal)

                      1 carry van vorige byte 
              1111 1111 
            + 1111 1111
            -----------
carry out 1   1111 1111


Deze carry ('[b]1[/b]') word vervolgens ingeschoven

Binaire optelling met carry (mijn methode)

              1111 1111
            + 0000 0001
            -----------
carry out 1   0000 0000
            + 1111 1111
            -----------
carry out 0   1111 1111 

Hier gaat het dus fout de carry moet eigenlijk '1' zijn maar is '0' deze wordt vervolgens ingeschoven en veroorzaakt deze fout:

11111101 11111110 00000000 00000001 (vette '0' = foute carry)

Nu om een lang verhaal kort te maken hoe reken jullie carry's softwarematig mee in een optelling.

De PIC18F serie kent de ADDWFC instructie.

Anders doe je

BTFSC STATUS,C
ADDLW 1

De foute carry was het probleem. De pic die ik gebruik heeft geen instructie ADDWFC dus moest het anders:

bv:


getal1 EQU 0x20
getal2 EQU 0x21
som    EQU 0x22

;Optelling met carry-in zonder verlies aan carry-out

MOVF   getal1,W
ADDWF  getal2,W
MOVWF  som        
INCF   som,F    ;som = getal1 + getal2 + carry-in

;test op carry out

BTFSS STATUC,C
..... ........ ;carry '0'
..... ........ ;carry '1'

Steve04, dit deugt niet. Allereerst gebruik je de directive "equ" verkeerd. Om geheugenplaatsen te bestemmen voor variabelen zijn er andere mogelijkheden, bv. getal1 res 1.
Je programmaatje is onzin. Je bedoelt waarschijnlijk dat na een optelling de overflow gechecked moet worden om dat te verrekenen in de hogere bytes. De INCF instructie komt dus na de BTFSS van de STATUS. Bovendien moet dan niet de "som" maar een hogere byte opgehoogd worden. Als je bedoelt dat je voorbeeld-optelling komt na een voorgaande optelling van lagere bytes dan moet je de route goed beschrijven: als overflow (carry) dan eerst INC som, anders alleen "som=getal1+getal2".

("Steve04, dit deugt niet / Je programmaatje is onzin" Komt wel hard over)

Nu ter zake, dat stukje code is om de carry mee te rekenen vanuit een optelling van twee vorige bytes zonder de instructie ADDWFC. Hierbij is best eerst de twee bytes op te tellen en daarna pas de carry.

Dan wat betreft die equ directive mijn mening is dat ik hem niet verkeerd gebruik.

EQU = defineer een constante bv. temp1 equ 0x20 Dit wil zeggen dat de assembler overal waar temp1 staat 0x20 zet.

SET = defineer een variabele bv. temp2 set 0x25 Dit wil zeggen dat de assembler overal waar temp2 staat 0x25 zet.

Het verschil tussen beiden is nu dat symbol temp1 gedefineerd door EQU steeds gebonden is aan 0x20. Terwijl symbol temp2 gedefineerd door SET niet gebonden is aan 0x25. Enkele voorbeelden:

  • temp1 EQU 0x20 ;
    temp1 EQU 0x23 ;assembler geeft error
  • temp2 SET 0x25 ;
    temp2 SET 0x80 ;assembler geeft geen error

Bovendien wil RES zeggen reserveer geheugen bv.:
temp RES 1 ;reserveer 1byte aan geheugen het adres maakt niet uit de assembler kiest dat zelf.

Verder werkt de routine mul_16x16, heb al verschillende voorbeelden geprobeerd en kreeg steeds het juiste resultaat.

Is inderdaad niks mis mee om EQU te gebruiken in absolute code. Ik gebruik het vaak.