Libreria: SAA1064 (CCS)

[vszener]

Holaaaa!!!bueno, no podia dormi en un viaje que tuve que hacer, asi que empece a escribir esta libreria....bien, para los que utilicen display"s de 7 segmentos multiplexados les sera de gran ayuda y utilidad dicha libreria, ya que este dispositivo, el SAA1064, se encarga de el manejo de display"s de 7segmentos.

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, 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!!!

[vszener]

Un ejemplo del manejo de la libreria vs_saa1064.c en modo DINAMICO:
El ejemplo numero 53 del post Ejemplitos en C para 16F648A


Suerte!!!

[vszener]

Un ejemplo del manejo de la libreria vs_saa1064.c en modo ESTATICO:
El ejemplo numero 54 del post Ejemplitos en C para 16F648A


Suerte!!!

[vszener]

Pues con estos dos ejemplos queda explicada todas las funciones de la libreria vs_saa1064.c espero que sea de utilidad...

Suerte!!!

[vszener]

He modificado la libreria para que podamos configurar la direccion del saa1064, asi en el caso de conectar al bus i2c mas de un dispositivo  no tener conflictos....aqui la libreria:

Código: C

1. ///////////////////////////////////////////////////////////////////////////////////////////
2. ///             VsZeNeR'06                                                              ///
3. ///             22/Mayo/06                                                              ///
4. ///         vszener@gmail.com                                                           ///
5. ///                                                                                     ///
6. ///     Libreria: vs_saa1064M.c         Compilador: CCS                                 ///
7. ///     Version: 1.0                                                                    ///
8. ///                                                                                     ///
9. ///     Notas: Controlador para manejo del dispositivo saa1064                          ///
10. ///            de Philips.                                                              ///
11. ///            Este dispositivo se encarga, mediante I2C, del tratamiento de            ///
12. ///            display's de 7segmentos, lo puede hacer en modo 'estatico' donde         ///
13. ///            simplemente manejara 2 display's o en modo 'dinamico' donde              ///
14. ///            puede manipular cuatro display's de 7segmentos mediante la               ///
15. ///            multiplexacion de los mismos.                                            ///
16. ///                                                                                     ///
17. ///     Funciones:  saa1064_init(int address)-> inicializa dispositivo, hay que         ///
18. ///                                             la direccion del saa1064 a usar, la     ///
19. ///                                             direccion en hex!!!                     ///
20. ///                                                                                     ///
21. ///                                             Direcciones:(ADR=address)               ///
22. ///                                             ¨¨¨¨¨¨¨¨¨¨¨¨                                ///
23. ///                                             · 0x70 -> GND                          ///
24. ///                                             · 0x72 -> 3/8 Vcc                      ///
25. ///                                             · 0x74 -> 5/8 Vcc                      ///                            
26. ///                                             · 0x76 -> Vcc                          ///
27. ///                                                                                     ///
28. ///                 saa1064_conf(int X_C6_C5_C4_C3_C2_C1_C0)                            ///
29. ///                                    -> Configura dispositivo                         ///
30. ///                                                                                     ///
31. ///                 saa1064_putc(int D2,INT D1) -> Modo 'ESTATICO'                      ///
32. ///                                     ·D1 -> Digito primero (codigo 7seg!!!)         ///
33. ///                                     ·D2 -> Digito segundo (codigo 7seg!!!)         ///
34. ///                                                                                     ///
35. ///                 saa1064_putc(int D4,int D3,int D2,INT D1) -> Modo 'DINAMICO'        ///
36. ///                                     ·D1 -> Digito primero (codigo 7seg!!!)         ///
37. ///                                     ·D2 -> Digito segundo (codigo 7seg!!!)         ///
38. ///                                     ·D3 -> Digito tercero (codigo 7seg!!!)         ///
39. ///                                     ·D4 -> Digito cuarto  (codigo 7seg!!!)         ///
40. ///                                                                                     ///
41. ///                 saa1064_subaddress(int address,int digito) -> cambio rapido del     ///
42. ///                                     valor de un digito.Antes de llamar a esta       ///
43. ///                                     funcion,debemos guardar el valor de los demas   ///
44. ///                                     digitos previamente.                            ///
45. ///                                     ·address -> SC_SB_SA (digito 1 al digito 4) Din        ///
46. ///                                     ·address -> SC_SB_SA (digito 1 al digito 2) Est        ///
47. ///                                     ·digito  -> nuevo valor                                ///
48. ///                                                                                     ///
49. ///     Para que el dispositivo funcione correctamente debemos inicializarlo con una    ///
50. ///     direccion correcta y configurarlo, una vez realizado estos pasos podremos       ///
51. ///     escribir en él sin problemas.                                                  ///
52. ///                                                                                     ///
53. ///     Subdirecciones:                                                                 ///
54. ///     ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨                                                                  ///      
55. ///             SC SB SA  FUNCION                                                       ///
56. ///             0  0  0  registro de control                                            ///
57. ///             0  0  1  digito 1                                                       ///
58. ///             0  1  0  digito 2                                                       ///
59. ///             0  1  1  digito 3                                                       ///
60. ///             1  0  0  digito 4                                                       ///
61. ///             1  0  1  no usado(reservado)                                            ///
62. ///             1  1  0  no usado(reservado)                                            ///
63. ///             1  1  1  no usado(reservado)                                            ///
64. ///                                                                                     ///
65. ///     Bits de control:    X C6 C5 C4 C3 C2 C1 C0                                      ///
66. ///     ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨                                                                ///
67. ///             C0=0    modo estatico->digitos 1 y 2                                    ///
68. ///             C0=1    modo dinamico->digitos 1&3 y 2&4 alternativamente               ///
69. ///             C1=0/1  digitos 1&3 no parpadep/parpadeo                                ///
70. ///             C2=0/1  digitos 2&4 no parpadep/parpadeo                                ///
71. ///             C3=1    test segmentos                                                  ///
72. ///             C4=1    +3mA de salida                                                  ///
73. ///             C5=1    +6mA de salida                                                  ///
74. ///             C6=1    +12mA de salida                                                 ///
75. ///                                                                                     ///
76. ///     ·Libreria solamente provada en simulador PROTEUS                               ///
77. ///////////////////////////////////////////////////////////////////////////////////////////
78.  
79. // Para usar modo 'DINAMICO' poner la siguiente declaracion en el programa principal(antes de incluir la libreria!)
80. // #define SAA1064_DINAMICO
81.  
82. #ifndef SAA1064_SCL             //para definir los pines de manejo del saa1064...
83. #define SAA1064_SCL PIN_B0
84. #define SAA1064_SDA PIN_B1
85. #endif                          //...en caso de no ser definidos en el programa principal
86.  
87. #use i2c(master,sda=SAA1064_SDA, scl=SAA1064_SCL)       //i2c
88.  
89. int control,ADR;                                        //control:variable que almacena la configuracion ; ADR:almacena dir.
90.  
91. void saa1064_subaddress(int address,int digito){        //funcion subdirecciones de digitos
92.    address=(0x07 & address);                            //me quedo con los 3bit's menos significativos de la direccion
93.  
94. #if defined SAA1064_DINAMICO    //modo DINAMICO para cambiar digitos  
95.    if(address>0x00 && address<0x05){                    //solo direcciones permitidas
96.         i2c_start();                                   
97.         i2c_write(ADR);                                 //direccion esclavo
98.         i2c_write(address);                             //la direccion del digito a cambiar
99.         i2c_write(digito);                              //cambia digito
100.         i2c_stop();
101.    }
102. #else                           //modo ESTATICO para cambiar digitos
103.    if(address==0x02)                                    //direccion del digito 2 en modo estatico
104.         address=0x03;
105.  
106.    if(address==0x01 || address==0x03){                  //solo direcciones permitidas 0(digito 1) y 3(digito2)
107.         i2c_start();                                   
108.         i2c_write(ADR);                                 //direccion esclavo
109.         i2c_write(address);                             //la direccion del digito a cambiar
110.         i2c_write(digito);                              //cambia digito
111.         i2c_stop();
112.    }
113. #endif
114. }
115.  
116. void saa1064_conf(int X_C6_C5_C4_C3_C2_C1_C0){          //funcion para configurar el saa1064
117.    control=X_C6_C5_C4_C3_C2_C1_C0;      
118. }
119.  
120. #if defined SAA1064_DINAMICO    //modo DINAMICO para escribir los digitos
121.  
122.         void saa1064_putc(int D4,int D3,int D2,int D1){
123.         control=(control | 0b00000001); //me aseguro modo dinamico
124.         i2c_start();
125.         i2c_write(ADR);         //direccion esclavo
126.         i2c_write(0x00);        //instruction byte -> registro de control
127.         i2c_write(control);     //control byte 
128.  
129.         i2c_write(D1);          //escribe digito 1
130.         i2c_write(D2);          //escribe digito 2
131.         i2c_write(D3);          //escribe digito 3
132.         i2c_write(D4);          //escribe digito 4     
133.         i2c_stop();
134.         }
135. #else                           //modo ESTATICO para escribir los digitos
136.  
137.         void saa1064_putc(int D2,int D1){
138.         control=(control & 0b01111110); //me aseguro modo estatico
139.         i2c_start();
140.         i2c_write(ADR);         //direccion esclavo
141.         i2c_write(0x00);        //instruction byte -> registro de control
142.         i2c_write(control);     //control byte
143.  
144.         i2c_write(D1);          //escribe digito 1
145.         i2c_write(0);           //libre
146.         i2c_write(D2);          //escribe digito 2
147.         i2c_write(0);           //libre
148.         i2c_stop();
149.         }
150. #endif
151.  
152. void saa1064_init(int address){         //funcion para inicializar saa1064
153.    ADR=address;                         //almaceno la direccion
154. }
155.  
156. void saa1064_stop(void){
157.    i2c_stop();
158. }

