Go Down

Topic: Variar a velocidade de um servo motor pelo intervalo de tempo (Read 237 times) previous topic - next topic

rodrigointerart

Jun 10, 2018, 06:50 am Last Edit: Jun 10, 2018, 05:31 pm by surbyte Reason: Add code tags
Boa noite pessoal, preciso de ajuda para entender como consigo variar a velocidade de um servo motor pelo intervalo de tempo, ou seja...
Tenho 2 potenciometros que estao nas portas A0 e A1, tenho 2 servos que estão nas portas 9 e 10 e um pull button que serve para gravar o movimento.
Cada vez que é pressionado o botão ele grava o valor dos dois potenciometros.
Um exemplo do que preciso, o servo 1 vai executar um movimento de 0 a 30 graus numa velocidade sempre constante e o servo 2 vai de 50 a 180 graus , preciso que servo 2 desloque os 130 graus no mesmo tempo em que o servo 1 desloque os 30 graus.


Code: [Select]
#include <VarSpeedServo.h>
#include <EEPROM.h>

#define espacoMemoria 199
#define tempoPausaEntreMovimentos 500  //configura o tempo de pausa entre cada movimento


#define pinServo4  10
#define pinServo5  9

#define pinBotao1     3
#define pinBotao2     2

#define pinLedA       5
#define pinLedB       4


#define pinPot4      A0
#define pinPot5      A1
#define pinPot6      A2

VarSpeedServo servo4;
VarSpeedServo servo5;

byte pinBotao1Modo();
bool pinBotao2Retencao();
void pinLedAPisca(bool reset = false);
void setMemoria(byte posicao, byte servo, byte valor);
byte readMemoria(byte posicao, byte servo);

int ultMemoria;

void setup() {

 servo4.attach(pinServo4);
 servo5.attach(pinServo5);
 

 pinMode(pinLedA, OUTPUT);
 pinMode(pinLedB, OUTPUT);

 pinMode(pinBotao1, INPUT_PULLUP);
 pinMode(pinBotao2, INPUT_PULLUP);

 ultMemoria = EEPROM.read(0);
}

void loop() {
static byte modo = 0;
static byte modoAnt;
static byte movimento = 0;
static byte posMemoria = 0;
static unsigned long delayPausa;

 //Modo Normal
 if (modo == 0) {
    digitalWrite(pinLedA, LOW);

    if (pinBotao2Retencao()) {
       digitalWrite(pinLedB, HIGH);

       //executa um movimento  
       if (movimento == 0) {
         byte velocidade = map(analogRead(pinPot6),0,1023,0,255);  
     
         servo4.slowmove(readMemoria(posMemoria,3), velocidade);
         servo5.slowmove(readMemoria(posMemoria,4), velocidade);
       
         movimento = 1;
       }

       //aguarda término de um movimento para selecionar o próximo movimento
       if (movimento == 1) {
         if ( (servo4.read() == readMemoria(posMemoria,3)) &&
              (servo5.read() == readMemoria(posMemoria,4)) ) {
 
            posMemoria++;
            if (posMemoria > ultMemoria) { posMemoria = 0; }
           
            delayPausa = millis();
            movimento = 2;
         }
       }

       //pausa entre movimentos
       if (movimento == 2) {
          if ((millis() - delayPausa) > tempoPausaEntreMovimentos) {
             movimento = 0;
          }
       }
       
    } else {
       digitalWrite(pinLedB, LOW);
       
       if (pinBotao1Modo() == 2) {
          modo = 1;
       }
    }
 }

 //Modo Gravação
 if (modo == 1) {

    if (modoAnt == 0) {
       pinLedAPisca(true);
       ultMemoria = -1;      
       EEPROM.write(0, ultMemoria);  
    }
   
    digitalWrite(pinLedB, LOW);
    pinLedAPisca();

    if (pinBotao1Modo() == 2) {
       modo = 0;
    }

   
    servo4.write( map(analogRead(pinPot4),0,1023,0,179) );    
    servo5.write( map(analogRead(pinPot5),0,1023,0,179) );  
 

    if (pinBotao2Apertado()) {
       ultMemoria++;
       EEPROM.write(0, ultMemoria);
     
       setMemoria(ultMemoria, 3, map(analogRead(pinPot4),0,1023,0,179));
       setMemoria(ultMemoria, 4, map(analogRead(pinPot5),0,1023,0,179));

       digitalWrite(pinLedB, HIGH);
       delay(250);
       digitalWrite(pinLedB, LOW);

       if ( ultMemoria == (espacoMemoria - 1)) {
           modo = 0;
       }
    }
 }

 modoAnt = modo;
}

