16 bits getal pic16f877 in asm

Hallo,

Ik ben nu met een project bezig waar ik met een pic16f877 een bepaalde loop x aantal keer moet doorlopen. Opzich geen probleem, maar wel als x een 16 bits getal is, wat nu dus helaas het geval is. Dit 16 bits getal staat nu verdeeld over 2 registers (data_L en data_H). Hoe kan ik er dus voor zorgen dat een loop dus het juiste aantal keren word doorlopen? Ik heb bij de site van microchip al gekeken omdat ik gehoord had dat die een AN over 16 bits getallen hadden, maar ik had niks gevonden. Ik heb ook al op google gezocht, maar helaas ook niks gevonden. Zelf heb ik mijn hoofd er ook al over gebroken, oftewel kort samengevat: HELP!:D

iig alvast bedankt!

AVR heeft daar een mooie instructie voor: adiw
Ik denk dat de PIC ook wel zulke instructies heeft ?
Zo niet, dan de Lage byte ophogen totdat die overflow geeft (255), dan het hoge ophogen. En zo doorgaan totdat de hoge byte overflow geeft, dan klokje rond geweest (256*256)

oke, bedankt voor het antwoord! Ik heb nog even een vraagje: stel de 16 bits waarde is 0xF76F, oftewel 1111011101101111. Dit splits ik op in 2 variable: var 1 is dan 11110111, oftewel 0xF7 en var 2 is 01101111, oftewel 0x6F. Kan ik dan ook een loop maken die 16x16xvar2+var1 keren doorlopen word? Ik neem aan van wel, maar wil het toch maar ff zeker weten:)

ja dat kan

Bedankt, dat werkt nu:). Maarja, nu weer het volgende probleem: Ik heb 20 8 bits getallen waar ik 10 16bits getallen van moet maken welk ik daarna allemaal bij elkaar moet optellen zodat ik een 32bits getal krijg, die dus in 4 registers staan. Ik heb weer flink gezocht op internet, maar kan weinig vinden over het optellen van 16 bits getallen. Weet iemand hier een site waar wat uitgelegd staat, of iemand die me zo wat kan vertellen hoe ik dit het beste kan aan aanpakken?

Bedankt!

heel simpel:

Als je 2 bytes optelt kun je een 9-de bit krijgen, het overflow bit.
Deze tel je vervolgens gewoon bij het hoge byte op, waarna je het tweede hoge byte weer hierbij optelt.... enz. enz.
Dit kun je gewoon blijven doen tot zoveel bytes als je maar wilt.

Misschien is het handig als je je eerst bekend maakt met het binair rekenen, en pas daarna kijkt hoe je dat gaat implementeren.

Op 4 april 2004 14:46:59 schreef Xenobinol:
heel simpel:

Als je 2 bytes optelt kun je een 9-de bit krijgen, het overflow bit.
Deze tel je vervolgens gewoon bij het hoge byte op, waarna je het tweede hoge byte weer hierbij optelt.... enz. enz.
Dit kun je gewoon blijven doen tot zoveel bytes als je maar wilt.

Misschien is het handig als je je eerst bekend maakt met het binair rekenen, en pas daarna kijkt hoe je dat gaat implementeren.

het is onderhand alweer een tijdje geleden, heb het namelijk behoorlijk druk gehad... Ik begrijp het enersinds, maar nog niet helemaal. Heb je misschien een voorbeeld code hiervan om het wat te verduidelijken?

10010111+10110001=1.01001000
als je twee 8 bits getallen bij elkaar optelt kan je een waarde groter dan 256 krijgen dit triggert in de pic het overflow bit
dus als je twee bytes bij elkaar telt kun je aan het overflow bit zien of de som groter was als 256
je hebt in w dan het 8 bits uitkomst en de overflow bit.
de overflow bit tel je op bij je tweede register
nu voor 16 bits tel je eerst de low byte op de uitkomst is je nieuwe low byte de overflow bit tel je bij high byte en dan tel je de high bytes op de uitkomst is nieuwe high byte
en de overflow is highest byte

