Mostrando entradas con la etiqueta MOTORES. Mostrar todas las entradas
Mostrando entradas con la etiqueta MOTORES. Mostrar todas las entradas

Tutorial - Driver L298N : Parte 1 / Motores DC

FUNCIONAMIENTO DE UN PUENTE H
Un "Puente H" nos permite hacer funcionar un motor en dos sentidos de giro y se utilizan al ser los microcontroladores incapaces de ofrecer una carga elevada de corriente. El funcionamiento de los mismos se puede resumir a partir de la siguiente figura.


En la figura observamos cuatro switches, cada uno conectado al motor y los mismos conectados a una fuente de alimentación. Podemos dividir los mismos en pares, siendo el primer par "S1 / S4" y el segundo "S2 / S3". En resumen tenemos dos movimientos:

# Al activar el primer par (S1 / S4): El motor se moverá en dirección de las agujas del reloj.
# Al activar el segundo par (S2 / S3): El motor se moverá en dirección contraria de las agujas del reloj.


En el primer caso, al cerrar circuito S1 y S4 la fuente "Vin" lleva corriente en la secuencia "S1 - M - S4". En el segundo caso, al cerrar circuito S2 y S3 la fuente "Vin" lleva corriente en la secuencia "S3 - M - S2".

Usando este principio, podemos visualizar lo mismo usando transistores. En este caso, se añaden diodos de protección que completan el circuito.


Como se observa, es posible construir un circuito por medio de transistores para poder manejar motores por medio de nuestro microcontrolador, pero hay drivers comerciales que pueden simplificar y mejorar el mismo circuito añadiendo un pin "Enable" y un Puente H adicional. Este pin "Enable" nos permite realizar con facilidad control de velocidad de los motores usando una señal "PWM".

DRIVER L298N
En el medio comercial encontramos el driver de manejo de motores DC y Paso a paso más usado, que es el L298N.



En el siguiente link puedes encontrar su "datasheet". El driver tiene los pines como se mira en la siguiente figura.


Las características principales del driver son:
# Voltaje de alimentación máximo: 46V.
# Corriente máxima total: 4A.
# Voltaje lógico máximo: 7V.
# Enable A: Activa Out 1 y Out 2.
# Enable B: Activa Out 3 y Out 4.
# Compatibilidad: Motores DC (2) o un motor Paso a Paso bipolar.

En cuanto a los pines físicos del driver, tenemos las siguientes características:
# El jumper en "A Enable" y "B Enable" activa permanentemente los dos puentes H.
# El jumper en "5V Enable" habilita la conversión de la alimentación externa en 5V.
# In 1 e In 2 corresponden a Out 1 y Out 2.
# In 3 e In 4 corresponden a Out 3 y Out 4

CONEXIÓN DEL DRIVER L298N A DOS MOTORES DC
Para este caso utilizaremos como referencia un motor "Smart Robot Wheel" que se muestra a continuación.



Las características de este motor son las siguientes:

# Rotación sin carga a 6V: 100 RPM.
# Corriente de consumo sin carga a 6V: 70mA.
# Corriente con motor bloqueado a 3V: 580 mA.
# Torque: 300 mg - cm.
# Peso: 40g.

La conexión para esta prueba es la siguiente:

# Pin 10: Arduino UNO => In 1: Driver L298N
# Pin 9: Arduino UNO => In 2: Driver L298N
# Pin 8: Arduino UNO => In 3: Driver L298N
# Pin 7: Arduino UNO => In 4: Driver L298N
# GND: Arduino UNO => GND: Driver L298N
# Batería 9V positivo => 12V: Driver L298N
# Batería 9V negativo => GND: Driver L298N

La siguiente figura nos ilustra de una mejor manera las conexiones:


PROGRAMA DE PRUEBA DEL DRIVER L298N
En el siguiente programa básico, usaremos la conexión anterior para hacer funcionar un motor en una dirección ingresando "a" por puerto serial y en la otra colocando "b"; de la misma manera para el otro motor ingresando la letra "c" y "d". En caso de ingresar la letra "e" los dos motores se detendrán.

