Autor Tema: Descomponer numero 16 bits  (Leído 2407 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Descomponer numero 16 bits
« 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.
« Última modificación: 26 de Septiembre de 2021, 19:01:31 por Miguelyx »

Desconectado elreypic2

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1295
Re:Descomponer numero 16 bits
« Respuesta #1 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.

Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Re:Descomponer numero 16 bits
« Respuesta #2 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.  ((:-))

Desconectado Eduardo2

  • PIC24F
  • *****
  • Mensajes: 947
Re:Descomponer numero 16 bits
« Respuesta #3 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 ;   
}


Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Re:Descomponer numero 16 bits
« Respuesta #4 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++;
         }

     }
« Última modificación: 25 de Septiembre de 2021, 16:36:56 por Miguelyx »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5878
    • Picuino
Re:Descomponer numero 16 bits
« Respuesta #5 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;
« Última modificación: 26 de Septiembre de 2021, 15:50:39 por Picuino »

Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Re:Descomponer numero 16 bits
« Respuesta #6 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.

Desconectado Sispic

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1678
    • winpic800
Re:Descomponer numero 16 bits
« Respuesta #7 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. }



« Última modificación: 27 de Septiembre de 2021, 08:16:31 por Sispic »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5878
    • Picuino
Re:Descomponer numero 16 bits
« Respuesta #8 en: 27 de Septiembre de 2021, 13:33:58 »
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.

Desconectado Eduardo2

  • PIC24F
  • *****
  • Mensajes: 947
Re:Descomponer numero 16 bits
« Respuesta #9 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++;
    }

}

Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Re:Descomponer numero 16 bits
« Respuesta #10 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.
« Última modificación: 27 de Septiembre de 2021, 20:38:39 por Miguelyx »

Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Re:Descomponer numero 16 bits
« Respuesta #11 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.
« Última modificación: 28 de Septiembre de 2021, 09:11:13 por Miguelyx »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5878
    • Picuino
Re:Descomponer numero 16 bits
« Respuesta #12 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?
« Última modificación: 29 de Septiembre de 2021, 13:58:59 por Picuino »

Desconectado Eduardo2

  • PIC24F
  • *****
  • Mensajes: 947
Re:Descomponer numero 16 bits
« Respuesta #13 en: 29 de Septiembre de 2021, 16:26:03 »
....
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.

Desconectado Miguelyx

  • PIC10
  • *
  • Mensajes: 30
Re:Descomponer numero 16 bits
« Respuesta #14 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.

« Última modificación: 30 de Septiembre de 2021, 05:00:18 por Miguelyx »


 

anything