[help] Buscando un Algoritmo "óptimo"...

Archivado
Buenas people,

Necesito encontrar un algoritmo óptimo , o por lo menos eficaz para resolver un problemilla, y no encuentro nada...

Se trata de agrupar distintos datos de tamaño variable ( por ejemplo de 13 , 5 y 17 bits ) ,que están guardados en variables de 1 byte ( u 2 ) , en una ristra de datos de longitud constante : 1 byte .

Por ejemplo , si tenemos estos datos de entrada:


Imagen

Se debería tener una salida así :

Imagen

Donde los cuadraditos como digo, son de 1 byte...

Lo estoy intentando programar en C , compilandolo con gcc..

Hoy no puedo poner el código ke llevo , se me ha olvidado en el curro :( ,

Mis optimizaciones van ,por ejemplo, en comprobar si el pakete de salida está vacío , así puedo hacer una asignación byte a byte ,para intentar ahorrar las operaciones a nivel de bits....

Aunque no sé , me está quedando un algoritmo para nada limpio ni eficaz (además momento no funciona del todo bien... )

1 Saludo

Pd: Sí , es para un programa libre :-p
No tengo mucha idea, pero por preguntar que no quede. ¿Cómo identificas los límites de los datos? Es que no lo acabo de comprender [ayay]

Saludos :)
Eso se da , digamos que los datos de entrada tienen un array asociado con sus longuitudes .

Y para que se vea algo más la lógica, explico para qué es:

Imaginemos una frase : " Dejame que te acaricie el Chou-chou " .

Este texto , lo tengo que sacar por una impresora y yo soy el programador del driver ¬_¬ .
El problema es que como las impresoras trabajan con líneas, tengo que renderizar por líneas la frase , por ejemplo la primera linea de este texto , sólo tendría datos devido a la primera D y a la C del chowchou :-P (empiezo a renderizar por arriba )

Pasar cada carácter al código que tengo que enviar es fácil (así como saber su longitud ), pero como cada letra tiene un tamaño distinto (y porque transmito de byte en byte), hay que ir juntandolos en los paquetes , para poder enviar a la impresora los 384 bits en los que se compone la línea.


En fíns , supongo que tampoco habrá quedado del todo claro , soy un caso para explicarme, si quieres vuelvo a explikarlo... ( ...y en el futuro quiero ser profe pufffff temblad futuros alumnos ... [jaja] )

1 Salu2!

Pd: De momento la altura de los caracteres no es problema, es cuestión de llamar a la función que quiero hacer, "printer_renderizar()" más veces..
Si te he entendido (que no estoy seguro) la forma más clara de programarlo es crear un stream de datos. Es decir, pegar todos los datos a bloque.

La cosa sería tomar un buffer de almacenamiento temporal suficientemente grande y meter todos los datos ahi. Metes un dato. Luego coges el siguiente, inicializas a 0 y haces un shift a la derecha tan largo como todo lo que tengas en el buffer y le haces un AND con el buffer donde estás almacenando todo y así sucesivamente.

Cuando termines ya lo partes en trozos de 8 bits.
Enas , perdón por el retraso pero el curro es mu malo XD

Pongo mi código a ver que os parece:

int conv_caracter (int * index_pixel,u8 res_intermedio,u8 res_intermedio2, int * acumulador, int * voy ,int ancho,int num_linea,u8 * linea_procesada )
{
   for (   *index_pixel=0;   *index_pixel<ancho &&    *index_pixel<8 ; *index_pixel+=1){
   
      if ( (0x80 >>    *index_pixel ) & res_intermedio ){
      
                   linea_procesada[*acumulador] |= (0x80 >> *voy );   
      }
      else
                  linea_procesada[*acumulador] &= ~(0x80 >> *voy );   
      
      if (   *voy== 7 ){
         *voy =0;
         *acumulador+=1;
      }
      else{
         *voy+=1;
      }
   }
   
   for (   ;   *index_pixel<ancho;    *index_pixel+=1){
   
      if ( (0x80 >>    (*index_pixel-8) ) & res_intermedio2 ){
      
          linea_procesada[*acumulador] |= (0x80 >> *voy );   
      }
      else
          linea_procesada[*acumulador] &= ~(0x80 >> *voy );   
      
      if (   *voy== 7 ){
         *voy =0;
         *acumulador+=1;
      }
      else{
         *voy+=1;
      }
   }
return 0;
}

A la función le paso res_intermedio y resintermedio2 , donde están los datos de entrada a enviar ( del caracter que se procesa, pero eso es lo de menos).

ancho dice el número de bits a procesar del caracter (y num_linea lo paso para otros menesteres que no cuento por no liarlo más ).

También uso un array (linea_procesada) donde voy guardando de byte en byte los datos del buffer de salida.
Acumulador es el índice de linea_procesada.

*voy es el número de bit del buffer de salida (de 0 a 7) actual.


¿ Sickboy, te refieres a usar campos de bit ? estoy pensando en ello, aunque no se, tengo que pensar si así reduzco el número de operaciones...

Por otro lado, por fín me han respondido en la web del fabricante cómo leches hacer para que cambie la configuración del puerto serie "on the fly", así que menos problemas todavía ;)

Un Saludo
4 respuestas
Archivado
Volver a Software libre