Em nossa última publicação "Como fazer", vamos explicar como controlar a temporização do movimento de um atuador linear usando um microcontrolador. Microcontroladores oferecem muita liberdade no controle de movimento e este é apenas um exemplo de uma quantidade quase infinita de opções de controle disponíveis. Dependendo da sua aplicação, o projeto de exemplo deste artigo pode ser ajustado para atender às suas necessidades — seja adicionando outro atuador temporizado ou reforçando a fonte de alimentação para lidar com um atuador linear mais potente, a decisão é sua.
Controle de movimento usando um microcontrolador
Usaremos um microcontrolador Arduino para controlar a temporização do movimento de um atuador linear, mas qualquer microcontrolador serve. No entanto, como estamos usando um shield, o microcontrolador precisa ser compatível. Vamos apresentar os diversos parâmetros que você pode ajustar para alterar a velocidade de um atuador linear.
O que você vai precisar
Para este exemplo, usaremos os seguintes componentes para controlar um atuador linear:
- 1 x MegaMoto Plus
- 1 x Arduino Uno Rev3
- 1 x Mini Atuador Industrial (PA-09, mas qualquer atuador linear serve)
- 1 x Fonte de alimentação (PS-20-12, mas qualquer fonte de 12 V serve)
Conectando os componentes
Agora que temos os materiais, vamos conectar tudo. Felizmente, as conexões são simples usando um shield, em vez de uma placa separada que exigiria fiação e soldagem adicionais.
Primeiro, vamos conectar nosso atuador ao nosso shield LC-80 MegaMoto Plus, conectando os dois cabos do atuador aos terminais de parafuso A/B no LC-80. Em seguida, precisamos conectar o LC-80 à nossa fonte de alimentação, neste caso, a PS-20-12. Fazemos isso conectando os cabos positivo e negativo da fonte de alimentação aos terminais BAT +/- do LC-80.
Por fim, precisamos conectar o LC-80 ao LC-066, o que é tão simples quanto encaixar um sobre o outro, como mostrado na imagem abaixo.
Ajustando o código
Para termos controle total sobre o movimento do nosso atuador, precisaremos fazer um pouco de programação de atuador linear com nossa unidade Arduino. Preparamos um código de exemplo que faz nosso atuador estender e depois retrair por 10 segundos em cada sentido, dentro de um ciclo de 300 segundos.
//Use the jumpers on the board to select which pins will be used
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;
int extendtime = 10 * 1000; // 10 seconds, times 1000 to convert to milliseconds
int retracttime = 10 * 1000; // 10 seconds, times 1000 to convert to milliseconds
int timetorun = 300 * 1000; // 300 seconds, times 1000 to convert to milliseconds
int duty;
int elapsedTime;
boolean keepMoving;
void setup() {
Serial.begin(9600);
pinMode(EnablePin1, OUTPUT);//Enable the board
pinMode(PWMPinA1, OUTPUT);
pinMode(PWMPinB1, OUTPUT);//Set motor outputs
elapsedTime = 0; // Set time to 0
keepMoving = true; //The system will move
}//end setup
void loop() {
if (keepMoving)
{
digitalWrite(EnablePin1, HIGH); // enable the motor
pushActuator();
delay(extendtime);
stopActuator();
delay(10);//small delay before retracting
pullActuator();
delay(retracttime);
stopActuator();
elapsedTime = millis();//how long has it been?
if (elapsedTime > timetorun) {//if it's been 300 seconds, stop
Serial.print("Elapsed time is over max run time. Max run time: ");
Serial.println(timetorun);
keepMoving = false;
}
}//end if
}//end main loop
void stopActuator() {
analogWrite(PWMPinA1, 0);
analogWrite(PWMPinB1, 0); // speed 0-255
}
void pushActuator() {
analogWrite(PWMPinA1, 255);
analogWrite(PWMPinB1, 0); // speed 0-255
}
void pullActuator() {
analogWrite(PWMPinA1, 0);
analogWrite(PWMPinB1, 255);//speed 0-255
}
É importante analisar o código, linha por linha, para entender o que está acontecendo. Assim, você pode personalizá-lo para executar muitas outras tarefas. Por enquanto, porém, a parte mais importante é a primeira seção e o loop de configuração, que se concentram em atribuir pinos e definir a velocidade do ciclo.
Você precisa configurar os pinos no nosso LC-80 para corresponder ao que está na primeira seção do código, definindo os jumpers no LC-80 ou ajustando o código. Neste caso, defina o pino "Enable" como D13, o pino "PWMA" como D11 e o pino "PWMB" como D3. O pino "Enable" controla e alimenta o motor e, sem ele, o atuador deixará de se mover e não poderá ser controlado. Os pinos “PWMA” e “PWMB” controlam a extensão e a retração do atuador. Não precisamos dos pinos "Sensor" neste exemplo, então não se preocupe em selecionar nada ali.
O controle por temporizador de um atuador linear está concluído. Você pode enviar o código para o Arduino usando o IDE deles (baixado no site da Arduino). Depois que o seu atuador linear estiver estendendo e retraindo, que tal brincar um pouco com o código? Tente ajustar o tempo de extensão/retração no código, envie-o novamente para o Arduino e veja como o atuador linear responde. Ao ajustar esses números no código, você pode controlar a velocidade e o tempo total do ciclo de movimento de acordo com a aplicação desejada.
Conclusão
Abaixo incluímos um vídeo de um atuador com temporização em ação. No exemplo do vídeo, quisemos mostrar outra maneira de alterar a temporização, então programamos para estender e retrair por 5 segundos de cada vez em um ciclo de 20 segundos.
Conforme mencionado, este é apenas um exemplo de como você pode alterar o movimento de um atuador com a ajuda dos nossos microcontroladores. Se você tiver em mente um método de controle personalizado, é possível criar um sistema de controle feito especificamente para as suas necessidades personalizadas com a ajuda da nossa talentosa equipe de engenharia. Eles vão orientá-lo durante o processo e garantir que você tenha controle total sobre suas unidades. Se quiser saber mais sobre o processo de pedido personalizado, dê uma olhada na nossa página de pedido personalizado.