Recorrimiento de un dato dentro de un array

Hola gracias por tomarte el tiempo de leer esto.
Quiero hacer un recorrimiento de un dato dentro de un array el cual es 1x2, mediante un sensor capacitivo, quiero guardar la señal de entrada del sensor en la primer posición del array {LECTURA} y después recorrer ese dato a la derecha la cual será la segunda posición la cual se llamara "anterior" {LECTURA, anterior} para ello utilizo el siguiente código (la verdad no se si es la forma correcta de realizarlo), después de eso quiero comparar mis dos datos del array para después aumentar un contado, pero nunca entra en la condicion if quese muestra, la cual tiene que comparar el dato anterior con el actual del sensor (si el dato anterior es y 0 y el actual 1 aumentara el contador un 1, aunque el estado del anteriro y actual se mantenga en 1 solo debe agregarse un 1 al contador), se muestra en el código. ¿saben por que? o ¿esta bien el código? ¿el corrimiento del array esta bien realizado?

#include <LiquidCrystal.h>
const int Sensor1 = A0;
int contar = 0, anterior = 0;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(Sensor1, INPUT);
}

void loop() {
  // put in code here, to run repeatedly:
  int LECTURA = digitalRead(Sensor1);
  int ArregloDatos[2] = {LECTURA, anterior};
  ArregloDatos[0] = LECTURA;
  ArregloDatos[1] = anterior;
  int aux = ArregloDatos[0];
  delay(20);
  int runleo = (ArregloDatos[0] >> ArregloDatos[1]);
  delay(20);
  ArregloDatos[1] = runleo;
  delay(20);
  ArregloDatos[0] = LECTURA;



  //  for (int i = 0; i < 2; i++) {
  //ArregloDatos[i]>>ArregloDatos[i+1];
  //}
  Serial.print("LECTURA:  ");
  Serial.print(",  ");
  Serial.println(ArregloDatos[0]);
  Serial.println();
  Serial.print("ANTERIOR: ");
  Serial.print(",  ");
  Serial.print(ArregloDatos[1]);
  Serial.println();

  if (runleo < LECTURA) {

    contar++;
    Serial.println(contar);
  }


}

si desea mantener el valor anterior, puede explorar algo como éste

const byte sensor1 = A0;
int valorActual, valorAnterior;

void setup() {
  Serial.begin(115200); Serial.println();
  valorAnterior = digitalRead(sensor1);
}

void loop() {
  valorActual = digitalRead(sensor1);
  if (valorActual > valorAnterior) {
    Serial.println("valor creixent");
  } else {
    Serial.println("valor decreixent");
  }
  valorAnterior = valorActual;
  delay(100); // 10 Hz
}

hola Jackson, gracias por responder.
En este caso los datos del sensor se actualizaran con respecto al tiempo ya que esta sensando un posición la cual varia quiero que se vaya recorriendo el estado que lee el sensor a la posición siguiente del array sin que este crezca, lo que tengo actualmente lo hace, pero al momento de compararlos en una condición if no logra entrar en esta, no se si tengo mal el arreglo del array.
de ante mano muchas gracias

en su código, la matriz intArrayData[2] es local para loop() y, por lo tanto, se pierde al final de cada ciclo.

Además, ¿qué esperas del operador >>?

no me queda claro lo que quieres hacer.
si desea almacenar valores consecutivos en una matriz de tamaño fijo, eso podría funcionar.

const byte sensor = A0;
const byte maxValor = 10;
byte valors[maxValor] ;
byte actualIndex = 0;

void setup() {}

void loop() {
  valors[actualIndex] = digitalRead(sensor);
  actualIndex = (actualIndex + 1) % maxValor;
  delay(100); // 10 Hz
}

Me hacía la misma pregunta.

No creo que quieras desplazar a la derecha los bits de ArregloDatos[0] tantas veces como indica ArregloDatos[1]. ¿O si?

La verdad no sabia del problema con la matriz array y el loop(), sin embargo al cambiar cosas del código me salió ese mensaje de error y no se como solucionarlo.

Lo del operador (>>) creo que es para recorrer el dato a uno anterior solo se me ocurrió porque se que funciona en recorrer bits para realizar tipos mascaras.

