Conversão de decimal para binário em C.

[fabio_pic]

Bom dia senhores,

Alguém sabe como se existe alguma forma simples de se fazer conversão de decimal para binário e vice-versa em liguagem C para PIC?

Abraços,
Fábio.

[ze]

desculpe minha ignorância, mas depois de converter o que vai fazer com os dados mesmo? ex. decimal com decimal faço isto... e com binário aquilo...e com hexa faço algo tipo assim sei lá entende?
estou com dificuldade pra enxergar uma utilidade prática. a não ser o lance de escrever em alguns rtc DSxxx
obrigado.

[fabio_pic]

Lellis,

A idéia é a seguinte:

Vou fazer um contador. Esse contador (em decimal) será utilizado para fazer o endereçamento da memória 62256, ou seja, contador=1 .... endereço=0b0000001, contador=2 .... endereço= 0b00000010 e assim vai, entendeu?
A pergunta é: como vou endereçar os valores do contador (1, 2, 3...) no endereçamento da memória. Resposta: só se transformar eles para binário, certo? Ou então deverei fazer o contador já na forma binária mas aí não sei como se faz....
Esse é o meu segundo projeto com PIC ainda não sei os macetes todos...

Abraços,

[ivan]

1 - Define um ponteiro de 16bits
Como não sei que compilador vc está usando, vou imaginar que int16 que dizer um inteiro de 16bist.

int16 *ptrEnd;

2 - Atribui ao ponteiro o endereço do primeiro byte onde estão armazenados os dados

prtEnd = &byte1_Memoria;

3 - Depois para acessar a posição de memória é só usar aritmética de ponteiros

ptrEnd++; ou ptrEnd--; ou ptrEnd += 20; e assim por diante

4 - para obter o dado, use:
int16 dado = *ptrEnd;

[msamsoniuk]

eu nao conheco muito bem o PIC, mas acho que ele eh um microcontrolador baseado em logica binaria... supostamente qualquer valor dentro dele eh armazenado na forma binaria!

supondo que vc tem um mcu com portas A e B conectadas no bus de enderecos e porta C conectada no bus de dados de uma memoria externa, bastaria fazer:

unsigned short counter;
unsigned char data;

for(counter=0;;counter++)
{
PTA = counter/256;
PTB = counter%256;
data = PTC;

printf("endereco %x = %x\n",counter,data);
}

note q a unica "conversao" eh quebrar a variavel counter de 16 bits para duas partes de 8 bits. eu peguei a parte alta dividindo por 256 e a parte baixa pegando o resto da divisao (poderia ter feito com shifts e mascaras) e coloquei a parte alta em PTA e a baixa em PTB, isso supoe que a variavel eh tratada como big-endian. se o seu mcu/compilador eh little-endian, as partes alta e baixa estariam ao contrario (soh inverter PTA e PTB).

[ze]

ahhhhhhhhhhhhhhh, bão. psá convertê não.
dica do marcelo = 0x0A!!!!!!

[fabio_pic]

Vamos por parte então.....

Primeiro o Ivan:

1 - int16 *ptrEnd;
Isso quer dizer que estou definindo uma variável int16 com o nome de prtEnd. É isso?

2 - prtEnd = &byte1_Memoria;
Posso escrever essa expressão desta forma? > "prtEnd=0b00000000;"

3 e 4 - Entendi.

Agora o Lellis:

marcelo = 0x0A,
então posso usar "marcelo++;"
e marcelo será igual a 0x0B?

Abraços,

[ze]

ah, fala sério! fala sério? trad: dica do marcelo com nota 0b1010 matou sua charada (se for usar o pic pra ler ram msm)
plz somehome explica pra ele o princípio de ponteiros. aproveito e pego carona pois num entendo paul newman!
abrçs....

[helton]

1 - int16 *ptrEnd;

Isso quer dizer que estou definindo uma variável do tipo PONTEIRO int16 com o nome de prtEnd.

2 - prtEnd = &byte1_Memoria;

Aqui o que está ocorrendo:

o Ponteiro "prtEnd" está recendo o endereço de memória da variável "byte1_Memoria"...para acessar os dados da variável "byte1_Memoria", usando o ponteiro "prtEnd", é simples:

byte aux = *prtEnd;


> Posso escrever essa expressão desta forma? > "prtEnd=0b00000000;"

Até pode...mas basicamente voce está fazendo que o prtEnd receba (ou aponte para ) o endereço 0b00000000;"


marcelo = 0x0A,
então posso usar "marcelo++;"
e marcelo será igual a 0x0B?

SIM


Alias...talvez a definição de "SETAR" seja isso: ponteiro de memória que aponta para um determinado endereço....

[msamsoniuk]

infelizmente o PIC eh fraquinho e nao tem bus externo, entao tem acessar a memoria pelos ports de i/o. na pratica daria para usar um unico port (PTA) e mais 3 sinais de strobe (PTB0, PTB1, PTB2) ativando dois 74LS374 para gerar os enderecos e um 74LS244 para a leitura. ficaria algo como:

