Comparar dois bytes com pic (Assembly)

Vicente Cesar · 29 de janeiro de 2015

Existe alguma instrução que compare dois bytes no PIC e alguma que compare dois bits ? Esses bytes e bits estão armazenados em variáveis diferente. Estou usando o PIC16F628A.

Tentei olhar o set de instruções desse PIC, mas não consegui entende-lo muito bem, então não achei o que queria. Alguém poderia me ajudar ?

OBS: Quero algo que me diga se esse dois bytes ou bits são iguais ou diferentes.

aphawk · 29 de janeiro de 2015

@Vicente Cesar,

Se é Assembly, voce deve ter na verdade os dois bytes em duas posições de memória diferentes, certo ?

A maneira mais simples é carregar esses bytes para dois registradores, e aí sim fazer a comparação, o que vai lhe informar o resultado por vários flags do registrador de status, por exemplo se são iguais ou diferentes.

Não conheço o Assembly dos Pics para lhe responder sobre a comparação de bits, creio que só pode testar se um bit é zero ou um... mas aguarde que logo alguém mais "da área" vai lhe responder !

Paulo

.if · 29 de janeiro de 2015

meio que chutar serve?

comparação não lembro se tem no pic mas subtração provavelmente sim. Neste caso você subtrai um do outro. Se for zero, me lembro de algo +- assim

btsc status,z ; tipo testa o bit do status, se for zero, pula a próxima linhapróxima linha ; geralmente um goto xxxcontinua

compar bit, vê se tem alguma função xor (ou exclusivo). bits iguais, resultado=zero e faça a mesma análise do registro de status

Espero que não exploda nada aí na sua cara kk

agora que me toquei!! asm??? iécaaaa !! kk

vtrx · 29 de janeiro de 2015

@aphawk

Pare de ser preguiçoso!!

Para quem analisou rotinas AVR em ASM,igual você fez,as do PIC são lições do pré-primário.

; VARIAVEIS QUE VÃO SER USADAS NA COMPARAÇÃO; AS VARIAVEIS(RAM)DEVEM COMEÇAR(NO PIC 16F628)a partir DO ENDEREÇO 0X20 CBLOCK	0x20	BYTE_TEST1         BYTE_TEST2        ENDC;... INICIALIZAÇÕA .....; COM O PIC 16F628,voce TEM QUE USAR O W PARA CARREGAR OS VALORES; NOS REGISTRADORES MOVLW 0X10 MOVWF BYTE_TEST1 ;CARREGAR ESTA VARIAVEL COM 10 HEXA MOVLW 0X05 MOVWF BYTE_TEST2 ;CARREGA ESTA VARIAVEL COM 5 HEXA........................; FAZENDO A COMPARAÇÃO MOVF  BYTE_TEST1,W  SUBWF BYTE_TEST2 BTFSS STATUS,Z     ;OS DOIS BYTES SÃO IGUAIS? GOTO  NAO          ;SE FOREM DIFERENTES,EXECUTA DAQUI  GOTO  SIM          ;SE FOREM IGUAIS,EXECUTA DAQUI----------------------------------------------------;TESTE DE BITS BTFSC BYTE_TESTE1,1  ;TESTA SE O BIT 1 É ZERO,SE FOR PULA GOTO  NAO

aphawk · 30 de janeiro de 2015

@vtrx,

Pior que você acertou....meu não me lembrava mais das instruções e teria de ver o set e pesquisar.... Me deu uma baita preguiça só de pensar kkkkkk !

Mas eu sabia que logo você apareceria com a resposta !

Agora estou ficando craque em Asm dos AVR's , tive de reescrever um driver de um display SPI que estava em Bascom para otimizar a velocidade, e olha que ficou bem legal, logo vou postar todo o projeto no Fórum. Só estou conferindo os resultados dos cálculos de capacidade das baterias, porque tá osso de achar algo bem padronizado.... Cada fabricante de bateria usa um método diferente para justificar a carga que eles escrevem nelas, então inventei um método prático para poderem ser comparadas em situações iguais, onde o usuário especifica a tensão útil mínima desejada.

