ASM51

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á.

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

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á.

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’.


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.

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.

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

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

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

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

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!

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.

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