How to Control Your Actuator Using an Ultra-Sonic Sensor

20 de mayo de 2021

Cómo controlar su actuador usando un sensor ultrasónico

Josh Nigh

PA Engineer

Contents show

En ocasiones, cuando estamos creando un proyecto utilizando un actuador lineal , intentamos solucionar un problema que no podría solucionarse sin las ventajas que ofrecen estos mecanismos. Otras veces, intentamos facilitar una determinada tarea automatizándola. Pero de vez en cuando crearemos algo sólo porque podemos. Este es uno de esos proyectos.

[cta-contenido]

¡Lleva el control de tu actuador lineal al siguiente nivel con nuestros microcontroladores Arduino!

Aprende más

En este artículo, veremos cómo se puede usar un sensor ultrasónico para medir la distancia del actuador lineal de un objeto y usarlo para cambiar automáticamente la posición de la carrera del actuador. Si bien esto no se creó con ninguna aplicación específica en mente, las posibilidades son infinitas.

Esto es lo que necesitará

1 x Escudo del controlador del motor RobotPower MegaMoto
1 Arduino Uno.
1 sensor ultrasónico.
1 x PA-04-12-400-HS-24VDC (puede ser cualquier actuador con retroalimentación de efecto Hall)
1 x PS-20-24 (o cualquier fuente de alimentación de 24 VCC con capacidad nominal de al menos 6 amperios)

Para el control utilizamos un Arduino Uno con un controlador de motor MegaMoto. Nuestro actuador es el PA-04-12-400-HS-24VDC . Es importante que el actuador tenga algún tipo de retroalimentación para que Arduino pueda monitorear su posición; cualquier control de retroalimentación del actuador lineal puede funcionar, por ejemplo, la retroalimentación del potenciómetro también sería efectiva aquí. El potenciómetro sería menos preciso, pero tendría la ventaja de no requerir un procedimiento de referencia después de una pérdida de energía. También sería necesario modificar el código.

Paso 1: cableado

El cableado para este proyecto es muy sencillo. Aquí solo utilizaremos uno de los dos sensores de efecto Hall del PA-04-HS, no importa cuál (pin 4 o 5). La distribución de pines a continuación es para el conector Molex de 6 pines que viene con el PA-04-HS:

Conector de 6 pines del actuador a Arduino/MegaMoto

Pin 3 a 5V
Pin 2 a GND
Pin 1 al pin 2 de Arduino
Pin 4 a A en el MegaMoto
Pin 5 a B en el MegaMoto

Sensor ultrasónico para Arduino/Megamoto

VCC a 5V
Tierra a Tierra
Disparo al pin 8
Eco al pin 7

MegaMoto a la fuente de alimentación

+ a V+
- a V-

Paso 2: Programando el Arduino

El código utilizado en el tutorial es una versión modificada de lo que usamos en otra publicación, Sensores de efecto Hall 1: control de posición . ¡No dudes en echar un vistazo a este tutorial para comprender mejor cómo utilizamos el sensor de efecto Hall para el control de posición! El funcionamiento del sensor ultrasónico es transmitiendo un ping ultrasónico que se activa mediante uno de los pines GPIO del Arduino. Ese ping ultrasónico luego se refleja en un objeto y el receptor lo detecta. Cuando el receptor detecta el ping, envía un pulso al Arduino. A través de esto, podemos realizar una ecuación para calcular la distancia de un actuador lineal midiendo la cantidad de tiempo entre la transmisión y la recepción, y usar una fórmula para convertir esa medida en pulgadas.

