Publicado por: vszener en 05 de Febrero de 2006, 10:56:00
Lo interesante de dicho dispositivo, es que el manejo de los display"s es mediante el bus I2C, es decir dos pines simplemente!!!, hacer cuentas y vereis que es una ventaja, digamos que tenemos que usar 4 display"s de 7seg, ahorrando patitas del micro, le mandaremos los datos en bcd asi solo usamos 4 pines, a esos cuatro se le añaden los de control de los display"s, con dos pines y un decodificador se pueden manejar, eso hace una suma total de 6 pines!, en cambio si usamos el SAA1064 simplemente tendremos que usar dos pines!!!.
El manejo del dispositivo es facil, mandamos la informacion que queremos visualizar en los display"s y en cuanto se la enviemos nos podemos olvidar ya de los display"s ya que el saa1064 se encarga de su correcta visualizacion.
Bien, no es mi intencion en este post realizar una explicacion detallada del dispositivo, aconsejo que mireis su data sheet, aqui el espacio que dedica Philips al SAA1064 (http://www.semiconductors.philips.com/pip/SAA1064T_N2.html), pero resaltar que el SAA1064 puede funconar en modo dinamico( es decir multiplexando los display"s -> un total de 4 display"s) o en modo estatico(manejo de dos display"s), tambien podremos configurar la iluminosidad de los digitos configurando previamente el dispositivo.
Bueno aqui la libreria:
BR]///////////////////////////////////////////////////////////////////////////////////////////
/// VsZeNeR"06 ///
/// 29/Enero/06 ///
/// ///
/// Libreria: vs_saa1064.c Compilador: CCS ///
/// Version: 0.0 ///
/// ///
/// Notas: Controlador para manejo del dispositivo saa1064 ///
/// de Philips. ///
/// Este dispositivo se encarga, mediante I2C, del tratamiento de ///
/// display"s de 7segmentos, lo puede hacer en modo "estatico" donde ///
/// simplemente manejara 2 display"s o en modo "dinamico" donde ///
/// puede manipular cuatro display"s de 7segmentos mediante la ///
/// multiplexacion de los mismos. ///
/// ///
/// Funciones: saa1064_init() -> inicializacion del dispositivo ///
/// ///
/// saa1064_conf(int X_C6_C5_C4_C3_C2_C1_C0) ///
/// -> Configura dispositivo ///
/// ///
/// saa1064_putc(int D2,INT D1) -> Modo "ESTATICO" ///
/// ·D1 -> Digito primero (codigo 7seg!!!) ///
/// ·D2 -> Digito segundo (codigo 7seg!!!) ///
/// ///
/// saa1064_putc(int D4,int D3,int D2,INT D1) -> Modo "DINAMICO" ///
/// ·D1 -> Digito primero (codigo 7seg!!!) ///
/// ·D2 -> Digito segundo (codigo 7seg!!!) ///
/// ·D3 -> Digito tercero (codigo 7seg!!!) ///
/// ·D4 -> Digito cuarto (codigo 7seg!!!) ///
/// ///
/// saa1064_subaddress(int address,int digito) -> cambio rapido del ///
/// valor de un digito.Antes de llamar a esta ///
/// funcion,debemos guardar el valor de los demas ///
/// digitos previamente. ///
/// ·address -> SC_SB_SA (digito 1 al digito 4) Din ///
/// ·address -> SC_SB_SA (digito 1 al digito 2) Est ///
/// ·digito -> nuevo valor ///
/// ///
/// Para que el dispositivo funcione correctamente debemos inicializarlo y ///
/// configurarlo, una vez realizado estos pasos podremos escribir en él sin ///
/// problemas. ///
/// ///
/// Subdirecciones: ///
/// ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨ ///
/// SC SB SA FUNCION ///
/// 0 0 0 registro de control ///
/// 0 0 1 digito 1 ///
/// 0 1 0 digito 2 ///
/// 0 1 1 digito 3 ///
/// 1 0 0 digito 4 ///
/// 1 0 1 no usado(reservado) ///
/// 1 1 0 no usado(reservado) ///
/// 1 1 1 no usado(reservado) ///
/// ///
/// Bits de control: X C6 C5 C4 C3 C2 C1 C0 ///
/// ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨ ///
/// C0=0 modo estatico->digitos 1 y 2 ///
/// C0=1 modo dinamico->digitos 1&3 y 2&4 alternativamente ///
/// C1=0/1 digitos 1&3 no parpadep/parpadeo ///
/// C2=0/1 digitos 2&4 no parpadep/parpadeo ///
/// C3=1 test segmentos ///
/// C4=1 +3mA de salida ///
/// C5=1 +6mA de salida ///
/// C6=1 +12mA de salida ///
/// ///
/// ·Libreria solamente provada en simulador PROTEUS ///
///////////////////////////////////////////////////////////////////////////////////////////
// Para usar modo "DINAMICO" poner la siguiente declaracion en el programa principal(antes de incluir la libreria!)
// #define SAA1064_DINAMICO
#ifndef SAA1064_SCL //para definir los pines de manejo del saa1064...
#define SAA1064_SCL PIN_B0
#define SAA1064_SDA PIN_B1
#endif //...en caso de no ser definidos en el programa principal
#use i2c(master,sda=SAA1064_SDA, scl=SAA1064_SCL) //i2c
int control; //variable que almacena la configuracion
void saa1064_subaddress(int address,int digito){ //funcion subdirecciones de digitos
address=(0x07 & address); //me quedo con los 3bit"s menos significativos de la
direccion
#if defined SAA1064_DINAMICO //modo DINAMICO para cambiar digitos
if(address>0x00 && address<0x05){ //solo direcciones permitidas
i2c_start();
i2c_write(0b01110000); //direccion esclavo
i2c_write(address); //la direccion del digito a cambiar
i2c_write(digito); //cambia digito
i2c_stop();
}
#else //modo ESTATICO para cambiar digitos
if(address==0x02) //direccion del digito 2 en modo estatico
address=0x03;
if(address==0x01 || address==0x03){ //solo direcciones permitidas 0(digito 1) y 3(digito2)
i2c_start();
i2c_write(0b01110000); //direccion esclavo
i2c_write(address); //la direccion del digito a cambiar
i2c_write(digito); //cambia digito
i2c_stop();
}
#endif
}
void saa1064_conf(int X_C6_C5_C4_C3_C2_C1_C0){ //funcion para configurar el saa1064
control=X_C6_C5_C4_C3_C2_C1_C0;
}
#if defined SAA1064_DINAMICO //modo DINAMICO para escribir los digitos
void saa1064_putc(int D4,int D3,int D2,int D1){
control=(control | 0b00000001); //me aseguro modo dinamico
i2c_start();
i2c_write(0b01110000); //direccion esclavo
i2c_write(0x00); //instruction byte -> registro de control
i2c_write(control); //control byte
i2c_write(D1); //escribe digito 1
i2c_write(D2); //escribe digito 2
i2c_write(D3); //escribe digito 3
i2c_write(D4); //escribe digito 4
i2c_stop();
}
#else //modo ESTATICO para escribir los digitos
void saa1064_putc(int D2,int D1){
control=(control & 0b01111110); //me aseguro modo estatico
i2c_start();
i2c_write(0b01110000); //direccion esclavo
i2c_write(0x00); //instruction byte -> registro de control
i2c_write(control); //control byte
i2c_write(D1); //escribe digito 1
i2c_write(0); //libre
i2c_write(D2); //escribe digito 2
i2c_write(0); //libre
i2c_stop();
}
#endif
void saa1064_init(){ //funcion para inicializar saa1064
output_float(SAA1064_SDA);
output_float(SAA1064_SCL);
}
Suerte!!! :wink:
Publicado por: vszener en 05 de Febrero de 2006, 11:13:00
El ejemplo numero 53 del post Ejemplitos en C para 16F648A (http://www.todopic.com.ar/foros/index.php?topic=4530.0)
Suerte!!! :wink:
Publicado por: vszener en 09 de Febrero de 2006, 04:06:00
El ejemplo numero 54 del post Ejemplitos en C para 16F648A (http://www.todopic.com.ar/foros/index.php?topic=4530.0)
Suerte!!! :wink:
Publicado por: vszener en 09 de Febrero de 2006, 04:07:00
Suerte!!!
Publicado por: vszener en 25 de Mayo de 2006, 11:40:20
Código: C
- ///////////////////////////////////////////////////////////////////////////////////////////
- /// VsZeNeR'06 ///
- /// 22/Mayo/06 ///
- /// vszener@gmail.com ///
- /// ///
- /// Libreria: vs_saa1064M.c Compilador: CCS ///
- /// Version: 1.0 ///
- /// ///
- /// Notas: Controlador para manejo del dispositivo saa1064 ///
- /// de Philips. ///
- /// Este dispositivo se encarga, mediante I2C, del tratamiento de ///
- /// display's de 7segmentos, lo puede hacer en modo 'estatico' donde ///
- /// simplemente manejara 2 display's o en modo 'dinamico' donde ///
- /// puede manipular cuatro display's de 7segmentos mediante la ///
- /// multiplexacion de los mismos. ///
- /// ///
- /// Funciones: saa1064_init(int address)-> inicializa dispositivo, hay que ///
- /// la direccion del saa1064 a usar, la ///
- /// direccion en hex!!! ///
- /// ///
- /// Direcciones:(ADR=address) ///
- /// ¨¨¨¨¨¨¨¨¨¨¨¨ ///
- /// · 0x70 -> GND ///
- /// · 0x72 -> 3/8 Vcc ///
- /// · 0x74 -> 5/8 Vcc ///
- /// · 0x76 -> Vcc ///
- /// ///
- /// saa1064_conf(int X_C6_C5_C4_C3_C2_C1_C0) ///
- /// -> Configura dispositivo ///
- /// ///
- /// saa1064_putc(int D2,INT D1) -> Modo 'ESTATICO' ///
- /// ·D1 -> Digito primero (codigo 7seg!!!) ///
- /// ·D2 -> Digito segundo (codigo 7seg!!!) ///
- /// ///
- /// saa1064_putc(int D4,int D3,int D2,INT D1) -> Modo 'DINAMICO' ///
- /// ·D1 -> Digito primero (codigo 7seg!!!) ///
- /// ·D2 -> Digito segundo (codigo 7seg!!!) ///
- /// ·D3 -> Digito tercero (codigo 7seg!!!) ///
- /// ·D4 -> Digito cuarto (codigo 7seg!!!) ///
- /// ///
- /// saa1064_subaddress(int address,int digito) -> cambio rapido del ///
- /// valor de un digito.Antes de llamar a esta ///
- /// funcion,debemos guardar el valor de los demas ///
- /// digitos previamente. ///
- /// ·address -> SC_SB_SA (digito 1 al digito 4) Din ///
- /// ·address -> SC_SB_SA (digito 1 al digito 2) Est ///
- /// ·digito -> nuevo valor ///
- /// ///
- /// Para que el dispositivo funcione correctamente debemos inicializarlo con una ///
- /// direccion correcta y configurarlo, una vez realizado estos pasos podremos ///
- /// escribir en él sin problemas. ///
- /// ///
- /// Subdirecciones: ///
- /// ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨ ///
- /// SC SB SA FUNCION ///
- /// 0 0 0 registro de control ///
- /// 0 0 1 digito 1 ///
- /// 0 1 0 digito 2 ///
- /// 0 1 1 digito 3 ///
- /// 1 0 0 digito 4 ///
- /// 1 0 1 no usado(reservado) ///
- /// 1 1 0 no usado(reservado) ///
- /// 1 1 1 no usado(reservado) ///
- /// ///
- /// Bits de control: X C6 C5 C4 C3 C2 C1 C0 ///
- /// ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨ ///
- /// C0=0 modo estatico->digitos 1 y 2 ///
- /// C0=1 modo dinamico->digitos 1&3 y 2&4 alternativamente ///
- /// C1=0/1 digitos 1&3 no parpadep/parpadeo ///
- /// C2=0/1 digitos 2&4 no parpadep/parpadeo ///
- /// C3=1 test segmentos ///
- /// C4=1 +3mA de salida ///
- /// C5=1 +6mA de salida ///
- /// C6=1 +12mA de salida ///
- /// ///
- /// ·Libreria solamente provada en simulador PROTEUS ///
- ///////////////////////////////////////////////////////////////////////////////////////////
- // Para usar modo 'DINAMICO' poner la siguiente declaracion en el programa principal(antes de incluir la libreria!)
- // #define SAA1064_DINAMICO
- #ifndef SAA1064_SCL //para definir los pines de manejo del saa1064...
- #define SAA1064_SCL PIN_B0
- #define SAA1064_SDA PIN_B1
- #endif //...en caso de no ser definidos en el programa principal
- #use i2c(master,sda=SAA1064_SDA, scl=SAA1064_SCL) //i2c
- int control,ADR; //control:variable que almacena la configuracion ; ADR:almacena dir.
- void saa1064_subaddress(int address,int digito){ //funcion subdirecciones de digitos
- address=(0x07 & address); //me quedo con los 3bit's menos significativos de la direccion
- #if defined SAA1064_DINAMICO //modo DINAMICO para cambiar digitos
- if(address>0x00 && address<0x05){ //solo direcciones permitidas
- i2c_start();
- i2c_write(ADR); //direccion esclavo
- i2c_write(address); //la direccion del digito a cambiar
- i2c_write(digito); //cambia digito
- i2c_stop();
- }
- #else //modo ESTATICO para cambiar digitos
- if(address==0x02) //direccion del digito 2 en modo estatico
- address=0x03;
- if(address==0x01 || address==0x03){ //solo direcciones permitidas 0(digito 1) y 3(digito2)
- i2c_start();
- i2c_write(ADR); //direccion esclavo
- i2c_write(address); //la direccion del digito a cambiar
- i2c_write(digito); //cambia digito
- i2c_stop();
- }
- #endif
- }
- void saa1064_conf(int X_C6_C5_C4_C3_C2_C1_C0){ //funcion para configurar el saa1064
- control=X_C6_C5_C4_C3_C2_C1_C0;
- }
- #if defined SAA1064_DINAMICO //modo DINAMICO para escribir los digitos
- void saa1064_putc(int D4,int D3,int D2,int D1){
- control=(control | 0b00000001); //me aseguro modo dinamico
- i2c_start();
- i2c_write(ADR); //direccion esclavo
- i2c_write(0x00); //instruction byte -> registro de control
- i2c_write(control); //control byte
- i2c_write(D1); //escribe digito 1
- i2c_write(D2); //escribe digito 2
- i2c_write(D3); //escribe digito 3
- i2c_write(D4); //escribe digito 4
- i2c_stop();
- }
- #else //modo ESTATICO para escribir los digitos
- void saa1064_putc(int D2,int D1){
- control=(control & 0b01111110); //me aseguro modo estatico
- i2c_start();
- i2c_write(ADR); //direccion esclavo
- i2c_write(0x00); //instruction byte -> registro de control
- i2c_write(control); //control byte
- i2c_write(D1); //escribe digito 1
- i2c_write(0); //libre
- i2c_write(D2); //escribe digito 2
- i2c_write(0); //libre
- i2c_stop();
- }
- #endif
- void saa1064_init(int address){ //funcion para inicializar saa1064
- ADR=address; //almaceno la direccion
- }
- void saa1064_stop(void){
- i2c_stop();
- }
Suerte!!! :wink:
Publicado por: vszener en 25 de Mayo de 2006, 11:46:00
Publicado por: Nocturno en 28 de Julio de 2007, 03:56:10
He modificado un poco la librería y ahora:
- se puede configurar la dirección del SAA con etiquetas
- se puede configurar el modo de funcionamiento del SAA con etiquetas
- se puede utilizar toda la potencia del printf para sacar el mensaje que queramos.
Adjunto la librería al post, y os dejo un programa ejemplo de su utilización con printf, y por supuesto, un vídeo del funcionamiento :D
Código: C
- ////////////////////////////////////////////////////////////////////////////////////
- // Nocturno'07
- //
- // Ejemplo de uso de SAA1064 con librería vs_saa1064M.c de vsZENER
- // ampliada para utilización de PrintF
- //
- // Dispositivo: PIC 16F876A Compilador: CCS vs3.242
- //
- // Conexiones: B0 -> SDA saa1064
- // B1 -> SCL saa1064
- // www.micropic.es
- //////////////////////////////////////////////////////////////////////////////////
- #include <16f876a.h>
- #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP
- #use delay (clock=4000000)
- #define SAA1064_DINAMICO
- #define SAA1064_SCL PIN_B1
- #define SAA1064_SDA PIN_B0
- #include <vs_saa1064M.c>
- #define Tamano 51
- char frase[Tamano]="Hola TodoPIC 0123456789 ABCDEFGHIJLMOPQRSTUVYZ ";
- char cadena[4];
- int posicion=0;
- void main(void)
- {
- saa1064_init(SAA_ADR_VDD);
- saa1064_conf(SAA_DINAMICO + SAA_DIG1_3_ON + SAA_DIG2_4_ON + SAA_MODONORMAL + SAA_3mA);
- delay_ms(1000);
- while (1) {
- delay_ms(400);
- posicion++;
- if (posicion==(Tamano-4))
- {posicion=0;
- delay_ms(1000);
- }
- }
- }
Aquí podéis ver el resultado:
Publicado por: vszener en 28 de Julio de 2007, 15:10:19
PD: el video esta muy way ;)
Publicado por: Marttyn en 31 de Julio de 2007, 22:30:13
hasta ahora no me habia metido con ellos porque me parecia de locos usar 8 pines para cada display... y como no entendia muy bien lo que era multiplexar... (tampoco me preocupe demasiado de enterarme :lol:)
ahora podre acabar mi fuente de alimentacion poniendole una salida de voltaje regulable y su correspondiente voltimetro con display de 7 segmentos....
una unica duda... que aplicaciones tienen los displays de anodo comun y los de catodo comun?? porque la vez que me iba a animar a usarlos fui a comprarlos y fue la pregunta que me hizo el de la tienda... "lo quieres de anodo o catodo comun?" y como no supe que contestar no compre nada....
que recomendais?
salu2
Publicado por: Nocturno en 01 de Agosto de 2007, 01:46:28
Si utilizas el SAA1064 no podrás escoger; te toca usar el de ánodo común, puesto que dicho integrado enciende cada segmento tirando a masa su pin correspondiente.
Si utilizas un PIC podrás elegir uno u otro porque podrás manejarlo a tu antojo. En cualquier caso, el PIC es capaz de proporcionar más corriente cuando entrega un 0 que cuando entrega un 1, por lo que yo te recomendaría utilizar el mismo display de ánodo común.
Publicado por: Marttyn en 03 de Octubre de 2007, 11:16:00
edito: POR CIERTO! como uso el PUNTO con el printf? no veo en la libreria Manolo
edito2: estuve mirando el datasheet del saa1064, y llegue a la conclusion de que para que se ilumine el punto de un display habra que añadirle 128 adicionales al valor del carcter o digito que queramos presentar en el display. ahora, no tengo idea como se hace eso... nocturno, crees que podrias implementarlo de manera que se puedan mostrar puntos en los displays, aun utilizando el printf normalmente?
salu2
Publicado por: Marttyn en 03 de Octubre de 2007, 22:10:39
ya empece con los problemas...
pero intenare primero aportar algo, creo que seria bueno modificar la forma en que se ven el "6" y el "9" en los displays... ya que el 6 se ve como una "b" minuscula y el 9, igual pero invertido... para que no de lugar a confusion, y de hecho, para seguir el stadard como cualquier calculadora, por ejemplo, propongo que el valor del 6 sea "125" en vez de 124, y el valor del 9 sea "111" en vez de 103. de esta manera se veran como se ven en todos los displays, y el 6 no se confundira con una b en caso de estar trabajando con valores hex. eso si, la forma en que se muestran la "g" y el "9" es la misma, pero no molesta con hexadecimales. y solo por molestar, la "j" podria representarse con el valor 30, en vez del 14
ahora la parte que necesito algo de ayuda...
en principio parece que funciona todo bien, probe el ejemplito de nocturno y tambien va bien...
pero alguien podria hacer esta pequeña prueba y decirme si le ocurre lo mismo?
por que creo que el problema esta en la libreria, y no en el codigo ya que es muy simple:
intentad sacar el valor de un adc de 10bits por el display
Código: C
- do{
- Lectura = read_adc();
- delay_ms(1000);
- }while(TRUE);
alguna idea?
salu2
Publicado por: Nocturno en 04 de Octubre de 2007, 01:44:42
Para ello, creo que será suficiente con hacer este cambio:
printf (saa1064, "%4Lu", Lectura);
Publicado por: Marttyn en 04 de Octubre de 2007, 11:10:25
suerte que tu te sabes todas las respuestas, sino que seria de mi!? :D
y se te ocurre alguna solucion a lo de presentar numeros y puntos a la vez? es decir poder presentar por ejemplo 12.75
si me das una idea tal vez lo pueda hacer yo...
salu2 y gracias!
Publicado por: Nocturno en 04 de Octubre de 2007, 11:20:21
Código: [Seleccionar]
else {
buffer[TextoRecibido]=c;
TextoRecibido++;
}y poner esta otra:
Código: [Seleccionar]
else {
if (c=='.')
buffer[TextoRecibido]=buffer[TextoRecibido]+128;
else {
buffer[TextoRecibido]=c;
TextoRecibido++;
}
}No lo he probado, pero estoy seguro que tú lo harás.
Publicado por: Marttyn en 04 de Octubre de 2007, 23:49:56
he hecho la modificacion que me propones y ahora funciona... bueno, en realidad estuve estudiando la libreria unas cuantas horas, porque tal cual me comentas no funcionaba, pero hice algunos pequeños arreglos y ahora esta todo bien. y lo mas importante... ahora entiendo como funciona toda la libreria! jeje
asi que ademas de implementar el punto la he comentado y ordenado un poquito mas...
si a alguien le interesa la dejo para descargar.
recuerdo que en mis comienzos RedPic me dijo algo asi:
Esto es lo que me gusta del foro, que es una cosa compartida, que entre todos hacemos que crezca día a día. :)
me encanta este foro!
y por cierto...
efectivamente, hay que enviar los 4 digitos al saa1064, porque sino se monta un follon y muestra cualquier verdura.
yo lo tengo implementado EXITOSAMENTE en un voltimetro digital, que tiene una resolucion de 0 a 23v. el programa muestra correctamente valores de voltaje de 10.00v o mayores... ya que se usan los 4 digitos, pero si el valor a mostrar es menor (=<9.99v) pues, otra vez se muestran verduras :?
probe con %04.2f, %4.2f, %4f, %2.2f... pero con todos salen valores anomalos por el display :(
la verdad que no tengo idea como solucionarlo... quizas separando la parte entera de la decimal y asegurarme que la parte entera sean dos digitos incluyendo un cero a la izquierda cuando se necesite... pero debe haber algo mas simple
alguna idea?
salu2
Publicado por: Nocturno en 05 de Octubre de 2007, 01:42:22
%02.2f
Publicado por: Marttyn en 05 de Octubre de 2007, 07:00:21
Publicado por: Nocturno en 05 de Octubre de 2007, 08:22:57
Publicado por: jfh900 en 05 de Octubre de 2007, 10:03:03
%02.5f
Un saludo
Publicado por: Nocturno en 05 de Octubre de 2007, 12:05:07
El punto decimal habría que contarlo también como carácter, aunque luego se imprima junto a un número en el 7-seg. Por tanto prueba así: %03.2f
Si no va, prueba esta otra opción:
printf("%*03.2f", 5, variable)
Publicado por: Marttyn en 05 de Octubre de 2007, 12:27:02
Si no va, prueba esta otra opción:
printf("%*03.2f", 5, variable)
efectivamente, hay que tener en cuenta el punto, que cuenta como caracter, pero %03.2f no funiona... y "%*03.2f", 5, variable... el compilador no lo agarra... tal vez en leguaje c para ordenadores el * signifique algo, pero mirando la ayuda del ccs, no es ningun parametro valido...
igualmente ya lo solucione...
Código: C
si el voltaje es menor a 10 le agrego un espacio en blanco a la izquierda y santo remedio!
estoy seguro qu no es la solucion mas directa, y deberia haber un formato valido para darle con el printf... pero asi funciona y me vale :mrgreen:
gracias por vuestra ayuda!
salu2
Publicado por: jfh900 en 05 de Octubre de 2007, 14:12:03
%05.2f
Disculpas por el post anterior, que indique los valores al revés.
Un saludo
Publicado por: Marttyn en 05 de Octubre de 2007, 21:06:04
sin quitarle merito a lo que dices, que tienes toda la razon, como no me di cuenta antes de eso?!
efectivamente, esa es la menera correcta de presentar los valores en el printf. asi que ya funciona bien sin tener que usar un if ni cosas raras. por cierto, yo lo use "%5.2f" sin el cero delante del 5, de esta manera dejara displays en "blanco" cuando no tenga nada que presentar
salu2 y gracias!
Publicado por: Nocturno en 06 de Octubre de 2007, 01:44:32
Publicado por: pocher en 06 de Octubre de 2007, 04:05:27
Si por ejemplo el número a representar es el 2.358 con %5.2f sacaría 2 decimales truncando el 8, es decir la parte decimal sería 35 y luego reservaría 5 caracteres sacando en pantalla un espacio seguido de 2.35 (4 caracteres)
Si hubiese sido %8.2f sacaría 4 espacios seguidos de 2.35
Si te equivocas o no quieres contar el número de caracteres exactos a reservar para la parte entera el compilador es muy listo y lo hace él. Por ejemplo: %1.2f sacaría 2.35 aunque le estemos diciendo que reserve solo un caracter.
En el caso de que en lugar de truncar deseemos redondear se utiliza la letra g y redondea a partir de 5 inclusive hacia arriba. Por ejemplo: 2.355 con dos decimales redondearía a 2.36
La opción con la letra w también es muy interesante ya que permite añadir un punto decimal "por la cara" a un número entero sin signo de 8 bits (un int8). Por ejemplo: si tenemos 234 y metemos en el printf %8.2 sacaría cuatro espacios seguidos de 2.34, si ponemos %1.1 sacaría 23.4
El printf con versiones antiguas del compilador no funcionaba bien en algunos casos, como para representar 0.23 sacaba .23 sin el cero y tenías que ingeniartelas para añadirlo si así lo querías. Me llevo de cabeza el puñetero :D :D
Un saludo
Publicado por: Marttyn en 20 de Enero de 2009, 16:45:23
Pocher, tu explicacion del printf me ha venido de perlas! :mrgreen: