ASM51

Amigos, na linguagem C é possível se criar variáveis desde 1 bit até reais (números irracionais). Agora, eu gostaria de perguntar se alguém sabe como criar variáveis em linguagem assembly no formato 1 bit, 8 bits, 16 bits, reais, etc...Nunca vi variáveis desse tipo no Mplab.

Que eu entenda, o assembly apenas acessa registradores de 8 bits e no PIC tem instruções de suporte a acesso de 1 bit.
Variaveis são uma abstração das linguagens de alto nivel, ou perdi algum detalhe ?
Ao menos no MPLAB quando eu usava era assim, mas não sei como é nesse novo MPLABX.

Até onde eu vejo, continua igual...

O tamanho das variáveis depende dos registradores do PIC,quem vai manipular é o programador.
Como deve saber,em ASM você acessa o Hardware.
Se pretende usar 1 bit,vai utilizar uma variável de 8 bits(que depende do pic usado),e acessar o bit que precisa coma as instruções diretamente.
Para variáveis maiores,você manipula vários registros.
Numa linguagem de alto nível,como o C,é assim que é feito.

Está certo. Então suponhamos que eu queira armazenar o valor 700 em uma variável ou conjunto de variáveis.
Como isso poderia ser feito?

O PIC tem instruções de teste de bit (BTFSS e BTFSC), que executam conforme o estado de um bit de um registrador. O compilador C implementa estas instruções quando você quiser ler ou setar uma variável de 1 bit de tamanho.
Para variáveis de 16 bits inteiras e sem sinal, você usa duas variáveis de 8 bits. Toda vez que incrementar a variável, você incrementa a menos significativa e sempre observa em seguida o bit de Carry (se não me falha a memória, ele está em STATUS). Se subiu, você deve incrementar também a variável mais significativa. O mesmo ocorre quando você decrementa.
Variáveis float... olha, a menos que você tenha um motivo muito, muito forte mesmo, você estuda a bagaça e implementa em assembly (já trabalhei num projeto assim, e foi muito chato, e fizemos um float simplificado para a aplicação). Caso contrário, faça em C, o compilador tem rotinas bem feitas e otimizadas de matemática, não vale a pena reinventar a roda.

pra definir o valor, use a cerquilha: #define variavel1_val d'700'

Algo que pode ajudar muito, são algumas Macros ou funções prontas que nos aliviam de ter de realizar algumas tarefas manualmente, como mencionado acima, se for em C você não tem de se preocupar muito com a implementação da lógica, mas apenas com a própria lógica.

Olá Pask.
O Xultz já se aproximou do que fazer.
Na realidade você precisa ter em mente o que deseja fazer com as variáveis. Operações matemáticas, apenas contadores, etc.
Em função disso, você tem que resolver.
Se forem contadores, o Xultz já mostrou para inteiros.
Se forem operações matemáticas, aí a coisa começa a complicar.
Você tem que tentar resolvê-las do modo mais simples.
Explico (ou vou tentar).
Se forem apenas as 4 operações (+ - * /), então tente fazer com números inteiros. Fuja de números reais racionais (ponto flutuante).
Uma dica seria você pré multiplicar alguns coeficientes para que ao final obtenha um múltiplo de 10 do valor da solução. Digamos que você programou sua solução para que seja 100 vezes maior que o desejado. Para exteriorizar em algum display, basta "andar com a vírgula" duas casas decimais. Com isso você, usando inteiros, obtém duas casas decimais.
Na Net tem muitos sítios com rotinas prontas de operações matemáticas em assembly. Com 8, 16, 24 e 32 bits. Mas é aquilo que já foi mencionado, se o uC for de 8 bits, então a linguagem tem que gerenciar números maiores que 255 e menores que 0.
Quanto a ponto flutuante.
Já tem as rotinas prontas na Microchip, mas não são imediatas. Tem que estudar um ou dois application notes deles.
Estou fazendo um projeto de um LC meter, que usa ponto flutuante. Nem sei quando vou terminá-lo. O caso é que você não deve confiar em rotinas prontas.
Tem que testá-las.
Fiz alguns programas em assembly, que testam boa parte do conjunto dos números em ponto flutuante.
Tipo...
A + B - B - A. Verifico se dá zero e vario os valores de A e B.
A - A. Verifico se dá zero e vario o valor de A.
A * B / B. Verifico se dá A.

Não são exatamente estas expressões, mas algo que teste as quatro operações.

A bagaça não é fácil, não.
Se você quiser eu posso postar os programas, mas não recomendo ir por este caminho. Além de trabalhoso é desnecessário, já que hoje há uC com maiores capacidades de memória flash e permitem o emprego de programas com mais alto nível.
Mesmo em termos de velocidade, não vale mais a pena.

MOR_AL

Sim. Mas, na verdade, não se trata de operações matemáticas mas somente uma simples curiosidade de como representar números inteiros maiores do que 8 bits em linguagem assembly para PIC.

Pask escreveu:Sim. Mas, na verdade, não se trata de operações matemáticas mas somente uma simples curiosidade de como representar números inteiros maiores do que 8 bits em linguagem assembly para PIC.

Ok!
MOR_AL

haja cúriosidade nisso....

Variável é uma abstração.
O que existe é um registrador do uP ou um endereço da Ram
(label no assembler)
Se 'Variáveis' são maiores que um Byte, procedimento indicado é que o Primeiro Byte
contenha seu comprimento. (Num. de Bytes ocupados)


