Servomotor de interfaz con brazo7

En nuestro tutorial anterior, hemos interconectado el motor paso a paso con ARM7-LPC2148. En este tutorial, controlaremos el servomotor con ARM7-LPC2148. El servomotor tiene una ventaja de bajo consumo de energía sobre el motor paso a paso. Un servomotor detiene su consumo de energía cuando se alcanza la posición deseada, pero el motor paso a paso continúa consumiendo energía para bloquear el eje en la posición deseada. Los servomotores se utilizan principalmente en proyectos de robótica debido a su precisión y fácil manejo.

En este tutorial aprenderemos sobre el servomotor y cómo interconectar el servo con ARM7-LPC2148. También se interconecta un potenciómetro para variar la posición del eje del servomotor y una pantalla LCD para mostrar el valor del ángulo.

Servo motor

Un servomotor es una combinación de motor de CC, sistema de control de posición y engranajes. La rotación del servomotor se controla aplicándole una señal PWM, el ancho de la señal PWM decide el ángulo de rotación y la dirección del motor. Aquí usaremos el servomotor SG90 en este tutorial, es uno de los más populares y más baratos. SG90 es un servo de 180 grados. Entonces con este servo podemos posicionar el eje de 0-180 grados:

Voltaje de funcionamiento: + 5 V
Tipo de engranaje: plástico
Ángulo de rotación: 0 a 180 grados
Peso: 9gm
Par de torsión: 2,5 kg / cm

Antes de que podamos comenzar a programar para el servomotor, debemos saber qué tipo de señal se enviará para controlar el servomotor. Debemos programar la MCU para enviar señales PWM al cable de señal del servomotor. Hay un circuito de control dentro del servomotor que lee el ciclo de trabajo de la señal PWM y coloca el eje del servomotor en el lugar respectivo, como se muestra en la siguiente imagen.

Por cada 20 milisegundos, el servomotor verifica el pulso. Por lo tanto, ajuste el ancho de pulso de la señal para hacer girar el eje del motor.

Ancho de pulso de 1 ms (1 milisegundo) para la rotación del servo a 0 grados
Ancho de pulso de 1,5 ms para rotación a 90 grados (posición neutra)
Ancho de pulso de 2 ms para la rotación del servo a 180 grados.

Antes de conectar el servo a ARM7-LPC2148, puede probar su servo con la ayuda de este circuito probador de servomotor. Compruebe también cómo se puede conectar un servomotor con otros microcontroladores:

Control de servomotor usando Arduino
Interfaz de servomotor con microcontrolador 8051
Control de servomotor con MATLAB
Control de servomotor con Raspberry Pi
Interfaz de servomotor con MSP430G2
Interfaz de servomotor con STM32F103C8

Control de servomotor usando LPC2148 PWM y ADC

Un servomotor puede ser controlado por LPC2148 usando PWM. Al proporcionar una señal PWM al pin PWM de SERVO con un período de 20ms y una frecuencia de 50Hz, podemos posicionar el eje del servomotor alrededor de 180 grados (-90 a +90).

Se utiliza un potenciómetro para variar el ciclo de trabajo de la señal PWM y rotar el eje del servomotor; este método se implementa mediante el módulo ADC en LPC2148. Por lo tanto, necesitamos que se implementen los conceptos de PWM y ADC en este tutorial. Por lo tanto, consulte nuestros tutoriales anteriores para aprender PWM y ADC en ARM7-LPC2148.

Cómo usar PWM en ARM7-LPC2148
Cómo utilizar ADC en ARM-LPLC2148

Pines PWM y ADC en ARM7-LPC2148

La siguiente imagen muestra los pines PWM y ADC en LPC2148. Los recuadros amarillos indican los (6) pines PWM y el recuadro negro indica los (14) pines ADC.

Componentes requeridos

Hardware

ARM7-LPC2148
Módulo de pantalla LCD (16x2)
Servomotor (SG-90)
Regulador de voltaje de 3.3V
Potenciómetro de 10k (2 números)
Tablero de circuitos
Conexión de cables

Software

Keil uVision5
Herramienta Flash Magic

Diagrama de circuito y conexiones

La siguiente tabla muestra la conexión entre el servomotor y ARM7-LPC2148:

PINES SERVO	ARM7-LPC2148
ROJO (+ 5V)	+ 5V
MARRÓN (GND)	GND
NARANJA (PWM)	P0.1

El pin P0.1 es la salida PWM de LPC2148.

La siguiente tabla muestra las conexiones del circuito entre LCD y ARM7-LPC2148.

