TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: Miguelyx en 25 de Septiembre de 2021, 09:22:49

Título: Descomponer numero 16 bits
Publicado por: Miguelyx en 25 de Septiembre de 2021, 09:22:49
Buenas, estoy tratando de descomponer un numero de 16 bits en decenas de mil, unidades de mil, centenas, decenas y unidades y cada vez que el conteo llega a 1000 pasa a mostrar 10?0 y sigue sin cambiar ese ? de las decenas, y siempre muestra un caracter ascii en las decenas si el numero es superior a 1000, a ver si me podeis echar una mano para encontrar el error porque yo lo he revisado como 40 veces y no consigo encontrarlo.
Permitidme que no ponga el codigo entero porque es bastante largo, llega a 32k, solo donde esta el error que es en la descomposicion del numero.

Lo descompongo asi:
     dmil = power / 10000;
     umil = (power -(dmil*10000))/1000;
     centena = (power - (dmil*10000 + umil*1000))/100;
     decena =(power - (dmil*10000 + umil*1000 + centena *100))/10;
     unidad = (power - (dmil*10000 + umil*1000 + centena *100 +decena *10));

A ver si sois capaces a ver el error porque a mi me tiene ya saturado y no lo consigo encontrar donde me he equivocado al crear esa descomposicion.
Título: Re:Descomponer numero 16 bits
Publicado por: elreypic2 en 25 de Septiembre de 2021, 10:11:24
Que tal Miguelyx,

No mencionas el lenguaje que estás usando, pero voy a asumir que es lenguaje C.

Lo que yo haría serí lo siguiente:

Código: [Seleccionar]
demil = power / 10000;             //Divido el numero de 16 bits entre 10000 para obtener las decenas de millar
residuo = power % 10000;        //Calculo el residuo de dividir el número de 16 entre 10000
umil = residuo / 1000;              //Divido el residuo obtenido anteriormente entre 1000 para obtener las unidades de millar
residuo = residuo % 1000;        //Calculo el residuo de dividir el resultado anterior con 1000
centena = residuo / 100;          //Divido el residuo obtenido anteriormente entre 100 para obtener las centenas
residuo = residuo % 100;         //Calculo el residuo de dividir el resultado anterior entre 100
decena = residuo / 10;            //Divido el resultado anterior entre 10 para obtener las decenas
unidad = residuo % 10;           //Calculo el residuo del resultado anterior para obtener las unidades

elreypic.
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 25 de Septiembre de 2021, 10:24:52
Gracias lo voy a probar aunque ya he encontrado el error, faltaban parentesis.
     dmil = power / 10000;
     umil = (power -(dmil*10000))/1000;
     centena = (power -(dmil*10000 + (umil*1000)))/100;
     decena =(power - (dmil*10000 + (umil*1000 + (centena *100))))/10;
     unidad = (power - (dmil*10000 + (umil*1000 + (centena *100 +(decena *10)))));

Pero voy a probar como me has propuesto, es muchisimo mas sencillo.  ((:-))
Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 25 de Septiembre de 2021, 15:30:16
Otra forma es dividiendo sucesivamente por 10 y guardando los restos:

Código: [Seleccionar]
int8 xdec[5] ;    //resultado

void bin2dec(int16 x){       
    for(int8 k=5 ; k>0 ; x/=10 ) xdec[--k] = x%10 ;   
}
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 25 de Septiembre de 2021, 16:07:32
EL caso es que pensaba que lo habia solucionado pero no, parece ser un problema de libreria, con una tft ILI9341 no se presenta el problema, ni en simulacion ni en real, sin embargo con una TFT 7735 se presenta tanto en simulacion como en real, pensaba que seria un fallo de simulacion, pero al pasarlo a la proto hace exactamente lo mismo.

He reducido el codigo a lo justo donde da el error a ver si veis donde esta el problema que me temo es en la libreria, si no, porque en la TFT ILI 9341 no sucede y en la TFT 7735 si.
la libreria esta en adjuntos por si alguien se atreve a echarle un vistazo.
El codigo consta de variasd partes, esta parte pertenece a la eeprom, guarda los datos en la eeprom y al usar el aparato que controla el pic contea una vez mas, logicamente para ello hay que guardar en la eeprom cada vez que se usa y recuperarlo, pero no hay manera que contee bien a partir de 1000 y no es fallo de lectura ni escritura de la eeprom porque el fallo se muestra con una simple simulacion de conteo sin que este presente la eeprom.
El fallo sucede cuando llega justo a 1000, en lugar de seguir contando normalmente, las decenas muestran caracteres ascii.

Código: [Seleccionar]
/*

  ST7735 TFT library for mikroC compiler is required!

*/


#define TFT_SPI_HARDWARE
                // Hardware SPI module is used
sbit TFT_CS at RD0_bit;                   // TFT CS pin is connected to RD0 pin
sbit TFT_DC at RD1_bit;                   // TFT DC pin is connected to RD1 pin
sbit TFT_CS_Direction at TRISD0_bit;
sbit TFT_DC_Direction at TRISD1_bit;
// End SPI TFT module connections

#include "ST7735.c"
/*#include <built_in.h>
#include "variables.c"
#include "rutinas.c"
#include "config.c"*/
char unidad, decena, centena, umil, dmil, cmil;
char *veces = "00000";
unsigned int power;

 //-----------------------------
 