Dj.

talvez a pergunta esteja apenas no forum errado... em sua implementacao original, C foi feita para processadores que lidavam com inteiros de 8 bits (char), 16 bits (short) e 32 bits (long). dependendo da maquina, int era de 16 ou 32 bits, indicando o tamanho mais natural da ALU do processador. e nestas maquinas vc tinha tambem suporte a ponto flutuante de precisao simples (float de 32 bits) ou dupla (double de 64 bits), bem como suporte a manipulacao de bits e ponteiros (incremento, decremento, indexacao, etc). a linguagem em si eh estruturada em torno de uma stack e usa os registros como uma "cache" para a stack.

em um PDP11, uma das maquinas onde C se popularizou inicialmente na decada de 70, cada linha de codigo C quase corresponde a uma linha de codigo asm, ou seja, a linguagem eh um asm de alto nivel.

no caso do PIC, tem que considerar que nem eh um procesador de verdade, mas sim um subproduto (um coprocessador de IO de uma era distante, programado diretamente em microcodigo) que foi reempacotado como sendo um processador. diferentemente da maioria dos processadores modernos que eh projetada focando linguagens estruturadas, o PIC nunca focou isso, entao adaptar uma coisa a outra dah um trampo gigantesco. dah para fazer, mas ateh em um Z80 vc faria de forma mais simples! e talvez uma boa escola para isso ainda seja dar uma olhada em como faziam essas operacoes multiprecisao em um Z80... eh uma boa escola!

mas assim, soh para adiantar o negocio... normalmente vc faz bibliotecas e vai construindo as coisas, do basico para o mais avancado. no caso, comeca com operacoes basicas multiprecisao: and, or, xor, not... sem muito segredo, por exemplo, um xor de 32 bits consiste simplesmente em fazer 4 xor sucessivamente. uma soma e subtracao multiprecisao jah eh um pouco mais complexa. se vc tem os bytes ABCD e vai somar com EFGH, vc vai fazer a soma de D+H primeiro, daih se der um overflow vai ter um carry, entao vc soma C+G+carry, se der overflow vai ter um carry e faz assim sucessivamente: B+F+carry e A+E+carry. para subtracao, vc pode usar a propria soma e apenas negar o segundo operando, assim ABCD-EFGH = ABCD + not(EFGH) + 1. e a soma multiprecisao vc jah conhece. para multiplicar, depende. vc vai precisar, certamente implementar o shift para a esquerda, o que nao eh complexo: ABCD << 1 vai ser feito primeiro D<<1, daih C<<1 com carry, B<<1 com carry, A<<1 com carry.

se o processador tem multiplicacao, vc pode fazer um truque AB*CD vai ser B*D + (A*D +C*B)<<8 + A*C<<16... os operandos de entrada de 16 bits vao gerar um resultado de 32 bits. outra forma eh fazer bit a bit, ou seja AB*CD vc pega sucessivamente M=AB<<1 e entao avalia bit a bit CD da direita para esquerda: se o bit for 1, entao T=T+M, senao nao faz nada. o resultado eh que vc tem 16 somas do operando M, que eh AB shiftado de 1 em 1. em termos praticos:

AB = 1110011100001111
CD = 0000000000000010

para simplificar.

vc tem entao:

AB<<0 = 1110011100001111 -> bit(0) de CD = 0
AB<<1 = 11100111000011110 -> bit(1) de CD = 1
AB<<2 = 111001110000111100 -> bit(2) de CD = 0
...

o resultado eh que na soma vc tem apenas AB<<1, pq eh o unico bit 1. isso para simplificar, pq senao ia complicar, mas enfim, note que o resultado eh precisamente o que esperavamos.

na divisao, imagine que vc tem AB*CD = EFGH. entao pense o contrario, EFGH/AB seria quantas vezes cabem AB em EFGH. uma solucao trivial seria subtrair EFGH-AB ateh EFGH for menor que AB. outra solucao seria uma subtracao binaria, ou seja, vc faz EFGH - AB<<31, se o resultado for positivo, vc soma CD = CD+1<<31, senao vc nao faz nada. e faz isso para AB<<31 ateh AB<<0. o resultado somado em CD eh a divisao.

tendo as operacoes logicas multiprecisao (and, or, xor, not), shifts (esquerda e direita) e aritmetica basica (add, neg, mul, div), vc pode implementar operacoes de ponto fixo ou ponto flutuante. no caso de ponto fixo, recomendaria vc ler isso aqui:

http://en.wikipedia.org/wiki/Q_%28number_format%29

no caso de ponto flutuante:

http://en.wikipedia.org/wiki/IEEE_floating_point

mas em essencia, com ponto flutuante as operacoes vai usar as operacos da sua biblioteca basica. por exemplo, ponto fixo de precisao simples consiste em 24 bits de mantissa e 8 bits de expoente. nao eh dificil imaginar que (A^m)*(B^n) em ponto flutuante seria algo como A*B^(m+n), onde A*B eh uma operacao de 24 bits e m+n uma operacao de 8 bits, justamente as operacoes que vc jah teria na sua biblioteca multiprecisao.

Sent from my iPhone using Tapatalk

Fica claro, dessa forma, que realizar simples operações matemáticas básicas como soma, subtração, divisão e multiplicação é extremamente complexo em assembly. Daí justifica-se o sucesso da linguagem C e a sua proliferação no mundo dos programadores dos mais diversos sistemas programáveis existentes ou criados até hoje.