[SOLUCIONADO] Arrays para generar Señales

JoseGD · January 11, 2023, 6:33pm

Alguien me puede por favor explicar como de estos arrays sale estas señales PWM.

O como sacar esos arrays teniendo una determinada señal.

Busque información por internet y encontré algunas calculadoras pero no generan estos arrays.

Ejemplos:

Esta Señal sale con este array:

const unsigned char Senal[]= {
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,0,0,2,2, 
      3,2,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,0,0,0,0  
    };

Esta otra con el siguiente array:

const unsigned char Senal[]= {
      3,3,3,3,3,3,3,3,3,2,
      2,2,2,2,0,0,0,0,0,0,
      0,0,0,1,1,1,1,1,1,1,
      3,3,3,2,2,2,2,2,0,0,
      0,0,0,0,0,0,0,1,1,1,
      1,1,1,1,1,1,1,0,0,0,
      0,0,0,0,0,0,0,0,2,2,
      2,3,3,3,3,3,1,1,1,1,
      1,0,0,0,0,0,0,0,0,0,
      0,0,0,0,0,1,1,1,1,1,
      1,1,3,3,3,2,2,2,2,2,
      0,0,0,0,0,0,0,0,0,1,
      1,1,1,1,1,1,1,1,1,0,
      0,0,0,0,0,0,0,0,0,0,
      0,2,2,3  
    };```
Y esta ultima con el siguiente:

![3|690x379](upload://8OTCp5V7I25YyXAs48yL6pQvlvD.jpeg)

const unsigned char Senal[]= {
1,1,1,1,1,1,1,1,1,1,
1,0,1,1,1,1,1,1,1,1,
1,1,1,0,1,0,1,1,1,1,
1,1,1,1,1,0,1,1,1,1,
1,1,1,1,1,1,1,0,1,1,
1,1,1,1,1,1,1,1,1,1,
1,0,1,1,1,1,1,1,1,1,
1,0
};

J-M-L · January 11, 2023, 9:19pm

lo que realmente ayudaría es el código real usando la matriz...

victorjam · January 12, 2023, 7:20am

La última foto no cargo bien y no se ve.

La verdad es que muy dificil a partir de una foto descubrir como es el array: no sabemos si en la captura esta toda la señal, la primera foto de la segunda difieren mucho en cuanto a la forma de onda, como si la forma de generarse hubiese sido otra...

Si puedes aportar algo mas de información podriamos ver analizar las señales mejor.

JoseGD · January 12, 2023, 8:22am

Gracias victorjam esta tarde me centro en una sola señal y hago diferentes caputas con el osciloscopio y lo vemos, pondre tambien el codigo entero (que no es mio).
Gracias

victorjam · January 12, 2023, 11:07am

Seguro que con el código tendremos mejor idea de lo que hace.

JoseGD · January 12, 2023, 6:46pm

Pues aquí esta el código que como dije no es mío, lo encontré en un foro y me gustaría saber como funciona ese array.

const byte Pin_Pontfreq  = A2;                       
const byte Pin_Sal1     =  3;                         
const byte Pin_Sal2     =  5;                         

int freq;                                              
int freqanterior;

const unsigned char Senal[]= {
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,0,0,2,2, 
      3,2,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,0,0,0,0  
    };
void setup() {                                        
  Serial.begin(9600);                                 
  pinMode (Pin_Sal1, OUTPUT);                         
  pinMode (Pin_Sal2, OUTPUT);                         
  noInterrupts();                                     
  TCCR1A = 0;                                         
  TCCR1B = 0;                                         
  TCNT1  = 0;                                         
  OCR1A  = 1000;                                      
  TCCR1B |= (1 << WGM12);                             
  TCCR1B |= (1 << CS12);                              
  TIMSK1 |= (1 << OCIE1A);                            
  interrupts();                                       
}                                                     
void loop() {                                         
int Datos = sizeof(Senal)/sizeof(Senal[0]);           
    for (int i = 0; i <= Datos; i++) {                
      switch (Senal[i]){                              
        case 0:                                       
          PORTD = 0B00000000;                         
          delayMicroseconds(freq);                     
          break;                                      
        case 1:                                      
          PORTD = 0B0001000;                          
          delayMicroseconds(freq);                     
          break;                                      
         case 2:                                      
          PORTD = 0B000000100;                        
          delayMicroseconds(freq);                     
          break;                                      
        case 3:                                       
          PORTD = 0B000001100;                        
          delayMicroseconds(freq);                     
          break;                                      
      }                                               
    }                                                 
}                                                     

ISR(TIMER1_COMPA_vect) {
  freq = analogRead(Pin_Pontfreq);                      
  freq = map(freq, 1023, 0, 150, 650);                  
}

Estas fotos la saque con el otro osciloscopio que tengo que es algo mejor y se aprecia mejor.
En las dos ultimas fotos se aprecia donde faltan dos y tres pulsos, que puede ser esta secuencia del array, pero no lo se.

                0,0,0,2,2, 
      3,2,1,0,1,0,1,0,1,0,

victorjam · January 12, 2023, 8:14pm

No soy muy experto en registros pero he analizado un poco por el código y he hecho un primer analisis, dejo el código comentado explicando lo que visto.

Cabe mencionar fuera del código que la señal que tu muestras en el osciloscpio es en realidad la de un pin y en el programa se juega con dos, alguna utilidad debe tener pero lo desconozco.

const byte Pin_Pontfreq  = A2;                       
const byte Pin_Sal1     =  3;    
// El pin 5 en realidad no se usa dentro del programa, cuando asigna una valor
// al puerto D (PORTD) trabaja sobre el pin 2 y 3. Por lo tango creo que este 
// valor está mal.                     
const byte Pin_Sal2     =  5;    

int freq;                                              
int freqanterior;

// Cada valor del array representa dos pines:
// 0: se apagan dos y tres.
// 1: se enciende 3 y apaga 2.
// 2: se apaga 3 y enciende 2.
// 3: ambos se encienden.
const unsigned char Senal[]= {
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,0,0,2,2, 
      3,2,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0,  
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,1,0,1,0, 
      1,0,1,0,1,0,0,0,0,0  
    };
void setup() {                                        
  Serial.begin(9600);                                 
  pinMode (Pin_Sal1, OUTPUT);                         
  pinMode (Pin_Sal2, OUTPUT); /* Creo que aquí hay un problema. */
  // Aquí configura el timer1.                        
  noInterrupts();            
  // No estoy muy ducho con los registros del atMega, pero creo que basicamente
  // pone el timer 1 en un modo de operación y le dice que cuando cuente hasta
  // algo se ejecute la interrupción que viene al final del código.
  // Algun experto en timers/registros que responda.
  TCCR1A = 0;                                         
  TCCR1B = 0;                                         
  TCNT1  = 0;                                         
  OCR1A  = 1000;                                      
  TCCR1B |= (1 << WGM12);                             
  TCCR1B |= (1 << CS12);                              
  TIMSK1 |= (1 << OCIE1A);                            
  interrupts();                                       
}                                                     
void loop() {                                         
int Datos = sizeof(Senal)/sizeof(Senal[0]);           
    for (int i = 0; i <= Datos; i++) {                
      switch (Senal[i]){   
        // Como nota hay que indicar que parece que los valores han funcionado de
        // casualidad al usar las macros. La macro de binarios se definen como 
        // BXXXXXXXXX, es decir, una B y ocho 0's o 1's indicando el valor en 
        // binario, aquí se ven cosas raras...
        case 0:                                       
          PORTD = 0B00000000; // Valor 0: pone ambos pines a LOW.                        
          delayMicroseconds(freq);                     
          break;                                      
        case 1:                                      
          PORTD = 0B0001000; // Valor 8: pone el pin 3 a HIGH y el pin 2 a LOW.
          delayMicroseconds(freq);                     
          break;                                      
         case 2:                                      
          PORTD = 0B000000100; // Valor 4: pone el pin 3 a LOW y el pin 2 a HIGH.
          delayMicroseconds(freq);                     
          break;                                      
        case 3:                                       
          PORTD = 0B000001100; // Valor 12: pone el pin 3 y 2 a HIGH.
          delayMicroseconds(freq);                     
          break;                                      
      }                                               
    }                                                 
}                                                     
// Esta función modifica el vector de interrupción del timer 1. Basicamente se lee el valor
// del ADC A2 y lo "mapea" entre 154 y 650 siendo usado despues como retrasos entre cada 
// valor del array de la señal.
// Como nota personal no me gusta nada usar el ADC dentro de una interrupción, que genera su
// propia interrupción.
ISR(TIMER1_COMPA_vect) {
  freq = analogRead(Pin_Pontfreq);                      
  freq = map(freq, 1023, 0, 150, 650);                  
}

Algún experto en la forma en la que se usa el timer1 en este caso puede ser una ayuda muy importante.

Surbyte · January 12, 2023, 8:17pm

Observa el array tiene 0, 1, 2 y 3. Todos estos números son explorados por el loop.
Cuando encuentra un 0, el switch case lo lleva al caso 0.

PORTD = 0B00000000;                         
delayMicroseconds(freq);

o sea no muestra nada o si, un 0 y lo hace durante freq microsegundos.
Lo mismo hace con 1, 2, y 3
Es muy simple entenderlo.
Todo es una gran secuencia.
Case 1 por ejemplo pone en 1 el bit 3 del puerto D
Case 2 pone en 1 el bit 2 del puerto D
Case 3 pone en 1 los bits 2 y 3 del puerto D
todos durante freq microsegundos
y claramente olvidé que el timer tmb juega haciendo una variacion de la freq PWM entre

freq = map(freq, 1023, 0, 150, 650);

pero para el valor de un potenciómetro ubicado en el pin A2.
Solo convierte el valor entre 0 y 1023 a 150 y 650 useg.
Asi que tu variación depende de como ajustes el potenciómetro.

JoseGD · January 14, 2023, 10:32am

Gracias a ambos por contestar y hacerme comprender este tema.

Entonces el autor de este código, realizo dos señales en el mismo array, en el pin 2 tengo esta señal:

Que lo mismo no es correcta por que no esta bien declarado el pin de salida, debería de ser 2 y no 5, pero bueno eso es lo de menos para comprender el array.

const byte Pin_Sal2     =  5;

En conclusión, si no estoy en lo cierto por favor corregirme, con ese array y utilizado los puerto ( cosa que voy a empezar a estudiar) se puede hacer dos formas de ondas sincronizadas y variables en frecuencia con el potenciómetro.

Incluso llegando un poco mas lejos que es lo que yo quería aprender, puedo capturar señales sincronizadas con el osciloscopio y según su forma crear un array y reproducirlas con arduino.
Estoy en lo cierto o me estoy equivocando?

Gracias

Surbyte · January 16, 2023, 3:49am

El uso de PORD te permite manejar 8 bits simultáneamente.
El potenciómetro entrega valores entre 0 yu 1023 y eso lo traduce en un delay en microsegundos con lo que modifia la presentación de esos patrones.
Capturar señales requiere de otro elemento que es el INPUT CAPTURE del Timer1. Te recomiendo que lo estudies.
Es mas busca INPUT CAPTURE de Nick Gammon.

JoseGD · January 16, 2023, 9:45pm

Gracias Surbyte
Estudiaré ambas cosas

Surbyte · January 17, 2023, 1:03pm

system · July 16, 2023, 1:03pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Problema con arrays Software	5	913	May 7, 2021
Cargar Array que están en una SD Software	2	446	May 7, 2021
Problema con array Software	3	1800	May 7, 2021
Re: array Software	7	2671	May 7, 2021
[SOLUCIONADO]Dudas con variables, constantes y PROGMEM Software	3	1064	May 7, 2021

[SOLUCIONADO] Arrays para generar Señales

Related topics