Publicado por: Alex_CBA en 26 de Marzo de 2004, 13:21:00
disculpen mi ignoracia pero necesito que alguien me informe como puedo hacer para convertir un valor(lo que me ha dado el conversor A/D) en unidades,decenas,centenas y miles para poder mostrarlos en 4 displays de 7segmentos.
Se me ocurrio una rutina empleando divisiones y trabajando con el modulo pero con el compilador de CCS no se como hacerlo.
Si alguien sabe estare muy agradecido.
Publicado por: cucaracha en 26 de Marzo de 2004, 20:02:00
Y no digas eso de ignorante, hombre!, que nadie nace sabiendo. O todos nacemos ignorantes, como quieras.
Suerte!
Publicado por: pocher en 27 de Marzo de 2004, 00:33:00
i=ATOI(char *ptr)
Esta función convierte la cadena de caracteres apuntada por ptr en un valor de tipo entero. Acepta argumentos en decimal y en hexadecimal. Si el resultado no se puede representar, el comportamiento es indeterminado. El prototipo de esta función está en el fichero de cabecera stdlib.h
La que hace lo contrario no es itoa(), esta más bien no existe. Yo utilizo para convertir un número en cadena de caracteres sprintf(cadena,"%lu",numero)... y esta es la que te hará falta para el conversor.
Luego troceando cada caracter de la cadena los envias a los displays correspondientes.
Un saludo
Publicado por: Alex_CBA en 27 de Marzo de 2004, 03:42:00
unidad=valor%10; //separo la unidad
decena=(valor%100)/10;//separo la decena
centena=(valor%1000)/100;//separo centena
miles=(valor%10000)/1000;//separo miles
Lo comprobe simulando en el proteus...
Si no les gusta avisen....
Saludos desde Argentina
Publicado por: cucaracha en 27 de Marzo de 2004, 04:20:00
Pero seguro que si existiese sería igual que esto que hicistes.
Mil perdones si te he liado.
Publicado por: MGLSOFT en 27 de Marzo de 2004, 05:32:00
Codigo:
Void Desmembra (int16 Dato) //Esta funcion obtiene el valor de los
{ // digitos a enviar al display
Digito[0] = Dato/1000; Dato = Dato%1000;
Digito[1] = Dato/100; Dato = Dato%100;
Digito[2] = Dato/10; Dato = Dato%10;
Digito[3] = Dato;
}
Espero te sirva, es lo mismo que hiciste, deberis probar cual forma te lleva mas ROM despues de compilarla, no te olvides que lo que haces como funcion tiene variables locales que no consumen memoria real en C...
Publicado por: pocher en 27 de Marzo de 2004, 09:57:00
unidad=valor%10;
decena=(valor/10)%10;
centena=(valor/100)%10;
miles=(valor/1000)%10;
Publicado por: Ginho_rj en 17 de Abril de 2004, 16:48:00
#include <16f877A.h> // microcontrolador utilizado
#device adc=10
#include <MATH.h> // Biblioteca de função matemática
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Configurações para gravação *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt // configuração dos fusíveis
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definições para uso de Rotinas de Delay *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use delay(clock=4000000, RESTART_WDT)
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Constantes internas *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//A definição de constantes facilita a programação e a manutenção.
#define t_filtro 500 // tamanho do filtro
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição e inicialização das variáveis *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//Neste bloco estão definidas as variáveis globais do programa.
float conversao = 0; // armazena o resultado da conversão AD
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição e inicialização dos port"s *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05
#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Declaração dos flags de software *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//A definição de flags ajuda na programação e economiza memória RAM.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* ENTRADAS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// As entradas devem ser associadas a nomes para facilitar a programação e
//futuras alterações do hardware.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* SAÍDAS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// As saídas devem ser associadas a nomes para facilitar a programação e
//futuras alterações do hardware.
#bit rs = porte.0 // via do lcd que sinaliza recepção de dados ou comando
#bit enable = porte.1 // enable do lcd
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Rotina que envia um COMANDO para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void comando_lcd(int caracter)
{
rs = 0; // seleciona o envio de um comando
portd = caracter; // carrega o portd com o caracter
enable = 1 ; // gera pulso no enable
delay_us(1); // espera 3 microsegundos
enable = 0; // desce o pino de enable
delay_us(40); // espera mínimo 40 microsegundos
return; // retorna
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Rotina que envia um DADO a ser escrito no LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void escreve_lcd(int caracter)
{
rs = 1; // seleciona o envio de um comando
portd = caracter; // carrega o portd com o caracter
enable = 1; // gera pulso no enable
delay_us(1); // espera 3 microsegundos
enable = 0; // desce o pino de enable
delay_us(40); // espera mínimo 40 microsegundos
return; // retorna
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Função para limpar o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
comando_lcd(0x01); // limpa lcd
delay_ms (2);
return;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Inicialização do Display de LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void inicializa_lcd()
{
comando_lcd(0x30); // envia comando para inicializar display
delay_ms(4); // espera 4 milisengundos
comando_lcd(0x30); // envia comando para inicializar display
delay_us(100); // espera 100 microsengundos
comando_lcd(0x30); // envia comando para inicializar display
comando_lcd(0x38); // liga o display, sem cursor e sem blink
limpa_lcd(); // limpa lcd
comando_lcd(0x0c); // display sem cursor
comando_lcd(0x06); // desloca cursor para a direita
return; // retorna
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Tela Principal *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void tela_principal()
{
while(1)
{
comando_lcd(0x86); // posiciona o cursor na linha 0, coluna 0
printf (escreve_lcd, "Voltimetro"
; // imprime mensagem no lcdcomando_lcd(0xcd); // posiciona o cursor na linha 1, coluna 14
printf (escreve_lcd, " V"
; // imprime mensagem no lcdreturn;
}
// retorna da função
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Configurações do Pic *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void main()
{
// configura microcontrolador
setup_adc_ports (RA0_RA1_RA3_analog);
setup_adc (adc_clock_div_32);
setup_counters (rtcc_internal, WDT_2304MS);
set_adc_channel (1);
// configura os tris
set_tris_a(0b11011111); // configuração da direção dos pinos de I/O
set_tris_b(0b00000000);
set_tris_c(0b11111101);
set_tris_d(0b00000000);
set_tris_e(0b00000100);
// inicializa os ports
// inicializa os ports
porta=0x00; // limpa porta
portb=0x00; // limpa portb
portc=0x00; // limpa portc
portd=0x00; // limpa portd
porte=0x00; // limpa porte
inicializa_lcd(); // configura o lcd
tela_principal(); // imprime a tela principal no LCD
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Rotina principal *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
loop:
while(TRUE) // rotina principal
{
RESTART_WDT(); // incia o watch-dog timer
conversao = read_adc(); // inicia conversão AD
conversao = (conversao * 5); // faz regra de 3 para converter o valor,
conversao = (conversao / 1023); // das unidades de AD em Volts.
comando_lcd(0xCa); // posiciona o cursor na linha 1, coluna 2
printf (escreve_lcd,"%1.2f", conversao); // envia dados para o display de LCD
// 1 número inteiro e 9 casas decimais.
delay_ms(100);
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
Mas se quiser somente separar inclua a biblioteca math.h e use a seguinte função :
float valor,parte_inteira,fracao ;
valor=-100.33
parte_inteira= modf (valor, & fracao));//valor=-100 e fracao=0.33
espero ter ajudado
Jorge(Brasil)