Tengo un problemilla. Resulta que necesito mover un paso a paso en función de un array con PROGMEM.
He logrado moverlo sin usar la librería. Y en la función que realiza los pasos, necesito colocar de atributo la lectura del array a través de PROGMEM, que irá aumentando el index para utilizar cada elemento dentro de la matriz como un número de pasos específico.
Además de esto, sólo necesito que aplique el paso, si el valor anterior es distinto. Si se repite un valor, no debe hacer nada hasta que este valor cambie.
Lo que tengo hasta ahora es lo siguiente:
void loop() {
mover(50, 10); >>En lugar de 50 "pasos" debe leerse el array con PROGMEM
delay(200);
}
void mover (int numSteps, int rpm) {
if (numSteps >= 0) {
forward (numSteps, rpm);
} else {
backward (abs(numSteps), rpm);
}
}
for (int = 0; i < lenghtArray; i++) { //No funcionará la condición si no ejecuto la lectura con pgm_read?
mover(pgm_read_word_near(pwm_map), 10); //Hace falta agregar la variable de aumento, n++ lueo de esta linea o esta dado por la del for anterior?
if (pgm_read_word_near(pwm_map) == n { // Acá necesito comparar el elemento actual con el anterior
Perdón si no se entiende lo que quiero explicar...
Estoy confundido con el aumento del index del array y con su uso dentro del atributo de la función que mueve el motor..
No supe interpretar lo que busqué en relación a mi cuestión. La referencia de arduino habla de caracteres y no entiendo como relacionarlo con el array de números que preciso.
Opté por empezar a controlar el stepper sin progmem, con un array mas chico.
Estoy teniendo buenos resultados pero a la hora de comparar los elementos del array entre sí, no se aplica al control del motor en sí.
Es decir, logro mover el motor con cuatro pasos cada 500ms cada uno, leídos desde el array. Pero cuando quiero limitar el movimiento si el elemento del array es igual al siguiente, no tengo resultado.
void loop() {
for (int i = 0; i < ndatos; i++) {
if (pwm1[i] == pwm1[i+1]) { //Acá es donde no entiendo cómo comparar el elemento i de array con el siguiente elemento. Si vale lo mismo que el elemento actual, no debería moverse y si es distinto sí. Me explico?
mover(0, 0);
delay(500);
} else {
mover(map(pwm1[i], 100, 800, 10, 100), 10);
delay(500);
}
}
}
A ver.
Si no conoces el funcionamiento de algo, lo mejor es mirar los ejemplos, entenderlo y luego aplicarlo a lo que necesitas.
No tener tantas dudas y variables que no sabes por donde seguir.
Otra cosa que estas haciendo mal en ESTE foro es que no parcialices tu código, siempre postea todo el código que estas usando, mal o bien nos permite aconsejarte debidamente.
Te puse como informarte del uso de PROGMEM y no sé si lo has hecho.
En los ejemplos se ve como indexar de modo de acceder a los elementos de la matriz o vector.
Se supone que con el ejemplo te debería quedar claro como continuar.
Si yo tuviera que hacer tu trabajo empezaría con un programa que tuviera un vector sin usar PROGMEM y cuando me asegure que funcione luego lo convierto a elementos almacenados en flash y no en RAM. Esa es la única diferencia.
He leído y tratado de analizar el comportamiento de cada parte que intento aplicar, incluso con mis apuntes de clase. Pero recurro acá porque no estoy viendo algo o no estoy entendiendo algo que me haga el click para encontrarle la vuelta. No sabía que era un foro únicamente para expertos.
Lo que quiero lograr con el código es que se recorra un array y que dependiendo de una condición (que el elemento actual sea diferente del anterior) se haga un movimiento y si el elemento actual es igual al anterior, que no haga nada y espere 500ms. Y vuelva a evaluar.
Entonces el motor se moverá con la cantidad de pasos que marque el array, salvo si se repite el número de pasos dentro, allí sólo esperará una y otra vez hasta que el valor cambie.
const int pwm1[] = {200, 200, 400, 800}; //ARRAY TO COMPARE ITSELF
int ndatos = 4;
//STEPPER VARIABLES
const int pinesUnipolar[] = {8, 9, 10, 11};
//int pinesUnipolar[] = {11, 10, 9, 8}; //REVERSE PINS TO MOVE BACKWARD, THAT'S ANOTHER STORY
const int numPines = 4;
int n = 0;
//END STEPPER VARIABLES
void setup() {
for (int i = 0; i < numPines; i++) {
pinMode(pinesUnipolar[i], OUTPUT);
digitalWrite(pinesUnipolar[i], LOW);
}
}
void loop() {
int a = pwm1[n];
if (a != pwm1[n++]) {
mover(0, 0);
delay(500);
a = pwm1[n++];
if (n > ndatos) {
n = ndatos - ndatos;
}
} else {
mover(map(pwm1[n], 100, 800, 10, 100), 10); //this maps
delay(500);
n++;
if (n > ndatos) {
n = ndatos - ndatos;
}
}
}
//FUNCTIONS
void mover(int numSteps, int rpm) {
if (numSteps >= 0) {
forward(numSteps, rpm);
} else {
backward(abs(numSteps), rpm);
}
}
void forward(int numSteps, int rpm) {
for (int i = 0; i < numSteps; i++) {
digitalWrite(pinesUnipolar[n], HIGH);
delay(rpm);
digitalWrite(pinesUnipolar[n], LOW);
n++;
if (n == numPines) {
n = 0;
}
}
}
void backward(int numSteps, int rpm) {
for (int i = 0; i < numSteps; i++) {
digitalWrite(pinesUnipolar[n], HIGH);
delay(rpm);
digitalWrite(pinesUnipolar[n], LOW);
n--;
if (n < 0) {
n = numPines - 1;
}
}
}
//END FUNCTIONS