Op 9 april 2004 23:45:01 schreef k.p.meinesz:
10010111+10110001=1.01001000
als je twee 8 bits getallen bij elkaar optelt kan je een waarde groter dan 256 krijgen dit triggert in de pic het overflow bit
dus als je twee bytes bij elkaar telt kun je aan het overflow bit zien of de som groter was als 256
je hebt in w dan het 8 bits uitkomst en de overflow bit.
de overflow bit tel je op bij je tweede register
nu voor 16 bits tel je eerst de low byte op de uitkomst is je nieuwe low byte de overflow bit tel je bij high byte en dan tel je de high bytes op de uitkomst is nieuwe high byte
en de overflow is highest byte

bedankt, ik denk dat ik het snap!
Zou het op deze manier werken?


CLRF	result_low_nibble
CLRF	result_high_nibble
MOVF	high_nibble, w
ADDWF	low_nibble, w
MOVWF	result_low_nibble
ADDCF	result_high_nibble, f

correct me if I'm wrong.
Nu kan ik dus van de 20 8 bits bytes 10 16 bits bytes maken. Nu moet ik eigenlijk deze 10 16 bits bytes nog allemaal bij elkaar optellen zodat 1 32 bits byte krijg. Dit kan (volgens mij) niet op deze manier meer, hoe kan ik dit dan doen?

Waarom zou je het resultaat 32 bits willen hebben eigenlijk? De som van 20 stuks 8-bit integers past altijd in een 16-bit integer.

Overigens is er niet zoiets als een '16 bit byte'. Een byte zijn er altijd 8, anders zijn het gewoon 2 bytes. Een 16 bit integer is dus een 2 byte integer.

Op 10 april 2004 13:48:23 schreef Ben_:
Waarom zou je het resultaat 32 bits willen hebben eigenlijk? De som van 20 stuks 8-bit integers past altijd in een 16-bit integer.

Dit is omdat ik bezig ben met een ethernet project. Dit stuk is om de checksum berekeningen te maken. De checksum word berekend door van 2 bytes 1 word te maken. Er zijn, in mijn geval tenmiste, 20 bytes, dus 10 words. Deze 10 words worden dan weer bijelkaar opgeteld zodat je een dword. de eerste 16 bits hiervan worden opgeteld bij de laatste 16 bits en tenslotte ginventeerd. Het zou dus idd ook gelijk in een dword, maar ik dacht dat het zo makkelijker zou zijn, en ik heb dit nog wel vaker in dit project nodig, dus komt het altijd wel van pas:)

Overigens is er niet zoiets als een '16 bit byte'. Een byte zijn er altijd 8, anders zijn het gewoon 2 bytes. Een 16 bit integer is dus een 2 byte integer.

ja sorry je hebt gelijk. Een 2 byte integer word ook wel een word genoemd, of zit ik dan weer verkeerd? (en een 4 byte integer een dword toch?)