void muestra_cantidad () {

     veces[4] =  unidad+48;

           if  (decena>0){
     veces[4] =  unidad+48;
     veces[3] =  decena+48;
                      }
     else
        veces[3] = ' ';

      if  (centena>0){
     veces[4] =  unidad+48;
     veces[3] =  decena+48;
     veces[2] =  centena+48;
}
     else
        veces[2] = ' ';

      if  (umil>0){
     veces[4] =  unidad+48;
     veces[3] =  decena+48;
     veces[2] =  centena+48;
     veces[1] =  umil+48;
                }
     else
        veces[1] = ' ';

     if (dmil>0){

     veces[4] =  unidad+48;
     veces[3] =  decena+48;
     veces[2] =  centena+48;
     veces[1] =  umil+48;
     veces[0] =  dmil+48;
}
     else
        veces[0] = ' ';

}

void configuracion ()
             {

//reloj interno, bits 4, 5 y 6 deciden la velocidad,
//  16 Mhz 0b01110000, o velocidad maxima del PIC sin PLL
//  8 Mhz 0b01100000  o velocidad del PIC sin PLL, velocidad maxima dividida entre 2 sin PLL
//  4 Mhz 0b01010000, o velocidad del PIC sin PLL     "         "   dividida entre 4 sin PLL
//  2 Mhz 0b01000000, o velocidad del PIC sin PLL     "         "   dividida entre 8 sin PLL
//  1 Mhz 0b00110000, o velocidad del PIC sin PLL     "         "   dividida entre 16 sin PLL

 OSCCON =0b01110000; // 0x70;

 ANSELC=0;     // puertos digitales = 0 o analogicos = 1, para 18F46K22 y 18F45k22
 ANSELD=0;     // puertos digitales = 0 o analogicos = 1, para 18F46K22 y 18F45k22
             }


void main() {

configuracion();


  ST7735_TFT_Init();                                // Initialize the TFT module
  fillScreen(ST7735_BLACK);




     drawtext(74, 80, "VECES", ST7735_WHITE, ST7735_BLACK, 1);

while (1){


     dmil = power / 10000;
     umil = (power -(dmil*10000))/1000;
     centena = (power -(dmil*10000 + (umil*1000)))/100;
     decena =(power - (dmil*10000 + (umil*1000 + (centena *100))))/10;
     unidad = (power - (dmil*10000 + (umil*1000 + (centena *100 +(decena *10)))));

muestra_cantidad();

drawtext(37, 80, veces, ST7735_WHITE, ST7735_BLACK, 1);

      power++;
         }

     }
Título: Re:Descomponer numero 16 bits
Publicado por: Picuino en 26 de Septiembre de 2021, 15:43:05
Es mucho más eficaz (y algo más complicado) utilizar una rutina de conversión de binario a BCD.
Algo así: https://my.eng.utah.edu/~nmcdonal/Tutorials/BCDTutorial/BCDConversion.html

Edito:
Esta es la rutina que yo utilizo para hacer la conversión de un número de 48 bits a BCD

Código: C
  1. /*
  2.    Transform 48bit unsigned integer to BCD string
  3. */
  4. #define DEC_DIG_48   15
  5. void ltoa48(unsigned char *str, uint48 bin) {
  6.    unsigned char maxdig, digcnt, bitcnt;
  7.    static unsigned char *p, carry;
  8.  
  9.    // Clear string
  10.    p = str;
  11.    digcnt = DEC_DIG_48 + 1;
  12.    do {
  13.       *p++ = 0;
  14.    } while (--digcnt);
  15.  
  16.    // Transform binary to BCD
  17.    bitcnt = 48;
  18.    maxdig = (DEC_DIG_48 - 1);
  19.    str += (DEC_DIG_48 - 1);
  20.    do {
  21.       // Shift left binary number with carry
  22.       carry = 0;
  23.       if (bin.b47==1) carry |= 1;
  24.       bin = sl48(bin);
  25.      
  26.       // Shift left decimal number with carry
  27.       p = str;
  28.       digcnt = DEC_DIG_48 - maxdig;
  29.       do {
  30.          carry = (*p<<1) + carry;
  31.          if (carry>=10) {
  32.             *p-- = carry - 10;
  33.             carry = 1;
  34.             if (digcnt==1) {
  35.                maxdig--;
  36.                digcnt++;
  37.             }
  38.          }
  39.          else {
  40.             *p-- = carry;
  41.             carry = 0;
  42.          }
  43.       } while(--digcnt);
  44.    } while(--bitcnt);
  45.  
  46.    // Transform BCD to ASCII
  47.    digcnt = DEC_DIG_48;
  48.    do *str-- += '0'; while (--digcnt);
  49. }
  50.  
  51.  
  52. /*
  53.    Shift left
  54.    return a<<1
  55. */
  56. uint48 sl48(uint48 a) {
  57.    st48.carry = 0;
  58.    if (a.b47==1) st48.carry = 1;
  59.    ans.dword = a.dword<<1;
  60.    if (a.b15==1) ans.b16 = 1;
  61.    ans.word[0] = a.word[0]<<1;
  62.    return ans;
  63. }
  64.  
  65.  
  66. /*
  67.    Shift right
  68.    return a>>1
  69. */
  70. uint48 sr48(uint48 a) {
  71.    st48.carry = 0;
  72.    if (a.b0==1) st48.carry = 1;
  73.    ans.word[0] = a.word[0]>>1;
  74.    if (a.b16==1) ans.b15 = 1;
  75.    ans.dword = a.dword>>1;
  76.    return ans;
  77. }
  78.  
  79.  
  80. // Unsigned 48 bit integer definition
  81. typedef union {
  82.    unsigned char  byte[6];
  83.    unsigned int   word[3];
  84.    struct {
  85.       unsigned int __word;
  86.       unsigned long dword;
  87.    };
  88.    struct {
  89.       unsigned char mantissa[5];
  90.       unsigned long exp;
  91.    };
  92.    struct {
  93.       unsigned b0:1;
  94.       unsigned b1:1;
  95.       unsigned b2:1;
  96.       unsigned b3:1;
  97.       unsigned b4:1;
  98.       unsigned b5:1;
  99.       unsigned b6:1;
  100.       unsigned b7:1;
  101.       unsigned b8:1;
  102.       unsigned b9:1;
  103.       unsigned b10:1;
  104.       unsigned b11:1;
  105.       unsigned b12:1;
  106.       unsigned b13:1;
  107.       unsigned b14:1;
  108.       unsigned b15:1;
  109.       unsigned b16:1;
  110.       unsigned b17:1;
  111.       unsigned b18:1;
  112.       unsigned b19:1;
  113.       unsigned b20:1;
  114.       unsigned b21:1;
  115.       unsigned b22:1;
  116.       unsigned b23:1;
  117.       unsigned b24:1;
  118.       unsigned b25:1;
  119.       unsigned b26:1;
  120.       unsigned b27:1;
  121.       unsigned b28:1;
  122.       unsigned b29:1;
  123.       unsigned b30:1;
  124.       unsigned b31:1;
  125.       unsigned b32:1;
  126.       unsigned b33:1;
  127.       unsigned b34:1;
  128.       unsigned b35:1;
  129.       unsigned b36:1;
  130.       unsigned b37:1;
  131.       unsigned b38:1;
  132.       unsigned b39:1;
  133.       unsigned b40:1;
  134.       unsigned b41:1;
  135.       unsigned b42:1;
  136.       unsigned b43:1;
  137.       unsigned b44:1;
  138.       unsigned b45:1;
  139.       unsigned b46:1;
  140.       unsigned b47:1;
  141.       unsigned b48:1;
  142.    };
  143. } uint48;
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 26 de Septiembre de 2021, 18:52:31
El problema es que utilice el metodo que sea, en cuanto trate de mostrar en esa pantalla tft7735 un numero superior a 1000 me mostrara un caracter ascii en las decenas que no se corresponde a ningun numero, que deberia ser como en los demas digitos un numero.
por ejemplo uso integer 2 bcd y me lo mostrara bien mientras el numero sea inferior a 1000, en cuanto supere la cifra de 1000 en lugar de mostrarse 1000 en la pantalla, mostrara algo parecido a esto 10?0.
y da igual el metodo de conversion, es indiferente, el error esta en el resultado a mostrar por pantalla aunque el metodo de conversion sea correcto, siempre mostrara un caracter cambiado en las decenas no correspondiente a un numero a partir de que la cifra sea superior a 1000.
Título: Re:Descomponer numero 16 bits
Publicado por: Sispic en 27 de Septiembre de 2021, 05:50:13
Yo uso esto para imprimir un int16
integer to string

