ASM51

Olá a todos,

Eu estava com um probleminha "besta" para resolver, e pesquisei aqui no forum uma solução, encontrei algumas dicas, mas um tanto complicadas.
Bom, depois de queimar os neuronios, cheguei a essa conclusão e gostaria de compartilhar com vocês, afim de ajudar quem esteja com o mesmo problema!

O problema era que eu queria "ajuntar" duas variáveis de 8 bits em uma variável de 16bits ou seja uma INT.:

cpp code

/************************************************
 JUNTA DOIS NÚMEROS DE 8 BITS HEXADECIMAIS
          EM UM INTEIRO DE 16BITS.
*************************************************/
   unsigned char a, b;
   unsigned int time, temp, temp1, temp2;

   a = 0x12;
   b = 0x34;
   temp1 = a;                                     // LOAD CHAR EM INT, PARTE BAIXA
   temp2 = b;                                     // LOAD CHAR EM INT, PARTE BAIXA
   temp1<<=8;                                     // TRANSPORTA PARTE BAIXA PARA ALTA
   temp = temp2^temp1;                            // JUNTA AS DUAS INTs EM UMA SÓ
   time = bcd2dec16(temp);                        // CONVERTE HEXA EM DECIMAL

Eu estou usando atualmente um jeito que depois de usar umas 300 vezes meio que quase comecei a me acostumar. Eu não vi essa sintaxe em lugar nenhum, meio que inventei e fiquei ligeiramente orgulhoso com ela. Eu já estou achando ela um pouco menos que bizarra, o resultado é bem otimizado.

Código: Selecionar todos

unsigned int final;
unsigned char a = 0x12;
unsigned char b = 0x34;

((unsigned char *)&final)[0] = b;    // Copia o valor de b no byte menos significativo de final
((unsigned char *)&final)[1] = a;    // Copia o valor de a no segundo byte de final

// Final agora tem valor 0x1234


union também é uma opção...

xultz escreveu:Eu estou usando atualmente um jeito que depois de usar umas 300 vezes meio que quase comecei a me acostumar. Eu não vi essa sintaxe em lugar nenhum, meio que inventei e fiquei ligeiramente orgulhoso com ela. Eu já estou achando ela um pouco menos que bizarra, o resultado é bem otimizado.

Código: Selecionar todos

unsigned int final;
unsigned char a = 0x12;
unsigned char b = 0x34;

((unsigned char *)&final)[0] = b;    // Copia o valor de b no byte menos significativo de final
((unsigned char *)&final)[1] = a;    // Copia o valor de a no segundo byte de final

// Final agora tem valor 0x1234


Caramba, nunca imaginei que daria pra fazer isso usando Cast.

Eu também não, até que um dia decidi experimentar e funcionou...

xultz escreveu:Eu estou usando atualmente um jeito que depois de usar umas 300 vezes meio que quase comecei a me acostumar. Eu não vi essa sintaxe em lugar nenhum, meio que inventei e fiquei ligeiramente orgulhoso com ela. Eu já estou achando ela um pouco menos que bizarra, o resultado é bem otimizado.

Código: Selecionar todos

unsigned int final;
unsigned char a = 0x12;
unsigned char b = 0x34;

((unsigned char *)&final)[0] = b;    // Copia o valor de b no byte menos significativo de final
((unsigned char *)&final)[1] = a;    // Copia o valor de a no segundo byte de final

// Final agora tem valor 0x1234


Utilizo parecido,só que deixo como #define,facilita muito.

O codigo do Xultz eh o mais otimizado.
Eu ainda uso aquele?
temp = a<<8 | b;

Aquino, uma vez eu dei uma olhada no assembly gerado por uma instrução do tipo

Código: Selecionar todos

x = (a << 24) + (b << 16) + (c << 8) + d;

e por incrível que pareça, o assembly não fazia nenhuma instrução de rotação e soma, ele simplesmente copiava os bytes pros lugares certos (ou seja, o compilador otimizou porque entendeu qual era o objetivo). Isso num PIC faz uma diferença absurda, porque ele só tem instrução de rotate de 1 bit, então um (a << 24) teria que ser feito dentro de um loop e executar 24 vezes o rotate.
Porém, não dá prá esperar que o compilador otimize sempre, ou entenda sempre o propósito, e por incrível que pareça, hoje eu acho mais fácil de entender o que o programa faz com as instruções de cast que eu fiz.

xultz escreveu:Eu também não, até que um dia decidi experimentar e funcionou...

Esta aqui foi a última aprendi:

Código: Selecionar todos


/* Protótipo da função */
int write (int fd, const void *buf, int size);

/* Aqui chamando a função, mas sem a necessidade de criar o buffer */
write(fd, &(int){0}, 1)



quer dizer entao que o compilador tem AI ?

Realmente, se for pensar em fazer em assembler, é bem simples fazer essa atribuição entre variáveis.

Eu demorei tantos anos para abraçar a causa da linguagem C, pois eu era Assembleiro de carteirinha, mas hoje não consigo olhar para um projeto e pensar em ASM, dá uma preguiça!...só de pensar em ficar manipulando bankos de memória, contanto paginas de alocação e outras coisas chatas...vixxi, como eu perdi tempo com assembler.

Não que assembler seja ruim, muito pela contrário, gosto muito de usa-lo, mas com limitações.

C, proporciona uma versatilidade muito grande aos trabalhos realizados, sem falar na facilidade de migração...moleza.

Falando em assembler,

Esses dias mexendo na bagunça, vi um kit de z80 da empresa digiplan, alguém ai lembra?

Comecei a brincar com o trem, mas, Meu Deus, que doidera, só de ficar colocando bytes em linguagem de maquina, inseridos por um teclado numérico...nossa!

É torturante, imagina ter que criar uma simples aplicação, daria uma listagem monstro e tortuosa...Se bem que na época já existiam o assembladores, MSX, IBM...que quebravam um galhão...

É nostálgico, foram bons tempos.

A propósito se algum intusiasta quiser comprar esse kit eu vendo...tá novinho.

Guri escreveu:A propósito se algum intusiasta quiser comprar esse kit eu vendo...tá novinho.

A propósito Guri, quanto vc espera receber pelo kit? R$ 1000, R$ 2000, R$ 5000? Conta para a gente...

Só para não deixar o pessoal no AR, quanto ao kit z80....

Quero explicar que deu uma DÓ de desfazer dele, pois é pura nostalgia dos velhos tempos do z80...

Eu tinha um MSX da sharp...pena que o vendi e me arrependo até hoje

Por falar em nostalgia, alguém sabe o que aconteceu com a linha 80256 da intel?

Guri,
Quando estava na faculdade (1983-1988), uma revista (acho que Nova Eletrônica) publicou um kit de Z80 chamado NESTOR. Eu montei um e descobri que o código hex publicado tinha erros depois de digitar os numeros em um Data I/O.

Depois disso, fiz um código melhor onde podia visualizar o conteúdo do registros alternativos.

Foi uma construção em placa ilhada com ligação ponto a ponto.
Já revirei minha casa muitas vezes a procura de minha 'joia' e não consigo achar mais.

Todos esses componentes antigos estão bem obsoletos e o que se acha por ai tem sério comprometimento com oxidação dos terminais.