Suerte!!!

[vszener]

El programa numero 57 del post Ejemplitos en C para 16F648A , muestra el manejo de 16 display's de 7segmentos simplemente con dos pines del microcontrolador usando la libreria anterior.

[Nocturno]

Muchas gracias por no haber podido dormir en aquel viaje, vszener. Ahora me vendrá de perlas para un proyecto que tengo que hacer.
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 

Código: C

1. ////////////////////////////////////////////////////////////////////////////////////
2. //                                                      Nocturno'07
3. //
4. //      Ejemplo de uso de SAA1064 con librería vs_saa1064M.c de vsZENER
5. // ampliada para utilización de PrintF
6. //
7. //      Dispositivo: PIC 16F876A                        Compilador:      CCS vs3.242
8. //
9. //                 Conexiones:          B0 -> SDA saa1064
10. //                                                         B1 -> SCL saa1064
11. //                                                          www.micropic.es
12. //////////////////////////////////////////////////////////////////////////////////
13.  
14. #include <16f876a.h>                                   
15. #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP            
16.  
17. #use delay (clock=4000000)                             
18.  
19. #define SAA1064_DINAMICO                               
20. #define SAA1064_SCL PIN_B1                             
21. #define SAA1064_SDA PIN_B0                             
22. #include <vs_saa1064M.c>                               
23.  
24. #define Tamano 51
25. char frase[Tamano]="Hola TodoPIC 0123456789 ABCDEFGHIJLMOPQRSTUVYZ    ";
26. char cadena[4];
27.  
28. int posicion=0;
29.  
30. void main(void)
31. {
32. saa1064_init(SAA_ADR_VDD);
33. saa1064_conf(SAA_DINAMICO + SAA_DIG1_3_ON + SAA_DIG2_4_ON + SAA_MODONORMAL + SAA_3mA); 
34.  
35. printf (saa1064,"HOLA");
36. delay_ms(1000);
37. while (1) {
38.  
39.    printf (saa1064,"%c%c%c%c",frase[posicion],frase[posicion+1],frase[posicion+2],frase[posicion+3]);
40.  
41.         delay_ms(400);
42.    posicion++;
43.    if (posicion==(Tamano-4))
44.       {posicion=0;
45.       delay_ms(1000);
46.       }
47. }
48. }

Aquí podéis ver el resultado:

[vszener]

Ha quedado de escándalo, era una tarea pendiente el de configurar la libreria con etiquetas, muchas gracias por hacerlo.

PD: el video esta muy way

[Marttyn]

por fin encuentro algo interesante sobre displays de 7 seg!
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  )
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

[Nocturno]

Depende básicamente de cómo vayas a construir tu circuito y cuál sea el driver que utilices para manejar los displays de 7 segmentos.
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.

[Marttyn]

JOJOJO!!! despues de 3 dias de no encontrar el error, LO HE CONSEGUIDO! ya tengo funcionando mi saa1064! ademas, lo he montado tipo modulo, es decir, el integrado y los 4 displays todo en una plaquita, con su entrada de voltaje e i2c. de esta manera puedo usarlo con cualquier pic sin tener que tocar nada. jiji, estoy feliz! ahora me queda el programa para que sea un voltimetro y un amperimetro para mi fuente de voltaje regulable 

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

[Marttyn]

bueno... tanta alegria no podia ser buena...
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

1. do{
2.       Lectura = read_adc();
3.       printf (saa1064, "%Lu", Lectura);
4.       delay_ms(1000);
5.    }while(TRUE);

lo que hago es conectar un pot de 10k a Vdd, a Vss y el pin del medio al adc, con lo que modificando el valor del pot conseguiremos valores de 0 a 1023 reflejados en el display... pero lo que me ocurre es que los digitos se mezclan... por ejemplo cuando deberia verse 1023 se ve 3102, o 2310... no se si se debe a algun fallo en mi hard... tengo los pull up de i2c de 10k y no se si es mucho... o tal vez el integrado este en mal estado... o quizas es el codigo...
alguna idea?
salu2

[Nocturno]

Asegúrate que siempre que imprimes algo, ocupas todo el ancho del display. Me explico: si tienes 4 displays de 7 segmentos, imprime siempre 4 caracteres, ya sea con un número de 4 dígitos o con 2 de 2 dígitos o como quieras.
Para ello, creo que será suficiente con hacer este cambio:
printf (saa1064, "%4Lu", Lectura);

[Marttyn]

jeje, perfecto!
suerte que tu te sabes todas las respuestas, sino que seria de mi!? 
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!

[Nocturno]

Creo que sería suficiente con modificar la función saa1064(), concretamente esta parte:

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.