PTA = count/256; // parte alta do endereco
PTB0 = 1; // latch 374 da parte alta
PTA = count%256; // parte baixa do endereco
PTB1 = 1; // latch 374 da parte baixa
PTADIR = 0x00; // seta para entrada, chutando q eh facil assim no seu mcu
PTB2 = 1; // tira o 244 do tri-state
data = PTA; // le o dado
PTB = 0; // desativa todo mundo
PTADIR = 0xff; // seta para sada novamente

para escrever daria talvez um pouco mais de trabalho, teria q usar um 74LS245 no lugar do 74LS244 e setar a direcao tb... mas se fosse um mcu com bus externo, obviamente seria mais simples e poderia usar um ponteiro diretamente:

char *memoria = 0x100000; // supondo que a memoria esta neste offset

data = memoria[123]; // para ler o byte 123 naquele offset
memoria[123] = data; // para escrever o byte 123 naquele offset

ou diretamente *memoria++ = data, por ex, vai gravando e incrementando o ponteiro. e por ae vai...

[Jorge_Francisco]

A memória é externa? Se sim, qual o problema de usar qualquer PORT e colocar o valor nele? Do tipo PORTD = 2 ou PORTD = 0X02 OU PORTD = 0b00000010. É claro que vc tem que falar qual é o compilador pra saber como é a declaração.

[proex]

Caramééelo !!!!

Num tô entendendo nada. Contar em decimal e depois converter em binário ????????

Que confuso.

[Maurício]

Salve, fabio_pic.

Cara! Todos os circuitos digitais já trabalham com binário de forma nativa!
Trabalhar com outra base de numeração só é conveniente para Humanos.
Seu compilador é quem tem que permitir vc poder trabalhar com decimal, com octal, com hexa ou com binário.

Não importa a forma como o número é armazenado dentro da máquina, desde que somar 25+25 dê 50 (lá na máquina tá armazenado 00110010B = 50D).

Se vc não conhece ponteiros, vc pode criar uma variável de 16 bits (inteiro) e ir incrementando ou decrementando essa variável e usá-la como endereçador da memória.
Quando vc colocar a variável no bus de 8 bits, os bits corretos vão estar lá.

Experimenta isso daqui ó:

Código: Selecionar todos

#include <PIC.H>

// PTA recebe o LSB do endereço
// PTB recebe o MSB do endereço
// PTC recebe o dado para enviar para a memória

void main ( void )
{
   unsigned int endereco;
   char dado;
   
   endereco = 0x1000;
   dado = 0x32;
   PTA = endereco;            // move o LSB do endereco   para o port A
   PTB = endereco >> 8;      // move a parte alta do endereço (MSB) para o port B
   PTC = dado;
   while ( 1 );
}

Já viu que nesse método aí vc precisa de 24 bits, né? Mais os bits de controle da memória. E nessa rotina não tem a parte que manda escrever na memória.

Quando se usa memória externa com microcontroladores, o que se faz é criar um hardware com latches, pra prender os endereços e liberar pinos pra poder fazer o restante.

[]'s

[fabio_pic]

Maurício,

Obrigado pela dica. Sempre quis aprender microcontroladores e é realmente muito interessante. Literalmente você tem que entender tudo o que se coloca dentro do "bichinho" pra ele funcionar. Imagino se fosse em assemble !!!!
Mesmo fazendo bons cursos sempre fica algo pendente que você não espera.

Até mais tarde. Obrigado a todos pelas ajudas.
Fábio.

[RobL]

Veja se isso ajuda:

Ponteiros em C ou outra lingua, em resumo:



1- Define-se (reserva-se) uma memória, cujo local será definido em tempo de compilação, por exemplo foi escolhido, 0x20 como endereço do ponteiro.

2- Associa-se a este ponteiro, um endereço de interesse, onde está o nosso

dado. Por exemplo 0x20, o ponteiro, contém o valor 0x40, que é o endereço do nosso dado. No endereço 0x40 temos o valor 0x3, nosso dado.

3- Pode-se ler esse dado indiretamente. Basta pedir o valor que está dentro do endereço apontado. Ao ler o ponteiro vamos obter o valor 0x3.

4- Da mesma forma podemos escrever na memória apontada pelo ponteiro.

5- Se escrevermos o valor 0x5, o endereço 0x40 ficará com 0x5. Mas isso foi pedido através do endereço 0x20(o ponteiro) que aponta para 0x40 e coloca aí 0x5.



Ponteiro dentro do PIC:

Temos dois registros dedicados, o FSR e o INDF e o registro Work (W) por onde todas as transferências tem que passar. W tem dados transitórios.

O valor do ponteiro é passado para o registro trabalho W. De W vai para o FSR. O valor a ser escrito vai para W e de W para o endereço final apontado por FSR através do registro INDF, conforme o exemplo acima em C.



Parece loucura a existência dos ponteiros, já que podemos realizar esse mesmo processo diretamente. Mas isso consumiria uma enorme quantidade de memória e instruções além de não viabilizar certas operações de trocas entre registros.



Ver como ler, escrever no ponteiro nos posts acima.