Código: C
  1. /************************************************************************/
  2.   void send_Inttostr ( unsigned int16 valor)  {
  3. /************************************************************************/
  4. unsigned char t1,i,wrote;
  5. unsigned int16 k;
  6.  wrote=0;
  7.   for (i=5-1; i>=1; i--){
  8.    switch(i){  
  9.      case 4: k=10000;   break;      
  10.      case 3: k=1000;   break;
  11.      case 2: k=100;   break;
  12.      case 1: k=10;
  13.    }
  14.     t1=valor/k;  
  15.    if((wrote)||(t1!=0)){SendChar(t1+'0'); wrote=1;}
  16.     valor-=(t1*k);    
  17.    }
  18.    SendChar( valor +'0');
  19.    
  20. }

la funcion SendChar() envia el caracter  correspondiente  .
lo puedes modificar con drawChar  de la libreria ST7735.c
o bien calcular el valor "veces" antes de enviar drawtext
haver si funciona .

PD : Dejo otro mas

Código: C
  1. /****************************************/
  2. /*  Escribe Valor numerico al LCD       */
  3. /*  Max 1 a 9 digitos                   */
  4. /*  ceros a la izquierda blancos        */
  5. /*  puno de miles y millones            */
  6. /****************************************/  
  7. /*  ejemplo :  341.000.780   1.886  23  */
  8. /*******************************************************************************************************/
  9.   void lcd_PUTUN (unsigned char Digitos ,unsigned char font ,unsigned long valor)
  10. /*******************************************************************************************************/
  11.   {
  12.    unsigned char t1,i,wrote;
  13.    unsigned long k;
  14.  
  15.  
  16.   wrote=0;
  17.   for (i=Digitos-1; i>=1; i--)
  18.      {
  19.      switch(i){
  20.  
  21.      case 8: k=100000000;
  22.         break;
  23.     case 7: k=10000000;
  24.         break;
  25.      case 6: k=1000000;
  26.         break;
  27.    case 5: k=100000;  if (Digitos > 6){ if (wrote==1){ lcd_print_char(font,'.');} else { lcd_print_char(font,' ');}} // millones
  28.         break;
  29.     case 4: k=10000;        
  30.         break;
  31.      case 3: k=1000;  
  32.         break;
  33.    case 2: k=100;     if (Digitos > 3){ if (wrote==1){ lcd_print_char(font,'.');} else {  lcd_print_char(font,' ');}} // miles
  34.        break;
  35.    case 1: k=10;
  36.    }
  37.     t1=valor/k;
  38.  
  39.    if((wrote)||(t1!=0)){lcd_print_char(font,t1 + '0'); wrote=1;}
  40.     else lcd_print_char(font,' ');                               // Ceros izquierda blanco
  41.  
  42.     valor-=(t1*k);
  43.    
  44.    }
  45.    lcd_print_char(font, valor +'0');
  46.  
  47. }



