Saludos.
ya inicie las pruebas físicas y no consigo integrar switch case a la lectura de pines analógicos
//https://forum.arduino.cc/t/seguidor-solar-automatizado-terminado/278788/41
const unsigned long INTERVALO_LECTURAS_analogRead = 650UL;
const unsigned long INTERVALO_PULSO_MOTOR_NORTE = 650UL;
const unsigned int TOTAL_PASOS_MOTOR_NORTE = 2000;
const bool DIRECCION_NORTE = LOW;
const unsigned long INTERVALO_PULSO_MOTOR_SUR = 650UL;
const unsigned int TOTAL_PASOS_MOTOR_SUR = 2000;
const bool DIRECCION_SUR = HIGH;
const unsigned long INTERVALO_PULSO_MOTOR_ESTE = 650UL;
const unsigned int TOTAL_PASOS_MOTOR_ESTE = 2000;
const bool DIRECCION_ESTE = LOW;
const unsigned long INTERVALO_PULSO_MOTOR_OESTE = 650UL;
const unsigned int TOTAL_PASOS_MOTOR_OESTE = 2000;
const bool DIRECCION_OESTE = HIGH;
//int DIRECCION;
int PUL_NS = 9; //Pin para la señal de pulso
int DIR_NS = 10; //define Direction pin
int EN_NS = 11; //define Enable Pin
int PUL_EO = 5; //Pin para la señal de pulso
int DIR_EO = 6; //define Direction pin
int EN_EO = 7; //define Enable Pin
enum estado_MA {
ESTADO_INICIAL,
ESTADO_NORTE,
ESTADO_SUR,
ESTADO_ESTE,
ESTADO_OESTE,
ESTADO_MOTOR_NORTE_EN_PULSO_LOW,
ESTADO_MOTOR_NORTE_EN_PULSO_HIGH,
ESTADO_MOTOR_SUR_EN_PULSO_LOW,
ESTADO_MOTOR_SUR_EN_PULSO_HIGH,
ESTADO_MOTOR_ESTE_EN_PULSO_LOW,
ESTADO_MOTORO_ESTE_EN_PULSO_HIGH,
ESTADO_MOTOR_OESTE_EN_PULSO_LOW,
ESTADO_MOTOR_OESTE_EN_PULSO_HIGH
} estado = ESTADO_INICIAL;
const bool DIRECCIONA_NORTE = !DIRECCION_SUR;
const bool DIRECCIONB_ESTE = !DIRECCION_OESTE;
unsigned long instantePasoMotornorte = 0;
unsigned int pasosRealizadosnorte = 0;
boolean direccionnorte = DIRECCION_NORTE;
unsigned long instantePasoMotorsur = 0;
unsigned int pasosRealizadossur = 0;
boolean direccionsur = DIRECCION_SUR;
unsigned long instantePasoMotoreste = 0;
unsigned int pasosRealizadoseste = 0;
boolean direccioneste = DIRECCION_ESTE;
unsigned long instantePasoMotoroeste = 0;
unsigned int pasosRealizadosoeste = 0;
boolean direccionoeste = DIRECCION_OESTE;
//unsigned long millisActualnorte = millis();
//unsigned long microsActualsur = micros();
//unsigned long millisActualeste = millis();
//unsigned long microsActualoeste = micros();
int Vplaca1 = A0;
int Vplaca2 = A1;
int Vplaca3 = A2;
int Vplaca4 = A3;
int km1 = 2;
int km2 = 3;
int km3 = 4;
int km4 = 5;
int fc1 = 6;
int fc2 = 7;
int fc3 = 8;
int fc4 = 9;
void setup() {
Serial.begin(9600);
pinMode (PUL_NS, OUTPUT);
pinMode (DIR_NS, OUTPUT);
pinMode (EN_NS, OUTPUT);
digitalWrite(EN_NS, HIGH);
digitalWrite(PUL_NS, LOW);
pinMode (PUL_EO, OUTPUT);
pinMode (DIR_EO, OUTPUT);
pinMode (EN_EO, OUTPUT);
digitalWrite(EN_EO, HIGH);
digitalWrite(PUL_EO, LOW);
// initialize km as outputs:
pinMode(km1, OUTPUT) ;
pinMode(km2, OUTPUT) ;
pinMode(km3, OUTPUT) ;
pinMode(km4, OUTPUT) ;
pinMode(fc1, INPUT) ;
pinMode(fc2, INPUT) ;
pinMode(fc3, INPUT) ;
pinMode(fc4, INPUT) ;
Serial.begin(9600) ;
}
void loop() {
// if (millis() - estado.analogRead > 500UL) {
//Serial.print("read ");
//Serial.println();
// estado,anlaogRead = millis();
unsigned long millisActualnorte = millis();
unsigned long microsActualnorte = micros();
unsigned long millisActualsur = millis();
unsigned long microsActualsur = micros();
unsigned long millisActualeste = millis();
unsigned long microsActualeste = micros();
unsigned long millisActualoeste = millis();
unsigned long microsActualoeste = micros();
// read the values of the solar panels:
int V1 = analogRead(Vplaca1) ;
int V2 = analogRead(Vplaca2) ;
int V3 = analogRead(Vplaca3) ;
int V4 = analogRead(Vplaca4) ;
int Km1 = digitalRead(km1) ;
int Km2 = digitalRead(km2) ;
int Km3 = digitalRead(km3) ;
int Km4 = digitalRead(km4) ;
int Lekfc1 = digitalRead(fc1) ;
int Lekfc2 = digitalRead(fc2) ;
int Lekfc3 = digitalRead(fc3) ;
int Lekfc4 = digitalRead(fc4) ;
int Tolerancia = 60;
// left move:
int Dif12 = V1 - V2 ;
int Dif34 = V3 - V4 ;
// right move
int Dif21 = V2 - V1 ;
int Dif43 = V4 - V3 ;
//up move
int Dif13 = V1 - V3 ;
int Dif24 = V2 - V4 ;
//Down move
int Dif31 = V3 - V1 ;
int Dif42 = V4 - V2 ;
// Print voltage.
Serial.print("-V1.."); Serial.print(V1);
Serial.print("-V2.."); Serial.print(V2);
Serial.print("-V3.."); Serial.print(V3);
Serial.print("-V4..."); Serial.print(V4);
// estado de las salidas:
Serial.print("..km1."); Serial.print(Km1);
Serial.print("..km2."); Serial.print(Km2);
Serial.print("..km2."); Serial.print(Km3);
Serial.print("..km4."); Serial.print(Km4);
// estado de las restas de tensión:
Serial.print("..fc1: "); Serial.print(digitalRead(fc1)); Serial.print("..fc2: "); Serial.print(digitalRead(fc2));
Serial.print("..fc3: "); Serial.print(digitalRead(fc3)); Serial.print("..fc4: "); Serial.print(digitalRead(fc4));
Serial.println();
delay(1000);
switch (estado) {
case ESTADO_INICIAL :
case ESTADO_NORTE :
case ESTADO_SUR :
case ESTADO_ESTE:
case ESTADO_OESTE:
// left move:
case ESTADO_MOTOR_NORTE_EN_PULSO_LOW:
if ((Lekfc1 == 0) && (((V1 > V2) && (Dif12 > Tolerancia)) || ((V3 > V4) && (Dif34 > Tolerancia) )))
if ((microsActualnorte - instantePasoMotornorte) >= INTERVALO_PULSO_MOTOR_NORTE) {
Serial.println(F("NORTE"));
direccionnorte = DIRECCION_NORTE;
if (estado = ESTADO_MOTOR_NORTE_EN_PULSO_LOW); {
digitalWrite(DIR_NS, direccionnorte);
instantePasoMotornorte = microsActualnorte;
pasosRealizadosnorte = 0;
direccionnorte = DIRECCION_NORTE;
break;
}
}
// right move
case ESTADO_MOTOR_SUR_EN_PULSO_HIGH:
if ( (Lekfc2 == 0) && (( (V2 > V1) && (Dif21 > Tolerancia)) || ( (V4 > V3) && (Dif43 > Tolerancia)) ))
if ((microsActualsur - instantePasoMotorsur) >= INTERVALO_PULSO_MOTOR_SUR) {
Serial.println(F("SUR"));
direccionsur = DIRECCION_SUR;
if (estado = ESTADO_MOTOR_SUR_EN_PULSO_HIGH);
digitalWrite(DIR_NS, direccionsur);
instantePasoMotorsur = microsActualsur;
pasosRealizadossur = 0;
direccionsur = DIRECCION_SUR;
break;
}
//up move
case ESTADO_MOTOR_ESTE_EN_PULSO_LOW:
if ( (Lekfc4 == 0) && (( (V1 > V3) && (Dif13 > Tolerancia) ) || ((V2 > V4) && (Dif24 > Tolerancia)) ))
if ((microsActualeste - instantePasoMotoreste) >= INTERVALO_PULSO_MOTOR_ESTE) {
Serial.println(F("ESTE"));
direccioneste = DIRECCION_ESTE;
if (estado = ESTADO_MOTOR_ESTE_EN_PULSO_LOW);
digitalWrite(DIR_NS, direccioneste);
instantePasoMotoreste = microsActualeste;
pasosRealizadoseste = 0;
direccioneste = DIRECCION_ESTE;
break;
}
//Down move
case ESTADO_MOTOR_OESTE_EN_PULSO_HIGH:
if ((Lekfc3 == 0) && (((V3 > V1) && (Dif31 > Tolerancia)) || ((V4 > V2) && (Dif42 > Tolerancia))))
if ((microsActualoeste - instantePasoMotoroeste) >= INTERVALO_PULSO_MOTOR_OESTE) {
Serial.println(F("OESTE"));
direccionoeste = DIRECCION_OESTE;
if (estado = ESTADO_MOTOR_OESTE_EN_PULSO_HIGH);
digitalWrite(DIR_NS, direccionoeste);
instantePasoMotoroeste = microsActualoeste;
pasosRealizadosoeste = 0;
direccionoeste = DIRECCION_OESTE;
break;
}
}
}
Saludos
Hola, veo que están bien ocupados, ya me que sola, nadie a venido desde hace 5 días, creo que el titulo no me ayuda, solo 74 puntos de vista, o sera que mi código en maquinas en estado no a causado ningún interés, creo que a causado penas. Saludo equipo Arduino en español. espero verlos pronto por aquí
Hola, no si mi duda la deba resolver en este hilo, tiene una intima relación con harware , pero es código si no corresponde digan lo,
void loop()
{
digitalWrite(DIR, HIGH);
for (int i = 0; i < 1000; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(400);
digitalWrite(PUL, LOW);
delayMicroseconds(400);
}
}
void loop ()
{
digitalWrite(DIR, LOW);
for (int i = 0; i > 1000; i--) {
digitalWrite(PUL, HIGH);
delayMicroseconds(400);
digitalWrite(PUL, LOW);
delayMicroseconds(400);
}
}
Es posible cambiar dentro del ciclo for, el i++ por i-- tienen idea de que sucede da los pulsos en decremento se quema el motor o algo peor.
Saludos
Hola @Surbyte, hice este código, funciona muy bien el motor 1, el motor 2 regular es mucho mas minimalista y funcional que con el que inicie el hilo.
int PUL = 8;
int DIR = 9;
int EN = 10;
int PUL2 = 5;
int DIR2 = 6;
int EN2 = 7;
const unsigned long TIEMPO_LECTURAS = 5000UL;
int LDR1 = A0;
int LDR2 = A1;
int LDR3 = A3;
int LDR4 = A4;
int error = 50;
unsigned long tiempolecturas = 0 ;
void setup()
{
Serial.begin(9600);
pinMode (PUL, OUTPUT);
pinMode (DIR, OUTPUT);
pinMode (EN, OUTPUT);
digitalWrite(EN, HIGH);
pinMode (PUL2, OUTPUT);
pinMode (DIR2, OUTPUT);
pinMode (EN2, OUTPUT);
digitalWrite(EN2, HIGH);
pinMode(LDR1, INPUT);
pinMode(LDR2, INPUT);
pinMode(LDR3, INPUT);
pinMode(LDR4, INPUT);
}
void loop()
{
if (millis() - tiempolecturas > 5000UL) {
int R1 = analogRead(LDR1);
int R2 = analogRead(LDR2);
Serial.println(LDR1);
Serial.println(LDR2);
int diff1 = abs(R1 - R2);
int diff2 = abs(R2 - R1);
if ((diff1 >= error) || (diff2 >= error)) {
if (R1 > R2)
{
digitalWrite(DIR, HIGH);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL, LOW);
delayMicroseconds(1000);
}
}
if ((diff1 >= error) || (diff2 >= error)) {
if (R1 < R2)
{
digitalWrite(DIR, LOW);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL, LOW);
delayMicroseconds(1000);
}
}
}
}
////////////////////////////////////////////////////// motor2
if (millis() - tiempolecturas > 5000UL) {
Serial.println(LDR3);
Serial.println(LDR4);
int R3 = analogRead(LDR3);
int R4 = analogRead(LDR4);
int diff3 = abs(R3 - R4);
int diff4 = abs(R4 - R3);
if ((diff3 >= error) || (diff4 >= error)) {
if (R3 > R4) {
{
digitalWrite(DIR2, HIGH);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL2, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL2, LOW);
delayMicroseconds(1000);
}
}
if ((diff3 >= error) || (diff4 >= error)) {
if (R3 < R4) {
{
digitalWrite(DIR2, LOW);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL2, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL2, LOW);
delayMicroseconds(1000);
}
}
}
}
}
}
}
}
}
Saludos.
En ningun momento actualizas
tiempolecturas = millis();
eso no te va a funcionar.
Y si los dos loops usan la misma variable para que poner dos condiciones?
if (millis() - tiempolecturas > 5000UL) {
Esta repetida, tanto para motor1 como para motor2, pero debieras usar un tiempolecturas1 y tiempolecturas2.
No hace falta al declararlas ponerlas a 0, porque justamente lo que quieres es que actue inicialmente, de todas maneras el compilador las pone a 0.
const int PUL = 8;
const int DIR = 9;
const int EN = 10;
const int PUL2 = 5;
const int DIR2 = 6;
const int EN2 = 7;
const unsigned long TIEMPO_LECTURAS = 5000UL;
const int LDR1 = A0;
const int LDR2 = A1;
const int LDR3 = A3;
const int LDR4 = A4;
int error = 50;
unsigned long tiempolecturas1, tiempolecturas2;
void muevoNema(int pinPUL, int pinDIR, int estado) {
digitalWrite(pinDIR, estado);
for (int i = 0; i < 400; i++) {
digitalWrite(pinPUL, HIGH);
delayMicroseconds(1000);
digitalWrite(pinPUL, LOW);
delayMicroseconds(1000);
}
}
void setup(){
Serial.begin(9600);
pinMode (PUL, OUTPUT);
pinMode (DIR, OUTPUT);
pinMode (EN, OUTPUT);
digitalWrite(EN, HIGH);
pinMode (PUL2, OUTPUT);
pinMode (DIR2, OUTPUT);
pinMode (EN2, OUTPUT);
digitalWrite(EN2, HIGH);
pinMode(LDR1, INPUT);
pinMode(LDR2, INPUT);
pinMode(LDR3, INPUT);
pinMode(LDR4, INPUT);
}
void loop() {
////////////////////////////////////////////////////// motor1
if (millis() - tiempolecturas1 > 5000UL) {
int R1 = analogRead(LDR1);
int R2 = analogRead(LDR2);
Serial.println(LDR1);
Serial.println(LDR2);
int diff1 = abs(R1 - R2);
int diff2 = abs(R2 - R1);
if ((diff1 >= error) || (diff2 >= error)) {
if (R1 > R2)
muevoNema(PUL, DIR, HIGH);
if (R1 < R2)
muevoNema(PUL, DIR, LOW);
}
tiempolecturas1 = millis();
}
////////////////////////////////////////////////////// motor2
if (millis() - tiempolecturas2 > 5000UL) {
Serial.println(LDR3);
Serial.println(LDR4);
int R3 = analogRead(LDR3);
int R4 = analogRead(LDR4);
int diff3 = abs(R3 - R4);
int diff4 = abs(R4 - R3);
if ((diff3 >= error) || (diff4 >= error)) {
if (R3 > R4)
muevoNema(DIR2, PUL2, HIGH);
if (R3 < R4)
muevoNema(DIR2, PUL2, LOW);
}
tiempolecturas2 = millis();
}
}
Aunque se que no esta del todo bien, al menos es una versión mas simple.
Hola @Surbyte, fue un error de pegado disculpe espero y esto se vea mejor
int PUL = 8; //Pin para la señal de pulso
int DIR = 9; //define Direction pin
int EN = 10; //define Enable Pin
int PUL2 = 5; //Pin para la señal de pulso
int DIR2 = 6; //define Direction pin
int EN2 = 7; //define Enable Pin
const unsigned long TIEMPO_LECTURAS = 2000UL; // intervalo entre lecturaa pines analogicos A0 A1 A2 A3
int LDR1 = A0; //declara pin de foto resistencias LDR A0
int LDR2 = A1; //declara pin de foto resistencias LDR A1
int LDR3 = A3; //declara pin de foto resistencias LDR A2
int LDR4 = A4; //declara pin de foto resistencias LDR A3
int error = 50; // margen de error entre 0v y 5v en milivolt
int diff1 = 0; //declara pines de foto resistencias LDR A0
int diff2 = 0; //declara pines de foto resistencias LDR A1
unsigned long tiempolecturas = 0; //declara los tiempos de lectura
void setup()
{
Serial.begin(9600); // velocidad en baudiso del monitor serial
pinMode (PUL, OUTPUT); // declara como salida en pin de pulsos
pinMode (DIR, OUTPUT); // declara el pin de dirección del motor izquierda o derecha
pinMode (EN, OUTPUT); // declara el pin del freno del motor
digitalWrite(EN, HIGH); // se inicia enfrenado el motor
pinMode (PUL2, OUTPUT); // declara como salida en pin de pulsos
pinMode (DIR2, OUTPUT); // declara el pin de dirección del motor izquierda o derecha
pinMode (EN2, OUTPUT); // declara el pin del freno del motor
digitalWrite(EN2, HIGH); // se inicia enfrenado el motor
pinMode(LDR1, INPUT); //declara el pin donde estar la RDL 1
pinMode(LDR2, INPUT); //declara el pin donde estar la RDL 2
pinMode(LDR3, INPUT); //declara el pin donde estar la RDL 3
pinMode(LDR4, INPUT); //declara el pin donde estar la RDL 4
}
void loop()
{
if (millis() - tiempolecturas > 2000UL) { // inicia los intevalos de lecturas de los pines analogicos
int R1 = analogRead(LDR1); // inicia la lectura del pin analogico A0
int R2 = analogRead(LDR2); // inicia la lectura del pin analogico A1
int R3 = analogRead(LDR3); // inicia la lectura del pin analogico A2
int R4 = analogRead(LDR4); // inicia la lectura del pin analogico A3
Serial.println(LDR1); // imprime en monitor serial la luz que recibe el pin analogico A0
Serial.println(LDR2); // imprime en monitor serial la luz que recibe el pin analogico A1
Serial.println(LDR3); // imprime en monitor serial la luz que recibe el pin analogico A2
Serial.println(LDR4); // imprime en monitor serial la luz que recibe el pin analogico A3
int diff1 = abs(R1 - R2); // establece las diferencias de la intensidad entre A0 y A1
int diff2 = abs(R2 - R1); // establece las diferencias de la intensidad entre A1 y A0
int diff3 = abs(R3 - R4); // establece las diferencias de la intensidad entre A3 y A4
int diff4 = abs(R4 - R3); // establece las diferencias de la intensidad entre A4 y A3
////////////////////////////////////////////////////motor 1
if ((diff1 >= error) || (diff2 >= error)) { // calcula la diferncia de iluminación que reciben las foto resistencias
if (R1 > R2) // si hay diferencia activa el motor 1 hasta que sea igual la intensidad de luz que reciben LDR
{
digitalWrite(DIR, HIGH); // enciende el motor 1 en dirección derecha
for (int i = 0; i < 400; i++) { //numero de pulsos que da el motor
digitalWrite(PUL, HIGH); // activa la bobina A del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
digitalWrite(PUL, LOW); //desactiva la bobina B del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
}
}
if ((diff1 >= error) || (diff2 >= error)) { // calcula la diferncia de iluminación que reciben las foto resistencias A0 A1
if (R1 < R2) // si hay diferencia activa el motor 1 hasta que sea igual la intensidad de luz que reciben la LDR
{
digitalWrite(DIR, LOW); // enciende el motor en dirección izquierda
for (int i = 0; i < 400; i++) { // numero de pulsos que dara el motor
digitalWrite(PUL, HIGH); //activa la bobina A del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
digitalWrite(PUL, LOW); //desactiva la bobina B del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
}
}
}
}
///////////////////////////////////////////////////motor 2
if ((diff3 > error) || (diff4 > error)) { // calcula la diferncia de iluminación que reciben las foto resistencias A3 A4
if (R3 > R4) // si hay diferencia activa el motor 1 hasta que sea igual la intensidad de luz que reciben la LDR (en mi caso lo hace de forma perfecta )
{
digitalWrite(DIR2, HIGH); // enciende el motor 2 en dirección derecha
for (int i = 0; i < 400; i++) { // numero de grados que dara el motor
digitalWrite(PUL2, HIGH); //activa la bobina A del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
digitalWrite(PUL2, LOW); //desactiva la bobina B del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
}
}
if ((diff3 > error) || (diff4 > error)) { // calcula la diferncia de iluminación que reciben las foto resistencias A3 A4
if (R3 < R4) // si hay diferencia activa el motor 2 hasta que sea igual la intensidad de luz que reciben la LDR (en mi caso no lo esta haciendo de forma correcta)
{
digitalWrite(DIR2, LOW); // enciende el motor 2 en dirección derecha
for (int i = 0; i < 400; i++) { //numero de grados que dara el motor
digitalWrite(PUL2, HIGH); //activa la bobina A del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
digitalWrite(PUL2, LOW); //desactiva la bobina B del motor
delayMicroseconds(1000); //numero de pulsos que recibe la bobina
}
}
}
}
}
}
//demasiadas llaves al final del codigo es posible generador de fallas
Como ve este
Saludos
Yo te voy a decir lo que veo.
Veo que te damos opciones y como que las descartas.
Y vuelves una y otra vez a tu forma de hacerlo y claro que esta bien, es tu decisión.
En lo personal no te quejes cuando en un hilo no tenga respuestas, porque no tomas lo que te indicamos. Te aclaro que no me enojo, pero te lo marco porque ya @anon90500195 te lo hizo ver.
te di algo mas minimalisa y lo pasas por alto.
Y regresas a tu código sin tomar nada de lo indicado.
estas dos comparaciones
if ((diff1 >= error) || (diff2 >= error)) {
se repiten y las pones 2 veces.
Lo mismo con diff2
hay mucho para simplificar.
Ahora respecto a los tiempos (tiempolecturas) , ahora si esta bien.
Hola @Surbyte, ya arregle lo de los millis, (segun yo), el motor 1 funciona perfecto, el motor 2 gira antihorario con las 2 celdas iluminadas todo el tiempo, y si bloqueo la iluminación a la celdas A3 da una rotación horaria y se detiene, no es cosa de hardware.
if ((diff1 >= error) || (diff2 >= error)) { // calcula la diferncia de iluminación que reciben las foto resistencias
if (R1 > R2) // si hay diferencia activa el motor 1 hasta que sea igual la intensidad de luz que reciben LDR
{
ya sea que cambie > < o el orden de los diff1 diff2 por diff2 diff1 funciona erráticamente. Los datos que da el monitor serial no tiene ningún sentido para mi.
14
15
17
18
Y lo repite de forma infinita,
Saludos
Sabes lo que es el valor absoluto de un número?
Si tienes R3 - R4 te quedas con el valor y no con su signo de modo que esto
abs(R3-R4) es lo mismo que abs(R4-R3)
Son la misma cosa de modo que repites situaciones en tu código haciendo que vaya para un lado y luego para otro.
Y ese error lo repites en ambos casos.
Por eso este código es mas simple porque se ve mejor lo que pretendes hacer pero no me había percatado de este fallo con las diferencias en valor absoluto, asi que esta mal tmb.
Te dejo el código, prúebalo
//#include <Arduino.h> // esto es para Platformio
const int PUL = 8;
const int DIR = 9;
const int EN = 10;
const int PUL2 = 5;
const int DIR2 = 6;
const int EN2 = 7;
const unsigned long TIEMPO_LECTURAS = 2000UL; // intervalo entre lecturaa pines analogicos A0 A1 A2 A3
const int LDR1 = A0;
const int LDR2 = A1;
const int LDR3 = A3;
const int LDR4 = A4;
int error = 50;
unsigned long tiempolecturas;
void muevoNema(int pinPUL, int pinDIR, int estado) {
digitalWrite(pinDIR, estado);
for (int i = 0; i < 400; i++) {
digitalWrite(pinPUL, HIGH);
delayMicroseconds(1000);
digitalWrite(pinPUL, LOW);
delayMicroseconds(1000);
}
}
void setup() {
Serial.begin(9600);
pinMode (PUL, OUTPUT);
pinMode (DIR, OUTPUT);
pinMode (EN, OUTPUT);
digitalWrite(EN, HIGH);
pinMode (PUL2, OUTPUT);
pinMode (DIR2, OUTPUT);
pinMode (EN2, OUTPUT);
digitalWrite(EN2, HIGH);
pinMode(LDR1, INPUT);
pinMode(LDR2, INPUT);
pinMode(LDR3, INPUT);
pinMode(LDR4, INPUT);
}
void loop() {
if (millis() - tiempolecturas > 2000UL) { // inicia los intevalos de lecturas de los pines analogicos
int R1 = analogRead(LDR1); // inicia la lectura del pin analogico A0
int R2 = analogRead(LDR2); // inicia la lectura del pin analogico A1
int R3 = analogRead(LDR3); // inicia la lectura del pin analogico A2
int R4 = analogRead(LDR4); // inicia la lectura del pin analogico A3
Serial.println(LDR1); // imprime en monitor serial la luz que recibe el pin analogico A0
Serial.println(LDR2); // imprime en monitor serial la luz que recibe el pin analogico A1
Serial.println(LDR3); // imprime en monitor serial la luz que recibe el pin analogico A2
Serial.println(LDR4); // imprime en monitor serial la luz que recibe el pin analogico A3
int diff1 = abs(R1 - R2); // establece las diferencias de la intensidad entre A0 y A1
int diff2 = abs(R3 - R4); // establece las diferencias de la intensidad entre A3 y A4
if ((diff1 >= error)) {
if (R1 > R2)
muevoNema(PUL, DIR, HIGH);
if (R1 < R2)
muevoNema(PUL, DIR, LOW);
}
if ((diff2 >= error)) {
if (R3 > R4)
muevoNema(DIR2, PUL2, HIGH);
if (R3 < R4)
muevoNema(DIR2, PUL2, LOW);
}
tiempolecturas = millis();
}
}
Hola @Surbyte, voy hacer pruebas
Saludos
Hola @Surbyte, ya probé, el motor 1 funciona de maravilla, movimientos suaves muy exactos, buena sensibilidad a las celdas. El motor 2 nada no se mueva en lo absoluto, ya inter cambie motores sensores drivers no es hardware y todo esta correcto sera que hay que declarar muevoNema de forma independiente?, Nema 1 Nema 2, o serán los pines del Arduino que 5-6-7 son son aptos para enviar pulsos de forma correcta a Nema
Saludos.
No fue eso ya cambie los pines 5-6-7 a R1-R2 y si funcionan de maravilla, no fueron los pines, ya declare dos void muevoNema_17 muevoNema_23 y tampoco, funciona con dos void, creo que algo tiene que ver el monitor Serial, siempre aparecen 14-15-17-18, y eso no tiene reacción con nada en un leonardo 18-19-21-22, no es necesario que tenga conectado nada, si conecto las celdas la repetición se da conforma a los millis establecidos, sin celdas la la lectura la hace miles de veces por segundo, lo que debería imprimir el monitos serial 0 a 1023, según la intensidad de la luz. El codigo base era con servos, los diff y el abs son muy típicos de códigos con servos pero porque el motor 1 funciona también.
Saludos.
No comprendo tu comentario. Dices haber cambiado 5-6-7 y si funciona de maravilla y luego que declaras dos void y que no lo hace, no se que dos void si solo te puse 1.
Porque no te ajustas a mi versión y avanzamos sobre algo de lo que ambos hablemos en sincronismo?
Ademas el procedimiento que yo cree surge de los que tu usas.
void muevoNema(int pinPUL, int pinDIR, int estado) {
Fijate que lo primero es el pin de pulsos (pinPUL) sea PUL o PUL2
Lo segundo el de direccion (pinDIR) sea DIR o DIR2
Y lo tercero el estado (estado) que deseas para la direccion sea HIGH o LOW
Cubres ambos Nema
Si Surbyte esta muy clara y acertada tu observación, lo de 5-6-7 era una prueba de hardware para ver si existía un problema en con PWM, en esos pines no lo hay problema, lo de hacer dos void solo fue una ocurrencia mía, que no trajo la solución,, lo de diff1 y diff2 no e podido comprobar si son la causa de que el motor 2 no lo active el código y al motor 1 lo active de manera perfecta, tu dime que sigue, yo dejo de hacer toda clase de intentos ideados en mi inquieto intelecto.
Que sigue?
Hola @Surbyte, ya termine de arreglar el código, con el que inicie el hilo, gracias a la ayuda de @anon90500195 y lo que aprendí con usted y el código minimalista que creo, pude deducir los errores que tenia ese código, (como estaba imposible que funcionase) no es bonito código pero ya funciona, solo faltaría agregar unos millis para que se detenga los motores un tiempo X para que sea funcional, lo subo para que lo revisen.
//https://forum.arduino.cc/t/seguidor-solar-de-motores-dcc-a-nema-17/986866/36
//nema 17-A
const int stepPin = 5;
const int dirPin = 6;
const int enPin = 7;
//nema17-B
const int stepPinA = 8;
const int dirPinA = 9;
const int enPinA = 10;
const unsigned long TIEMPO_LECTURAS = 2000UL;
// 4 fotoceldas
int Vplaca1 = A0;
int Vplaca2 = A1;
int Vplaca3 = A2;
int Vplaca4 = A3;
// calcula fc
int fc1 = A0;
int fc2 = A1;
int fc3 = A2;
int fc4 = A3;
unsigned long tiempolecturas;
void setup() {
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
pinMode(enPin, OUTPUT);
digitalWrite(enPin, HIGH);
pinMode(stepPinA, OUTPUT);
pinMode(dirPinA, OUTPUT);
pinMode(enPinA, OUTPUT);
digitalWrite(enPinA, HIGH);
pinMode(fc1, INPUT) ;
pinMode(fc2, INPUT) ;
pinMode(fc3, INPUT) ;
pinMode(fc4, INPUT) ;
Serial.begin(9600) ;
}
void loop() {
tiempolecturas = millis (); {
// read the values of the solar panels:
int V1 = analogRead(Vplaca2) ;
int Lekfc1 = V1 < 1;
int V2 = analogRead(Vplaca1) ;
int Lekfc2 = V2 < 2;
int V3 = analogRead(Vplaca3) ;
int Lekfc3 = V3 < 4;
int V4 = analogRead(Vplaca4) ;
int Lekfc4 = V4 < 3;
int Tolerancia = 60;
// left move:
int Dif1 = V1 - V2 ;
int Dif2 = V2 - V1 ;
// right move
int DifA = V2 - V1 ;
int DifB = V1 - V2 ;
//up move
int Dif5 = V3 - V4 ;
int Dif6 = V4 - V3 ;
//Down move
int DifC = V4 - V3 ;
int DifD = V3 - V4 ;
// Print voltage.
Serial.print(" V1- "); Serial.println( V1);
Serial.print(" V2- "); Serial.println(V2);
Serial.print(" V3- "); Serial.println(V3);
Serial.print(" V4- "); Serial.println(V4);
// estado de las restas de tensión:
Serial.println();
delay(1);
// left move:
if ((Lekfc1 == 0) && (((V1 > V2) && (Dif1 > Tolerancia)) || ((V2 < V1) && (Dif2 > Tolerancia) )))
{
digitalWrite(dirPin, HIGH);
for (int x = 0; x < 400; x++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
}
// right move
if ( (Lekfc2 == 0) && (( (V2 > V1) && (DifA > Tolerancia)) || ( (V1 < V2) && (DifB > Tolerancia) )))
{
digitalWrite(dirPin, LOW);
for (int x = 0; x < 400; x++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
}
//up move
if ((Lekfc3 == 0) && (((V3 > V4) && (Dif5 > Tolerancia)) || ((V4 < V3) && (Dif6 > Tolerancia))))
{
digitalWrite(dirPinA, HIGH);
for (int x = 0; x < 400; x++) {
digitalWrite(stepPinA, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPinA, LOW);
delayMicroseconds(1000);
}
}
//Down move
if ((Lekfc4 == 0) && (( (V4 > V3) && (DifC > Tolerancia) ) || ((V3 < V4) && (DifD > Tolerancia))))
{
digitalWrite(dirPinA, LOW);
for (int x = 0; x < 400; x++) {
digitalWrite(stepPinA, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPinA, LOW);
delayMicroseconds(1000);
}
}
}
}
Saludos.
Hola @anon90500195, ya funciona el código con el que inicie el hilo, me ayudaría si lo comentas porque estoy segura de que debe tener mas de un error de sintaxis, te agradezco tu paciencia y consejos.
Saludos.
Hola foro en español, ya le di una limpiada al código en maquina de estados, solo que no e podido vincular switch con los motores, en visual studio ya no da errores, en arduino si lo da, en el ciclo for de los pulsos del motor.
/*
Name: track_0017F.ino
Created: 16/05/2022 2:50:25
Author: DELL
*/
//https://forum.arduino.cc/t/seguidor-solar-de-motores-dcc-a-nema-17/986866
#include <arduino.h>
int LDR_X;
int LDR_Y;
int DIRECCION;
int INTERVALO_PULSOS_NEMA23;
int INTERVALO_PULSOS_NEMA17;
const unsigned long INTERVALO_LECTURAS_analogRead = 650UL;
const unsigned long INTERVALO_PULSO_NEMA23 = 650UL;
const unsigned int TOTAL_PASOS_NEMA23 = 2000;
const unsigned long INTERVALO_PULSO_NEMA17 = 650UL;
const unsigned int TOTAL_PASOS_NEMA17 = 2000;
const bool DIRECCION_X = LOW;
const bool DIRECCION_Y = HIGH;
const unsigned long TIEMPO_LECTURAS = 2000UL;
//int FOTOCELDAS;
const int LDR1 = A0;
const int LDR2 = A1;
const int LDR3 = A2;
const int LDR4 = A3;
int error = 50;
int i;
int ESTADO_NEMA23;
const int PUL = 5;
const int DIR = 6;
const int EN = 7;
int ESTADO_NEMA17;
const int PULA = 8;
const int DIRA = 9;
const int ENA = 10;
enum estado_N {
ESTADO_DIRECCION,
ESTADO_LDR_X,
ESTADO_LDR_Y,
ESTADO_DIRECCION_X,
ESTADO_DIRECCION_Y,
ESTADO_NEMA23_PULSO_LOW,
ESTADO_NEMA23_PULSO_HIGH,
ESTADO_NEMA17_PULSO_LOW,
ESTADO_NEMA17_PULSO_HIGH
} estado = ESTADO_DIRECCION;
const bool DIRECCIONA = !DIRECCIONA;
const bool DIRECCIONB = !DIRECCIONB;
const byte instantePasosnema23;
const byte instantePasosnema17;
boolean direccion = DIRECCION;
unsigned long tiempolecturas;
void setup() {
Serial.begin(9600);
pinMode(PUL, OUTPUT);
pinMode(DIR, OUTPUT);
pinMode(EN, OUTPUT);
digitalWrite(EN, HIGH);
pinMode(PULA, OUTPUT);
pinMode(DIRA, OUTPUT);
pinMode(ENA, OUTPUT);
digitalWrite(ENA, HIGH);
pinMode(LDR1, INPUT);
pinMode(LDR2, INPUT);
pinMode(LDR3, INPUT);
pinMode(LDR4, INPUT);
Serial.begin(9600);
}
void loop() {
if (millis() - tiempolecturas > 2000UL);
unsigned long millisActual = millis();
unsigned long microsActual = micros();
int LDR1 = analogRead(LDR1);
int LDR2 = analogRead(LDR2);
int LDR3 = analogRead(LDR3);
int LDR4 = analogRead(LDR4);
Serial.println(LDR1);
Serial.println(LDR2);
Serial.println(LDR3);
Serial.println(LDR4);
int diff1 = abs(LDR1 - LDR2);
int diff2 = abs(LDR2 - LDR1);
int diff3 = abs(LDR3 - LDR4);
int diff4 = abs(LDR4 - LDR3);
int error = 60;
switch (estado) {
case ESTADO_DIRECCION:
case ESTADO_LDR_X:
case ESTADO_LDR_Y:
case ESTADO_DIRECCION_X:
case ESTADO_DIRECCION_Y:
// mover izquierda
case ESTADO_NEMA23_PULSO_LOW: {
if ((diff1 > error))
if ((LDR1 > LDR2))
digitalWrite(DIR, HIGH);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL, LOW);
delayMicroseconds(1000);
}
}
break;
// mover deracha
case ESTADO_NEMA23_PULSO_HIGH: {
if ((diff2 > error))
if ((LDR2 < LDR1))
digitalWrite(DIR, HIGH);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL, LOW);
delayMicroseconds(1000);
}
}
break;
//mover arriba
case ESTADO_NEMA17_PULSO_LOW: {
if ((diff3 > error))
if ((LDR3 > LDR4))
digitalWrite(DIR, HIGH);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL, LOW);
delayMicroseconds(1000);
}
}
break;
//mover abajo
case ESTADO_NEMA17_PULSO_HIGH: {
if ((diff4 < error))
if ((LDR4 > LDR3))
digitalWrite(DIR, HIGH);
for (int i = 0; i < 400; i++) {
digitalWrite(PUL, HIGH);
delayMicroseconds(1000);
digitalWrite(PUL, LOW);
delayMicroseconds(1000);
}
}
break;
tiempolecturas = millis();
}
}
Saludos.
Hola foro en español, referente al código de la publicación #30, sabrán porque en el monitor serial da estos datos, en lugar de el voltaje que reciben las foto resistencias.
02:21:29.063 -> LDR
02:21:29.063 -> 14
02:21:29.063 -> 15
02:21:29.063 -> 17
02:21:29.063 -> 18
02:21:32.672 -> LDR
02:21:32.672 -> 14
02:21:32.672 -> 15
02:21:32.672 -> 17
02:21:32.672 -> 18
02:21:36.289 -> LDR
02:21:36.289 -> 14
02:21:36.289 -> 15
02:21:36.289 -> 17
02:21:36.289 -> 18
Saludos.
Me extraña que a estas alturas no veas un error de tipeo tan evidente...
En lugar de
Serial.println(LDR1);
debe ser
Serial.println(R1);
(lo mismo para las otras 3 impresiones)
De todos modos la salida será el valor leído por el ADC, para pasarlo a voltaje tienes que hacer el cálculo correspondiente.
Saludos