Afinal, existem casos onde uma bateria alcalina pode continuar funcionando satisfatóriamente forneçendo 1,2 volts apenas, e casos onde abaixo de 1,3 já causam problemas ( por exemplo, usando 6 em série já é uma perda caindo de 9 Volts para 7,8 Volts ).

Como as alcalinas ainda conseguem fornecer uma boa corrente, tem fabricante que considera energia útil até 1,1 Volts....

Paulo

MOR_AL · 30 de janeiro de 2015

Tenho algumas macros, que retirando algumas linhas podem ser usadas para o seu problema.

;    Arquivo de Macros "MacrosM.ASM";;    Utilizar a diretiva INCLUDE <MacrosM.ASM>;1)    Pule se o conteúdo do registro R1 for menor que o conteúdo do registro R2 (R1MeR2)    R1MeR2 macro R1, R2, End_R1_menor_que_R2      movf    R2, w            ; w = R2      subwf    R1, w            ; w = R1 - R2      btfss    STATUS, C        ; Se C = 1 pule. (R1 >= R2)      goto    End_R1_menor_que_R2    ; C = 0. (R1 < R2)      endm        ;2)    Pule se o conteúdo do registro R for menor que o valor V (RMeV)    RMeV macro R, V, End_R_menor_que_V      movlw    V            ; w = V      subwf    R, w            ; w = R - V      btfss    STATUS, C        ; Se C = 1 pule. (R >= V)      goto    End_R_menor_que_V    ; C = 0. (R < V)      endm        ;3)    Pule se o conteúdo do registro R1 for igual ao conteúdo do registro R2 (R1IgR2)R1IgR2 macro R1, R2, End_se_iguais      movf    R1, w            ; w = R1      xorwf    R2, w            ; w = R1 xou R2      btfsc    STATUS, Z        ; Se Z = 0 pule (R1 é diferente de R2)      goto    End_se_iguais          endm        ;4)    Pule se o conteúdo do registro R for igual ao valor V (RIgV)    RIgV macro    R, V, End_se_iguais      movlw    V            ; w = V      subwf    R, w            ; w = R - V      btfsc    STATUS, Z        ; Pula se w for diferente de V.      goto    End_se_iguais        ; w = V      endm            ;5)     Pule se o conteúdo do registro R1 for maior que o conteúdo do registro R2 (R1MaR2)    R1MaR2 macro R1, R2, End_R1_maior_que_R2      movf    R1, w            ; w = R1      subwf    R2, w            ; w = R2 – R1. Se C = 0, o resultado é negativo (R1 > R2).                    ; Se C = 1, o resultado é positivo ou nulo (R1 =<  R2).      btfss    STATUS, C          goto    End_R1_maior_que_R2    ; C = 0. (R1 > R2)      endm                ; C = 1. R1 =<  R2 .;6)     Pule se o conteúdo do registro R for maior que o valor V (RMaV)    RMaV macro R, V, End_R_maior_que_V      movf      R, w             ; w = R      sublw     V            ; w = V – R. Se C = 0, o resultado é negativo (R > V).                     ; Se C = 1, o resultado é positivo ou nulo (V >= R).      btfss    STATUS, C          goto    End_R_maior_que_V    ; C = 0. (R > V)      endm                ; C = 1. R =<  V.;7)    Pule se o conteúdo do registro R1 for Diferente do conteúdo do registro R2.  (R1DifR2)    R1DifR2 macro R1, R2, End_se_diferentes      movf    R1, w            ; w = R1      xorwf    R2, w            ; w = R1 xou R2      btfss    STATUS, Z        ; Se Z = 1 pule (R1 é igual a R2)      goto    End_se_diferentes          endm        ;8)    Pule se o conteúdo do registro R for diferente do valor V (RDifV)    RDifV macro R, V, End_se_diferentes      movlw    V                        ; w = V      subwf    R, w                        ; w = R - V      btfss    STATUS, Z              ; Pula se R for igual a V.      goto    End_se_diferentes    ; w dif V      endm        ;9)     Pule se o conteúdo do registro R1 é menor ou igual ao o conteúdo do registro R2 (R1MeIgR2)    R1MeIgR2  macro     R1, R2, End_R1_menor_ou_igual_a_R2      movf    R2, w        ; w = R2      subwf   R1, w        ; w = R1 – R2. Se C = 0, o resultado é negativo.                            ; Se C = 1, o resultado é positivo ou nulo.      btfss    STATUS, C          goto    End_R1_menor_ou_igual_a_R2        ; C = 0, R1 < R2      btfsc    STATUS, Z                ; C = 1, R1 >= R2      goto    End_R1_menor_ou_igual_a_R2        ; Z = 1, R1 = R2      endm        ;10)     Pule se o conteúdo do registro R é menor ou igual ao valor V (RMeIgV)RMeIgV macro R, V, End_R_menor_ou_igual_a_V      movf    R, w                ; w = R      sublw    V                                   ; w = V - R      btfsc    STATUS, C                           ; Pula se R > V      goto    End_R_menor_ou_igual_a_V       ; R =< V      endm        ;11)     Pule se o conteúdo do registro R1 for maior ou igual ao o conteúdo do registro R2 (R1MaIgR2)    R1MaIgR2 macro R1, R2, End_R1_maior_ou_igual_a_R2      movf    R2, w                ; w = R2      subwf    R1, w                ; w = R1 – R2.      btfsc    STATUS, C            ; Se C = 0, o resultado é negativo (R1 < R2).                        ; Se C = 1, o resultado é positivo ou nulo (R1 >= R2).      goto    End_R1_maior_ou_igual_a_R2    ; C = 1. R1 >= R2      endm                    ; C = 0. R1 < R2;12)     Pule se o conteúdo do registro R for maior ou igual ao valor V (RMaIgV)RMaIgV macro R, V, End_R_maior_ou_igual_a_V      movlw    V                ; w = V      subwf    R, w                ; w = R – V      btfsc    STATUS, C            ; Se C = 0, o resultado é negativo (R < V).                        ; Se C = 1, o resultado é positivo ou nulo (R >= V).      goto    End_R_maior_ou_igual_a_V    ; C = 1. R >= V      endm                    ; C = 0. R < V;13)    Compare o conteúdo do registro R1 com o conteúdo do registro R2 (R1MeIgMaR2)R1MeIgMaR2 macro R1, R2, End_R1_menor_que_R2, End_R1_maior_que_R2      movf    R2, w                 ; w = R2      subwf    R1, w            ; w = R1 – R2. Se C = 0, o resultado é negativo.                         ; Se C = 1, o resultado é positivo ou nulo.      btfss    STATUS, C          goto    End_R1_menor_que_R2    ; C = 0, R1 < R2      btfss    STATUS, Z        ; C = 1, R1 >= R2      goto    End_R1_maior_que_R2    ; Z = 0, R1 > R2      endm