El programa es el siguiente:
/*
   PROGRAMA DE PRUEBA DEL DRIVER L298N CON DOS MOTORES DC
  
   CONEXION:
             In1 (Driver L298N): Pin 10 (Arduino UNO)
             In2 (Driver L298N): Pin 9 (Arduino UNO) 
             In3 (Driver L298N): Pin 8 (Arduino UNO)
             In4 (Driver L298N): Pin 7 (Arduino UNO)              
             GND: Conectar los dos GND del Arduino UNO, driver L298N y la bateria
             12V: Positivo de una batería o fuente de 9 o 12V
   
   En el siguiente programa probaremos el funcionamiento del driver L298N usando dos motores DC. Al
   ingresar la letra "a" por puerto serial, el motor 1 rota en direccion de las agujas del reloj;
   al ingresar la letra "b" lo hace en sentido contrario. El mismo principio se aplica al siguiente
   motor usando las letras "c" y "d". La letra "e" para los dos motores.
   
   NOTA: Los pines "Enable" deben estar habilitados en la placa del driver
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/
   
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/
const int in1 = 10, in2 = 9; // Pines asignados al primer motor
const int in3 = 8, in4 = 7;  // Pines asignados al segundo motor

void setup() {
  Serial.begin(9600); // Configuracion del puerto serial de comunicacion
  pinMode(in1, OUTPUT); pinMode(in2, OUTPUT); // Configuracion de salida de los pines del primer motor
  pinMode(in3, OUTPUT); pinMode(in4, OUTPUT); // Configuracion de salida de los pines del segundo motor
  
  Serial.println("Tenemos los siguientes comandos:"); // Mensaje inicial
  Serial.println("Letra a: Rotacion del primer motor en sentido horario");
  Serial.println("Letra b: Rotacion del primer motor en sentido antihorario");
  Serial.println("Letra c: Rotacion del segundo motor en sentido horario");
  Serial.println("Letra d: Rotacion del segundo motor en sentido antihorario");
  Serial.println("Letra e: Detener motores");
}

void loop() {
  if (Serial.available()) { // Verificaion que el puerto serial recibe datos                                  
   delay(10);                                              
   rotacion_motor(); // Rutina rotacion de motor                        
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }
}

void rotacion_motor(){          // RUTINA DE PRUEBA DE MOTORES DC

                                // RUTINA DE ROTACION 1
  if (Serial.peek() == 'a'){ // Discriminacion de la letra correspondiente a la primera rutina
    Serial.println("Motor 1: Rotancion horaria"); // Indicacion por pantalla de la rotacion  
    digitalWrite(in1, HIGH); digitalWrite(in2, LOW); // Activacion del motor 1 en sentido horario
    digitalWrite(in3, LOW); digitalWrite(in4, LOW);  // Desactivacion del motor 2  
  }

                                // RUTINA DE ROTACION 2
  if (Serial.peek() == 'b'){ // Discriminacion de la letra correspondiente a la segunda rutina
    Serial.println("Motor 1: Rotancion antihoraria"); // Indicacion por pantalla de la rotacion    
    digitalWrite(in1, LOW); digitalWrite(in2, HIGH); // Activacion del motor 1 en sentido horario
    digitalWrite(in3, LOW); digitalWrite(in4, LOW);  // Desactivacion del motor 2  
  }

                                // RUTINA DE ROTACION 3
  if (Serial.peek() == 'c'){ // Discriminacion de la letra correspondiente a la tercera rutina 
    Serial.println("Motor 2: Rotancion horaria"); // Indicacion por pantalla de la rotacion    
    digitalWrite(in3, HIGH); digitalWrite(in4, LOW); // Activacion del motor 1 en sentido horario
    digitalWrite(in1, LOW); digitalWrite(in2, LOW);  // Desactivacion del motor 2  
  }

                                // RUTINA DE ROTACION 4
  if (Serial.peek() == 'd'){ // Discriminacion de la letra correspondiente a la cuarta rutina  
    Serial.println("Motor 2: Rotancion antihoraria"); // Indicacion por pantalla de la rotacion    
    digitalWrite(in3, LOW); digitalWrite(in4, HIGH); // Activacion del motor 1 en sentido horario
    digitalWrite(in1, LOW); digitalWrite(in2, LOW);  // Desactivacion del motor 2  
  }
                                // RUTINA DE ROTACION 5
  if (Serial.peek() == 'e'){ // Discriminacion de la letra correspondiente a la quinta rutina 
    Serial.println("Detener motores"); // Indicacion por pantalla de la rotacion    
    digitalWrite(in1, LOW); digitalWrite(in2, LOW); // Activacion del motor 1 en sentido horario
    digitalWrite(in3, LOW); digitalWrite(in4, LOW);  // Desactivacion del motor 2  
  }  
}

Como resultado en pantalla obtendremos lo siguiente:


Al ingresar la letra "a".



Al ingresar la letra "b".


Al ingresar la letra "c".


Al ingresar la letra "d".


Al ingresar la letra "e".



Autor: 

Tutorial - Driver ESC HW 30A para Quadcopters

LOS MOTORES BRUSHLESS
Los motores brushless son motores eléctricos de imán permanente y de conmutación electrónica de alimentación en las bobinas. Su construcción de tres bobinados colocados a 120° y generan un campo magnético giratorio por medio de conmutación.

A diferencia de un motor DC normal, encontraremos tres cables de salida de control, por lo que es necesario un controlador especial para determinar tanto la orientación del rotor y su posición respecto a las bobinas del estator.

Los motores sin escobillas permiten un gran rendimiento y una gran potencia pero con un consumo considerable. Podemos ver algunas ventajas y desventajas en comparación a los motores comerciales de escobillas:

Ventajas:

  # Mayor eficiencia.
  # Mayor rendimiento.
  # Mayor potencia.
  # Alta velocidad.
  # Poco ruido.
  # Precisión en el control de velocidad.
  # Par elevado.

Desventajas:

  # Costo elevado.
  # Necesita un controlador especial ESC dedicado (Electronic Speed Control).

ESC (ELECTRONIC SPEED CONTROLLERS)

Son circuitos electrónicos diseñados con el propósito de variar la velocidad de los motores eléctricos, su dirección, y en muchos casos funcionar como freno dinámico. Estos controladores se encargan de generar tres fases eléctricas para controlar el motor.  

Los ESC crean básicamente una fuente de poder AC trifásica, a partir de una entrada de voltaje DC. Al momento de seleccionar un driver ESC debemos fijarnos que los motores brushless pueden ser de dos tipos:

  # Outrunner (usados en aeromodelismo)
  # Inrunner


En la mayoría de casos, estos driver son programables y se necesitan tarjetas especiales para poder configurarlos, aunque existe información y métodos para poder hackearlos y programarlos por otros medios (Arduino).


PROGRAMACIÓN DEFAULT Y PRUEBA
Para este ejemplo usamos un motor brushless EMAX CF2822 que tiene las siguientes características:

# KV: 1200
# Potencia de salida: 140 W
# RPM/V: 1200
# Características según hélice:
                                                   * Hélice 10 x 5: 7100 RPM
                                                   * Hélice 10 x 4.7: 6100 RPM

# Corriente de consumo: 14.5 A
# Eficiencia máxima: 82%
# Peso: 39g



En el caso del ESC, usamos un HW 30A que tiene las siguientes características:

# Máxima corriente continua: 30 A
# BEC (Battery Eliminator Circuit): 2 A
# Resistencia: 0.005 ohm
# Fets: 12
# PWM: 8 kHz
# Temperatura de protección: 110 °C

El conjunto armado se compone de una hélice de 10 x 4.5 in, un soporte de motor de aluminio, un motor brushless, un ESC y un controlador Arduino.

# PIN 11 : Arduino UNO => SEÑAL : ESC (Cable blanco)
# GND : Arduino UNO  => VCC : ESC (Cable rojo)
# 5V : Arduino UNO  => GND : ESC (Cable negro)
# GND : Batería  => GND : ESC (Cable negro)
# 11.1V : Batería  => VCC : ESC (Cable rojo)
# ENTRADA BOBINADO : Motores (Cables negros) => SALIDA MOTOR : ESC (Cables azules)

Al momento de conectar el motor al ESC, debemos percatarnos conectar los cables centrales, la rotación dependerá de la posición que coloquemos los cables faltantes. El circuito de prueba se muestra a continuación:



El conjunto de hélice y motor se muestra en el siguiente esquema:



El programa usado tiene un menú con dos opciones:

# La opción "a" entra a un modo de programación, en el cual se introduce una señal PWM de 2000us.
# La opción "b" entra a un modo de prueba que permite probar el motor al introducir la velocidad en porcentaje de 0 a 100 %.

NOTA:

# Dentro de la opción "a" tenemos dos más:
   Al introducir "c" asignamos como valor mínimo 700us.
   Al introducir "d" asignamos como valor mínimo 1000us.

Con ello, podemos tener un rango mayor o menor de control de los motores y dependerá del modelo usado. El programa es el siguiente:
/*
   PROGRAMA DE PRUEBA: ESC HW 30A
   CONEXION:
             PWM: Arduino Pin 11
             GND: Arduino GND
             VCC: Arduino 5V
   
   El siguiente programa nos ayuda a configurar los driver ESC en modo default para poder usarlos con
   la funcion servo con dos distintos rangos. Seguir las instrucciones del menu. Despues de configurado
   el driver, se pueden hacer pruebas en vacio del motor.
             
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/
  
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

#include <Servo.h> // Libreria de manejo de servos
Servo esc;         // Construccion del objeto ESC usando la libreria Servo

int valor_esc_max = 2000, valor_esc_min, por_esc; // Variables para configuracion del driver
float valor_esc; // Variable de conversion de porcentaje a microsegundos
char cabecera;   // Variable

void setup() {
  esc.attach(11); // ESC configurado para ser usado en el pin 11
  
  Serial.begin(9600); // Inicializacion del puerto serial a 9600 bps
  // Menu inicial
  Serial.println("Programa de programacion default y prueba de driver ESC HW 30A");
  Serial.println("Menu: ");
  Serial.println("a : Entrar al modo de programacion");
  Serial.println("b : Entrar al modo de de prueba");
}

void loop() {
  if (Serial.available()) {  // Verificacion que el puerto serial recibe datos                           
   delay(10);
   cabecera = Serial.read(); // Lectura de la cabecera para ingresar al menu
   menu(cabecera);           // Ingresando a la funcion del menu deseada
   while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }  
}

void menu(char menu_pointer){ // Rutina de menu
  switch (menu_pointer) {
    case 'a':
      esc.write(valor_esc_max); // Asignacion del valor minimo de 700 ms
      // Menu
      Serial.println("Ingresando al modo de programacion...");
      delay(500); Serial.println("Encender la fuente o conectar la bateria");
      delay(1000); Serial.println("Ingresar c para valor minimo de 700 ms");
      delay(1000); Serial.println("Ingresar d para valor minimo de 1000 ms");        
    break;
    
    case 'c':
      valor_esc_min = 700;      // Asignacion del valor minimo de 700 ms
      esc.write(valor_esc_min); // Programacion del valor minimo en el ESC
      // Menu
      Serial.print("Valor maximo: "); Serial.println(valor_esc_max);
      Serial.print("Valor minimo: "); Serial.println(valor_esc_min);
      Serial.println("Ingresar b para entrar a modo de prueba... ");
    break;
    
    case 'd':
      valor_esc_min = 1000;     // Asignacion del valor minimo de 1000 ms
      esc.write(valor_esc_min); // Programacion del valor minimo en el ESC
      // Menu
      Serial.print("Valor maximo: "); Serial.println(valor_esc_max);
      Serial.print("Valor minimo: "); Serial.println(valor_esc_min);
      Serial.println("Ingresar b para entrar a modo de prueba... ");
    break;    
    
    case 'b':
    // Menu
    Serial.println("Ingresar b con un valor de 0 a 100");
    Serial.println("Ejemplo: b0 para 0%");
    Serial.println("Ejemplo: b100 para 100%");
      while (Serial.available()){
        por_esc = Serial.parseInt(); // Lectura del porcentaje de velocidad deseado
        // Conversion del porcentaje al valor en microsegundos por interpolacion
        valor_esc = (valor_esc_max - valor_esc_min); 
        valor_esc = valor_esc / 100;
        valor_esc = por_esc * valor_esc;
        valor_esc = valor_esc_min + valor_esc;
        // Menu
        Serial.print("ESC Porcentaje: "); Serial.print(por_esc);
        Serial.print(" || ECS Microsegundos: "); Serial.println(valor_esc, 0);
        Serial.println(" ");        
     }
      esc.writeMicroseconds(valor_esc); // Escritura del valor deseado en el ESC
    break;
  }
}

La demostración del uso del anterior programa se muestra en el siguiente video:


Autor: 

Tutorial - Servomotores analógicos y digitales

TEORÍA DE SERVOMOTORES
Los servomotores son actuadores rotativos o lineales que permiten el control preciso ya sea del ángulo o la posición lineal, velocidad y aceleración. Su construcción básica comprende de un motor con un sensor de posición acoplado al mismo, que sirve como retroalimentación; todo el conjunto es manejado por un controlador o un módulo dedicado para realizar la tarea.
El término Servo es generalmente usado para todo aquel motor que posea un sistema de control de lazo cerrado.

Algunas de las aplicaciones de los mismos se pueden ver en:
# Robótica.
# Maquinaria CNC.
# Manufactura automatizada.

Las partes que construyen un servo motor se pueden dividir en tres:
# ENCODERS : Sirven como retroalimentación, pueden ser construidos tanto por discos ranurados o dentados, potenciómetros o encoders rotativos absolutos o incrementales.
# MOTORES : Generalmente son usados los motores DC que pueden ser controlados con Mosfets para usos de baja potencia y motores AC con variadores de frecuencia para usos industriales.
# CONTROL : Dependiendo de la aplicación y resolución, existen controladores basados en circuitos dedicados o hechos a partir de microcontroladores.


SERVOS ANALÓGICOS Y DIGITALES
Los circuitos de control de servomotores son construidos generalmente a partir de un control proporcional. El ángulo o set point se ingresa por medio de una señal PWM, cuyo margen de operación de trabajo va de 1 a 2 milisegundos. Para determinar el ángulo para la mayoría de servos, se usa la fórmula "t = 1 + ángulo/180" siendo el tiempo en microsegundos y el ángulo en grados.

La cantidad de microsegundos en comparación del ángulo, se puede ver en la siguiente figura:


A diferencia de los servos analógicos, los digitales cuentan con la siguientes ventajas:
# Mayor torque.
# Mayor precisión.
# Tiempo de respuesta menor.
# Posibilidad de cambiar los valores de ángulos mínimo y máximo.

Pero sus desventajas son:
# Mayor costo.
# Mayor consumo de energía.

Todos los servos ya sean digitales o analógicos tienen la misma disposición de pines que en su mayoría son tres:
# Cable negro o marrón : GND.
# Cable rojo : Alimentación de voltaje.
# Cable blanco, amarillo o naranja : Entrada de señal PWM

LIBRERÍA "SERVO"
Esta librería permite que la plataforma Arduino controle servomotores. Los servomotores usualmente van de los 0 a los 180 grados. Esta librería permite trabajar hasta con 12 servomotores en la mayoría de plataformas y 48 en caso del Arduino Mega.

En caso de usar un Arduino UNO o similares, al usar 12 motores la utilización de la función analogWrite() de los pines 9 y 10 son desabilitadas. Para el caso del Arduino Mega al usar más de 12 motores, la utilización de la función analogWrite() de los pines 11 y 12 son desabilitados.

Algunas de las funciones de la librería se explican a continuación:
# Servo nombre : Asigna al nombre las facultades de las funciones de la librería Servo.
# nombre.attach(pin) o nombre.attach(pin, min, max) : Configura la plataforma para el uso del servo para un pin específico. En caso de usar valores máximos y mínimos consideramos lo siguiente:
   * MIN : Es el valor correspondiente en microsegundos a los 0 grados de ángulo (Por defecto es 544).
   * MAX : Es el valor correspondiente en microsegundos a los 180 grados de ángulo (Por defecto es 2400).

# nombre.write(ángulo) : Asigna el valor del ángulo deseado para el servo que puede ir de 0 a 180.
# nombre.writeMicroseconds(microsegundos) : Asgina el valor del ángulo deseado para el servo a partir de los microsegundos como valor "integer" sin decimales. En servos estándar 1000 microsegundos es el extremo antihorario, 1500 microsegundos el medio y 2000 microsegundos es el extremo horario. Fuera de lo escrito, los valores pueden cambiar de fabricante en fabricante y generalmente se encuentran en el rando de los 700 a los 2300 microsegundos.
# nombre.read() : Retorna el último ángulo del servo escrito por la función write(). Nos devuelve un dato "integer" de 0 a 180.
# nombre.attached() : Retorna "true" si el servo está asignado al pin y "falso" en el caso contrario.
# nombre.detach() : Desliga al servo asignado "nombre" del pin. Esto es bueno en caso de querer usar los pines 9 y 10 con las funciones analogWrite().

SERVO ANALÓGICO: TOWER PRO SG90
Uno de los servos de mayor uso comercial de bajo coste son los "Tower Pro SG90".



Sus características principales son las siguientes:
# Torque : 1.8 kg - cm.
# Voltaje : 4.8 a 6 V.
# Posiciones : "0" (1.5 ms), "90" (2 ms) y "-90" (1 ms).
# Ciclo de trabajo : 1 a 2 ms.
# Periodo PWM : 20 ms.
# Disposición de cables : Naranja (Señal PWM), Rojo (VCC) y Marrón (GND).
# Engranes : Nylon

SERVO DIGITAL: LS 0009AF
Un servo digital comercial es el "LS 0009AF", puedes también bajar su "datasheet".



Sus características principales son las siguientes:
# Torque : 1.3 a 1.5 kg - cm.
# Voltaje : 4.8 a 6 V.
# Consumo : 120 a 150 mA. 
# Posiciones : "0" (1.5 ms), "90" (2 ms) y "-90" (1 ms).
# Ciclo de trabajo : 1 a 2 ms
# Periodo PWM : 800 a 2200 microsegundos.
# Disposición de cables : Amarillo (Señal PWM), Rojo (VCC) y Marrón (GND).
# Engranes : Metálicos

PRUEBAS DE PROGRAMACIÓN CON SERVOS Y ALGUNOS TRUCOS
La conexión para las pruebas es la siguiente:

# PIN 11 : Arduino UNO => SEÑAL : Servomotor (Cable naranja o amarillo)
# GND : Arduino UNO  => VCC : Servomotor (Cable rojo)
# 5V : Arduino UNO  => GND : Servomotor (Cable negro)


En este primer programa haremos una prueba introduciendo ángulos a través del Monitor Serial:
/*
   PROGRAMA DE PRUEBA DE SERVOS: SERVOS ANALOGICOS

   CONEXION:
             PWM: Pin 11 del Arduino UNO
             GND: Conectar los dos GND
             VCC: Conectar los dos 5V
   
   En el siguiente programa probaremos la posicon angular de un servo por medio de escritura de su 
   angulo por monitor serial. El angulo inicial es 0 grados.
   
   NOTA: Para el siguiente programa necesitamos la libreria "Servo.h"
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/

   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

#include <Servo.h> // Libreria de manejo de servos

Servo servo_prueba;        // Nombre asignado al servo
const int salida_pwm = 11; // Variable para configuracion del pin de salida de senal PWM
int angulo;                // Variable de almacenamiento del angulo ingresado por Monitor Serial

void setup() {
  Serial.begin(9600);              // Configuracion del puerto serial de comunicacion con la PC
  servo_prueba.attach(salida_pwm); // Configuracion del pin de salida de la senal PWM
  servo_prueba.write(0);           // Angulo inicial 
  
  // Mensaje inicial en el monitor serial
  Serial.println("Escribir la posicion de angulo de 0 a 180: ");
}

void loop() {
  if (Serial.available()) {    // Verificacion que el puerto serial recibe datos                                  
   delay(10);               
   angulo = Serial.parseInt(); // Lee solo los datos tipo int del buffer
   servo_prueba.write(angulo); // Escritura de microsegundos ingresado por Monitor Serial
   
   // Mensaje de confirmacion del angulo ingresado por Monitor Serial
   Serial.print("Posicion angular: "); 
   Serial.print(angulo);
   Serial.println(" grados");
   
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }
}
Podemos ver como cambia la posición introduciendo el ángulo.
# -90° que corresponde a la posición 0.
# 0° que corresponde a la posición 90.
#  90° que corresponde a la posición 180.




De la misma manera, podemos obtener el mismo resultado a través de la escritura de microsegundos. Como sabemos nuestro rango va de los 1000 us a los 2000 us según las especificaciones del fabricante.
/*
   PROGRAMA DE PRUEBA DE SERVOS: SERVOS ANALOGICOS

   CONEXION:
             PWM: Pin 11 del Arduino UNO
             GND: Conectar los dos GND
             VCC: Conectar los dos 5V
   
   En el siguiente programa probaremos la posicon angular de un servo por medio de escritura de su 
   posicion angular en microsegundos por monitor serial. El angulo inicial es 0 grados o 1000 us.
   
   NOTA: Para el siguiente programa necesitamos la libreria "Servo.h"
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/

   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del 
   autor
*/