ARM7-LPC2148	LCD (16x2)
P0.4	RS (Seleccionar registro)
P0.6	E (habilitar)
P0.12	D4 (pin de datos 4)
P0.13	D5 (pin de datos 5)
P0.14	D6 (pin de datos 6)
P0.15	D7 (pin de datos 7)
GND	VSS, R / W, K
+ 5V	VDD, A

La siguiente tabla muestra las conexiones entre ARM7 LPC2148 y el potenciómetro con regulador de voltaje de 3.3V.

Regulador de voltaje de 3.3V IC	Función pin	Pin ARM-7 LPC2148
1.Pin izquierdo	- Ve de GND	Pin GND
2.Pin central	Salida regulada de + 3.3V	A la entrada del potenciómetro y la salida del potenciómetro a P0.28 de LPC2148
3.Pin derecho	+ Ve desde 5V ENTRADA	+ 5V

Puntos a tener en cuenta

1. Aquí se usa un regulador de voltaje de 3.3V para proporcionar un valor de entrada analógica al pin ADC (P0.28) de LPC2148. Como usamos una potencia de 5V, necesitamos regular el voltaje con un regulador de voltaje de 3.3V.

2. Se usa un potenciómetro para variar el voltaje entre (0V a 3.3V) para proporcionar entrada analógica (ADC) al pin P0.28 del LPC2148

3. El pin P0.1 de LPC2148 proporciona salida PWM al servomotor para controlar la posición del motor.

4. De acuerdo con el valor de la entrada analógica (ADC), la posición del servomotor cambia de (0 a 180 grados) a través del pin de salida PWM en P0.1 de LPC2148.

Programación de ARM7-LPC2148 para control de servomotor

Para programar ARM7-LPC2148 necesitamos la herramienta keil uVision y Flash Magic. Estamos usando un cable USB para programar ARM7 Stick a través del puerto micro USB. Escribimos código usando Keil y creamos un archivo hexadecimal y luego el archivo HEX se actualiza a la barra ARM7 usando Flash Magic. Para saber más sobre la instalación de keil uVision y Flash Magic y cómo usarlos, siga el enlace Comenzando con el microcontrolador ARM7 LPC2148 y prográmelo usando Keil uVision.

Pasos involucrados en la configuración de LPC2148 para PWM y ADC para controlar el servomotor

Paso 1: - Incluya los archivos de encabezado necesarios para codificar LPC2148

#incluir #incluir #incluir #incluir

Paso 2: - Lo siguiente es configurar el PLL para la generación de reloj, ya que establece el reloj del sistema y el reloj periférico de LPC2148 según las necesidades de los programadores. La frecuencia de reloj máxima para LPC2148 es 60Mhz. Las siguientes líneas se utilizan para configurar la generación de reloj PLL.

void initilizePLL (void) // Función para usar PLL para la generación de reloj { PLL0CON = 0x01; PLL0CFG = 0x24; PLL0FEED = 0xAA; PLL0FEED = 0x55; while (! (PLL0STAT & 0x00000400)); PLL0CON = 0x03; PLL0FEED = 0xAA; PLL0FEED = 0x55; VPBDIV = 0x01; }

Paso 3: - Lo siguiente que debe hacer es seleccionar los pines PWM y la función PWM de LPC2148 utilizando el registro PINSEL. Usamos PINSEL0 como usamos P0.1 para la salida PWM de LPC2148.

PINSEL0 - = 0x00000008; // Configuración del pin P0.1 de LPC2148 como PWM3

Paso 4: - A continuación, necesitamos RESETEAR los temporizadores usando PWMTCR (Registro de control del temporizador).

PWMTCR = 0x02; // Restablecer y deshabilitar el contador para PWM

Y luego, establezca el valor de preescala que decide la resolución de PWM.

PWMPR = 0x1D; // Valor del registro de preescala

Paso 5: - A continuación, configure el PWMMCR (registro de control de coincidencia de PWM) ya que establece operaciones como reinicio, interrupciones para PWMMR0 y PWMMR3.

PWMMCR = 0x00000203; // Restablecer e interrumpir en la coincidencia de MR0, interrumpir en la coincidencia de MR3

Paso 6: - El período máximo del canal PWM se establece mediante PWMMR0 y la tonelada del ciclo de trabajo PWM se establece inicialmente en 0,65 ms

PWMMR0 = 20000; // Período de tiempo de la onda PWM, 20 ms PWMMR3 = 650; // Tonelada de onda PWM 0,65 mseg