byte pinBotao1Modo() {
#define tempoDebounce 40 //(tempo para eliminar o efeito Bounce EM MILISEGUNDOS)
#define tempoBotao    1500

  bool estadoBotao;
  static bool estadoBotaoAnt;
  static byte estadoRet = 0;
  static unsigned long delayBotao = 0;
  static byte enviado = 0;

  if ( (millis() - delayBotao) > tempoDebounce ) {
      estadoBotao = digitalRead(pinBotao1);
      if (estadoRet == 0) {
         if ( !estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
            estadoRet = 1;
            delayBotao = millis();
         }
      }

      if (estadoRet == 1) {
         if ( estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
            estadoRet = 0;
            delayBotao = millis();
         }
      }
      estadoBotaoAnt = estadoBotao;      
  }

  if (estadoRet == 1) {
     if ((millis() - delayBotao) > tempoBotao) {
        estadoRet = 2;
        delayBotao = millis();
      }
  }

  if (estadoRet == 2) {
     enviado++;
         
     if (enviado >= 2) {
        estadoRet = 0;
        delayBotao = millis();
        enviado = 0;
     }        
  }

  return estadoRet;
}

bool pinBotao2Retencao() {
#define tempoDebounce 40 //(tempo para eliminar o efeito Bounce EM MILISEGUNDOS)

  bool estadoBotao;
  static bool estadoBotaoAnt;
  static bool estadoRet = false;
  static unsigned long delayBotao = 0;

  if ( (millis() - delayBotao) > tempoDebounce ) {
      estadoBotao = digitalRead(pinBotao2);
      if ( !estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
         estadoRet = !estadoRet;
         delayBotao = millis();
      }
      if ( estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
         delayBotao = millis();
      }
      estadoBotaoAnt = estadoBotao;
  }

  return estadoRet;
}

bool pinBotao2Apertado() {
#define tempoDebounce 40 //(tempo para eliminar o efeito Bounce EM MILISEGUNDOS)

  bool estadoBotao;
  static bool estadoBotaoAnt;
  static bool estadoRet;
  static unsigned long delayBotao = 0;

  estadoRet = false;
  if ( (millis() - delayBotao) > tempoDebounce ) {
      estadoBotao = digitalRead(pinBotao2);
      if ( !estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
         estadoRet = true;
         delayBotao = millis();
      }
      if ( estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
         delayBotao = millis();
      }
      estadoBotaoAnt = estadoBotao;
  }

  return estadoRet;
}

void pinLedAPisca(bool reset) {
static unsigned long delayPisca = 0;

  if (reset) {
     delayPisca = millis();
  } else {

    if ((millis() - delayPisca) < 500) {
       digitalWrite(pinLedA, LOW);
    } else {
       digitalWrite(pinLedA, HIGH);
    }
   
    if ((millis() - delayPisca) >= 1000) {
       delayPisca = millis();
    }  
  }
}

void setMemoria(byte posicao, byte servo, byte valor) {
int posMem;

   posMem = ((posicao * 5) + servo) + 1;
   EEPROM.write(posMem, valor);
}

byte readMemoria(byte posicao, byte servo) {
int posMem;

   posMem = ((posicao * 5) + servo) + 1;
   return EEPROM.read(posMem);
}




Obrigado e fico no aguardo !!!

bubulindo

Calcula a diferença de posição entre cada um.

Divide ambas as diferenças por, por exemplo, 10. Isto vai ser o valor dos passos a dar.

Dentro dum for, dá os dez passos com valores diferentes para cada um dos servos.
This... is a hobby.

ProfCristiano

Tente esta biblioteca. Ou veja como foi sua implementação e faça igual.

Eu uso esta bilioteca em uma plataforma MeArm e é muito satisfatória.

https://github.com/netlabtoolkit/VarSpeedServo

Go Up