#include <Servo.h> // Libreria de manejo de servos

Servo servo_prueba;        // Nombre asignado al servo
const int salida_pwm = 11; // Variable para configuracion del pin de salida de senal PWM
int usegundos;             // Variable de almacenamiento del microsegundo ingresado por Monitor Serial
float angulo;              // Variable para calculo del angulo a partir de microsegundos

void setup() {
  Serial.begin(9600);                   // Configuracion del puerto serial de comunicacion con la PC
  servo_prueba.attach(salida_pwm);      // Configuracion del pin de salida de la senal PWM
  servo_prueba.writeMicroseconds(1000); // Posicion angular inicial de 1000 us
 
  // Mensaje inicial en el monitor serial
  Serial.println("Escribir la posicion angular en microsegundos de 1000 a 2000: ");
}

void loop() {
  if (Serial.available()) {       // Verificacion que el puerto serial recibe datos                                  
   delay(10);               
   usegundos = Serial.parseInt(); // Lee solo los datos tipo int del buffer
   servo_prueba.writeMicroseconds(usegundos); // Escritura del angulo ingresado por Monitor Serial
   
   // angulo por interpolacion 
   // angulo = 0 + (usegundos - 1000)*(180 - 0)/(2000 - 1000);
   angulo = 0 + (usegundos - 1000) * 0.18;
   
   // Mensaje de confirmacion del angulo ingresado por Monitor Serial
   Serial.print("Posicion en microsegundos: "); 
   Serial.print(usegundos);
   Serial.print(" us || ");
   Serial.print("Posicion angular: ");
   Serial.print(angulo,0);
   Serial.println(" grados");
   
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer
  }
}
Ahora probamos tres diferentes posiciones:
# 1000 us que corresponde a -90° o la posición 0.
# 1500 us que corresponde a 0° o la posición 90.
# 2000 us que corresponde a 90° o la posición 180.