aphawk · 30 de janeiro de 2015

@MOR,

Por acaso voce trabalhou com o L80 / M80 ?????

Eu fiz um montão de macros para os Z80, a listagem ficava muito legal...

Paulo

MOR_AL · 30 de janeiro de 2015

@MOR,

Por acaso voce trabalhou com o L80 / M80 ?????

Eu fiz um montão de macros para os Z80, a listagem ficava muito legal...

Paulo

Não trabalhei, não!

Depois de alguns programas em Assembler, comecei a ver que algumas rotinas apareciam muito, aí copiei algumas e fiz outras.

As apresentadas, fui eu que fiz.

MOR_AL

xyko-2020 · 30 de janeiro de 2015

Pra quem trabalha com ASM como eu,..

Todos os mCs parevem iguais. Só substituir os mnemônicos.

Estou certo ou errado?

aphawk · 31 de janeiro de 2015

@,

Quanto a parecerem iguais, concordo. Mas quanto às instruções, não é tão simples... Por exemplo, o Z80 tinha uma instrução muito poderosa, que todos os outros processadores na época precisavam de um loop de várias instruções para fazerem a mesma coisa, mas mais de 10 vezes mais lento.

No próprio exemplo do PIC, ter de mover antes os dados pelo W para levar a outros registradores é um processo bem diferente do que num AVR.