La forma en que determinamos la posición del actuador es contando el número de pulsos emitidos por el sensor de efecto Hall (esto se describe con mayor detalle en la publicación mencionada anteriormente). Podemos determinar la posición de la carrera en pulgadas averiguando cuántos pulsos/pulgada emite nuestro actuador específico y luego dividiendo nuestro recuento de pulsos por ese número. Tener la lectura del sensor ultrasónico y la lectura del sensor de efecto Hall convertidas a pulgadas hace que la codificación sea mucho más limpia y sencilla. A partir de ahí, básicamente le estamos diciendo al Arduino "si el objeto está a x pulgadas de distancia, extienda el actuador x pulgadas". Cargar el código a continuación le permitirá implementar el modelo de distancia controlada por actuador lineal en uno de nuestros actuadores PA-04-12-400-HS-24VDC. En el siguiente paso repasaremos las modificaciones que se pueden realizar en el código.

 [código]
 /* El propósito de este código es poder medir la distancia de un objeto y posicionar el recorrido de un acuador lineal en consecuencia. 
* Los componentes necesarios son un Arduion Uno, un controlador PobotPower MegaMoto y un sensor ultrasónico.
 *Escrito por Automatizaciones Progresivas 02/02/21
 */

 #definir PWMA0 6
 #definir PWMB0 5
 #define enable0 13 //pines para MegaMoto

 #define hall0 2 // pines de interrupción para sensores de efecto hall

 #define echoPin 7 //pin de eco en el sensor ultrasónico
 #define trigPin 8 //salida en sensor ultrasónico

 duración de la flotación, distancia;

 int habilitar = 0; //habilitar pin para megaMoto

 int recuento[] = {0};
 int currentPos = 0;//posición actual
 umbral int = 100;//tolerancia de posición
 destino int = 0;

 bool adelante = falso;
 bool al revés = false;// estados motores

 configuración nula() {
 pinMode(PWMA0, SALIDA);
 pinMode(PWMB0, OUTPUT);//establecer salidas PWM

 pinMode(enable0, SALIDA);
 digitalWrite(enable0, LOW);//establece la habilitación y apaga la placa

 pinMode(hall0, ENTRADA);
 digitalWrite(hall0, LOW);//establecer hall, establecer nivel bajo para comenzar con el flanco ascendente

 adjuntarInterrupción(0, velocidad0, ASCENDENTE); //habilitar las interrupciones del efecto hall

 pinMode(trigPin,SALIDA);
 pinMode(echoPin, ENTRADA);
   
Serie.begin(9600);
 //homeActuator();//retrae completamente el actuador
 Serial.println("LISTO");
 }//finalizar configuración

 bucle vacío() {
 getDistance();//medir la distancia del objeto desde el sensor ultrasónico
 PosActual = contar[0];
 if(distancia < 13) //ignorar el valor si es mayor que la longitud del trazo
 {
 destino = distancia * 275; //traduce la distancia medida (en pulgadas) a la posición de carrera deseada (en pulsos)
 }
 if ((destino >= (currentPos - umbral)) && (destino <= (currentPos + umbral))) stopMoving();//detener el accionador si está en la posición deseada
 de lo contrario, si (destino > posición actual) goForwards();
 de lo contrario, si (destino <PosActual) goBackwards();

 Serial.print("Cuenta: "); Serial.println(cuenta[0]);
 Serial.print("Pos.Actual: "); Serial.println(PosActual);
 Serial.print("Destino: "); Serial.println(destino);

 }//finalizar bucle

 velocidad nula0() {
 //Serial.println("Actualización 1");
 if (hacia adelante == verdadero) cuenta[0]++; //si avanzamos, sumamos recuentos 
de lo contrario si (al revés == verdadero) cuenta[0]--; //si retrocedes, restas los recuentos
 }//velocidad final0

 /*void Entradas de lectura() {

 sw[0] = digitalRead(switch0), sw[1] = digitalRead(switch1);//verificar interruptores
 PosActual = contar[0];
 }//finalizar entradas de lectura
 */
 anular ir hacia adelante()
 {
 adelante = verdadero;
 al revés = falso;
 //Serial.println("Avanzando");
 digitalWrite(enable0, HIGH);//habilitar placa
 //Serial.print(" Velocidades "), Serial.print(spd[0]), Serial.print(", "), Serial.print(spd[1]);
 //Serial.print(" Cuentas "), Serial.println(cuenta[0]);
 escritura analógica(PWMA0, 255);
 analogWrite(PWMB0, 0);//aplicar velocidades
 }//fin de ir hacia adelante

 anular ir hacia atrás()
 {
 adelante = falso;
 al revés = verdadero;
 //Serial.println("Moviéndose hacia atrás");
 digitalWrite(enable0, HIGH);//habilitar placa
 //Serial.print(" Velocidades "), Serial.print(spd[0]), Serial.print(", "), Serial.print(spd[1]);
 //Serial.print(" Cuentas "), Serial.println(cuenta[0]);
 escritura analógica(PWMA0, 0);
 analogWrite(PWMB0, 255);//aplicar velocidades
 }//fin de ir hacia atrás

 parada vacía en movimiento ()
 {
 adelante = falso;
 al revés = falso; 
Serial.println("Detenido");
 escritura analógica(PWMA0, 0);
 analogWrite(PWMB0, 0);//establece las velocidades en 0
 retraso(10);


 digitalWrite(enable0, LOW);//deshabilitar placa
 }//finalizar detenerMovimiento

 anular getDistance()
 {
 escritura digital (trigPin, BAJO);
 retrasoMicrosegundos(10);
 escritura digital (trigPin, ALTA);
 retrasoMicrosegundos(10);
 escritura digital (trigPin, BAJO);

 duración = pulseIn(echoPin, ALTA);

 distancia = duración/58,2/2,5;
 Serial.print("Distancia:"); Serial.println(distancia);
 }

 void homeActuator() //retrae completamente el actuador y establece el conteo en 0
 {
 dar marcha atrás();
 delay(25000);//cambie este valor a la cantidad de tiempo que tarda el actuador en retraerse completamente
 contar[0] = {0};
 }
 [/código]

Paso 3: Modificar el código

El valor del umbral determina con qué precisión la posición del actuador debe coincidir con la lectura del sensor ultrasónico. Aumentarlo disminuirá la precisión, disminuirlo tendrá el efecto inverso. Al tener este valor establecido en 100, esencialmente le decimos al Arduino que no mueva el actuador siempre que los pulsos del efecto Hall y los sensores ultrasónicos estén a una distancia de 100 pulsos entre sí. Si este número es demasiado bajo, puede provocar que el actuador se mueva con frecuentes movimientos bruscos mientras intenta llegar a la posición exacta y correcta.

Cambie este valor a la longitud de carrera de su actuador (o una pulgada más). Esto le indicará al Arduino que ignore cualquier valor que sea demasiado alto.

Cambie este valor a los pulsos/pulgadas de su actuador.

[cta-contenido]

¡Nuestro PA-04-HS tiene un sensor de efecto Hall incorporado!