Como se observa en las figuras anteriores, en comparación de usar los ángulos para el caso de los microsegundo se tiene que tener más cuidado; y es preferible hacer pruebas de ajuste para tener una mayor precisión de la posición angular (Es recomendable usar las especificaciones como referencia).

Usando el mismo programa modificado para no tener el valor del ángulo podemos ajustar el ángulo y la posición física del brazo, todo ello para tener una mayor precisión de la posición angular.
/*
   PROGRAMA DE PRUEBA DE SERVOS: SERVOS ANALOGICOS

   CONEXION:
             PWM: Pin 11 del Arduino UNO
             GND: Conectar los dos GND
             VCC: Conectar los dos 5V
   
   En el siguiente programa probaremos la posicon angular de un servo por medio de escritura de su 
   posicion angular en microsegundos por monitor serial. El angulo inicial es 0 grados o 1000 us.
   
   NOTA: Para el siguiente programa necesitamos la libreria "Servo.h"
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/

   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del 
   autor
*/

#include <servo .h> // Libreria de manejo de servos

Servo servo_prueba;        // Nombre asignado al servo
const int salida_pwm = 11; // Variable para configuracion del pin de salida de senal PWM
int usegundos;             // Variable de almacenamiento del microsegundo ingresado por Monitor Serial