Título: Re:Descomponer numero 16 bits
Publicado por: Picuino en 27 de Septiembre de 2021, 13:33:58
Cita de: Miguelyx en 26 de Septiembre de 2021, 18:52:31
El problema es que utilice el metodo que sea, en cuanto trate de mostrar en esa pantalla tft7735 un numero superior a 1000 me mostrara un caracter ascii en las decenas que no se corresponde a ningun numero, que deberia ser como en los demas digitos un numero.
por ejemplo uso integer 2 bcd y me lo mostrara bien mientras el numero sea inferior a 1000, en cuanto supere la cifra de 1000 en lugar de mostrarse 1000 en la pantalla, mostrara algo parecido a esto 10?0.
y da igual el metodo de conversion, es indiferente, el error esta en el resultado a mostrar por pantalla aunque el metodo de conversion sea correcto, siempre mostrara un caracter cambiado en las decenas no correspondiente a un numero a partir de que la cifra sea superior a 1000.

Prueba a enviar cadenas de caracteres fijos "1000", "1001", etc
Sin rutina de conversión.
Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 27 de Septiembre de 2021, 14:34:59
Probá mejor convirtiendo con sprintf  (el ejemplo empieza con power=980)

Código: [Seleccionar]
/*
  ST7735 TFT library for mikroC compiler is required!
*/

#define TFT_SPI_HARDWARE        // Hardware SPI module is used
sbit TFT_CS at RD0_bit;         // TFT CS pin is connected to RD0 pin
sbit TFT_DC at RD1_bit;         // TFT DC pin is connected to RD1 pin
sbit TFT_CS_Direction at TRISD0_bit;
sbit TFT_DC_Direction at TRISD1_bit;
// End SPI TFT module connections

#include "ST7735.c"
/*#include <built_in.h>
#include "variables.c"
#include "rutinas.c"
#include "config.c"*/
char unidad, decena, centena, umil, dmil, cmil;
char *veces = "00000";
unsigned int power;

 //-----------------------------
/*
void muestra_cantidad () {

     veces[4] =  unidad+48;

     if(decena>0){
         veces[4] =  unidad+48;
         veces[3] =  decena+48;
     }
     else
         veces[3] = ' ';

     if  (centena>0){
         veces[4] =  unidad+48;
         veces[3] =  decena+48;
         veces[2] =  centena+48;
     }
     else
         veces[2] = ' ';

     if(umil>0){
        veces[4] =  unidad+48;
        veces[3] =  decena+48;
        veces[2] =  centena+48;
        veces[1] =  umil+48;
     }
     else
        veces[1] = ' ';

     if(dmil>0){
        veces[4] =  unidad+48;
        veces[3] =  decena+48;
        veces[2] =  centena+48;
        veces[1] =  umil+48;
        veces[0] =  dmil+48;
    }
     else
        veces[0] = ' ';
}
*/
void configuracion ()
{

//reloj interno, bits 4, 5 y 6 deciden la velocidad,
//  16 Mhz 0b01110000, o velocidad maxima del PIC sin PLL
//  8 Mhz 0b01100000  o velocidad del PIC sin PLL, velocidad maxima dividida entre 2 sin PLL
//  4 Mhz 0b01010000, o velocidad del PIC sin PLL     "         "   dividida entre 4 sin PLL
//  2 Mhz 0b01000000, o velocidad del PIC sin PLL     "         "   dividida entre 8 sin PLL
//  1 Mhz 0b00110000, o velocidad del PIC sin PLL     "         "   dividida entre 16 sin PLL

    OSCCON =0b01110000; // 0x70;

    ANSELC=0;     // puertos digitales = 0 o analogicos = 1, para 18F46K22 y 18F45k22
    ANSELD=0;     // puertos digitales = 0 o analogicos = 1, para 18F46K22 y 18F45k22
}


void main() {

    configuracion();

    ST7735_TFT_Init();                                // Initialize the TFT module
    fillScreen(ST7735_BLACK);

    drawtext(74, 80, "VECES", ST7735_WHITE, ST7735_BLACK, 1);

    power = 980 ;

    while (1){

/*
        dmil = power / 10000;
        umil = (power -(dmil*10000))/1000;
        centena = (power -(dmil*10000 + (umil*1000)))/100;
        decena =(power - (dmil*10000 + (umil*1000 + (centena *100))))/10;
        unidad = (power - (dmil*10000 + (umil*1000 + (centena *100 +(decena *10)))));

        muestra_cantidad();
*/

        sprintf(veces,"%5u",power) ;
       
        drawtext(37, 80, veces, ST7735_WHITE, ST7735_BLACK, 1);

        power++;
    }

}
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 27 de Septiembre de 2021, 20:33:11
Nada, no hay nada que hacer, el error esta en la funcion drawchar, drawtext es una funcion que necesita de drawchar para funcionar y existir y es la unica forma de presentar numeros o caracteres por pantalla en la tft7735 usando una de esas 2 funciones, eso demuestra que el error esta en drawchar porque drawchar reproduce el mismo error y drawtext tira de drawchar para funcionar.

La unica solucion que se me ocurre es de 2 formas, una, modificando drawchar, pero no soy capaz.
La otra es crear un flag que se llame por ejemplo power1 y se le sume 1 cada vez que power supere 999, acto seguido, se ponga power a 0 de nuevo y power1 marque un incremento en 1, de esta forma marcaria a partir de 1000 correctamente, porque si lo hago con unidades de mil y decenas de mil esta claro que cada vez que supere 1000 se reproducira el error, para evitarlo es cuando power supere 999 se ponga a 0 y power no siga contando, sino que inicie la cuenta de nuevo desde 0 pero con el flag power1 incrementado.
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 27 de Septiembre de 2021, 23:07:52
Bueno, lo he solucionado a medias con un parche como decia, impidiendo que contee mas de 1000 y devolviendo la variable a 0 al llegar a 1000.
He añadido 2 nuevas variables
Código: C
  1. unsigned char uumil=0;
  2. unsigned char ddmil=0;
  3. char *veces = "000";
  4. char *veces1 = "00";

