Divisão de 2 variáveis em asm

[rsdias_]

Bom dia, tudo bem ?

Alaguem poderia me ajudar em uma questão, estou gravando um valor de contagem em duas variáveis de 8 Bits ( Var_High e Var_Low ), estou usando pic 16f636 e a programação é em assembly, gostaria de saber como faço para dividir esta contagem por 2 e mover o resultado para outras duas variaveis. Obrigado desde já.

[cfreund]

Está na seção 13 (INSTRUCTION SET SUMMARY) do documento https://ww1.microchip.com/downloads/en/ ... 41232D.pdf

[rsdias_]

Desculpe, acho que não me expressei direito, sei que usando o RRF uma vez eu divido por 2 (Uma variavel simples), agora como aplicar isso em duas variáveis que formam apenas uma contagem, ou seja, Var_High e Var_Low forma um numero de contagens, como divido isso por 2, porque se eu pegar a primeira variavel e dividir por 2 e depois pegar a segunda variavel e dividir por 2, os valores finais estariam errados não ?
Obrigado desde já.

[cfreund]

Limpe o carry, desloque Var_High uma vez para a direita e depois o mesmo com Var_Low.

Página 158:

Código: Selecionar todos

RRF f,d

 The contents of register ‘f’ are
rotated one bit to the right through
the Carry flag. If ‘d’ is ‘0’, the
result is placed in the W register.
If ‘d’ is ‘1’, the result is placed
back in register ‘f’.


[rsdias_]

Boa tade, se fizer assim daria isso:

Exemplo 360 - Var_Total ( 0000 0001 0110 1000 )
Então Var_High ( 0000 0001 ) e Var_Low ( 0110 1000 )

Após Rotacionar seria isso:

Var_High ( 0000 0000 ) e Var_Low ( 0011 0100 )

Var_Total ( 0000 0000 0011 0100 ) = 52

Teria que ser 180, isto que não sei como fazer, acho que consegui explicar melhor agora. Aguardo e Obrigado pela ajuda.

[cfreund]

Quando fizer RRF, a variável irá girar para a direita, carry irá para o MSB e o LSB que foi perdido irá para o carry. Da uma olhada no esquema da página 158.

Por isso tem de limpar o carry de início, fazer RRF em Var_High e então RRF em Var_Low.

[rsdias_]

Assim o 1 não seria perdido ? Não consegui entender direito.

[rsdias_]

Veja se consegui compreender, ao zerar o carry e rotacionar a variavel Var_High, entra zero docarry e vai pro carry o 1 rotacionado, ai quando rotacionar a Var_Low, este 1 do carry vai para Var_low, seria isso ?
Acho que entendi. Obrigado

[cfreund]

Primeiro bit vai para o carry. E na segunda operação o carry vai para o oitavo bit

[rsdias_]

Entendi, Muito Obrigado pela paciência e atenção. Obrigado mesmo, vou fazer uns testes depois.

[brasilma]

OLá RS, caso precise realmente dividir duas variáveis em asm, tenho a rotina para o '51.

Ela além de executar a divisão permite o processo entre duas variáveis com 24 bits!

E não é muito grande!

[rsdias_]

OPa, Muitissimo Obrigado brasilma, mas a principio consegui entender o que foi explicado aqui e deu certo. Agradeço mesmo, se precisar te peço ou se quiser deixar aqui pra que todos saibam também seria interessante.

[brasilma]

Tenho várias rotinas matemáticas em 24 bits que utilizava em um projeto, inclusive raiz

Vamos ver como fica a formatação...

; |##################################################################|
; ----=| DIVISAO 24:24 |=----------
; | INPUT= Dividendo R2, R3, R4 (MSB), Divisor R5, R6, R7 (MSB) |
; | OUTPUT= R5, R6, R7 (MSB) |
; | used regs: A, B, R2, R3, R4, R5, R6, R7, 08, 09, 0A, 0B, 0C, 0D |
; |##################################################################|
; Rotina de divisão 24:24bits dividendo em R2, R3 e R4 (MSB) e divisor (e resultados) R5, R6 e R7 (MSB)
; usa 08-0DH. Processo: desloca com carry o divisor para a esquerda ate obter carry (o 1 mais a esquerda
; estoura o byte mais significativo, isto faz com que o divisor obtenha o mesmo numero de casas do
; dividendo), conta-se qtos shifts são necessários (B guarda o valor), na sequencia começa a desloca-lo
; (divisor) novamente para a direita, e enquanto faz isso tenta subtrai-lo do dividendo; qdo for possível
; começa a deslocar o dividendo, da direita para a esquerda, pelo resultado ate zerar B.

DIV24_24: MOV B,#00h ; Limpa B, que ira contar o numero de deslocamentos a esquerda
MOV 0BH,#0 ; !não pode haver sujeira nestas posições!
MOV 0CH,#0
MOV 0DH,#0


DIV24_24L1: INC B ; INC a cada deslocamento do divisor (p/ assumir tamanho igual ao dividendo)
MOV A,R5 ; Desloca divisor a esquerda
RLC A
MOV R5,A
MOV A,R6
RLC A
MOV R6,A
MOV A,R7
RLC A
MOV R7,A
JNC DIV24_24L1 ; Repete o deslocamento ate haver o carry


DIV24_24L2: MOV A,R7 ; Desloca divisor a direita
RRC A
MOV R7,A
MOV A,R6
RRC A
MOV R6,A
MOV A,R5
RRC A
MOV R5,A
CLR C ; Limpa carry que não e útil
MOV 0AH,R4 ; Copia do dividendo (MSB)
MOV 09H,R3
MOV 08H,R2

MOV A,R2 ; R2 = Dividendo (LSB)
SUBB A,R5 ; Dividendo - Divisor deslocado = carry (0 or 1)
MOV R2,A ; Guarda Dividendo resultante
MOV A,R3
SUBB A,R6
MOV R3,A
MOV A,R4
SUBB A,R7
MOV R4,A
JNC DIV24_24L3 ; Se não houve carry o resultado e 1 (Dividendo > Divisor)
MOV R4,0AH ; Se houve, o resultado e 0 (Dividendo ainda < Divisor)
MOV R3,09h ; Recupera valor original (antes da subtração) do Dividendo
MOV R2,08h

DIV24_24L3: CPL C ; Inverte o carry, o copia diretamente nos registro do resultado
MOV A,0BH ; e vai deslocando-o para a esquerda (O carry nesta situação e uma
RLC A ; copia do Dividendo)
MOV 0BH,A
MOV A,0CH
RLC A
MOV 0CH,A
MOV A,0DH
RLC A
MOV 0DH,A
DJNZ B,DIV24_24L2 ; Repete os deslocamentos e as subtrações ate zerar B

MOV R7,0DH ; Copia o resultado nos registros de saída
MOV R6,0Ch
MOV R5,0Bh

RET