usar una variable uint128_t como dos uint64_t

International Español Software
1

Buenos dias, tengo un proyecto con un panel rgb y quisiera hacer una prueba pero no se muy bien como programarlo.

Este es mi codigo:

uint64_t row1[16];
uint64_t temp;
int LP = 10;           // Latch Pin
int ClkP = 11;         // Clock Pin
int R1P = 24;          // R1 Pin
int G1P = 25;          // B1 Pin
int B1P = 26;          // G1 Pin
int R2P = 27;          // R2 Pin
int G2P = 28;          // B2 Pin
int B2P = 29;          // G2 Pin
int AP = A0;           // A Pin
int BP = A1;           // B Pin
int CP = A2;           // C Pin
int OEP = 9;           // OE Pin
int row = 0;


const int pinA=2;
const int pinB=3;
const int pinC=4;
const int pinD=5;

byte x=1;
byte i=0;

void setup() {

pinMode(LP, OUTPUT);
pinMode(ClkP, OUTPUT);
pinMode(R1P, OUTPUT);
pinMode(B1P, OUTPUT);
pinMode(G1P, OUTPUT);
pinMode(R2P, OUTPUT);
pinMode(B2P, OUTPUT);
pinMode(G2P, OUTPUT);
pinMode(AP,OUTPUT);
pinMode(BP,OUTPUT);
pinMode(CP,OUTPUT);
pinMode(OEP,OUTPUT);

digitalWrite(AP, LOW);
digitalWrite(BP, LOW);
digitalWrite(CP, LOW);
digitalWrite(LP, LOW);
digitalWrite(OEP, LOW);
row=0;
temp = 0x0000000000000001;


row1 [0]= 0x0000387F1CFE0000;                       
row1 [1]= 0x0000FFFFFFFF0000;                       
row1[2]=  0x00007CFF3EFF0000;                       
row1 [3]= 0x0000FFFFFFFF0000;                       
row1 [4]= 0x0000FE3F7FFC0000;                       
row1 [5]= 0x0000C00003000000;                       
row1 [6]= 0x0000FE1F7FF80000;                       
row1 [7]= 0x0000E00107800000;
             
                                                                           
}

void loop() {

for(row=0; row<4; row++){
   for (i = 0; i < 64; i++)  {
      digitalWrite(B1P, !!(row1[row] & (temp << (63-i))));
      digitalWrite(G1P, 0);
      digitalWrite(R1P,  0);
      digitalWrite(B2P,  !!(row1[row+4] & (temp << (63-i))));
      digitalWrite(G2P, 0);
      digitalWrite(R2P, 0);
      digitalWrite(ClkP, HIGH);
      digitalWrite(ClkP, LOW);
          }  
      
   digitalWrite(OEP, HIGH);
   digitalWrite(LP, HIGH);
   digitalWrite(AP, row & B10);//Cambiado respecto al código que no funcionaba
   digitalWrite(BP, row & 01);//Cambiado respecto al código que no funcionaba
   digitalWrite(OEP, LOW);
   digitalWrite(LP, LOW);  
  }

La cuetion es que en la parte de:
for (i = 0; i < 64; i++) {
digitalWrite(B1P, !!(row1[row] & (temp << (63-i))));

me gustaria unsar una veriable el doble de larga, Actualmente uso:
row1 [0]= 0x0000387F1CFE0000; pero me gustria probar con algo como
row1 [0]= 0xC00F0FFCF03F03F0CFFFFFFFFFFFFFFF; Aunque fuera haciendolo en dos variables tipo Row una al llegar a 63 y otra despue.

¿Alguien puede darme alguna idea?

2

Con que arduino trabajas para comenzar?

3

Buenos dias, uso arduino uno o mega 2560.

4

Bueno he investigado tu consulta y ya me parecía rara pero debía confirmarla. De tanto en tanto alguien pregunta cosas que para responderlas hay que informarse bien.

Esto es lo que encontré:

  1. uint132_t no existe de modo que no puedes usar o definir una variable del doble de uint64_t
  2. Según este mismo dato uint64_t se usa a nivel compilador pero yo he comprobado que en mi compilador funciona como variable definida pero no puede hacer lo mismo con uint132_t
  3. Debes usar vectores del tipo uint32_t o uint8_t para lograr lo que buscas. O sea llevarlo a expresiones manejables y disponibles.

Esta es mi sugerencia, nada nuevo pero.. tal vez te sirva

struct Uint132_32{
  uint32_t myData[4];
};

struct Uint132_64{
  uint64_t myData[2];
};

//uint64_t row1[16];
//uint64_t temp;

Uint132_32 row1 = {0x0000387F, 0x1CFE0000, 0x0000387F, 0x1CFE0000};
Uint132_64 row2 = {0x0000387F1CFE0000, 0x0000387F1CFE0000};
uint32_t  temp1 =  0x00000001;
uint64_t  temp2 =  0x0000000000000001;
void setup() {
  Serial.begin(9600);
  //uint32_t myData[4] = {0x12345678, 0x87654321, 0xABCDEF12, 0x12ABCDEF};
  Serial.println("Version uint32_t");
  for (int i=0; i<4; i++) {
       for (int j=0; j<32; j++)
            Serial.print(!!(row1.myData[i] & (temp1 << (31-j))));
  }
  Serial.println();
  Serial.println("Version uint64_t");
  for (int i=0; i<2; i++) {
      for (int j=0; j<64; j++)
           Serial.print(!!(row2.myData[i] & (temp2 << (63-j))));
  }
    Serial.println("\nPrueba finalizada");
}

void loop()
{
 
}
5

Buenas tardes, gracias por la contestación, ahora inverstigare como hacerlo en mi programa para aumentar el tamaño de la variable que envio usando el ejemplo que has puesto, muchas gracias nuevamente.

Lo unico que seria mucho mas facil si en el puerto serie salieran los datos como HEX pero lo he probado sin lograrlo.
Continuare trabajando sobre esta base. Gracias.

6

La versión uint32_t se pueden ver directamente con HEX, en la version uint64_t arroja error porque no esta soportado.
El limite es uint64 ara uso interno y en el manejo de bit que tu usas se tolera pero hasta ahi llega su tolerancia.

7

Buenas tardes, he probado a poner la definicion directamente en hexadecimal, pero no me parece.

¿Podiras indicarme el fallo? Si mal no entendi, comentastes que si se podria.

//uint32_t myData[4] = {0x12345678, 0x87654321, 0xABCDEF12, 0x12ABCDEF};
  Serial.println("Version uint32_t");
  for (int i=0; i<4; i++) {
       for (int j=0; j<32; j++)
            Serial.print(!!(row1.myData[i] & (temp1 << (31-j))), HEX);
  }

Este es el resultado que tengo por puerto serie, que correponde con lo que tiene que ser pero en binario.
Prueba finalizadaVersion uint32_t
00000000000000000011100001111111000111001111111000000000000000000000000000000000001110000111111100011100111111100000000000000000

Saludos,