y he variado una funcion y añadido una nueva funcion

Código: C
  1. void muestra_cantidad () {
  2.  
  3.      veces[2] =  unidad+48;
  4.      veces[1] =  decena+48;
  5.      veces[0] =  centena+48;
  6.  
  7. }
  8.  
  9. void muestra_cantidad1 () {
  10.  
  11.      veces1[1] =  uumil+48;
  12.      veces1[0] =  ddmil+48;
  13.  
  14. }

 y en el codigo he añadido esto:

Código: C
  1. if (power > 999) {
  2.           power =0;
  3.           uumil++;
  4.               }
  5.           if (uumil > 9) {
  6.           uumil =0;
  7.           ddmil++;
  8.               }
  9.              
  10.           if (ddmil > 9) {
  11.           ddmil =0;
  12.           uumil=0;
  13.           power=0;
  14.               }
  15.  
  16.      muestra_cantidad ();
  17.      muestra_cantidad1 ();
  18.      drawtext(37, 80, veces, ST7735_WHITE, ST7735_BLUE, 1);
  19.      drawtext(25, 80, veces1, ST7735_WHITE, ST7735_BLUE, 1);

Ahora cuando llega a 1000 power se pone a 0 y suma 1 a las unidades de millar mostrado 1000 y los sucesivos numeros correctamente.

En fin un parche a medias porque aunque el conteo ya lo hace bien, ahora la eeprom ya no guarda el numero correctamente y muestra la cantidad de la modificacion, no la real.
Supongo que debere hacer una rutina que tenga en cuenta las decenas de mil de la variable ddmil, las unidades de mil de la variable uumil y la cantidad de power haciendo una descomposicion a la inversa, es decir una recomposicion.

por ejemplo 24630
Si ddmil esta contada 2 veces son 20000 + si uumil esta contada 4 veces son 4000 + la cantidad de power 630 en total 24630 y escribirlo/leerlo en hexadeximal en la eeprom.
Título: Re:Descomponer numero 16 bits
Publicado por: Picuino en 29 de Septiembre de 2021, 13:56:12
Creo que sería más sencillo y más apropiado descomponer el número ya traducido a formato texto en grupos de 3 dígitos y enviarlo al display de 3 en 3 dígitos.
Pero internamente sigues contando con una variable entera única.

Un saludo.

Edito: Pero creo que no es un problema de las rutinas de impresión en display. Es muy raro que funcionen mal al imprimir 4 caracteres. ¿Puede que tengas un desbordamiento en el buffer en el que vuelcas la conversión de número a texto?
Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 29 de Septiembre de 2021, 16:26:03
Cita de: Picuino en 29 de Septiembre de 2021, 13:56:12
....
Edito: Pero creo que no es un problema de las rutinas de impresión en display. Es muy raro que funcionen mal al imprimir 4 caracteres. ¿Puede que tengas un desbordamiento en el buffer en el que vuelcas la conversión de número a texto?

Pienso igual, tal vez un overflow en alguna multiplicación.

Si en lugar de esa kilométrica conversión hago directamente:
Código: [Seleccionar]
        sprintf(veces,"%5u",power) ;     
        drawtext(37, 80, veces, ST7735_WHITE, ST7735_BLACK, 1)
desaparece el problema.
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 30 de Septiembre de 2021, 04:22:25
Explicate porfavor, como haces para colocar este codigo en la conversion:

        sprintf(veces,"%5u",power) ;     
        drawtext(37, 80, veces, ST7735_WHITE, ST7735_BLACK, 1)

y hacer que desaparezca el problema sin que se trunque el numero que sale por pantalla y sea identico al escrito en la eeprom ademas de leerlo de la eeprom y sumerle 1 al de la eeprom?
Tal cual y  ya esta?
Porque yo lo coloco despues de la extraccion de cualquier digito y sigue mostrando algun ascii,
Donde muestra menos ascii es colocandolo justo despues de la extraccion de todos los digitos y antes de muestra_canidad();
Colocandolo hay, es cuando menos sale un ascii, aunque sale un / en las decenas de vez en cuando.

Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 30 de Septiembre de 2021, 08:58:24
El código que puse en la respuesta #9  es el mismo que habías subido pero marcando como comentario lo referido a la conversión , siendo reemplazado por el sprintf.
Simulando en Proteus, originalmente a partir de 1000 sale 10?0 10?1 10?2   mientras que después sale bien.
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 30 de Septiembre de 2021, 10:00:56
Cita de: Picuino en 29 de Septiembre de 2021, 13:56:12
Creo que sería más sencillo y más apropiado descomponer el número ya traducido a formato texto en grupos de 3 dígitos y enviarlo al display de 3 en 3 dígitos.
Pero internamente sigues contando con una variable entera única.

Un saludo.

Edito: Pero creo que no es un problema de las rutinas de impresión en display. Es muy raro que funcionen mal al imprimir 4 caracteres. ¿Puede que tengas un desbordamiento en el buffer en el que vuelcas la conversión de número a texto?

Suena bien eso, como lo harias para ademas escribirlo en 16 bits en la eeprom y leerlo sin que se altere al mostrarlo en pantalla?
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 30 de Septiembre de 2021, 10:12:35
Cita de: Eduardo2 en 30 de Septiembre de 2021, 08:58:24
El código que puse en la respuesta #9  es el mismo que habías subido pero marcando como comentario lo referido a la conversión , siendo reemplazado por el sprintf.
Simulando en Proteus, originalmente a partir de 1000 sale 10?0 10?1 10?2   mientras que después sale bien.
le he metido un delay tras power++; para ver lo que hace mas claramente
y a mi me muestra un / en las decenas desde 1000 a 1010 luego hace un tileo pero los muestra bien hasta que llega a 2000, a partir de ahi vuelve a mostrarse el error.  :5] Que rabia.
Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 30 de Septiembre de 2021, 12:45:43
No puedo adivinar ni el código ni la conexión que estás usando.
Esto es lo que me sale con el código del mensaje #9  al que le agregué un delay y un salto en el conteo de  990...1010 a 1990... para no esperar tanto.