void setup() {
  Serial.begin(9600);                   // Configuracion del puerto serial de comunicacion con la PC
  servo_prueba.attach(salida_pwm);      // Configuracion del pin de salida de la senal PWM
 
  // Mensaje inicial en el monitor serial
  Serial.println("Escribir la posicion angular en microsegundos: ");
}

void loop() {
  if (Serial.available()) {       // Verificacion que el puerto serial recibe datos                                  
   delay(10);               
   usegundos = Serial.parseInt(); // Lee solo los datos tipo int del buffer
   servo_prueba.writeMicroseconds(usegundos); // Escritura del angulo ingresado por Monitor Serial
   
   // Mensaje de confirmacion del angulo ingresado por Monitor Serial
   Serial.print("Posicion en microsegundos: "); 
   Serial.print(usegundos);
   Serial.println(" us");
   
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer
  }
}
El resultado es el siguiente:



De esa manera podemos modificar el programa anterior. De esa manera, la modificación al programa es la siguiente:
/*
   PROGRAMA DE PRUEBA DE SERVOS: SERVOS ANALOGICOS

   CONEXION:
             PWM: Pin 11 del Arduino UNO
             GND: Conectar los dos GND
             VCC: Conectar los dos 5V
   
   En el siguiente programa probaremos la posicon angular de un servo por medio de escritura de su 
   posicion angular en microsegundos por monitor serial. El angulo inicial es 0 grados o 545 us.
   
   NOTA: Para el siguiente programa necesitamos la libreria "Servo.h"
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/

   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del 
   autor
*/