E sempre existem várias maneiras de se fazer uma coisa, mas algumas são bem mais rápidas do que outras.

Creio que o difícil é saber como fazer o ASM de maneira eficiente, pois envolve um conhecimento da arquitetura interna dos processadores.

Paulo

Vicente Cesar · 1 de fevereiro de 2015

@MOR, eu ainda não entendo muito de Assembly, o que são macros ? E o que a instrução endm faz ?
@vtrx Obrigado pela ajuda.
Agora uma duvida, quais são as funcionalidades do registrador STATUS ? Eu o vi nos códigos que vocês passaram, mas ainda não entendi bem como ele funciona.

aphawk · 1 de fevereiro de 2015

@Vicente Cesar,

Macros são uma espécie de subrotinas , isto é, são várias instruções em sequência, que podemos chamar sempre que for necessário.

Mas na verdade são mais do que isso.

Com elas, podemos criar novas "instruções", que o próprio compilador se encarrega de substituir pelos trechos de código que criamos dentro das macros.

Assim fica bem mais fácil escrever programas, pois uma vez que confiamos no funcionamento da macro, podemos usar ela para substituir uma série de instruções.

A instrução Endm apenas sinaliza ao compilador que chegou o final daquela macro. Repare que toda macro tem de ser declarada, e nessa declaração damos o nome que queremos à macro, e informamos quais são os parâmetros que iremos passar para ela.

Quanto ao registrador STATUS, todo processador tem, mesmo com outros nomes.

É um registrador especial, que contém um monte de flags de sinalização. Esses flags são alterados por várias instruções, por exemplo quando fazemos uma soma, conforme o resultado dessa soma vários flags pode ser afetados, como o ZERO flag, indicando que o resultado é zero, ou o CARRY flag, que sinaliza que a soma deu um resultado maior do que a capacidade do acumulador ( nos casos mais comuns onde utilizamos processadores de 8 bits, quando a soma ultrapassa 255 esse flag é ligado ).

Nas linhas mais antigas de Pics, esse registrador continha 5 bits. cada um desses bits é um flag.

Para voce entender melhor, creio que tem de aprender um pouco mais sobre o ASM dos Pics.

Paulo

xyko-2020 · 1 de fevereiro de 2015

http://picprojects.org.uk/projects/pictips.htm

https://books.google.com.br/books?id=s8DBXs-jIRQC&pg=PA108&lpg=PA108&dq=instruction+of+comparison+in+PIC&source=bl&ots=kp0x4jCb0u&sig=7Hi_TEuspwTcVcI0W82gmuh7etI&hl=pt-BR&sa=X&ei=WczNVJX_FZL5ggTSmIGgDA&ved=0CFEQ6AEwDg#v=onepage&q=instruction%20of%20comparison%20in%20PIC&f=false

MOR_AL · 1 de fevereiro de 2015

O Paulo (aphawk) explicou muito bem o que vem a ser macro.

Só falta um exemplo.

1 - Copie minhas instruções acima que tratam da Macro. Copie desde a primeira linha

"; Arquivo de Macros "MacrosM.ASM"", até as últimas linhas. ...

;13)   Compare o conteúdo do registro R1 com o conteúdo do registro R2 (R1MeIgMaR2)