En la simulación le desconecte TFT_CS porque el driver no lo gestiona bien y te ralentiza la ejecución.
 - Tienes que ingresar para ver archivos adjuntos -  
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 30 de Septiembre de 2021, 13:12:18
No lo comprendo, a ti te lo hace perfecto y a mi me falla tanto en la simulacion como en la proto, la proto reproduce exactamente lo mismo que la simulacion.

Que compilador usas y que version, puede que sea un tema de actualizacion.
Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 30 de Septiembre de 2021, 13:21:19
Es con MikroC v7.1
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 30 de Septiembre de 2021, 13:44:36
Pues no es eso, porque yo tengo la 7.5  y he bajado de version a la 7.1 para probarlo y lo sigue haciendo.
Esto es desesperante jaja.
Y es con la libreria que yo subi? porque esa libreria esta modificada por mi para tener la funcion drawtext y drawchar porque la original escribia un digito sin borrar lo que habia anteriormente en esa posicion y tras escribir varias veces solo se veia un cuadrado, a ver si el fallo esta ahi.
Hay 2 versiones de esa libreria, una que tiene rotacion pero no tiene drawtext y para limpiar  lo que hay antes de escribir hay que hacer un clear y otra que tiene drawtext pero no tiene rotacion y de las 2 saque una que podia rotar y ademas escribir texto. sin restos de lo que habia escrito anteriormente.
Voy a probar con la libreria original pero añadiendo un fillrectangle del mismo color que el fondo y mismo tamaño que la fuente antes de escribir cada digito encima de otro, asi el nuevo digito se vera correctamente sin residuos del anterior.
Pero es una faena tener que crear por cada digito, palabra o frase un rectangulo para eliminar lo que habia escrito anteriormente.

Ademas que he de cambiar a un 46k22 para poder usar sprintf, estoy a un 11% de los 32k del 45k22 pero en cuanto activo la libreria sprintf me quedo sin ROM, cambio a un 46k22 y la rom esta al 67%, esa libreria se ha comido un 24% de la rom.

Pero en el 45k22 se come el equivalente al 47% se dice pronto.
Título: Re:Descomponer numero 16 bits
Publicado por: Eduardo2 en 30 de Septiembre de 2021, 15:01:05
Cita de: Miguelyx en 30 de Septiembre de 2021, 13:44:36
....
Y es con la libreria que yo subi? porque esa libreria esta modificada por mi para tener la funcion drawtext y drawchar porque la original escribia un digito sin borrar lo que habia anteriormente en esa posicion y tras escribir varias veces solo se veia un cuadrado, a ver si el fallo esta ahi.

Si, era con la que subiste.   
Como dije antes, el manejo del TFT_CS  no andaba bien.  No sé hasta donde modificaste, pero si eliminás todos los  TFT_CS = 0 y  TFT_CS = 1 , dejando solamente:
Código: [Seleccionar]
void startWrite(void) {
    TFT_CS = 0;
}
void endWrite(void) {
    TFT_CS = 1;
}
Marcha como corresponde.


Citar
Ademas que he de cambiar a un 46k22 para poder usar sprintf, estoy a un 11% de los 32k del 45k22 pero en cuanto activo la libreria sprintf me quedo sin ROM, cambio a un 46k22 y la rom esta al 67%, esa libreria se ha comido un 28% de la rom.
Pero en el 45k22 se come el equivalente al 47% se dice pronto.
Son ventajas y desventajas,  sprintf  formatea de mil formas y para una conversión a ascii es mucho mas rápida que una conversión multiplicando/dividiendo enteros de 16 bit (porque internamente no divide).  Si no se la va a usar en otra cosa ciertamente pesa bastante.
Título: Re:Descomponer numero 16 bits
Publicado por: Picuino en 30 de Septiembre de 2021, 15:49:28
Esta rutina funciona bien en Arduino y es capaz de realizar una conversión de binario 16 bits a string en 66 microsegundos (unos 1000 ciclos) es decir, es muy rápida y ocupa muy pocos bytes de código, muchísimos menos que sprintf o que el método de las divisiones.