Paso 7: - A continuación, debemos configurar Latch Enable en los registros de coincidencia correspondientes usando PWMLER

PWMLER = 0x09; // Activar bloqueo para PWM3 y PWM0

(Usamos PWMMR0 & PWMMR3) Entonces habilite el bit correspondiente configurando 1 en PWMLER

Paso 8: - Para habilitar la salida PWM al pin, necesitamos usar el PWMTCR para habilitar los contadores del temporizador PWM y los modos PWM.

PWMPCR = 0x0800; // Habilita PWM3 y PWM 0, PWM controlado por un solo flanco PWMTCR = 0x09; // Habilita PWM y contador

Paso 9: - Ahora necesitamos obtener los valores del potenciómetro para configurar el ciclo de trabajo de PWM desde el pin P0.28 del ADC. Entonces, usamos el módulo ADC en LPC2148 para convertir la entrada analógica de potenciómetros (0 a 3.3V) a los valores ADC (0 a 1023).

Paso 10: - Para seleccionar el pin ADC P0.28 en LPC2148, usamos

PINSEL1 = 0x01000000; // Configurando P0.28 como ADC INPUT AD0CR = (((14) << 8) - (1 << 21)); // Configuración de reloj y PDN para conversión A / D

Las siguientes líneas capturan la entrada analógica (0 a 3,3 V) y la convierten en valor digital (0 a 1023). Y luego estos valores digitales se dividen por 4 para convertirlos en (0 a 255) y finalmente se alimentan como salida PWM en el pin P0.1 de LPC2148. Aquí estamos convirtiendo los valores de 0-1023 a 0-255 dividiéndolos con 4 ya que el PWM de LPC2148 tiene una resolución de 8 bits (28).

AD0CR - = (1 << 1); // Seleccione el canal AD0.1 en el registro ADC delaytime (10); AD0CR - = (1 << 24); // Inicie la conversión A / D while ((AD0DR1 & (1 << 31)) == 0); // Verifique el bit DONE en el registro de datos ADC adcvalue = (AD0DR1 >> 6) & 0x3ff; // Obtener el RESULTADO del registro de datos de ADC dutycycle = adcvalue / 4; // fórmula para obtener valores del ciclo de trabajo de (0 a 255) PWMMR1 = ciclo de trabajo; // establece el valor del ciclo de trabajo en el registro de coincidencia PWM PWMLER - = (1 << 1); // Habilita la salida PWM con el valor del ciclo de trabajo

Paso 11: - A continuación, mostramos esos valores en el módulo de pantalla LCD (16X2). Entonces agregamos las siguientes líneas para inicializar el módulo de pantalla LCD

Void LCD_INITILIZE (void) // Función para preparar el LCD { IO0DIR = 0x0000FFF0; // Configura el pin P0.12, P0.13, P0.14, P0.15, P0.4, P0.6 como tiempo de retardo de SALIDA (20); LCD_SEND (0x02); // Inicializar lcd en modo de operación de 4 bits LCD_SEND (0x28); // 2 líneas (16X2) LCD_SEND (0x0C); // Mostrar en cursor apagado LCD_SEND (0x06); // Cursor de incremento automático LCD_SEND (0x01); // Mostrar claro LCD_SEND (0x80); // Primera línea, primera posición }

Como conectamos LCD en modo de 4 bits con LPC2148, necesitamos enviar valores para que se muestren como mordisco por nibble (nibble superior y nibble inferior). Entonces se usan las siguientes líneas.

void LCD_DISPLAY (char * msg) // Función para imprimir los caracteres enviados uno a uno { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envía el nibble superior IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH para imprimir datos IO0CLR = 0x00000020; // RW LOW Modo de escritura delaytime (2); IO0CLR = 0x00000040; // EN = 0, RS y RW sin cambios (es decir, RS = 1, RW = 0) delaytime (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envía un nibble inferior IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; delaytime (2); IO0CLR = 0x00000040; delaytime (5); i ++; } }

Para mostrar esos valores ADC y PWM usamos las siguientes líneas en la función int main () .

LCD_SEND (0x80); sprintf (displayadc, "adcvalue =% f", ciclo de trabajo); LCD_DISPLAY (displayadc); // Muestra el valor ADC (0 a 1023) angle = (adcvalue / 5.7); // Fórmula para convertir el valor ADC en ángulo (o a 180 grados) LCD_SEND (0xC0); sprintf (anglevalue, "ANGLE =%. 2f deg", ángulo); LCD_DISPLAY (valor de ángulo);

El código completo y la descripción del video del tutorial se dan a continuación.