R1MeIgMaR2 macro R1, R2, End_R1_menor_que_R2, End_R1_maior_que_R2

      movf   R2, w                ; w = R2
      subwf   R1, w           ; w = R1 – R2. Se C = 0, o resultado é negativo.
                        ; Se C = 1, o resultado é positivo ou nulo.
      btfss   STATUS, C
      goto   End_R1_menor_que_R2   ; C = 0, R1 < R2
      btfss   STATUS, Z       ; C = 1, R1 >= R2
      goto   End_R1_maior_que_R2   ; Z = 0, R1 > R2

2 - Abra um editor de texto, daqueles simples como o Notepad (Bloco de notas), ou o WordPad. Cole tudo que você copiou.

O arquivo tem que ficar igual ao que eu apresentei.

3 - Salve o arquivo criado com o nome MacrosM.asm no seu PC, mais precisamente na pasta onde se encontra o seu projeto.

4 - No seu arquivo que você está digitando as instruções em ASM (dentro do MPLAB), inclua a diretiva INCLUDE <MacrosM.ASM> como a seguir (exemplo de utilização do PIC16F628A. Substitua pelo seu micro):

list P=PIC16F628A
include <P16F628A.INC>
include <MacrosM.asm>

Com isso você informa ao compilador que algumas instruções, aquelas que você colocou no arquivo da macro, se encontram no arquivo MacrosM.asm.

As instruções a que me refiro são, por exemplo que consta no ítem 13.

Você coloca a instrução

R1MeIgMaR2 macro R1, R2, End_R1_menor_que_R2, End_R1_maior_que_R2

Toda a vez que o compilador encontrar esta instrução, quando for compilar, ele vai substituir pelas instruções...

      movf   R2, w                ; w = R2
      subwf   R1, w           ; w = R1 – R2. Se C = 0, o resultado é negativo.
                        ; Se C = 1, o resultado é positivo ou nulo.
      btfss   STATUS, C
      goto   End_R1_menor_que_R2   ; C = 0, R1 < R2
      btfss   STATUS, Z       ; C = 1, R1 >= R2
      goto   End_R1_maior_que_R2   ; Z = 0, R1 > R2
      endm

Então, você criou uma instrução mais complexa, formada por uma sequência de instruções simples, que o compilador está preparado para reconhecer.

No exemplo usando o item 13.

R1MeIgMaR2 macro R1, R2, End_R1_menor_que_R2, End_R1_maior_que_R2

Significa que:

1 - Você renomeou dois registros de propósito geral (GPR) com os nomes de R1 e R2 (registro 1 e registro 2). Poderiam ter outros nomes. Depois eu explico.

2 - Você incluiu em seu arquivo principal em asm, os seguintes endereços (Labels) End_R1_menor_que_R2 e End_R1_maior_que_R2.

End_R1_menor_que_R2 - É o label que o programa desvia quando R1 for menor que R2.

End_R1_maior_que_R2 - É o label que o programa desvia quando R1 for maior que R2.

Caso R1 seja igual a R2, então o programa não desvia para nenhum dos dois endereços, apenas segue para a instrução seguinte ao grupo de instruções da macro.

Sim, você pode alterar os nomes de R1, R2, End_R1_menor_que_R2 e End_R1_maior_que_R2 em seu programa principal. Mantenha o que está escrito no arquivo MacrosM.asm.

No programa principal, você decidiu que em vez de R1 e R2 fica melhor X1 e X2 e em vez de End_R1_menor_que_R2 e End_R1_maior_que_R2, fica melhor E1 e E2.

Então sua instrução no programa fica:

R1MeIgMaR2 macro X1, X2, E1, E2

O compilador vai procurar por R1MeIgMaR2 no arquivo MacrosM.asm e montar o seu grupo de instruções, já que R1 é um mnemônico, assim como X1 e os outros. Apenas nos ajudam a lembrar. Para a máquina são apenas endereços de registradores e de memória de programa.

MOR_AL