Código: C
  1. #define BIN16_DECIMAL_DIGITS 5
  2.  
  3.  
  4. void bin16_to_str(char *str, unsigned int bin) {
  5.    char maxdig, digcnt, bitcnt;
  6.    static char *p, carry;
  7.  
  8.    // Clear string
  9.    p = str;
  10.    digcnt = BIN16_DECIMAL_DIGITS + 1;
  11.    do { *p++ = 0; } while (--digcnt);
  12.  
  13.    // Transform binary to BCD
  14.    bitcnt = 16;
  15.    maxdig = (BIN16_DECIMAL_DIGITS - 1);
  16.    str += (BIN16_DECIMAL_DIGITS - 1);
  17.    do {
  18.       // Shift left binary number with carry
  19.       carry = 0;
  20.       if (bin & 0x8000)
  21.          carry |= 1;
  22.       bin <<= 1;
  23.  
  24.       // Shift left decimal number with carry
  25.       p = str;
  26.       digcnt = BIN16_DECIMAL_DIGITS - maxdig;
  27.       do {
  28.          carry = (*p<<1) + carry;
  29.          if (carry >= 10) {
  30.             *p-- = carry - 10;
  31.             carry = 1;
  32.             if (digcnt == 1) {
  33.                maxdig--;
  34.                digcnt++;
  35.             }
  36.          }
  37.          else {
  38.             *p-- = carry;
  39.             carry = 0;
  40.          }
  41.       } while(--digcnt);
  42.    } while(--bitcnt);
  43.  
  44.    // Transform BCD to ASCII
  45.    digcnt = BIN16_DECIMAL_DIGITS;
  46.    do *str-- += '0'; while (--digcnt);
  47. }
  48.  
  49.  
  50. void setup() {
  51.    Serial.begin(9600);
  52. }
  53.  
  54.  
  55. void loop() {
  56.    unsigned long timeit;
  57.    unsigned int bin;
  58.    char strnum[BIN16_DECIMAL_DIGITS + 1];
  59.    strnum[BIN16_DECIMAL_DIGITS] = 0; // End of char
  60.  
  61.    timeit = millis();
  62.    for(bin=0; bin<50000; bin++) {
  63.       bin16_to_str(strnum, bin);
  64.    }
  65.    timeit = millis() - timeit;
  66.    Serial.print("50000 conversions in ");
  67.    Serial.print(timeit);
  68.    Serial.println(" milliseconds");
  69.    delay(5000);
  70.    
  71.    for(bin=0; bin<50000; bin++) {
  72.       bin16_to_str(strnum, bin);
  73.       Serial.println(strnum);
  74.    }
  75. }


Salida:
Código: [Seleccionar]
50000 conversions in 3253 milliseconds
00000
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 30 de Septiembre de 2021, 19:23:38
La modificacion fue muy superficial, lo justo para incorporar drawchar y drawtext a la libreria que encendia la pantalla y no daba error con el SPI, pero esa era la que tenia el problema de escribir encima de otras escrituras sin borrarlas previamente, la otra daba directamente error en TFT_DATA si no recuerdo mal y habia que modificar casi toda la libreria, pero incorporaba drawchar y drawtext que permitia escribir texto borrando lo que habia escrito previamente en cada celdilla, por lo que decidi, copiar drawchar y drawtext tal cual estaban en la 2ª libreria a la 1ª libreria.

Las he metido en adjuntos.

Esas son las 2 librerias originales, la que funciona es la 7735.c  y la que da error es la 7735_TFT.c pero es la que tiene nativamente drawchar y drawtext.

Nada mi gozo en un pozo, he usado la libreria original usando la funcion display_Puts que hace lo mismo que drawtext, pero lo que comentaba, no limpia lo escrito en esa misma posicion y tras varias escrituras una encima de la otra solo se ve un cuadrado.

Código: C
  1. muestra_cantidad();
  2.  
  3.     display_setCursor(37, 80);
  4.     display_setTextSize(1);
  5.     display_setTextColor(ST7735_WHITE, ST7735_BLACK);
  6.     display_puts(veces);

Para ello lo soluciono con un fillrect que dibuja un rectangulo del color del fondo y mismo tamaño que lo escrito para limpiar la zona donde voy a escribir, pero, no hay manera, se vuelve a reproducir el error a partir de 2000 aunque use Sprintf.

Código: C
  1. muestra_cantidad();
  2.  
  3.     display_setCursor(37, 80);
  4.     display_setTextSize(1);
  5.     display_setTextColor(ST7735_WHITE, ST7735_BLACK);
  6.     fillRect(37,80,30,10, ST7735_BLACK);
  7.     display_puts(veces);
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 01 de Octubre de 2021, 04:48:03
Cita de: Picuino en 30 de Septiembre de 2021, 15:49:28
Esta rutina funciona bien en Arduino y es capaz de realizar una conversión de binario 16 bits a string en 66 microsegundos (unos 1000 ciclos) es decir, es muy rápida y ocupa muy pocos bytes de código, muchísimos menos que sprintf o que el método de las divisiones.

Código: C
  1. #define BIN16_DECIMAL_DIGITS 5
  2.  
  3.  
  4. void bin16_to_str(char *str, unsigned int bin) {
  5.    char maxdig, digcnt, bitcnt;
  6.    static char *p, carry;
  7.  
  8.    // Clear string
  9.    p = str;
  10.    digcnt = BIN16_DECIMAL_DIGITS + 1;
  11.    do { *p++ = 0; } while (--digcnt);
  12.  
  13.    // Transform binary to BCD
  14.    bitcnt = 16;
  15.    maxdig = (BIN16_DECIMAL_DIGITS - 1);
  16.    str += (BIN16_DECIMAL_DIGITS - 1);
  17.    do {
  18.       // Shift left binary number with carry
  19.       carry = 0;
  20.       if (bin & 0x8000)
  21.          carry |= 1;
  22.       bin <<= 1;
  23.  
  24.       // Shift left decimal number with carry
  25.       p = str;
  26.       digcnt = BIN16_DECIMAL_DIGITS - maxdig;
  27.       do {
  28.          carry = (*p<<1) + carry;
  29.          if (carry >= 10) {
  30.             *p-- = carry - 10;
  31.             carry = 1;
  32.             if (digcnt == 1) {
  33.                maxdig--;
  34.                digcnt++;
  35.             }
  36.          }
  37.          else {
  38.             *p-- = carry;
  39.             carry = 0;
  40.          }
  41.       } while(--digcnt);
  42.    } while(--bitcnt);
  43.  
  44.    // Transform BCD to ASCII
  45.    digcnt = BIN16_DECIMAL_DIGITS;
  46.    do *str-- += '0'; while (--digcnt);
  47. }
  48.  
  49.  
  50. void setup() {
  51.    Serial.begin(9600);
  52. }
  53.  
  54.  
  55. void loop() {
  56.    unsigned long timeit;
  57.    unsigned int bin;
  58.    char strnum[BIN16_DECIMAL_DIGITS + 1];
  59.    strnum[BIN16_DECIMAL_DIGITS] = 0; // End of char
  60.  
  61.    timeit = millis();
  62.    for(bin=0; bin<50000; bin++) {
  63.       bin16_to_str(strnum, bin);
  64.    }
  65.    timeit = millis() - timeit;
  66.    Serial.print("50000 conversions in ");
  67.    Serial.print(timeit);
  68.    Serial.println(" milliseconds");
  69.    delay(5000);
  70.    
  71.    for(bin=0; bin<50000; bin++) {
  72.       bin16_to_str(strnum, bin);
  73.       Serial.println(strnum);
  74.    }
  75. }

