tengo un motor a pasos y necesito activarlo, el problema es que quiero que la secuencia en la que se activa cada bobina no utilice delay!
este es el programa que se me ocurrio pero tiene un problema solo enciende una vez la bobina 1 y despues la secuencia se queda en las otras bobinas(ya no vuelve a encender bobina 1)
byte bobinas[]={3,4,5,6};
int contador=-1;
unsigned long almacen=0;
unsigned long aux=0;
unsigned long act=1000;
Aca es donde me doy cuenta que me falta mucho por aprender.
Un programa tan simple y no podia inicializar el segundo ciclo... todo por programarlo apurado.
Ahora si funciona.
Borre el anterior porque no aportaba.
const byte bobinas[]={3,4,5,6}; // agregué const ya que son pines fijos.
int contador = -1;
unsigned long almacen=0;
unsigned long aux=0;
unsigned long act=1000;
void setup(){
Serial.begin(9600);
for(int a=0;a<=4;a++){
pinMode(bobinas[a],OUTPUT);
}
almacen = millis();
}
void loop(){
char str[50];
sprintf(str, "Contador= %d millis = %ld almacen = %ld aux = %ld", contador, millis(), almacen, aux);
Serial.println(str);
if(millis()-almacen > aux){
contador++;
digitalWrite(bobinas[contador],HIGH);
digitalWrite(bobinas[contador-1],LOW);
almacen = millis();
aux = act;
}
if (contador == 4){
contador = 0;
almacen = millis();
aux = 0;
contador = -1;
}
}
si inicializas almacen en esa posicion con cada ciclo de loop almacen se reseteará a un valor cercano al actual. Ahi no puede ir almacen porque es la variable a comparar con millis() para que su diferencia nos de un cambio cada 1000 mseg
Esto
contador=contador++;
para mi es redundante pero además no se que comportamiento tiene
Como ya dije, o es contador = contaror +1; o bien es contador += 1; o por ultimo contador++;
Todas hacen lo mismo. Creo que la ultima es la mejor desde la optimización del compilador.
aux=millis()+act;
no vale explicarlo porque almacen ya viene actualizado a un valor pocos mseg proximo a millis asi que esto como que nunca se cumpliría.
Yo lo reemplacé por
almacen = millis();
aux = act;
y porque lo hice, porque quiero que cada vez que entro al if prepare las condiciones para la siguiente comparación y justamente debe ser de ambos valores. Almacen sera 1000 y algo mseg mayor, y aux puede tomar dos valores, 0 o act.
0 para la condicion inicial y act = 1000 msg para las 4 posiciones de las bobinas.
Por ultimo la comparación cuando contador = 4 me pone todo a la situación de arranque y si miras, veras que llevo contador = -1; como bien lo definiste y aux = 0 como arrancó tambien.
Al explicarte, encontre un error o algo que deje pasar y es que cada vez que se inicia el ciclo el código quiere ejecutar algo que no esta bien
Arranca o reinicia el contador a -1 luego de haber igualado a 4.
Lo pongo a -1.
Por las condiciones impuestas, el if permite ejecutar su contenido.
contador se incrementa a 0
Y ejecuta
digitalWrite(bobinas[0],HIGH); BIEN!!!
digitalWrite(bobinas[-1],LOW); MALLLLL!!!!
esta linea debe ponerse en un if para contador > 0 por ejemplo.
if(millis()-almacen > aux){
contador++;
digitalWrite(bobinas[contador],HIGH);
if (contador> 0) digitalWrite(bobinas[contador-1],LOW);
almacen = millis();
aux = act;
}
Ultima modificación. He estado viendo el código y me preguntaba si podía mejorarlo y aunque lo hice no estoy 100% satisfecho
Ahora esta mucho mejor.
const byte bobinas[]={3,4,5,6}; // agregué const ya que son pines son fijos.
int contador = 0;
unsigned long almacen=0;
unsigned long aux=0;
unsigned long act=1000;
void setup(){
Serial.begin(9600);
for(int a=0;a<=4;a++){
pinMode(bobinas[a],OUTPUT);
}
almacen = millis()+30;
}
void loop(){
char str[50];
sprintf(str, "Contador= %d millis = %ld almacen = %ld aux = %ld", contador, millis(), almacen, aux);
Serial.println(str);
if(millis()-almacen > aux){
digitalWrite(bobinas[contador],HIGH);
if(contador>0) digitalWrite(bobinas[contador-1],LOW);
almacen = millis();
if (contador++ == 4){
contador = 0;
aux = 0;
}
else
aux = act;
}
}
Tengo una pregunta: Alguien sabe como es que se apaga bobinas[3] con este código. ya que nunca supuestamente se ejecutaría
con contador = 4, la opción
digitalWrite(bobinas[contador-1],LOW);
Hola.
No he mirado a fondo el programa, pero creo que la respuesta a tu pregunta está en la línea
if (contador++ == 4)
Que, si no me equivoco, primero compara y después incrementa, al contrario que si hubieras puesto
if (++contador == 4)
No obstante, están muy bien ciertas "abreviaturas" de C (++, --, += ...) pero no conviene abusar de ellas sencillamente por ahorrarse líneas de código, pues a veces la apariencia es muy críptica, se tarda más en depurar, y el resultado en tamaño y eficiencia tras la compilación suele ser el mismo. (Te aviso de que por dentro estoy diciendo "mira tú quién fue a hablar").
En tu caso te recomendaría dos líneas.
contador++;
if (contador == 4){
Ahhh quedó eso. bueno si miras el Monitor serie, ejecuta el 0 y hace algo raro, con 30 le doy tiempo a que no lo haga y pasa por el If y se acomoda todo bien. 30 es loa que tarda en inicializar almacen, aumentar contador, etc, etc.
siii ya vi eso en el monitor!! y si es como se fuera un tiempo en donde se acomoda todo! pero tambien me salio otra duda! jaja
en un arreglo o matriz... lo que hay dentro de las llaves las enumera empezando desde cero verdad?
ejemplo:
int array[]={4,5,6,7}
4 seria 0
5 seria 1... etc,
en el monitor yo observe que en el contador el 0 aparece solo un vez no durante todo un segundo, y ademas tambien cuenta el cuatro durante un segundo como es posible que encienda la bobina[0] durante solo un segundo si en el monitor aparece como un flasheo? y al igual cuando contador esta en 4? como es que enciende la bobina 3 cuando contador vale eso? :S disculpa si no logro comprender aun :C
Bueno, he mirado con otros ojos y ahora entiendo estas 4 lineas de código (por dios, nunca estare cerca de enviar nada al espacio).
mira esto
en el vemos que contador almacen y aux arrancan en 0.
la condición en el if es verdadera y ejecuta lo que está dentro.
compara contador con 4 ve que no es asi que ajusta aux = 1000 pero luego incrementa contador a 1.
Eso se ve plasmado en la 3ra linea.
cuando
Contador = 1 millis = 23 almcacen = 23 aux = 1000
ahora que ocurre ?
ocurre que hasta que la diferencia millis - almacen no sea maor a 1000 no va a repetir los cambios.
quiere decir que los cambios y el encendido de las bobinas ocurren con los cambios de contador lo que es logico.
con 0 a 1 tenemos bobina 0
con 1 a 2 tenemos bobina 1
con 2 a 3 tenemos bobina 2
con 3 a 4 tenemos bobina 3
al llegar a 4 resetea contador y pone todo como en el inicio.
asi que esta bien.
exelente explicacion!! ahora ya comprendo bien que es lo que ocurre jaja me gustaria saber cuanto tiempo tienes trabajando con arduino ? XD otra cosa...este programa es solo para que el motor gire en un sentido... tambien necesito que gire en el otro sentido
. sera cuestion de cambiar algunas cosas para que el contador descienda en vez de acender pero de eso me encargo yo.
por otro lado le deje en su correo un programa que hice de unos foquitos de navidad me gustaria que lo viera y me diga que le parece
¡¡¡¡ Ojo !!!!
No tengo apenas tiempo para completarlo, pero hay un asunto que veo muchas veces en los códigos y que puede ser un verdadero dolor de cabeza.
Si el sketch se pone en funcionamiento "continuo", hay un momento en que millis() vuelve a ser cero y entonces... nada funciona como debe y se queda "tieso".
Hay que controlar este punto, yo ya lo he sufrido en otros entornos y tengo callo en el c...o y siempre que programo cuestiones de tiempos lo tengo en cuenta.
Echad una mano con el asunto a este buen hombre.
Me hablas de 49 días? Claro.
En ese lapso de tiempo es mas facil que lo apagues por alguna razón.
Millis usa un unsigned long o sea 4bytes o 32 bits. O sea 2^32 = 4294967296 -1 serán los valores posibles contados desde 0.
Ahora llevar eso desde mseg a dias para tener un desbordamiento
bien, si eso te parece poco a pensar en como resetearlo.
No sabía como hacerlo asi que lo investigué y es muy interesante el resultado.
Esto esta tomado de este lugar Reset millis()
ATENCION: resetear o modificar millis() puede hacer que otras librerías dejen de funcionar o bien tu propio código lo haga, de modo que prestar mucha atención porque puede ser mas complejo hacer esto que intentar otra cosa.
De todos modos el link para resetearlo luce bien y está prolijamente realizado.
Uy, yo tengo un proyecto que lleva más de cuatro meses de corrido... la solución es hacer un control de millis almacenados vs. millis actuales y "resetear" el millis almacenados para que las diferencias no salgan negativas
Aunque lo que dices excede lo que pide LABU, es muy interesante tu enfoque. Porque no creas un nuevo hilo comentándolo y debatimos ahi el tema reset millis()
sigue haciendo lo mismo
no entieno porque en la parte de void setup();
Jeje... sí... a mí también me gusta mucho...
pero de eso me encargo yo.