Variable no cambia en programa de ventilador holografico

International Español Software
1

Hola buenas,
estoy creando un ventilador holográfico donde se proyecte la hora que yo decida. El error o lo que no entiendo es por qué no se intercambian las variables "X1, X2, X3 y X4" por los N0 y compañía cuando con el "for" lo indica.

¡¡Gracias!!

 int N1[]={0,0,1,0,0,0,0,1, 0,1,0,0,0,0,0,1, 1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1};
 int N0[]={1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1};
 int N2[]={1,0,0,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,1,1,1,0,0,0,1};
 int N3[]={1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,1,1,1,1,1,1,1};
 int N4[]={1,1,1,1,0,0,0,0, 0,0,0,1,0,0,0,0, 0,0,0,1,0,0,0,0, 0,0,0,1,0,0,0,0, 1,1,1,1,1,1,1,1};
 int N5[]={1,1,1,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,1,1,1,1};
 int N6[]={1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,1,1,1,1};
 int N7[]={1,0,0,0,0,0,0,0, 1,0,0,0,0,0,1,1, 1,0,0,0,1,1,0,0, 1,0,1,1,0,0,0,1, 1,1,0,0,0,0,0,0};
 int N8[]={0,1,1,0,1,1,1,0, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 0,1,1,0,1,1,1,0};
 int N9[]={1,1,1,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,1,1,1,1,1,1,1};
 int P2[]={0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,1,0,0,0,1,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
 int _[]= {0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
 int A[] = {0,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 0,1,1,1,1,1,1,1};
 int B[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 0,1,1,0,1,1,1,0};
 int C[] = {0,0,1,1,1,1,0,0, 0,1,0,0,0,0,1,0, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1};
 int D[] = {1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 0,1,0,0,0,0,1,0, 0,0,1,1,1,1,0,0};
 int E[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1};
 int F[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0};
 int G[] = {0,1,1,1,1,1,1,0, 1,0,0,0,0,0,0,1, 1,0,0,0,0,1,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,0,1,1,0};
 int H[] = {1,1,1,1,1,1,1,1, 0,0,0,1,0,0,0,0, 0,0,0,1,0,0,0,0, 0,0,0,1,0,0,0,0, 1,1,1,1,1,1,1,1};
 int I[] = {1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1};
 int J[] = {1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0};
 int K[] = {1,1,1,1,1,1,1,1, 0,0,0,1,1,0,0,0, 0,0,1,0,0,1,0,0, 0,1,0,0,0,0,1,0, 1,0,0,0,0,0,0,1};
 int L[] = {1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1};
 int M[] = {1,1,1,1,1,1,1,1, 0,1,0,0,0,0,0,0, 0,0,1,0,0,0,0,0, 0,1,0,0,0,0,0,0, 1,1,1,1,1,1,1,1};
 int N[] = {1,1,1,1,1,1,1,1, 0,1,0,0,0,0,0,0, 0,0,1,1,1,1,0,0, 0,0,0,0,0,0,1,0, 1,1,1,1,1,1,1,1};
 int O[] = {0,1,1,1,1,1,1,0, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 0,1,1,1,1,1,1,0};
 int P[] = {0,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 0,1,1,0,0,0,0,0};
 int Q[] = {0,1,1,1,1,1,0,0, 1,0,0,0,0,0,1,0, 1,0,0,0,0,1,1,1, 1,0,0,0,0,0,1,0, 0,1,1,1,1,1,0,0};
 int R[] = {0,1,1,1,1,1,1,1, 1,0,0,1,1,0,0,0, 1,0,0,1,0,1,0,0, 1,0,0,1,0,0,1,0, 0,1,1,0,0,0,0,1};
 int S[] = {0,1,1,0,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,0,1,1,1,0};
 int T[] = {1,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0};
 int U[] = {1,1,1,1,1,1,1,0, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,0};
 int V[] = {1,1,1,1,0,0,0,0, 0,0,0,0,1,1,1,0, 0,0,0,0,0,0,0,1, 0,0,0,0,1,1,1,0, 1,1,1,1,0,0,0,0};
 int W[] = {1,1,1,1,1,1,1,1, 0,0,0,0,0,0,1,0, 0,0,0,0,0,1,0,0, 0,0,0,0,0,0,1,0, 1,1,1,1,1,1,1,1};
 int X[] = {1,0,0,0,0,0,0,1, 0,1,1,0,0,1,1,0, 0,0,0,1,1,0,0,0, 0,1,1,0,0,1,1,0, 1,0,0,0,0,0,0,1};
 int Y[] = {1,1,0,0,0,0,0,0, 0,0,1,0,0,0,0,0, 0,0,0,1,1,1,1,1, 0,0,1,0,0,0,0,0, 1,1,0,0,0,0,0,0};
 int Z[] = {1,0,0,0,0,0,1,1, 1,0,0,0,0,1,0,1, 1,0,0,1,1,0,0,1, 1,0,1,0,0,0,0,1, 1,1,0,0,0,0,0,1};
 
 int* alpha[]= {A,B,C,D,E,F,G,H,I,J,K,L,M,N};//,T,U,V,W,X,Y,Z};
 int letterSpace;
 int delayTime;
 int X1;
 int X2;
 int X3;
 int X4;
 int hora;
 int minut;
 
 
 #define IR_pin 10
 
void setup() {

  Serial.begin(2000000);       
         pinMode(IR_pin,INPUT);
         for( int i = 2; i<10 ;i++ )
           {
            pinMode(i, OUTPUT);
           }
                
         letterSpace =4;        
         delayTime =1;
         
}

void printLetter(int letter[])
 {
           int y;
          // printing the first y row of the letter
           for (y=0; y<8; y++)
           {
           digitalWrite(y+2, letter[y]);
           }
           delay(delayTime);
          // printing the second y row of the letter
           for (y=0; y<8; y++)
           {
           digitalWrite(y+2, letter[y+8]);
           }
           delay(delayTime);
          // printing the third y row of the letter
           for (y=0; y<8; y++)
           {
           digitalWrite(y+2, letter[y+16]);
           }
           delay(delayTime);
           for(y = 0; y<8; y++) {
           digitalWrite(y+2, letter[y+24]);
           }
           delay(delayTime);
          for(y = 0; y<8; y++) {
           digitalWrite(y+2, letter[y+32]);
           }
           delay(delayTime);
           // printing the space between the letters
           for (y=0; y<8; y++)
           {
           digitalWrite(y+2, 0);
           }
           delay(letterSpace);
 }

 int h=20;
 int m=32;
 long t=((h*60+m)*60000/100); 

void loop() {

  for (long double i = t; i <= 864000; i++)
{
  int hora=(i/(36000));
  double horas=(i/36000);
  int minut= ((horas-hora)*60);
  if (hora<10)
  {
  int (X1=N0);}
  if (9<hora<20)
  {
  int (X1=N1);}
  if (19<hora<24)
  {
  int (X1=N2);}

  if (hora%10==0)
  {
  int (X2=N0);}
  if (hora%10==1)
  {
  int (X2=N1);}
  if (hora%10==2)
  {
  int (X2=N2);}
  if (hora%10==3)
  {
  int (X2=N3);}
  if (hora%10==4)
  {
  int (X2=N4);}
  if (hora%10==5)
  {
  int (X2=N5);}
  if (hora%10==6)
  {
  long (X2=N6);}
  if (hora%10==7)
  {
  long (X2=N7);}
  if (hora%10==8)
  {
  int (X2=N8);}
  if (hora%10==9)
  {
  int (X2=N9);}

  if (minut<10)
  {
  int (X3=N0);}
  if (9<minut<20)
  {
  int (X3=N1);}
  if (19<minut<30)
  {
  int (X3=N2);}
  if (29<minut<40)
  {
  int (X3=N3);}
  if (39<minut<50)
  {
  int (X3=N4);}
  if (49<minut)
  {
  int (X3=N5);}

  if (minut%10==0)
  {
  int (X4=N0);}
  if (minut%10==1)
  {
  int (X4=N1);}
  if (minut%10==2)
  {
  int (X4=N2);}
  if (minut%10==3)
  {
  int (X4=N3);}
  if (minut%10==4)
  {
  int (X4=N4);}
  if (minut%10==5)
  {
  int (X4=N5);}
  if (minut%10==6)
  {
  int (X4=N6);}
  if (minut%10==7)
  {
  int (X4=N7);}
  if (minut%10==8)
  {
  int (X4=N8);}
  if (minut%10==9)
  {
  int (X4=N9);}
  if(digitalRead(IR_pin)==LOW){
  printLetter (X1);  
  printLetter (X2);     
  printLetter (P2);    
  printLetter (X3);    
  printLetter (X4);
  delay(55);

  }
}
}
2

Que se supone es esto para ti?

 if (hora < 10) {
         int(X1 = N0); // <=======  No es posible en Arduino o en C pasar un vector a una variable de este modo.
      }

N0 y solo por citar el primer error es un array de enteros.
No puedes simplemente igualar asi!

3

Hola gracias.

Para mi eso significa que cuando la hora es menor de 10 la variable cambie a N0, que es para que se cree un 0 en el ventilador y sea la pimera cifra de la hora.

Entonces como podria hacer para que se muestre el array?

4

Tampoco puedes hacer esto

if (9 < hora < 20) {

Debes escribirlo

if ( (hora > 9) && (hora < 20)) {

Para vos significa eso pero no para el compilador.
Hay que respetar la sintaxis del lenguaje que estás usando, no puedes programar como te parezca y pretender que el compilador lo entienda.

5

Gracias por eso.

Ya entiendo que no puede ser asi, entonces como seria? Hay alguna manera de igualar variables a arrays?

6

Tienes muchos errores en tu código. Además de los ya señalados...

Esta expresión se considerará incorrecta en arduino de 8 bits, porque el lado derecho se calcula como un tipo int y habrá un desbordamiento en él:

hora & horas siempre serán iguales:

Aquí cada variable X1 es una nueva variable, no relacionada de ninguna manera con la que usa en printLetter (X1); al final del programa

Lo mismo se aplica a las variables X2, X3 y X4. Por eso sus valores no intercambian,

7

Ok, gracias por esas correcciones.

Mirando en el monitor serie, me sale que horas tiene los decimales que le faltan a hora, y, por lo tanto, minutos funciona bien.

Lo que no entiendo es como solucionar el problema de las variables, para sustituir por arrays cuando ese sea el valor de la hora o minuto.

8

pero ella siempre tiene decimales .00 ?
Como lo está escrito, la división pasa en números enteros.

Puede verificar, por ejemplo, sustituir i =18000, resultará 0.00 y no 0.50.

Para que los cálculos se realicen correctamente, debe escribir así
double horas=(i/36000.0);

9

Cada vez que agrega un tipo a una variable, como esta

int X1 = 3;

está declarando (creando) una nueva variable.
Si se escribe sin un tipo

X1 = 3;

esta es la asignación de un nuevo valor a una variable declarada en algún lugar anterior.

Por lo tanto, la solución a su problema es simple: debe eliminar el tipo int antes de X1 en todas partes, excepto al comienzo del programa. La variable debe declararse exactamente una vez.
Lo mismo con las variables X2 X3 X4.

10

Hola,

"Horas" funciona bien, me pone los decimales que necesito y hace funcionar "minutos" bien.

11

Ok, ya intentare probarlo. Pero con el error que me comentaron de no poder igualar una variable a array, no se si funcionara.

12

¿Cuál es el problema con la array?
En su primera publicación, no mencionó la array en absoluto.

13

Me dijeron que no se podia igualar una array con una variable, pero lo intentare.

14

No hay forma de que pueda hacer esto, una variable no se puede igualar a una array

¿Por qué quieres hacer esto?

15

Puedes hacer así, en lugar de

int X1;

la defines como puntero a int

int *X1;

Luego

X1 = N0;

Hace lo que pretendes, el problema es que creo que

 printLetter (X1);

no te va a funcionar a menos que espere una array como parametro.

16

Es para hacer un reloj, y cuando es "printLetter (N0)" por ejemplo, con la array de "N0" sale un 0 en el ventilador. Por eso intento que pueda ir cambiando segun la hora.

17

Gracias, cuando pueda lo pruebo. En teoria si que espera una array.

18

Еs mejor escribir asi:

void printLetter(int* letter)

19

A ver si esto funciona, he hecho cambios importanes a como manejas la información de usar una matriz de enteros a usar bits que es lo que solo necesitas, ahorrando mucha RAM.

int N0[] = { 0B11111111, 0B10000001, 0B10000001, 0B10000001, 0B11111111 };
int N1[] = { 0B00100001, 0B01000001, 0B11111111, 0B00000001, 0B00000001 };
int N2[] = { 0B10011111, 0B10010001, 0B10010001, 0B10010001, 0B11110001 };
int N3[] = { 0B10010001, 0B10010001, 0B10010001, 0B10010001, 0B11111111 };
int N4[] = { 0B11110000, 0B00010000, 0B00010000, 0B00010000, 0B11111111 };
int N5[] = { 0B11110001, 0B10010001, 0B10010001, 0B10010001, 0B10011111 };
int N6[] = { 0B11111111, 0B10010001, 0B10010001, 0B10010001, 0B10011111 };
int N7[] = { 0B10000000, 0B10000011, 0B10001100, 0B10110001, 0B11000000 };
int N8[] = { 0B01101110, 0B10010001, 0B10010001, 0B10010001, 0B01101110 };
int N9[] = { 0B11110000, 0B10010000, 0B10010000, 0B10010000, 0B11111111 };
int P2[] = { 0B00000000, 0B00000000, 0B01000100, 0B00000000, 0B00000000 };
int  _[] = { 0B00000000, 0B00000000, 0B00000000, 0B00000000, 0B00000000 };
int  A[] = { 0B01111111, 0B10010000, 0B10010000, 0B10010000, 0B01111111 };
int  B[] = { 0B11111111, 0B10010001, 0B10010001, 0B10010001, 0B01101110 };
int  C[] = { 0B00111100, 0B01000010, 0B10000001, 0B10000001, 0B10000001 };
int  D[] = { 0B11111111, 0B10000001, 0B10000001, 0B01000010, 0B00111100 };
int  E[] = { 0B11111111, 0B10010001, 0B10010001, 0B10010001, 0B10010001 };
int  F[] = { 0B11111111, 0B10010000, 0B10010000, 0B10010000, 0B10010000 };
int  G[] = { 0B01111110, 0B10000001, 0B10000101, 0B10001001, 0B10000110 };
int  H[] = { 0B11111111, 0B00010000, 0B00010000, 0B00010000, 0B11111111 };
int  I[] = { 0B10000001, 0B10000001, 0B11111111, 0B10000001, 0B10000001 };
int  J[] = { 0B10000001, 0B10000001, 0B11111111, 0B10000000, 0B10000000 };
int  K[] = { 0B11111111, 0B00011000, 0B00100100, 0B01000010, 0B10000001 };
int  L[] = { 0B11111111, 0B00000001, 0B00000001, 0B00000001, 0B00000001 };
int  M[] = { 0B11111111, 0B01000000, 0B00100000, 0B01000000, 0B11111111 };
int  N[] = { 0B11111111, 0B01000000, 0B00111100, 0B00000010, 0B11111111 };
int  O[] = { 0B01111110, 0B10000001, 0B10000001, 0B10000001, 0B01111110 };
int  P[] = { 0B01111111, 0B10010000, 0B10010000, 0B10010000, 0B01100000 };
int  Q[] = { 0B01111100, 0B10000010, 0B10000111, 0B10000010, 0B01111100 };
int  R[] = { 0B01111111, 0B10011000, 0B10010100, 0B10010010, 0B01100001 };
int  S[] = { 0B01100001, 0B10010001, 0B10010001, 0B10010001, 0B10001110 };
int  T[] = { 0B10000000, 0B10000000, 0B11111111, 0B10000000, 0B10000000 };
int  U[] = { 0B11111110, 0B00000001, 0B00000001, 0B00000001, 0B11111110 };
int  V[] = { 0B11110000, 0B00001110, 0B00000001, 0B00001110, 0B11110000 };
int  W[] = { 0B11111111, 0B00000010, 0B00000100, 0B00000010, 0B11111111 };
int  X[] = { 0B10000001, 0B01100110, 0B00011000, 0B01100110, 0B10000001 };
int  Y[] = { 0B11000000, 0B00100000, 0B00011111, 0B00100000, 0B11000000 };
int  Z[] = { 0B10000011, 0B10000101, 0B10011001, 0B10100001, 0B11000001 };


int* alpha[] = { A,B,C,D,E,F,G,H,I,J,K,L,M,N };//,T,U,V,W,X,Y,Z};
int letterSpace;
int delayTime;
int* X1;
int* X2;
int* X3;
int* X4;
int hora;
int minut;

#define IR_pin 10

void setup() {

  Serial.begin(115200);
  pinMode(IR_pin, INPUT);
  for (int i = 2; i < 10;i++) {
    pinMode(i, OUTPUT);
  }
  letterSpace = 4;
  delayTime = 1;
}

void printLetter(int letter[]) {
  int y;
  int val;
  delay(delayTime);
  for (int j=0; j<5; j++){
    val = letter[j];
    for (int i = 0; i < 8; i++) {
      bool b = val & 0x80;
      //Serial.print(b);
      digitalWrite(y + 2, b);
      val = val << 1;
    }
    
    Serial.println();
  }  
  delay(delayTime);
  for (y = 0; y < 8; y++) {
    digitalWrite(y + 2, 0);
  }
}

int h = 20;
int m = 32;
long t = h * 3600 + m*60;

void loop() {
  for (long double i = t; i <= 86400; i++) {
  long hora = i / 3600;
  long minut = (t- (hora *3600))/60;
    //hora = 1;
    if (hora < 10) {
      X1 = N0;
    }
    if (9 < hora && hora < 20) {
      X1 = N1;
    }
    if (19 < hora && hora < 24) {
      X1 = N2;
    }

    if (hora % 10 == 0) {
      X2 = N0;
    }
    if (hora % 10 == 1) {
      X2 = N1;
    }
    if (hora % 10 == 2) {
      X2 = N2;
    }
    if (hora % 10 == 3) {
      X2 = N3;
    }
    if (hora % 10 == 4) {
      X2 = N4;
    }
    if (hora % 10 == 5) {
      X2 = N5;
    }
    if (hora % 10 == 6) {
      X2 = N6;
    }
    if (hora % 10 == 7) {
      X2 = N7;
    }
    if (hora % 10 == 8) {
      X2 = N8;
    }
    if (hora % 10 == 9) {
      X2 = N9;
    }

    if (minut < 10) {
      X3 = N0;
    }
    if (9 < minut && minut < 20) {
      X3 = N1;
    }
    if (19 < minut && minut < 30) {
      X3 = N2;
    }
    if (29 < minut && minut < 40) {
      X3 = N3;
    }
    if (39 < minut && minut < 50) {
      X3 = N4;
    }
    if (49 < minut) {
      X3 = N5;
    }

    if (minut % 10 == 0) {
      X4 = N0;
    }
    if (minut % 10 == 1) {
      X4 = N1;
    }
    if (minut % 10 == 2) {
      X4 = N2;
    }
    if (minut % 10 == 3) {
      X4 = N3;
    }
    if (minut % 10 == 4) {
      X4 = N4;
    }
    if (minut % 10 == 5) {
      X4 = N5;
    }
    if (minut % 10 == 6) {
      X4 = N6;
    }
    if (minut % 10 == 7) {
      X4 = N7;
    }
    if (minut % 10 == 8) {
      X4 = N8;
    }
    if (minut % 10 == 9) {
      X4 = N9;
    }
    if (digitalRead(IR_pin) == LOW) {
      printLetter(X1);
      printLetter(X2);
      printLetter(P2);
      printLetter(X3);
      printLetter(X4);
      delay(55);

    }
  }
}

El programa compila, y muestra lo mismo que muestra el tuyo, asi que no deberias tener problemas.

Vuelve a poner la velocidad en BAUDIOS que tu tienes.

EDITO 1: Verificando errores con la hora y minutos ademas del cálculo erróneo de t.
EDITO 2: otro error en los calculos.

  long hora = i / 3600;
  long minut = (t- (hora *3600))/60;

Este es el cálculo correcto.
t%60 da los segundos si se desea.
Observar que yo no uso 864000 sino 86400 = 24*3600
No entiendo para que la décima a menos que sea deseo del OP.

1 Like
20

Si, si. No vi que la función estaba definida, la pasé de largo.