#include <Servo.h> // Libreria de manejo de servos

Servo servo_prueba;        // Nombre asignado al servo
const int salida_pwm = 11; // Variable para configuracion del pin de salida de senal PWM
int usegundos;             // Variable de almacenamiento del microsegundo ingresado por Monitor Serial
float angulo;              // Variable para calculo del angulo a partir de microsegundos

void setup() {
  Serial.begin(9600);                   // Configuracion del puerto serial de comunicacion con la PC
  servo_prueba.attach(salida_pwm);      // Configuracion del pin de salida de la senal PWM
  servo_prueba.writeMicroseconds(545);  // Posicion angular inicial de 545 us
 
  // Mensaje inicial en el monitor serial
  Serial.println("Escribir la posicion angular en microsegundos de 545 a 2250: ");
}

void loop() {
  if (Serial.available()) {       // Verificacion que el puerto serial recibe datos                                  
   delay(10);               
   usegundos = Serial.parseInt(); // Lee solo los datos tipo int del buffer
   servo_prueba.writeMicroseconds(usegundos); // Escritura del angulo ingresado por Monitor Serial
   
   // angulo por interpolacion 
   // angulo = 0 + (usegundos - 545)*(180 - 0)/(2250 - 545);
   angulo = (usegundos - 545) * 0.1056;
   
   // Mensaje de confirmacion del angulo ingresado por Monitor Serial
   Serial.print("Posicion en microsegundos: "); 
   Serial.print(usegundos);
   Serial.print(" us || ");
   Serial.print("Posicion angular: ");
   Serial.print(angulo,0);
   Serial.println(" grados");
   
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer
  }
}
El resultado en el Monitor Serial es el siguiente:


A partir de lo que sabemos ahora, podemos combinar las dos aproximaciones y usarlos en parametrizar el servo usando la función "nombre_servo.attach(pin, min, max)". De esta manera, el programa inicial se puede modificar y quedaría de la siguiente manera:
/*
   PROGRAMA DE PRUEBA DE SERVOS: SERVOS ANALOGICOS

   CONEXION:
             PWM: Pin 11 del Arduino UNO
             GND: Conectar los dos GND
             VCC: Conectar los dos 5V
   
   En el siguiente programa probaremos la posicon angular de un servo por medio de escritura de su 
   angulo por monitor serial. El angulo inicial es 0 grados.
   
   NOTA: Para el siguiente programa necesitamos la libreria "Servo.h"
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/

   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

#include <Servo.h> // Libreria de manejo de servos

Servo servo_prueba;        // Nombre asignado al servo
const int salida_pwm = 11; // Variable para configuracion del pin de salida de senal PWM
int angulo;                // Variable de almacenamiento del angulo ingresado por Monitor Serial

void setup() {
  Serial.begin(9600); // Configuracion del puerto serial de comunicacion con la PC
  servo_prueba.attach(salida_pwm, 545, 2250); // Configuracion del pin de salida de la senal PWM
  servo_prueba.write(0); // Angulo inicial 
  
  // Mensaje inicial en el monitor serial
  Serial.println("Escribir la posicion de angulo de 0 a 180: ");
}

void loop() {
  if (Serial.available()) {    // Verificacion que el puerto serial recibe datos                                  
   delay(10);               
   angulo = Serial.parseInt(); // Lee solo los datos tipo int del buffer
   servo_prueba.write(angulo); // Escritura de microsegundos ingresado por Monitor Serial
   
   // Mensaje de confirmacion del angulo ingresado por Monitor Serial
   Serial.print("Posicion angular: "); 
   Serial.print(angulo);
   Serial.println(" grados");
   
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }
}
Los resultados del programa son los siguientes:

 



Autor: