Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
You are viewing an older revision! See the latest version
PROGRAM MOVIMIENTO SERVOMOTORES
Movimiento de servo-motores con la tarjeta de programación NUCLEO-F411RE¶
Selección de la Tarjeta de Programación¶
En esta sección se explica la forma de escoger o de cargar al MBED, la tarjeta de programación que se usará, en este caso, será la STMNucleo-F411RET6.
PASO 1¶
Primeramente, ingresamos a nuestra cuenta MBED
PASO 2¶
Para seleccionar la tarjeta correspondiente, en la esquina superior derecha, encontramos el nombre de la tarjeta, damos click en el recuadro.
PASO 3¶
Nos aparece un recuadro en cuál nos aparece la tarjeta ya cargada en la plataforma MBED, sólo la seleccionamos y damos click en "Select Platform"
PASO 4¶
En caso de no tenerla cargada en la plataforma, damos click en "Add Board", lo que nos redigirá a una nueva pestaña, en donde encontarremos un gran número de componentes y tarjetas de programación
PASO 5¶
Buscamos, con ayuda de CNTRL+F, el nombre de la tarjeta Nucleo-F411RE
PASO 6¶
Damos click en el recuadro de la tarjeta, esto nos abre una pesataña en donde encontramos toda la información con respecto a la tarjeta, las características, el pinout de la misma, y demás.
PASO 7¶
En los recuadros de la parte inferior derecha, aparecerá un recuadro que dice: "Add to your MBED compiler", damos click en el y automáticamente quedará cargada en nuestra cuenta de MBED y se procede a seguir el paso 3, anteriormente mencionado.
PASO 8¶
Para crear un nuevo programa, en la parte superior izquierda, encontramos el ícono de "NEW", damos click en el
PASO 9¶
Inmediatamente después, nos aparecerá un recuadro en el que podemos ver la tarjeta o la plataforma de programación, nos permite escoger una plantilla y obviamente, ponerle un nombre al programa.
PASO 10¶
Nos abrirá una página en el que aparece un archivo main.cpp, damos click en el y nos llevara a la página para crear el código
PASO 11¶
Y listo, es todo lo que se necesita para poder empezar a programar en la plataforma.
Descripción del programa¶
Este programa se trabajó en la plataforma online MBED, por medio de un lenguaje de programación c++ orientado a objetos. Se pretende mover un brazo robótico que consta de 4 servomotores, el cuál se explica con detalle a continuación.
Programa Servomotores
#include "mbed.h"
Serial command(USBTX, USBRX); //es la comunicación serial entre la tarjeta y el PC
PwmOut myservo1(PB_4); //asigno PWM al pin PB_4 (D5)para el servomotor #1
PwmOut myservo2(PB_5); //asigno PWM al pin PB_5 (D4)para el servomotor #2
PwmOut myservo3(PB_10); //asigno PWM al pin PB_10 (D6)para el servomotor #3
PwmOut myservo4(PB_3); //asigno PWM al pin PB_3 (D3)para el servomotor #4
#define INITCMD 0xFF //es una varíable global para inicializar el programa
uint8_t N_parametro; //asigno variable de 8 bits, al número de parámetros que voy a leer
uint8_t N_tipocomando; //asigno variable de 8 bits, al número de comando que voy a leer
void setup_uart(); //función para determinar la velocidad de comunicación
void setup_servo(); //función para modificar el periodo y el ancho de pulso del PWM, asignados a los servos
void leer_datos(); //función para leer datos ingresados desde el PC
void posicion(uint8_t tipocomando, uint8_t parametro); //defino función para mover los servos
int main() //función principal
{
setup_uart(); //llamo a la función setup_uart
setup_servo(); //llamo a la función setup_servo
while(1)
{
leer_datos(); //llamo la función leer datos
posicion(N_tipocomando, N_parametro); //asigno los valores de tipo de comande y parámetro a la clase posición
}
}
void leer_datos() //se crea la función datos
{
while(command.getc()!= INITCMD); //si el comando enviado lleva el valor de inicio de programa se leen los demás parámetros
N_tipocomando=command.getc(); //asigna el valor introducido en tipocomando a la variable N_tipocomando
N_parametro=command.getc(); //asigna el valor introducido en tipoparametro a la variable N_parametro
}
void setup_uart() //se crea la función setup_uart
{
command.baud(115200); //se establece la velocidad a la que manejaré la comunicación entre la PC y la tarjeta
}
void setup_servo() //se crea la función setup_servo
{
myservo1.period_ms(20); //se modifica el periodo en ms de los motores
myservo1.pulsewidth_us(1000); //se modifica el ancho de pulso en us de los motores
myservo2.period_ms(20);
myservo2.pulsewidth_us(1000);
myservo3.period_ms(20);
myservo3.pulsewidth_us(1000);
myservo4.period_ms(20);
myservo4.pulsewidth_us(1000);
}
void posicion(uint8_t tipocomando,uint8_t parametro) //se crea la función posición y se asignan los valores leídos a las variables tipocomando y parametro
{
if (tipocomando == 1) //se crea un if para saber que tipo de comando se desea ingresar
{
if (parametro == 1) //se crea un if para saber que parámetro se desea usar
{
uint32_t dpulse=0; //es una variable para asignar los us del ancho de pulso del motor
dpulse=(700+0*1700/50); //en la variable dpulse, se crea una fórmula para pasar de grados a u
myservo2.pulsewidth_us(dpulse); //se carga el valor de la variable dpulse al servo motor en us
wait(0.5): //se espera 0.5 ms para ejecutar el siguiente movimiento
dpulse=0;
dpulse=(700+180*1700/105);
myservo4.pulsewidth_us(dpulse);
wait(0.5);
}
if (parametro == 2) //mover a posición material
{
uint32_t dpulse=0;
dpulse=(700+90*1700/20);
myservo1.pulsewidth_us(dpulse);
wait(0.5);
dpulse=0; //es importante cargar el valor dpulse con 0 para que se reinicie la variable en 0
dpulse=(700+90*1700/110);
myservo2.pulsewidth_us(dpulse);
wait(0.5);
dpulse=0;
dpulse=(700+180*1700/40);
myservo4.pulsewidth_us(dpulse);
wait(0.5);
}
if (parametro == 3) //mover a posición celda 1
{
uint32_t dpulse=0;
dpulse=(700+180*1700/90);
myservo1.pulsewidth_us(dpulse);
wait(0.5);
dpulse=0;
dpulse=(700+180*1700/90);
myservo2.pulsewidth_us(dpulse);
wait(0.5);
uint8_t i; //se crea una variable i de 8 bits
for (i=110;i>90;i--) //se crea un for con el valor de la variable i, para hacer un barrido de grados
{
dpulse=(700+0*1700/180);
wait(0.025);
myservo3.pulsewidth_us(dpulse);
}
wait(0.5);
}
if (parametro == 4) //mover a posición celda 2
{
uint32_t dpulse=0;
dpulse=(700+180*1700/110);
myservo1.pulsewidth_us(dpulse);
wait(0.5);
dpulse=0;
dpulse=(700+180*1700/180);
myservo2.pulsewidth_us(dpulse);
wait(0.5);
uint8_t i;
for (i=110;i>90;i--)
{
dpulse=(700+0*1700/105);
wait(0.025);
myservo3.pulsewidth_us(dpulse);
}
wait(0.5); }
if (parametro == 5) //mover a posición celda 3
{
uint32_t dpulse=0;
dpulse=(700+180*1700/110);
myservo1.pulsewidth_us(dpulse);
wait(0.5);
dpulse=0;
dpulse=(700+180*1700/130);
myservo2.pulsewidth_us(dpulse);
wait(0.5);
uint8_t i;
for (i=110;i>90;i--)
{
dpulse=(700+0*1700/105);
wait(0.025);
myservo3.pulsewidth_us(dpulse);
}
wait(0.5);
}
if (parametro == 6) //mover a posición celda 4
{
uint32_t dpulse=0;
dpulse=(700+180*1700/150);
myservo1.pulsewidth_us(dpulse);
wait(0.5);
dpulse=0;
dpulse=(700+180*1700/180);
myservo2.pulsewidth_us(dpulse);
wait(0.5);
uint8_t i;
for (i=110;i>90;i--)
{
dpulse=(700+0*1700/105);
wait(0.025);
myservo3.pulsewidth_us(dpulse);
}
wait(0.5);
}
}
if(tipocomando==2) //if del comando abrir y cerrar pinza
{
if (parametro==1) //abrir pinza
{
uint32_t dpulse=0;
dpulse=(700+180*1700/70);
myservo4.pulsewidth_us(dpulse);
wait(0.5);
}
if (parametro==2) //cerrar pinza
{
uint32_t dpulse=0;
dpulse=(700+180*1700/108);
myservo4.pulsewidth_us(dpulse);
wait(0.5);
}
}
}
Descarga del Programa CoolTerm¶
El programa CoolTerm, es una aplicación o programa que se usa para comunicar a través del puerto serial a la tarjeta con el pc y enviar dichos valores en hexadecimal.
Primero se abre el CoolTerm y se da click en "Connect", para realizar la conexión entre la tarjeta y el pc, esto por medio de un cable de datos
Inmediatamente, se despliega un recuadro en el cuál debemos establecer el puerto de la tarjeta, la velocidad que se estableció previamente en el programa para la comunicación entre la tarjeta y el pc (115.200), dejamos las demás opciones por defecto y damos click en "OK"
Nos dirigimos a la barra de herramientas, ubicamos la pestaña que dice "connection" y clickeamos en la opción "send string", pues desde allí se enviarán los datos.
Se abre el recuadro y ubicamos la opción "HEX", para empezar a enviar los parámetros y los comandos en hexadecimal
Se envía un parámetro FF para inicializar el programa, seguidamente se envía un 01 o un 02, para determinar el tipo de comando y por último, se envía el valor del respectivo Parámetro
Conexión y Características de los Motores¶
Los motores usados para la programación y el montaje del brazo robótico son servomotores MG995 de piñonerí metálica 180°
Características:¶
Modulación: Digital
Torque (kg)(4.8v): 8.5
Stall Torque: 4.8V: 130.54 oz-in (9.40 kg-cm) 6.0V: 152.76 oz-in (13.00 kg-cm)
Velocidad: 4.8V: 0.20 sec/60° 6.0V: 0.16 sec/60°
Periodo: 20 ms
Ancho pulso: 1.0 ~ 2.5 ms
Peso: 1.94 oz (55.0 g)
Dimensiones: Largo:1.60 in (40.7 mm) Ancho:0.78 in (19.7 mm) Alto:1.69 in (42.9 mm)
Conexión de los motores en la tarjeta¶
Se ubica en el motor y en la tarjeta el GND y el positivo de los mismos (en el motor: cable café=GND, Cable rojo=Positivo, Cable amarillo=Control PWM), y se procede a realizar la respectiva conexión.
Se ubica, dependiendo el pinout de la tarjeta de programacíon un periferico que maneje PWM y así mismo, especificado en el programa prinicipal, para conectar el cable de control del motor
Planos del Brazo Robótico¶
A continuación, se anexan los planos del brazo robótico, usados para este proyecto. /media/uploads/barrero_99/corte_brazo_robotico.pdf