edit: Volgens mij heb ik tijdens het stellen van deze vraag behoorlijk zitten te slapen|:(. Ik moet de bytes niet bij elkaar optellen, maar de words|:(. Ik zal het ff wat duidelijker uitleggen: Ik heb 20 adressen die allemaal achter elkaar staan. Elke 2 bytes stelt eigenlijk een word voor. Deze 10 words moet ik dus bij elkaar optellen zodat ik een dword krijg van 32 bits lang, die dus over 4 registers versprijd staan.

De vraag wat/is dus eigenlijk: Hoe tel ik 2 words bijelkaar op, zodat ik een dword krijg?

iig bedankt voor alle antwoorden tot nu toe!

[Bericht gewijzigd door Wouter Sijm op ]

Er is helaas heel veel soms overlappende terminologie voor datatypes. De lengte van een 'int' varieert bijvoorbeeld per platform en architectuur, zodat het vaak niet meteen duidelijk is wat je ermee wilt.

word en dword zijn normaagesproken usigned 16- en 32 bits typen.

Op 10 april 2004 15:09:11 schreef Ben_:
Er is helaas heel veel soms overlappende terminologie voor datatypes. De lengte van een 'int' varieert bijvoorbeeld per platform en architectuur, zodat het vaak niet meteen duidelijk is wat je ermee wilt.

word en dword zijn normaagesproken usigned 16- en 32 bits typen.

ah oke, in mijn geval bedoel ik idd 16 bits en 32 bits.

Niemand die weet hoe ik 2 16 bits getallen kan optellen tot 1 32 bits getal? :'(

waarom zou je dit niet kunnen op de bovengeschreven manier?
word trouwens 24 bit geen 32
eerst de low byte bij elkaar carry naar high byte
hight bytes bij elkaar carry naar de volgende enz tot 32/64/128/265


    11001100.10010110
    11000011.11011011
    ------------------+
           1.01110001   lowbyte
  1.10001111            highbyte
  --------------------+
  1.10010000.01110001   result1
    10010011.01100110   next 16 bit
             11010111   lowbyte result
  1.00100011            highbyte result
  --------------------+
 10.00100011.11010111    result2

[Bericht gewijzigd door k.p.meinesz op ]

Op 11 april 2004 22:53:51 schreef k.p.meinesz:
waarom zou je dit niet kunnen op de bovengeschreven manier?
word trouwens 24 bit geen 32
eerst de low byte bij elkaar carry naar high byte
hight bytes bij elkaar carry naar de volgende enz tot 32/64/128/265


    11001100.10010110
    11000011.11011011
    ------------------+
           1.01110001   lowbyte
  1.10001111            highbyte
  --------------------+
  1.10010000.01110001   result1
    10010011.01100110   next 16 bit
             11010111   lowbyte result
  1.00100011            highbyte result
  --------------------+
 10.00100011.11010111    result2

Je, je hebt gelijk, het kan dan idd wel op die manier:). Eigenlijk idd precies zoals wij mensen dat doen.

Dus het zou met deze code moeten werken?

CLRF	result_1
CLRF	result_2
CLRF	result_3
MOVF	byte1_1, w
ADDWF	byte1_2, w
MOVWF	result_1
ADDCF	byte2_1, f
MOVF	byte2_1, w
ADDWF	byte2_2, w
MOVWF	result_2
ADDCF	result_3, f

Byte1_1 is dus de laagste 8 bits van het eerste op te tellen getal, byte1_2 de laagste 8 bits van het tweede op te tellen getal. Byte3_1 de hoogste 8 bits van het eerste op te tellen getal, byte3_2 de hoogste 8 bits van het tweede op te tellen getal. Mocht er een fout in zitten dan zou ik dat graag horen!

Het klopt idd dat het 24 bits is, maar de 10 words die ik bij elkaar moet optellen kunnen er meer zijn, zodat ik toch ook 32 bits getal krijg:)

Bedankt voor alle hulp!
Wouter

ik heb ff geen asm sheet bijdehand maar:


             movwf lowbyte1 (8bit)
             addwf lowbyte2
             movwf result1
             btfsc status,c(carry)
             call  carryset
             movwf highbyte1
             addwf highbyte2
             movwf result1
             btfsc status,c
             call  carryset2
 .........enz