Es curioso que menciones el arduino, precisamente me llego ayer un Arduino Uno, empece con Arduino hace 12 horas literalmente, en toda mi vida jamas lo habia tocado hasta que me ha llegado el Arduino Uno, lo pedi a principios de Junio y me llego ayer, casi 4 meses mas tarde tras pedirlo, y nada mas llegarme me he liado con una pantalla china que incorpora panel tactil y me esta volviendo loco, es una ILI9341 con panel tactil pero se ve que es una version muy antigua, porque usa un driver SPFD-5408, pero lo curioso es que a diferencia de las mas modernas que tienen los pines en la parte estrecha del PCB, esta mas antigua tiene 2 hileras de pines en la parte ancha y encaja a la perfeccion en los slots del Arduino Uno, pero no tengo ni idea de que puertos tengo libres en el 328 tras acoplarle la pantalla, la pantalla la he encendido y he hecho mi primer trabajo con exito, un contador a la inversa, pero controlar la pantalla tactil es otro cantar, se ha convertido en toda una odisea, no consigo que obedezca a la pulsacion tactil sin que el contador deje de funcionar.  :lol:  :lol:  :lol:

Creo que voy a pedir un Arduino Mega 2560 porque aunque la potencia y capacidad del arduino uno de momento me es suficiente para controlar una TFT y un panel tactil, el tener 28 pins me corta las alas porque necesito varios pins libres y ahora mismo no tengo ni idea de cuantos pins me ha dejado libres la pantalla, fisicamente mirandolo la pantalla tiene 28 pines conectados a la placa del arduino y ni un solo pin esta descocupado,

(https://cdn.shopify.com/s/files/1/1509/1638/products/Back_74a28418-c723-4bf0-a4f8-5f00eacb0bdb_800x.jpg?v=1602515161)

Con que tuviese 2 o 3 libres me seria de momento suficiente para que el contador funcione con el panel tactil y active esos 2 o 3 pins libres cuando el contador esta en marcha y los desactive cuando finaliza.

Voy a intentar sacar el 328P de su placa y colocarlo en una proto para ver si puedo trabajar con la TFT+tactil desde la proto y asi poder usar los pines que me deja libres, si es que deja alguno.
Título: Re:Descomponer numero 16 bits
Publicado por: Picuino en 01 de Octubre de 2021, 10:30:23
Por lo que veo puedes utilizar cinco pines que está dejando libres en J1, J2 y J3
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 01 de Octubre de 2021, 12:15:02
Ah si, cierto, parece que estan sin asignacion aunque tengan el pin insertado.
Por cierto, tu sabrias hacer una simulacion del uno y esa pantalla en proteus?
Porque no consigo hacerla funcionar en proteus y es una tocadura de narices no poder hacer debug en proteus y tener que quemar el programa cada vez que hago una modificacion en el codigo.
Título: Re:Descomponer numero 16 bits
Publicado por: Picuino en 01 de Octubre de 2021, 13:57:24
Ni idea. Yo prefiero probar el programa sobre el sistema real.
Título: Re:Descomponer numero 16 bits
Publicado por: Miguelyx en 04 de Octubre de 2021, 09:04:51
Bueno, sigo intentando solucionar el problema y voy avanzando poco a poco, ahora se me ha presentado este otro problema;

Consigo escribir el numero que es de 32bits en la Eeprom, pero no lo consigo recuperar con el mismo valor.

Lo escribo asi:

el numero se almacena en la variable valor y acto seguido lo escribe y lo hace bien.

Supongamos que el numero ha llegado a 3854808738

En hexadecimal es E5 C3 B6 A2 y lo escribo correctamente.
Pero no consigo recuperarlo que siga siendo el mismo valor que se acaba de escribir.

Código: C
  1. void pausa50(){
  2. Delay_ms(50);
  3. }
  4. unsigned long valor=3854808738; // Numero de 32 bis
  5.  
  6.  
  7. //para Eeprom de 1024 Bytes lo escribo en los 4 ultimos bytes de la Eeprom
  8. //Para Eeprom de 256 Bytes sustituir 0x3FF por 0xFF y lo escribo en los 4 ultimos bytes de la Eeprom
  9.  
  10. void EEPROM32bits() {
  11.  
  12. unsigned char byte4 = (valor);                   //separa primer byte
  13. unsigned char byte3 = (valor >> 8);              //separa segundo byte
  14. unsigned char byte2 = (valor >> 16);             //separa tercer byte
  15. unsigned char byte1 = (valor >> 24);             //separa cuarto byte
  16.  
  17. Eeprom_write(0x3FC, byte4);                       //escribe primer byte en 0x3FC
  18. pausa50();
  19. Eeprom_write(0x3FC + 1, byte3);                   //escribe segundo byte en 0x3FD
  20. pausa50();
  21. Eeprom_write(0x3FC + 2, byte2);                   //escribe tercer byte en 0x3FE
  22. pausa50();
  23. Eeprom_write(0x3FC + 3, byte1);                   //escribe cuarto byte en 0x3FF
  24. pausa50();
  25. }