CONTRIBUIÇÃO...

[Guri]

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

[xultz]

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


[B-EAGLE]

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

[denis]

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.

[xultz]

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

[milordy]

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.

[Red Neck Guy]

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

[xultz]

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.

[denis]

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)



[tcpipchip]

quer dizer entao que o compilador tem AI ?

[Guri]

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.

[Guri]

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.

[KrafT]

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

[Guri]

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?

[rona123]

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.