Hola espero y me puedan ayudar es que no se mucho de codigo lo que pasa es que tengo el muscle sensor(Señal analoga) con el cual muevo un servo, utilice el ejemplo que viene de servo Knob.
#include <Servo.h>
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180)
[color=red] if (val >= 100){
myservo.write(180);[/color] // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}
}
lo de rojo se lo agregue lo que quiero es que cuando se le la señal analoga >= 100 le mande al servo 180°, pero quiero que cuando se vuelva a leer la señal analoga >= 100 ahora le mande la servo 0°
espero y me puedan ayudar soy nuevo en esto
a lo mejor no me explique bien ya que nadie me responde o a lo mejor no es el codigo adecuado. Lo que quiero hacer es que tengo una señal analoga y quiero que la 1ra vez que esa señal suba a 500 o mas mueva un servo a 180 grados y la 2da vez que esa señal llegue a 500 mueva el servo a su posicion original 0 grados. Utilizo el Muscle Sensor V3 alguien que lo haya utilizado
que me de consejos.
Hola.
Está sin comprobar. Mira a ver si hace algo:
#include <Servo.h>
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the potentiometer
int lecturaanterior=0; // variable to read the value from the analog pin
int lecturanueva;
int valorservo=0;
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
myservo.write(valorservo);
delay(15);
}
void loop()
{
lecturanueva = analogRead(potpin);
lecturanueva = map(lecturanueva, 0, 1023, 0, 179);
if (lecturaanterior <100 && lecturanueva >= 100){ // Si la lectura anterior estaba por debajo de 100 y la actual por encima
if(valorservo==0)
valorservo=180;
else
valorservo=0;
myservo.write(valorservo); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}
lecturaanterior=lecturanueva;
}
void loop()
{
lecturanueva = analogRead(potpin);
lecturanueva = map(lecturanueva, 0, 1023, 0, 179);
if (lecturaanterior <100 && lecturanueva >= 100){ // Si la lectura anterior estaba por debajo de 100 y la actual por encima
if(valorservo==0){
while (valorservo<180){
valorservo++;
myservo.write(valorservo);
delay(5);
}
} else {
while (valorservo>0){
valorservo--;
myservo.write(valorservo);
delay(5);
}
}
}
lecturaanterior=lecturanueva;
}
Gracias noter ahora tengo otra duda el codigo que mandaste lo acomode para tres pero asi como lo puse solo me mueve los servos de 1 en 1 no los mueve los 3 juntos aunque los 3 pasen de 100. Mi pregunta es como le hago para que los haga los 3 juntos cuando los 3 pasen de 100?
void loop()
{
lecturanueva = analogRead(potpin);
lecturanueva = map(lecturanueva, 0, 600, 0, 179);
Serial.print(" Lec 1= ");
Serial.print(lecturanueva, DEC);
Serial.print(" Lec 2= ");
Serial.print(lecturanueva1, DEC);
Serial.print(" Lec 3= ");
Serial.println(lecturanueva2, DEC);
delay(100);
if (lecturaanterior <100 && lecturanueva >= 100){ // Si la lectura anterior estaba por debajo de 100 y la actual por encima
if(valorservo==167){
while (valorservo>16){
valorservo--;
myservo.write(valorservo);
delay(10);
}
} else {
while (valorservo<167){
valorservo++;
myservo.write(valorservo);
delay(10);
}
}
}
lecturaanterior=lecturanueva;
lecturanueva1 = analogRead(potpin1);
lecturanueva1 = map(lecturanueva1, 0, 600, 0, 179);
//Serial.println(lecturanueva1, DEC);
if (lecturaanterior1 <100 && lecturanueva1 >= 100){ // Si la lectura anterior estaba por debajo de 100 y la actual por encima
if(valorservo1==16){
while (valorservo1<60){
valorservo1++;
myservo1.write(valorservo1);
delay(30);
}
} else {
while (valorservo1>16){
valorservo1--;
myservo1.write(valorservo1);
delay(30);
}
}
}
lecturaanterior1=lecturanueva1;
lecturanueva2 = analogRead(potpin2);
lecturanueva2 = map(lecturanueva2, 0, 600, 0, 179);//26, 125);
//Serial.println(lecturanueva2, DEC);
if (lecturaanterior2 <100 && lecturanueva2 >= 100){ // Si la lectura anterior estaba por debajo de 100 y la actual por encima
if(valorservo2==125){
while (valorservo2>26){
valorservo2--;
myservo2.write(valorservo2);
delay(30);
}
} else {
while (valorservo2<125){
valorservo2++;
myservo2.write(valorservo2);
delay(30);
}
}
}
lecturaanterior2=lecturanueva2;
}
Y tambien como puedo hacer para que con una misma lectura analoga pueda controlar 2 servos por decir que cuando lea 50 mueva 1 servo y cuando lea 100 mueva el otro servo. Lo intente hacer pero solo movia el que leia 50 y el de 100 no porque siempre llegaba antes a 50
Efectivamente, la programación actualmente está encaminada a que cuando se detecta la subida de la lectura analógica realice el movimiento del servo, desatendiendo todo lo demás. Es el eterno problema de la programación: ¿cómo hacer varias cosas simultáneamente? La respuesta es "un trozo de tarea en cada momento". En tu caso, podemos, por ejemplo, establecer una variable int para cada servo que cambiaremos a +1, 0 ó -1 según el servo deba estar subiendo, parado o bajando. En cada recorrido del loop sumaremos ese número a cada servo y lo escribiremos en el servo correspondiente, controlando que si llega arriba o abajo del todo, ponerla a cero para que deje de incrementar o decrementar. Quedaría por ver qué debe ocurrir si durante la subida o bajada la lectura analógica cambia (si debe olvidarse y acabar el ciclo o invertir el sentido del movimiento). Mira a ver si este código te sirve de ayuda (está sin comprobar). Teóricamente, con una sola lectura analógica debería controlar los tres servos según tres niveles establecidos (en lugar de mapear utilizo la lectura directa, que debería estar entre 0 y 1023, pero también puedes mapearla)
#include <Servo.h>
Servo myservo1;
Servo myservo2;
Servo myservo3;
int potpin = 0;
int lecturaanterior=0;
int lecturanueva;
int valorservo1=0;
int valorservo2=0;
int valorservo3=0;
int incremento1=0;
int incremento2=0;
int incremento3=0;
void setup()
{
myservo1.attach(9);
myservo1.write(valorservo1);
myservo2.attach(10);
myservo2.write(valorservo2);
myservo3.attach(11);
myservo3.write(valorservo3);
delay(15);
}
void loop()
{
lecturanueva = analogRead(potpin);
if (lecturaanterior <250 && lecturanueva >= 250){ // si la lectura analógica ha saltado por encima de 250
if(valorservo1==0 || incremento1<0) // Si está parado en posición 0 o esta decrementando, cambiamos a incremento.
incremento1=1;
else // Si no, cambiamos a decremento.
incremento1=-1;
}
if (lecturaanterior <500 && lecturanueva >= 500){
incremento2 = valorservo2==0 || incremento2<0 ? 1 : -1; // otra forma de escribir el mismo if anterior
}
if (lecturaanterior <750 && lecturanueva >= 750){ // igual que los otros dos
incremento3 = valorservo3==0 || incremento3<0 ? 1 : -1;
}
lecturaanterior=lecturanueva;
// Incrementamos los valores de servo según su estado (subiendo, parado, bajando)
valorservo1 += incremento1;
valorservo2 += incremento2;
valorservo3 += incremento3;
// Si el servo está en un extremo u otro, detenemos incremento o decremento
if (valorservo1<=0 || valorservo1>=180) incremento1=0;
if (valorservo2<=0 || valorservo2>=180) incremento2=0;
if (valorservo3<=0 || valorservo3>=180) incremento3=0;
// Escribimos los valores correspondientes en cada servo
myservo1.write(valorservo1);
myservo2.write(valorservo2);
myservo3.write(valorservo3);
}