carryset     incf highbyte1,f(16bit
             btfsc status,c
             call extracarry
             return
carryset2    incf highbyte3,f(24bit)
             btfsc status,c
             call extracarry2
             return
extracarry   incf highbyte3,f(24bit)
             btfsc status,c
             call extracarry2
             return
extracarry2  incf highbyte4,f(32bit)
             return

addc ken ik niet als instuctie
lowbyte1=1e 8bits
lowbyte2=2e 8bitss
highbyte1= 1e 16bits
highbyte2= 2e 16bits
highbyte3= 24bits resultaat
highbyte4= 32bits resultaat
zoiets zou het moeten zijn
ik hoop dat je me snapt anders doe ik morgen nog wel een poging

Op 12 april 2004 00:17:59 schreef k.p.meinesz:
addc ken ik niet als instuctie

Waarschijnlijk Add Carry

Op 12 april 2004 00:20:44 schreef Bastiaan:

[...]

Waarschijnlijk Add Carry

dat denk ik ook maar is dat een geldige instructie dan?

Op 12 april 2004 00:20:44 schreef Bastiaan:

[...]

Waarschijnlijk Add Carry

yep, dat klopt idd. Het is idd geen "echte" instructie, waarschijnelijk zet mplab deze zelf om naar een andere instructie. Ik dacht dat deze instructie, plus nog wat andere speciale intructies zoals MOVFW en SKPC, ergens in de help van MPLAB te vinden waren (moet je anders maar eens zoeken in de help naar addcf). Als ik het zie komt de code van k.p.meinesz en die van mij overeen, behalve dat ik dus gebruik maak van de ADDCF instructie. Ik zal hem zo eens ff testen, en dan laat ik het wel weten of het werkt:)

Bedankt allemaal!

Op 12 april 2004 00:24:17 schreef k.p.meinesz:
[...]
dat denk ik ook maar is dat een geldige instructie dan?

Weet ik niet, maar kun je zo zien in de datasheet van de PIC die je gebruikt. Niet elke PIC kent elke code, het kan dus dat je het nog niet eerder bent tegengekomen maar het wel bekend is bij bepaalde PIC's.

Op 12 april 2004 12:41:40 schreef Bastiaan:

[...]

Weet ik niet, maar kun je zo zien in de datasheet van de PIC die je gebruikt. Niet elke PIC kent elke code, het kan dus dat je het nog niet eerder bent tegengekomen maar het wel bekend is bij bepaalde PIC's.

zoals ik al zei, kijk eens in de help;). Heb even wat namen van wat variable verandt en de code toen geprobeert, en hij werkt:). Dit is dus de code die ik gebruik:

main		MOVLW		b'10011101'
		MOVWF		byte1_1

		MOVLW		b'10101011'
		MOVWF		byte1_2

		MOVLW		b'10101001'
		MOVWF		byte2_1

		MOVLW		b'01111010'
		MOVWF		byte2_2

		CLRF		result_1
		CLRF		result_2
		CLRF		result_3
		MOVF		byte1_1, w
		ADDWF		byte2_1, w
		MOVWF		result_1
		ADDCF		byte1_2, f
		MOVF		byte1_2, w
		ADDWF		byte2_2, w
		MOVWF		result_2
		ADDCF		result_3, f

Als ik dan via de usart achtereenvolgens result_3, result_2 en result_1 verstuur, komt dit binnen:10010011001000110, oftewel decimaal 75334. Het klopt dus precies!

Nogmaals allemaal bedankt!

graag gedaan zelf ook weer wat geleerd:-)

Even toch nog een klein vraagje: De carry bit, wordt deze automatisch gecleared na de volgende instructie (uiteraard niet als er dan ook een overflow is;)) of moet ik deze zelf weer clearen? In de datasheet zie ik dat de carry bit een read only bit is, dus ik neem aan dat hij dus automatisch gecleared word?

Op 13 april 2004 23:01:32 schreef Wouter Sijm:
Even toch nog een klein vraagje: De carry bit, wordt deze automatisch gecleared na de volgende instructie (uiteraard niet als er dan ook een overflow is;)) of moet ik deze zelf weer clearen? In de datasheet zie ik dat de carry bit een read only bit is, dus ik neem aan dat hij dus automatisch gecleared word?

de volgende instrucktie waarbij al dan niet een carry geset kan worden zal deze setten of resetten
in het datasheet staat welke instructies invloed hebben op
bepaalde registers w/c/z/enz