Lo que de seo hacer en esta parte del código es ver la posición de un pistón que estará entrando y saliendo con dos estados estado bajo (0 =pistón retraído) y estado alto (1= pistón extendido), para poder contar las veces que el pistón entra y sale , solo tengo que sumar de 1 en 1, para eso se realice una variable contador que ira incrementando cuando el estado sea 1 (pistón extendido), el problema principal es cuando la maquina que controla al pistón se para y el estado queda en 1, lo que pasara aqui es que ira incrementado indeterminadamente.

Para solucionar eso quise hacer una matriz con dos datos para ir recorriendo la lectura y guardarlos para poder aumentar solo con la condición siguiente si el pistón esta contraído será cero al cambiar de estado seria 1 por ende nuestro arreglo de array quedaría 01 y con el if cuando se cumpla esta condición el contador aumente en +1.

el código que realice para ello es el siguiente pero no se como arreglar lo de la matriz con el loop();

const int Sensor1 = A0;
int contar = 0, anterior = 0;

void setup() {
  // put your setup code here, to run once:
  pinMode(Sensor1, INPUT);
}

void loop() {
  int LECTURA = digitalRead(Sensor1);
  int ArregloDatos[2] = {LECTURA, anterior};

  for (int i = 0; i < 2; i++) {
    ArregloDatos[i + 1] = ArregloDatos[i];
  }
  ArregloDatos[0] = LECTURA;
  delay(100);
  if (ArregloDatos[1] < ArregloDatos[0] ) {
    contar++;
  }else{
    contar = contar;
    }
}

la verdad es que si, estos datos se irán actualizando con un sensor, los cuales serán miles, todo con el fin de poder contar las veces que se extiende un pistón, el problema principal radica en que si la maquina queda con el pistón extendido (que seria el estado 1) este ira aumentando un contador indeterminadamente siempre que el pistón este en esa posición.

Para solucionar eso quise hacer una matriz con dos datos para ir recorriendo la lectura y guardarlos para poder aumentar solo con la condición siguiente si el pistón esta contraído será cero al cambiar de estado seria 1 por ende nuestro arreglo de array quedaría 01 y con el if cuando se cumpla esta condición el contador aumente en +1

Ok, pero ">>" es una operación de dezplazamiento de bits, no para desplazar datos de una posición a la otra.

ArregloDatos[i + 1]

No existe cuando i = 1 porque 1 + 1 = 2 y el índice 2 no existe.

Es absolutamente valido usar un array de 2 elementos pero ¿por que no usar directamente 2 variables y listo?

Por ejemplo

if ((estadoActual != estadoAnterior) && estadoActual) {
  contar++;
}
estadoAnterior = estadoActual;

va a entrar al if() solo si hay un cambio en el estado del pistón Y el pistón está extendido.

Yo declararía ambas variables globales o al menos estadoAnterior como static.

1 Like

gatul gracias por contestar.
con lo del array me queda claro, hice las modificaciones y ahora funciona, pero sigue aumentando indefinidamente cuando el sensor detecta un estado 1 (pistón extendido).

He probado tu recomendación y ha funcionado, muchas gracias!!. Anexo código funcional.

Ahora tengo una duda, si son 3 sensores es mejor que lo haga por variables o por un array de 3x2?

const int Sensor1 = A0;
int contar = 0;
static int  ArregloDatosA;

void setup() {
  Serial.begin(9600);
  pinMode(Sensor1, INPUT);
}

void loop() {
  const int ArregloDatosL = digitalRead(Sensor1);

  if ((ArregloDatosA != ArregloDatosL) && ArregloDatosA) {
    contar++;
  }
  ArregloDatosA = ArregloDatosL;
}
const int ArregloDatosL = digitalRead(Sensor1); 

No puede ser constante si va a guardar un valor variable.
Además si guardas el valor de un pin digital usa bool o en su defecto byte, int es un desperdicio de memoria para solo guardar 1 bit.


Un array es más práctico en caso de más sensores, el asunto es que ArregloDatos es poco claro para alguien que lea el código que no seas tú, no se entiende que guardas ahí.

Podrías armar una estructura y con ésta hacer un array, en pos de la claridad

Por ej.

struct estado_s {
  bool actual;
  bool anterior;
};

estado_s estadoPiston[3];  // declara un array de tipo estado_s

Luego lo accedes, por ej.

estadoPiston[0].anterior = estadoPiston[0].actual;

Saludos

https://www.arduino.cc/en/Tutorial/BuiltInExamples/StateChangeDetection

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