Duda con display VFD

[Alex_Sade]

Entonces ahi lo que haces es convertir el array de char en una unica cadena de bits no?
Lo que me gustaria hacer es más o menos esto:

long long a = B00000000100000000000000000000000>>1;
int b = B00001000>>1;
//Ahora quiero sustituir los primeros 2 bytes de la variable a por los de la variable b para que quede algo asi:
a = B00000100010000000000000000000000;
//He pensado en hacerlo con un OR
a = a | b;
//Pero esto me lo añadiria al final de la cadena no? y quedaria algo como esto (pienso)
a = B00000000010000000000000000000100;

 

[Dr. Zoidberg]

Entonces ahi lo que haces es convertir el array de char en una unica cadena de bits no?

Básicamente sí, pero la conversión es "bidireccional". 64 bits <--> arreglo de 8 bytes

 

[Alex_Sade]

Estaba editando el mensaje anterior!

 

[Dr. Zoidberg]

Lo que me gustaria hacer es más o menos esto:

long long a = B00000000100000000000000000000000>>1;
int b = B00001000>>1;
//Ahora quiero sustituir los primeros 2 bytes de la variable a por los de la variable b para que quede algo asi:
a = B00000100010000000000000000000000;
//He pensado en hacerlo con un OR
a = a | b;
//Pero esto me lo añadiria al final de la cadena no? y quedaria algo como esto (pienso)
a = B00000000010000000000000000000100;

y sí, está mal por que el long long y el int no tienen el mismo tamaño y la operación lógica siempre arranca en el bit menos significativo.
Usando la union podés hacer esto:

de64bitsa8bytes dato;
dato.largo = B00000000100000000000000000000000>>1;
dato.bytes[0] = B00001000>>1;

y listo, el "largo" ya tiene el MSB modificado...

Solo hay que verificar si es el bytes[0] o el bytes[8]....pero juraría que es el [0]

 

[Alex_Sade]

vale... y hacer eso no seria lo mismo que hacer:

long long a = B00000000100000000000000000000000>>1;
long long b = B00000100000000000000000000000000>>1;

a = a | b;

y ocuparia el mismo espacio en memoria tambien no? por que si tienes que declarar un array de 8bytes para solo utilizar la primera posicion estas a la misma...

 

[Dr. Zoidberg]

vale... y hacer eso no seria lo mismo que hacer:

long long a = B00000000100000000000000000000000>>1;
long long b = B00000100000000000000000000000000>>1;

a = a | b;

y ocuparia el mismo espacio en memoria tambien no? por que si tienes que declarar un array de 8bytes para solo utilizar la primera posicion estas a la misma...

Me parece que no estás entendiendo nada de las uniones, leíste el link que te pasé??

• En tu código declarás dos variables long long ==> gastás 16 bytes ==> 128 bits.
• En el mío solo declaro una sola unión que ocupa SOLAMENTE 64 bits por que el long long y el arreglo de 8 char VIVEN JUNTOS EN EL MISMO ESPACIO DE MEMORIA!!! La contraparte es que solo se puede usar uno u otro cada vez, pero en este caso viene como anillo al dedo por que uso el long long para inicializar, el arreglo para operar y el long long para usar el resultado.

Si no entendés las union no tiene caso seguir...

 

[Alex_Sade]

Ostia vale... ahora lo entiendo! pero eso me presenta otro problema... si hago largo>>1 me correra desde la posicion 0 del array y necesito que lo haga desde la posicion 2 y modifique hasta la 7. Por que lo 2 primeros bytes no los quiero desplazar en ese momento y como es el mismo espacio de memoria si que lo hará...

 

[Dr. Zoidberg]

Por que lo 2 primeros bytes no los quiero desplazar en ese momento y como es el mismo espacio de memoria si que lo hará...

Lo probaste???
Si nó, no especulés. Escribí el código y hacelo funcionar...son 10 líneas.
El desplazamiento es sobre UN BYTE, no tiene por qué tocar los otros...

Y probá si es con bytes[0] o bytes[7], por que lo acabo de probar en mi PC (no el código Arduino, sino C ANSI sobre Intel) y es el bytes[7]...al menos usando el GCC

 

[Alex_Sade]

A ver, si hago un desplazamiento sobre una posicion del array no hay problema ya me ha quedado claro, ahora el problema es si lo hago sobre la variable de los 64bits (largo), por que si me afectara a TODOS los bytes.

 

[Dr. Zoidberg]

A ver, si hago un desplazamiento sobre una posicion del array no hay problema ya me ha quedado claro, ahora el problema es si lo hago sobre la variable de los 64bits (largo), por que si me afectara a TODOS los bytes.

Y es así como debe ser en ese caso...
Según la teoría el long long es un tipo atómico, así que no podés esperar algo diferente si le aplicás un desplazamiento a la variable long long.

 

[Alex_Sade]

entonces como puedo hacerlo?

 

[Dr. Zoidberg]

entonces como puedo hacerlo?

Y trabajando con los bytes individuales que están en el arreglo....
Para eso lo hemos dividido usando la "union"...

 

[Alex_Sade]

Asi lo estoy haciendo ahora... Trabajo con un array de bytes, pero se vuelve muy complicado todo. A ver si alguien se le ocurre otra cosa por que nose si podre manejar dos variables de 64bits con el arduino para hacer el OR entre ellos...

 

[Dr. Zoidberg]

Por que mejor no explicas claramente las operaciones que querés hacer, por que no se entiende.
Hablás de desplazar 16 bits pero solo trabajas sobre 8 o 64. Por que no posteás la secuencia de modificaciones completas??

 

[Alex_Sade]

Es algo bastante complejo, tal vez deberia de crear un hilo para el proyecto, pero bueno voy a intentar explicarme: Estoy intentado hacer funcionar una pantalla VFD, esta compuesta por rejillas y segmentos. Pues bien en este caso la pantalla es de tipo circular, aqui tienes una imagen con un segmento apagado y todas las rejillas encendidas:

https://www.forosdeelectronica.com/attachments/img20200401162521-jpg.188326/

Esto esta gestionado mediante un Shifter de 64bits, los primeros 2Bytes corresponde a la rejilla y los otros 6Bytes corresponden a los segmentos. Para hacer una animacion que recorra toda la circunferencia tengo que desplazar un bit a apatir del tercer byte (por que los dos anteriores corresponden a las rejillas) y en el 6º bit del Byte nº6 tiene que desplazar el Byte nº2 para cambiar de rejilla. Espero haberme explicado mejor, a ver si tengo tiempo y creo el codigo con las dos frases de 64bits como comento anteriormente para que se entienda mejor. Un saludo

 

[Alex_Sade]

Bueno al fín he conseguido realizar lo que queria, al final que tenido que tratar byte por byte lo que me ha costado unas cuantas lineas de codigo pero bueno!. El siguiente problema que tengo es el ghosting. Que no encuentro manera de eliminarlo. ¿Puede ser que el arduino no tengo suficiente velocidad? o estoy haciendo alguna cosa mal?. Ahora mismo el codigo lo que hace es:
1º ilumina todo el display excepto la rejilla correspondiente a los segmentos que me interesa apagar.
2º ilumina todas las rejillas excepto los segmentos que me interesa apagar (un segmento corresponde a varias rejillas de ahí el ghosting).
Aquí teneis el video para que se entienda mejor: