Lecturas Anteriores en t=millis()

[barbol_music]

Hola

tengo una duda, necesito hacer una formula, algo compleja, y necesito hacer dos lecturas anteriores de ella.
La función debería variar con el tiempo (t=millis();) necesito dos lecturas una L_ant_1 y L_ant_2 que aniden momentáneamente dos lecturas en los últimos dos milisegundos.
Para ello, se debería también crear como una correlación entre los datos.

en Void Loop:

t=millis();

-para t=0, el valor de valCC=d_ASY; donde: valCC es la variable a anidar. d_ASY es un valor de iniciación (desfase inicial, puede ser 0 hasta 100) * aqui de debe anidar el primer valor de valCC.
-para t=1, aca el valor toma un valor dado m1 y lo suma al la lectura anterior o sea: valCC=m1+valCC_ant;
siendo valCC_ant la primera lectura en t=0.

-para t>1...... aca viene el caos:

 if(t>1){
     //valCC =AMP+ELEGIR(1+(O   (Y( y(n-2)>y(n-1) ; (y(n-1)-m1>Amin*(1+TOL%))  ;  (y(n-1)+m1> A*(1+TOL%))  ;  m1 ;-m2)
                                                                                                                                                          
        if ( ((L_ant_2>L_ant_1)&&((L_ant_1-m1)>(-AMP)*(1+tol%))) || ((L_ant_1 + m1)> (AMP*(1+tol%))) ){
          // Si es Verdadero   "1" m1
          valCC = L_ant_1 + m1;
          }
          else { // Si es Falso "0" -m2
          valCC = L_ant_1 -m2;
          }

para t=2 especificamente, ya esta el valor de t=0 y t=1 disponibles... (como? aun no lo sé, pero estarían)

pero cuando t=3... ya la lectura anterior 1, L_ant_1 no es de t=0, ni la lectura anterior 2, es la de t=1....
si no que deberían variar, o sea, la L_ant_1 correspondería a t=1 y la L_ant_2 a t=2.... y así cíclicamente hasta el infinito.

Lo principal, es que la formula general de valCC = lectura anterior +- m. Esto no depende de t.
Necesito hacer que sea cíclica, y dependa de t.

(aparece en mi mente otro dilema, que tiene que ver con int y float... si valCC esta en int... y sus valores varían mas lento que t... se rompería la formula... pero eso es otro, tema, primero a lograr que esto se mueva)

Si tienen dudas al respecto, aclarare cualquier falta de información.
Saludos, espero poder encaminar esto.

[anon90500195]

Como solo has puesto un fragmento de código lo cual está mal porque empezamos con las suposiciones y preguntas, doy por hecho que has definido

unsigned long t, L_ant_1, L_ant_2;

como globales.

Si interpreto bien, la gran pregunta es ¿Cuándo y cómo asignar los valores de L_ant_1 y L_ant_2?
Pues con solo ese fragmento de código es casi imposible ayudarte.

Saludos

[barbol_music]

No, no había declarado aun las variables.

Estoy en confección del código, por lo tanto, enviar el código completo, provocaría mil preguntas mas, ya que este es una parte del código, tengo puestos, potenciómetros, switches de palancas, hasta un encoder, y varias formas de ondas mas, que ya son funcionales. Pero si es necesario, lo posteo de todas formas.

Y la pregunta es claro, como y donde asignar o anidar esas variables, el donde en el código, supongo que es sobre el código que las esta utilizando, pero como esto va en un loop, y van cambiando...
En los potenciómetros tengo una lectura anterior que voy actualizando al final de las instrucciones, para poder variarla del valor a cambiar. o sea el código de impresión serial solo se ejecuta cuando existe una igualdad diferencia entre los valores actuales y anteriores.... en fin que me lio...

En este caso, cómo guardo los valores de valCC actuales, anterior1 y anterior2
y donde se guardan?
El cuando, es cada t(ms). Pero que tiene que ir actualizando en cada milisegundo las variables que cambian...

Envío el código para que puedan echarle un ojo.
(presionan ctl+mayus+L para abrir el plotter para ver las ondas por defecto viene Sinusoidal, pero se puede cambiar a Triangular y Cuadrada)

LFO_PROJECT_ASY.ino (21.7 KB)

[Surbyte]

Pero tu fórmula qué describe, un filtro digital? Puedes orientarnos un poco?
Mi consejo es que no uses millis() y en lugar uses micros() para tener mejor control sobre la operación. ya que millis() tiene resolución de 1 mseg y micros() de useg.

que tal una máquina de estados con case 0 para tu tiempo 0, case 1 para tu tiempo 1 o ahora 1000 segun mi sugerencia de micros() y por ultimo default para todo lo que es mayor a 1000?

Puedes llevar un contadorEstados = micros() /1000;
Cuando micros() sea 1000 useg = 1 mseg eso vale 1, y en adelante cada 1000 tendras un cambio.

algo asi

contadorEstados = micros() / 1000; // solo cambia cada 1000 useg

switch(contadorEstados) {
   case 0: valCC=d_ASY;  // valCC es la variable a anidar.
               break;
  case 1: // t = 1000 useg
              valCC = L_ant_1 + m1;
              break;
  default: // t > 1000 useg
              //valCC =AMP+ELEGIR(1+(O   (Y( y(n-2)>y(n-1) ; (y(n-1)-m1>Amin*(1+TOL%))  ;  (y(n-1)+m1> A*(1+TOL%))  ;  m1 ;-m2)
                                                                                                                                                          
            if ( ((L_ant_2>L_ant_1)&&((L_ant_1-m1)>(-AMP)*(1+tol%))) || ((L_ant_1 + m1)> (AMP*(1+tol%))) ){
                // Si es Verdadero   "1" m1
                valCC = L_ant_1 + m1;
            }
            else { // Si es Falso "0" -m2
                 valCC = L_ant_1 -m2;
           }
           break;
}

No he visto tu código de 21k pero intenté retratar lo que has expuesto en tus primeros post. Toma la idea. puede que haya cosas mas en como asignar las variables.

contadorEstados es un valor entero inicializado a 0.

[barbol_music]

Claro, eso de la maquina de estados esta muy bien, pero como asigno el valor resultante de cada estado, cierto, a los valores anteriores de la misma resultante. Pense que siempre son dos valores previos en cada caso.

Case 0 ---> t=0ms ---> valor valCC=d_ASY ---> L_ant_2 = valCC ---> (para t=2ms...)
---> L_ant_1 = valCC ---> (para t=1ms...)
Case 1 ---> t=1ms ---> valor valCC=L_ant_1 + m1 ---> L_ant_2 = valCC ---> (para t=3ms...)

---> L_ant_1 = valCC ---> (para t=2ms...)

cuando t=2ms usa L_ant_1 y L_ant_2, de 2ms o sea 0ms y 1ms...
cuando t=3ms usa L_ant_1 y L_ant_2, de 3ms o sea 1ms y 2ms...
y desde aquí se empieza a repetir.
cuando t=n ---> L_ant_1 = valCC(n-1) y L_ant_2 = valCC(n-2)

Esto ultimo, no se como codificarlo.

Como/donde guardo/anido/almaceno momentáneamente valores relativos,
de una función que no depende del tiempo,
(directamente, ya que indirectamente, esta asociada a la pendiente,
que depende del periodo T que se define por los
BPM que el usuario introduce para modular la onda al tiempo que se desee.)
para usarla en la misma formula cuando el tiempo ya haya avanzado y por consiguiente,
cambiado dichos valores...

Y si, es un cacharro con varios potes, que sirve para modular un valor MIDI CC#
de una pedalera multi-efectos. Un Oscilador de valores CC#.
Con esto pretendo realizar mis propios efectos de Tremolo, whammys automáticos,
autoWahs con ondas distintas y automatizar cualquier parámetro. Le colocare un
foot switch para poder prender y apagar el oscilador. y en su interfaz,
tiene potenciómetros, selectores, y botones, que cambian parámetros de la onda, como BPM, desfase,
CCmin, CCmax, las figuras rítmicas, la velocidad al doble o a la mitad... esta bien interesante.

Con esta nueva formula que intento agregar... quiero poder transformar las ondas que
son simétricas, en asimétricas ...

podría pasar de una onda triangular, a una onda SAW o para el otro lado SAW invertida.

Y ese es el proyecto. un Oscilador con varios tipos de ondas. (hasta ahora, están la
cuadrada, sinusoidal y triangular modeladas en el código) con eso para varios, ya bastaría ... pero
me obsesioné con las ondas asimétricas, que no están muy fáciles de modelar, (maldito Fourier)

En fin. Eso, si alguien domina este tema, quizás pueda echarme una manito con este codigo.

[Surbyte]

Ahora te empiezo a entender
Entonces tienes algo como un filtro IIR (digital) donde se modifican los valores por los instantes Xn-1 y Xn-2 o sea tu L_ant_1 y L_ant_2
Bien. Hasta ahi bien, o al menos yo te comprendo.
La maquina de estados no sirve como lo habia pensado entonces porque no es 0, 1, y lo demas sino que va corriendose de ese modo, considerando los ultimos dos casos temporales.

Lo que entonces te recomiendo es que lleves un vector con los valores anteriores L_ant1 y L_ant2 y el valor actual si quieres
Entonces supongamos

vector[2] = L_ant2
vector[1] = L_ant1
vector[0] = no se con que lo cargas

En cada iteraccion mueves los valores segun esperas que ocurra.

Todavia no le veo completo.

[barbol_music]

No se muy bien como utilizar los vectores,
Comprendo que dentro de los [ ] esta una lista de valores, pero no se como asociarlos

vector[2] = L_ant2
vector[1] = L_ant1
vector[0] = A(0) o d_ASY (que es el desfase, si es 0 parte de 0 si es 50, parte de 50 y asi funciona)
con d_ASY el usuario define donde comienza la onda.

pero como le hago esto hasta el infinito? con algún for, while... loop...