SERVOMOTOR MG995

Servomotor TowerPro MG995 con alto Torque, hasta 15Kg-cm. Robusto, alto rendimiento, compacto, con engranes de Metal, tamaño estándar, incluye accesorios y tornillos para montarlo en cualquier proyecto. Ideal para proyectos de Electronica, Robotica... etc.


Se puede utilizar con Arduino o cualquier Microcontrolador, compatible con tarjetas controladoras de Servos.

CARACTERÍSTICAS 
 
  • Dimensiones: 40.7 * 19.7 * 42.9mm
  • Peso: 55g
  • Torque: 8.5kg/cm (4.8V), 10kg/cm (6V)
  • Deadband settings: 4 microseconds
  • Tipo de conector: JR, FUTABA General, Conector universal para la mayoría de los receptores de radio control
  • Ángulo de rotación: Un máximo de 180º
  • Operating current: 100mA
  • Tensión de funcionamiento: 3-7.2V
  • Rango de Temperatura: -30 a +60 °C
  • Velocidad de Operación (4.8V sin carga): 0.2 seg / 60 grados
  • Velocidad de Operación (6V sin carga): 0.16 seg / 60 grados

CONEXIONES


Qué es y como instalar Geany en Ubuntu para programar en C

Geany es un editor de texto pequeño y ligero con características básicas de entorno de desarrollo integrado (IDE). Está disponible para distintos sistemas operativos, como GNU/Linux, Mac OS X y Microsoft Windows. Es distribuido como software libre bajo la Licencia Pública General de GNU.



Algunas de sus principales características:
  • Sirve para programar en varios lenguajes como C, Java, Pascal, HTML, CSS, PHP y muchos más. 
  • Se pueden gestionar proyectos grandes de forma sencilla. 
  • Tiene la función de autocompletado, con la cual hay que tener cuidado ya que nos puede llevar a cometer errores de sintaxis, pero siendo cuidadoso esta muy bien. 
  • Se le pueden instalar plugins para añadirle funcionalidades. 
  • El código se puede “plegar” por secciones, para tener una vista general de todo el texto. 
  • Es un entorno bastante ligero y fácil de usar. 
  • Colorea nuestro código en función del lenguaje que estemos usando para una más fácil búsqueda de textos. 
  • Permite búsqueda de textos concretos en el código. 
  • Está disponible para los principales sistemas operativos. Geany
  • Numeración de las líneas del documento.
Opciones para instalar Geany
  
1.- Instalar este programa en Ubuntu añadiendo el PPA correspondiente, para ello tenéis que abrir la Terminal y escribir el siguiente comando:

 sudo add-apt-repository ppa:geany-dev/ppa

Ahora toca recargar los repositorios de Ubuntu con este otro comando:

 sudo apt-get update 

Y por ultimo, ya hemos agregado el PPA, ahora solo nos falta instalar el programa con este otro comando:

sudo apt-get install geany geany-plugins

Ahora, después de que termine el proceso ya tendremos a nuestra disposición este excelente programa con el cual podremos escribir código.

2.- Instalar Geany directamente desde "Centro de software de Ubuntu"
Está disponible para ser instalado sin necesidad de acceder al terminal.


Una vez instalado el programa necesitamos configurar varios parámetros para compilar el código escrito en C y después ejecutar el programa generado.

Es necesario acceder al menú Construir y acceder a la opción Establecer comandos de construcción. Nos aparecerá una ventana donde tenemos que introducir los valores que faltan.


Pasos a seguir para compilar y ejecutar un programa con geany

  • Los ficheros se han de guardar en la carpeta personal.
  • Los ficheros tienen la extensión .c, Ejemplo: areaCirculo.c
  • Pulsar la tecla “F9” para compilar y construir el ejecutable.
  • A continuación pulsar  “F5” para ejecutar el programa.


La polea reductora

La polea reductora es un operador compuesto de un motor y una polea doble que están unidos mediante una correa.


Se emplea para transformar el movimiento rápido y con poca fuerza, del motor en el movimiento, más lento pero con mayor fuerza de la polea.

Entre otras aplicaciones, la polea reductora sirve para construir mecanismos que son capaces de elevar pesos, vehículos que se desplazan, etc... empleando para ello motores de poca potencia

Cómo construir una polea reductora

Si no se tiene una polea, se puede fabricar una utilizando cartón o contrachapado de 10 mm de grosor. El tamaño de esta polea dependerá de la carga y velocidad, cuanto mayor sea la carga, tanto mayor deberá ser el radio de la polea.



Se coloca la polea en un eje, fijando la polea a dicho eje, tiene que quedar solidaria a dicho eje. Si el eje se ha fabricado utilizando varilla roscada, la polea se fija mediante tuercas y arandelas.

A la hora de colocar el motor eléctrico , se tendrá en cuenta que:

Si el motor está muy lejos de la polea, cuando se unan, la goma elástica que los une quedará muy tensa y al motor le costará más trabajo hacer girar la polea.

  • Si el motor está muy próximo a la polea, la goma que los une estará poco tensa, el motor patinará y la polea no se moverá.

  • Si el eje del motor y el de la polea son convergentes, cuando giré el motor la gomilla se escapará .

  • Si el eje del motor y el de la polea son divergentes, la gomilla rozará con el motor y le hará perder fuerza.

Una vez que sabemos cuales son la posición y distancia adecuadas, se fija el motor a la base. Fijar el motor a la base

Se conecta la correa de la polea con el eje del motor.

¿Cómo es la estructura general de un programa en Arduino?

Un programa de Arduino se denomina sketch o proyecto y tiene la extensión .ino 

La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen declaraciones, estamentos o instrucciones.

setup()

La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los modos de trabajo de los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya declaración que ejecutar. Así mismo se puede utilizar para establecer el estado inicial de las salidas de la placa. 

loop()

Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se ejecuta de forma cíclica, lo que posibilita que el programa esté respondiendo continuamente ante los eventos que se produzcan en la placa.
//Declaración de las funciones y variables

void setup()
{
 // Funciones de inicialización que define el modo de los pines y del puerto USB
}

void loop()
{
//Funciones, estructuras de control y operadores que definen el funcionamiento de la placa

}


//Programa de ejemplo

int tiempoEncendido=1000; // Variable que establece el tiempo durante el cual el diodo se va a mantener encendido
int tiempoApagado=1000; // Variable que establece el tiempo durante el cual el diodo se va a mantener encendido

int pinDiodo=0; // Variable para establecer el pin donde va a esta conectado el diodo
void setup()
{
pinMode(pinDiodo, OUTPUT);
}

// El programa se ejecuta cíclicamente por tiempo indefinido
void loop()
{
digitalWrite(pinDiodo, HIGH); // Enciende el led
delay(tiempoEncendido); // Se mantiene encendido el tiempo establecido en la variable tiempoEncendido
digitalWrite(pinDiodo, LOW);  // Se apaga el diodo led
delay(tiempoApagado); //Se mantiene apagado el diodo led el tiempo establecido en la variable tiempoApagado
}

¿Qué es una instrucción?

Una instrucción puede ser considerada como un hecho o suceso de duración determinada que genera unos cambios previstos en la ejecución de un programa, por lo que debe ser una acción previamente estudiada y definida.

Ejemplos:

int n=0;
delay(1000);
adelante();

Tipos de instrucciones

Los tipos de instrucciones permitidos están definidos y determinados dentro de cada plataforma y  podemos encontrar las siguientes:
  • Instrucciones de definición de datos.
  • Instrucciones primitivas.
    • Instrucciones de entrada.
    • Instrucciones de salida.
    • Instrucciones de asignación.
  • Instrucciones compuestas
  • Instrucciones de salto.

Instrucciones primitivas

Se consideran como tales las instrucciones de entrada/salida y las instrucciones de asignación.


Instrucciones de entrada

Son aquellas instrucciones encargadas de recoger el dato de un periférico o dispositivo de entrada (sensor) y seguidamente almacenarlo en memoria en una variable previamente definida.

 
Ejemplos

digitalRead(num_del_pin); // Devuelve un valor digital (HIGH o LOW) leído desde el pin num_del_pin.

analogRead(num_del_pin);  //Devuelve un número que es la tensión  leída en el pin num_del_pin.


millis(); //Devuelve el tiempo em milisegundos, desde que se activó el programa.

Serial.read(); //Lee el puerto USB y devuelve el valor 0_255 del dato allí presente.


Instrucciones de salida

Son aquellas instrucciones encargadas de recoger los datos procedentes de variable o los resultados obtenidos de expresiones evaluadas y depositarlos en periféricos o dispositivos de salida.

Ejemplos

pinMode(numero_del_pin, modo); // Pone elpin numero_del_pin en  modo INPUT o OUTPUT.
digitalWrite(numero_del_pin, valor); // Escribe un valor digital ( HIGH o LOW)  en el pin numero_del_pin.
analogWrite(num_del_pin, valor _0_255); // Pone en el pin numero_del_pin una señal digital  PWM, proporcional al valor valor _0_255.


Instrucciones de asignación de datos

Son aquellas instrucciones utilizadas para informar al procesador del espacio que debe reservar en memoria para almacenar un dato mediante el uso de variables.

La definición consiste en indicar un nombre a través del cual haremos referencia al dato, un tipo para informar al procesador de las características y espacio que debe reservar en memoria y opcionalmente un valor inicial.

int n=0;  // Variable "n" de tipo entero y con el valor inicial 0.

nivel_ldr=leerEstadoLdr();  //Llamada a la función leerEstadoLdr y asignar el valor devuelto por dicha función a la variable nivel_ldr.

Instrucciones compuestas

Son aquellas instrucciones que no pueden ser ejecutadas directamente por el procesador, y están constituidas por un bloque de acciones agrupadas en subprogramas.

//Función para controlar el movimiento de subida de un puente levadizo

 void subir()
{
 analogWrite(EA, velocidad);
 digitalWrite(I1, HIGH);
 digitalWrite(I2, LOW);
}


Instrucciones de salto

Son aquellas instrucciones que alteran o rompen la secuencia de ejecución de un programa, perdiendo toda posibilidad de retornar el control de ejecución del programa al punto de llamada. El uso de este tipo de instrucciones debe quedar restringido y usarlo solo en excepciones.





Puente levadizo controlado por Arduino

Se trata de idear, diseñar, planificar y construir una maqueta de un PUENTE LEVADIZO con diversos materiales disponibles, que cumpla las siguientes condiciones: 

CONDICIONES 

  • La elevación y descenso del tablero será suave.
  • Su accionamiento será eléctrico a 4,5V y su control:
    • El control será automático mediante Arduino y sensores de final de carrera.
    • El ajuste de piezas y acabado deberá ser preciso.
    • Las medidas máximas del conjunto no excederán de 300x200x150 mm
Solución adoptada

La solución final consiste en la construcción de una maqueta construida con listones de madera de samba y contrachapado.

Puente levadizo

Sistema de transmisión formado por un motor con reductora y un sistema de transmisión por correa.


El sistema de subida y bajada está formado por un torno fabricado con varilla roscada.


En la parte superior hemos colocado dos poleas de madera, para reducir rozamiento del cable.


Como elementos final de carrera se ha utilizado dos LDR, una para detectar la subida del tablero,


y otra para detectar la bajada del tablero


Por último el circuito de control está formado por una placa de Arduino Uno, un pulsador, dos LDRs  y  un driver L293D.


Circuito eléctrico
 

Programa

#define EA 9
#define I1 8
#define I2 10
#define pinPulsador 0  // Pin digital de entrada para el pulsador
int pinLDR_S = 0;      //A0, Pin analógico para LDR superior
int pinLDR_I = 1;     //A1,  Pin analógico para LDR inferior
int valorLDR_S = 0;
int valorLDR_I = 0;
int velocidad=200;
int estadoPulsador=HIGH;

 void subir()
{
 analogWrite(EA, velocidad);
 digitalWrite(I1, HIGH);
 digitalWrite(I2, LOW);
}

 void bajar()
 {
 analogWrite(EA, velocidad);
 digitalWrite(I1, LOW);
 digitalWrite(I2, HIGH);
}
 void parar()
{
 digitalWrite(I1, LOW);
 digitalWrite(I2, LOW);
 }
 void setup()
 {
  pinMode(EA, OUTPUT);
  pinMode(I1, OUTPUT);
  pinMode(I2, OUTPUT);
  pinMode (pinPulsador, INPUT);

}


void loop()
{
estadoPulsador = digitalRead(pinPulsador); //Leer estado del pulsador

valorLDR_S= analogRead(pinLDR_S);
valorLDR_I= analogRead(pinLDR_I);

if ( estadoPulsador == LOW && valorLDR_I>300)<300 br=""><300 300="">
<300 br="">{
while(valorLDR_S >300)
{
  subir();
  valorLDR_S= analogRead(pinLDR_S);
  delay(300);
}
parar();
}
if(estadoPulsador==LOW && valorLDR_S>300)
<300 br=""><350 br=""><350 br=""> {
<300 br=""><350 br=""><350 br=""> while(valorLDR_I >300)
  {
   bajar();
   valorLDR_I= analogRead(pinLDR_I);
   delay(300);
  }
   //parar motor
   parar();
  }
 }

Estructuras de control

Son utilizadas para controlar la secuencia de ejecución de un programa así como, determinados bloques de instrucciones.

Una clasificación podría ser la siguiente:
  • Estructura secuencial. Es aquella que permite la ejecución de un bloque de instrucciones de forma secuencial, es decir, una a continuación de la otra, respetando rigurosamente el orden establecido entre ellas de arriba a bajo y de izquierda a derecha. Leer más..

  • Estructuras alternativas. También llamadas estructuras condicionales, son aquellas que controlan la ejecución o la no ejecución de una o más instrucciones en función de que se cumpla o no una condición establecida. Leer más..

  • Estructuras repetitiva. Son aquellas instrucciones que nos permiten variar o alterar la secuencia normal de ejecución de un programa haciendo posible que un grupo de acciones se ejecuten más de una vez de forma consecutiva. Este tipo de instrucciones también reciben el nombre de bucles o lazos. Leer más..




Estructuras repetitivas


Estructuras repetitivas

Son aquellas instrucciones que nos permiten variar o alterar la secuencia normal de ejecución de un programa haciendo posible que un grupo de acciones se ejecuten más de una vez de forma consecutiva. Este tipo de instrucciones también reciben el nombre de bucles o lazos.

Estructura mientras (while)

La estructura mientras se caracteriza porque su diseño permite repetir un bloque de instrucciones mientras que se cumpla la condición establecida, en el caso que la condición sea falta, dicho bloque de instrucciones no se ejecutará ninguna vez.




Ejemplo: Realizar un programa que encienda un diodo led al presionar un pulsador y permanezca  encendido mientras esté presionado dicho pulsador.

 

 
int estadoPulsador;
int pinPulsador=8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado

int pinLed=13; //Pin donde esta conectado el diodo led
int estadoPulsador=0;

void setup() // Función que se ejecuta una sola vez.
{
   pinMode(pinPulsador, INPUT); // Inicializa el pin  8 como entrada
   pinMode(pinLed, OUTPUT); // Inicializar el pin digital (pinLed) como salida.
}

void loop() // Función que se ejecuta una y otra vez, de forma ininterrumpida.
{
estadoPulsador= digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable estadoPulsador
while(estadoPulsador==LOW)
  {
    digitalWrite(pinDiodo, HIGH); // Si es así activa el diodo
    estadoPulsador= digitalRead(pinPulsador);
  }
 }


Estructura Para (for)

Este tipo de instrucciones repetitivas se caracterizan porque el número de veces que se repetirá el bloque de instrucciones general está fijado de antemano.


  • Vcont: Variable contador del bucle.
  • Vi: Valor inicial que toma Vcont ( es el valor inicial a partir del cual comienza la ejecución del bucle.
  • Vf: Valor final para Vcont (es el valor final que se toma como referencia para la finalización del bucle).
  • n: Cantidad en que se incrementa o decrementa (según sea el valor especificado positivo o negativo) la variable Vcont al final de cada vuelta del bucle. Por defecto, este valor es siempre 1.
El control del bucle se utiliza en aquellas ocasiones en las que se conoce previamente el número de veces que se van a efectuar las operaciones del bucle.


Ejemplo: Inicializar los pines digitales como entradas

int n;

void setup()
{
   for(n=0;n<13 n="" p="">    {
      pinMode(n,OUTPUT);
    }
}


Estructuras alternativas

Estructuras alternativas

También llamadas estructuras condicionales, son aquellas que controlan la ejecución o la no ejecución de una o más instrucciones en función de que se cumpla o no una condición establecida.

a) Alternativa simple

Ejemplo

Realizar un programa para encender un diodo Led en función del estado de un pulsador.




int pinPulsador=8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado
int pinLed=13; //Pin donde esta conectado el diodo led
int estadoPulsador=0;

void setup() // Función que se ejecuta una sola vez.
{
pinMode(pinPulsador, INPUT); // Inicializa el pin  8 como entrada
pinMode(pinLed, OUTPUT); // Inicializar el pin digital (pinLed) como salida.
}

void loop() // Función que se ejecuta una y otra vez, de forma ininterrumpida.
{
estadoPulsador= digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable estadoPulsador
if(estadoPulsador==LOW)
  {
    digitalWrite(pinDiodo, HIGH); // Si es así activa el diodo
    delay(1000); // Esperar un segundo
  } }


b) Alternativa doble

Ejemplo

Realizar un programa para encender o apagar un diodo Led en función del estado de un pulsador. ON el diodo led luce, OFF  el diodo led no luce.




int pinPulsador=8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado
int pinLed=13; //Pin donde esta conectado el diodo led
int estadoPulsador=0;

void setup() // Función que se ejecuta una sola vez.
{
pinMode(pinPulsador, INPUT); // Inicializa el pin  8 como entrada
pinMode(pinLed, OUTPUT); // Inicializar el pin digital (pinLed) como salida.
}

void loop() // Función que se ejecuta una y otra vez, de forma ininterrumpida.
{
estadoPulsador= digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable estadoPulsador
if(estadoPulsador==LOW)
{
digitalWrite(pinDiodo, HIGH); // Si es así activa el diodo
delay(1000); // Esperar un segundo
}
else
{
digitalWrite(pinLed, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
delay(500); // Esperar un segundo
}
}

Estructuras secuencial

Estructura secuenciales

Es aquella que permite la ejecución de un bloque de instrucciones de forma secuencial, es decir, una a continuación de la otra, respetando rigurosamente el orden establecido entre ellas de arriba a bajo y de izquierda a derecha.

Ejemplo

Realizar un programa para encender y apagar un diodo Led.



int pinLed=13; //Pin donde esta conectado el diodo led

void setup() // Función que se ejecuta una sola vez.
{
pinMode(pinLed, OUTPUT); // Inicializar el pin digital (pinLed) como salida.
}
void loop() // Función que se ejecuta una y otra vez, de forma ininterrumpida.
{
digitalWrite(pinLed, HIGH); // Encender el led, haciendo que el voltaje sea alto.
delay(1000); // Esperar un segundo
digitalWrite(pinLed, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
delay(500); // Esperar un segundo
}

Entradas analógicas en Arduino

En esta entrada vamos a ver las entradas analógicas, su funcionamiento y características.

Son pines de entrada a los que podemos conectar periféricos que proporcionan señales eléctricas variables; por ejemplo un sensor de luz cuya tensión es proporcional a la cantidad de luz que recibe.

¿Qué es una señal analógica?

Una señal analógica es una magnitud que puede tomar cualquier valor dentro de un intervalo –Vcc y + Vcc. Por ejemplo, una señal analógica de tensión entre 0V y 5V podría valer 2,72V, o cualquier otro valor con cualquier número de decimales. Por contra, recordemos que una señal digital de tensión teórica únicamente podía registrar dos valores (en el ejemplo, 0V o 5V).

 Por norma general en los autómatas las entradas analógicas son más escasas, más lentas y más caras que las entradas digitales. En el caso de Arduino uno disponemos de un número variable de entradas analógicas, que en el caso de Arduino Uno y Mini Pro son 6 (A0, A1, A2, A3, A4, A5).

Precisión de la medición

 Para entender la precisión de una entrada analógica es necesario entender cómo funciona un conversor analógico digital (ADC), que es su componente fundamental. Un ADC es un dispositivo que convierte una medición analógica en una medición digital codificada con un número N de bits.

En el caso de Arduino Uno, Mini Pro, y Mega, las entradas analógicas disponen de 10 bits de resolución, lo que proporciona 1024 niveles digitales, lo que a 5V supone una precisión de la medición de +-2,44mV.

 Conexión de entradas analógicas en Arduino

Supongamos que dispongamos un sensor analógico que proporciona una señal analógica entre 0V a 5V.

El código para realizar la lectura es similar al que realizado para las entradas digitales. Simplemente realizamos la lectura mediante AnalogRead() y almacenamos el valor devuelto en una variable.

Ejemplo: Leer el valor de un sensor y mostrar en el monitor serie un mensaje en función del valor leído.

#define pinSensor 0; // seleccionar la entrada para el sensor A0
int valorSensor; // variable que almacena el valor (0 a 1023)

void setup()
{
Serial.begin(9600);
}

void loop()
{
valorSensor = analogRead(pinSensor); // realizar la lectura
//mandar mensaje al monitor serie en función del valor leído

if (valorSensor > 512)
{
Serial.println("Mayor que 2,5V");
}
else
{
Serial.println("Menor que 2,5V");
}
delay(1000);
}

 En la siguiente entrada se puede observar el uso de la utilización de las entradas analógicas para la lectura del valor devuelto por una LDR (Medidor de luz con LDR). 

Salidas analógicas PWM en Arduino

Son patillas que actúan como si fueran salidas analógicas hacia los periféricos.
Arduino Uno implementa por hardware salidas PWM en varios de sus pines, que aparecen identificados en la placa con el símbolo “~” junto al número del pin. Patillas: 11, 10, 9, 6 ,5 y 3.


En ocasiones necesitaremos proporcionar un valor analógico de tensión, por ejemplo, para regular la intensidad de iluminación de un LED, o variar la velocidad de un motor DC.

En esta entrada vamos a ver cómo utilizar una salida PWM para emular una señal analógica de tensión desde Arduino.

Lo primero que tenemos que entender es que la mayoría de automatismos (y Arduino no es una excepción) no son capaces de proporcionar una auténtica salida analógica. Ni siquiera pueden suministrar una salida analógica discretizada (es decir, a saltos) de tensión. Lo único que pueden proporcionar es una salida digital de -Vcc o Vcc. (por ejemplo, 0V y 5V).

Para salvar esta limitación y simular una salida analógica la mayoría de los automatismos emplean un “truco”, que consiste en activar una salida digital durante un tiempo y mantenerla apagada durante el resto. El promedio de la tensión de salida, a lo largo del tiempo, será igual al valor analógico deseado.

Existe más de una forma de hacer esta aproximación. Una de las más sencillas, y por ello muy empleada en automatización, es la modulación de ancho de pulso (PWM). En esta modulación se mantiene constante la frecuencia (es decir, el tiempo entre disparo de pulsos), mientras que se hace variar la anchura del pulso. 

Para generar una señal PWM en los pines digitales de la placa Arduino, hay que usar la función analogWrite(pin, valor).

Esta función nos permitirá emular una señal analógica a partir de una digital. Presenta dos variables:

Pin. Hace referencia al pin digital en el que vamos a producir la señal PWM. (pines, que aparecen identificados en la placa con el símbolo “~” junto al número del pin).
Valor. Es un número comprendido entre 0 y 255. El valor 0 corresponde a 0V de promedio y el valor 255 a 5V.

Ejemplo: Variar la intensidad de luz de un led

int pinLed=9; //Declaramos la variable donde se conectará el led

void setup()
{
pinMode(pinLed, OUTPUT);
}

void loop()
{
for( int n=0;n<256 n="" p="">{
analogWrite(pinLed,n);
delay(100);
}
 
PWM  no es una señal analógica


Es importante recordar en todo momento que en una salida PWM el valor de tensión realmente es Vcc. Por ejemplo, si estamos alimentando un dispositivo que necesita 3V, y usamos una señal pulsada, en realidad estaremos suministrando 5V durante un 60% del tiempo y 0V durante el 40%. Pero si el dispositivo, por ejemplo, soporta como máximo 3V, podemos dañarlo si lo alimentamos mediante un PWM. 

Una señal pulsada es suficiente para emular una señal analógica en muchas aplicaciones. Por ejemplo, podemos variar la intensidad luminosa en un LED mediante un PWM. El LED realmente se enciende y apaga varias veces por segundo, pero este parpadeo es tan rápido que el ojo no lo aprecia. El efecto global percibido es que el LED brilla con menor intensidad. 

Otro ejemplo, al variar la velocidad de un motor DC con un PWM, en la mayoría de los casos la inercia del motor se encargará de que el efecto del PWM sea despreciable. No obstante, en función de la frecuencia podemos notar vibraciones o ruidos, en cuyo caso podremos deberemos variar la frecuencia del PWM. 

Por otro lado, debemos tener en cuenta los efectos que supone la rápida conexión y desconexión de la señal pulsada puede suponer en el dispositivo alimentado. Por ejemplo, en el caso de cargas inductivas (motores, relés, o electroimanes) la desconexión supondrá la generación de voltaje inducido que puede dañar la salida digital o el propio dispositivo, por lo que será necesario disponer de las protecciones oportunas.

En cuanto a transistores, en general, los de tipo BJT resultan apropiados para funcionar como amplificación de señales PWM. Esto no suele ser así en los transistores MOS, donde los efectos capacitivos del mismo, unidos a la limitación de corriente de las salidas digitales, frecuentemente harán que necesitemos un driver de amplificación previo para evitar que el transistor trabaje en zona activa.

Sensor de ultrasonidos HC-SR04

El sensor de ultrasonidos se enmarca dentro de los sensores para medir distancias o superar obstáculos, entre otras posibles funciones.


Un sensor de ultra sonidos es un dispositivo para medir distancias. Su funcionamiento se base en el envío de un pulso de alta frecuencia, no audible por el ser humano. Este pulso rebota en los objetos cercanos y es reflejado hacia el sensor, que dispone de un micrófono adecuado para esa frecuencia

Los sensores de ultrasonidos son sensores baratos, y sencillos de usar. Este sensor en concreto tiene un rango de distancias sensible entre 3cm y 3m con una precisión de 3mm.

Los sensores de ultrasonidos son sensores de baja precisión. La orientación de la superficie a medir puede provocar que la onda se refleje, falseando la medición. Además, no resultan adecuados en entornos con gran número de objetos, dado que el sonido rebota en las superficies generando ecos y falsas mediciones. Tampoco son apropiados para el funcionamiento en el exterior y al aire libre. 

Pese a esta baja precisión, que impide conocer con precisión la distancia a un objeto, los sensores de ultrasonidos son ampliamente empleados. En robótica es habitual montar uno o varios de estos sensores, por ejemplo, para detección de obstáculos, determinar la posición del robot, crear mapas de entorno, o resolver laberinto.

¿Qué recibimos en el sensor?

El tiempo que transcurre entre el envío y la recepción de un pulso sonoro.

¿Cómo vamos a traducir dicho tiempo en distancia?

Aprovechando que la velocidad de dicho ultrasonido en el aire es de valor 340 m/s, o 0,034 cm/microseg (ya que trabajaremos con centímetros y microsegundos). Para calcular la distancia, recordaremos que v=d/t (definición de velocidad: distancia recorrida en un determinado tiempo).

De la fórmula anterior despejamos d, obteniendo d=v·t, siendo v la constante anteriormente citada y t el valor devuelto por el sensor a la placa Arduino.


También habrá que dividir el resultado entre 2 dado que el tiempo recibido es el tiempo de ida y vuelta.


Pines de conexión
  • Vcc.
  • Trig (Disparo ultrasonido).
  • Echo (Recepción de ultrasonido)
  • GND
 Montaje en una protoboard




Programa

Para activar el sensor necesitamos generar un pulso eléctrico en el pin Trigger (disparador) de al menos 10us. Previamente, pondremos el pin a Low durante 4us para asegurar un disparo limpio. 

Posteriormente usamos la función “pulseIn” para obtener el tiempo requerido por el pulso para volver al sensor. Finalmente, convertimos el tiempo en distancia mediante la ecuación correspondiente. 

Observar que intentamos emplear siempre aritmética de enteros, evitando usar números en coma flotante. Esto es debido a que las operaciones en coma flotante ralentizan mucho el procesador, y suponen cargar un gran número de librerías en memoria.


const int EchoPin = 5;
const int TriggerPin =6;
long distancia;
long tiempo;

void setup(){

Serial.begin(9600);
pinMode(TriggerPin, OUTPUT); /*activación del pin 9 como salida: para el pulso ultrasónico*/
pinMode(EchoPin, INPUT); /*activación del pin 8 como entrada: tiempo del rebote del ultrasonido*/
}

void loop(){

digitalWrite(TriggerPin,LOW); /* Por cuestión de estabilización del sensor*/
delayMicroseconds(5);
digitalWrite(TriggerPin, HIGH); /* envío del pulso ultrasónico*/
delayMicroseconds(10);
tiempo=pulseIn(EchoPin, HIGH); /* Función para medir la longitud del pulso entrante. Mide el tiempo que transcurrido entre el envío del pulso ultrasónico y cuando el sensor recibe el rebote, es decir: desde que el pin 12 empieza a recibir el rebote, HIGH, hasta que deja de hacerlo, LOW, la longitud del pulso entrante*/
distancia= int(0.017*tiempo); /*fórmula para calcular la distancia obteniendo un valor entero*/
/*Monitorización en centímetros por el monitor serial*/
Serial.println("Distancia ");
Serial.println(distancia);
Serial.println(" cm");
delay(1000);
}

Placa de pruebas (Protoboard)

El protoboard: Es una especie de tablero con orificios, en la cual se pueden insertar componentes electrónicos y cables para montar circuitos. Como su nombre lo indica, esta tableta sirve para experimentar con circuitos electrónicos, con lo que se asegura el buen funcionamiento del mismo.


Así pues, con una protoboard, nos olvidamos del trabajo de soldar, y sólo nos limitamos a introducir los terminales de nuestros componentes electrónicos en las perforaciones que trae.

Estas placas están agujereadas con conexiones internas dispuestas en hileras, de modo que forman una matriz de taladros a los que podemos directamente insertar componentes y formar el circuito deseado.


Como el nombre indica, se trata de montar prototipos, de forma eventual, por lo que probamos y volvemos a desmontar los componentes, quedando la protoboard lista para el próximo experimento. 

En estos tableros montaremos los circuitos formados por resistencias, condensadores, transistores, Leds, displays, pulsadores y circuitos integrados principalmente. Hay que tener en cuenta que para realizar las conexiones entre componentes utilizaremos cables, que tienen que ser de un hilo rígido de 0,5 a 0,75 mm de diámetro aproximadamente. Estos cables también se venden preparados para los protoboard. Se trata de unos cables de longitud fija, los cuales tienen en los extremos unos contactos que facilitan ese trabajo de “pinchar” en la placa.
Básicamente un protoboard se divide en tres partes:


La central: Es la región localizada en el medio ldel protoboard, se utiliza para colocar los circuitos integrados.

A los lados de la central: En ella van los buses y se localizan en ambos extremos del protoboard.

Parte exterior de la placa. Hay dos filas de contactos a cada lado de la placa para poner la alimentación del circuito.

  • La línea azul siempre sera negativo, también llamada: tierra

  • Por otro lado, la línea roja siempre será positivo.

Esta disposición de conexiones nos ayuda a la hora de organizarnos, siguiendo algunas premisas que nos llevarán a un diseño limpio, sin problemas y efectivo:

  • Emplearemos las conexiones laterales para la alimentación.

  • Utilizaremos cables de distintos colores para cada “canal” de alimentación, rojo para el positivo y negro para el negativo (GND).

  • Coloca los circuitos integrados en una sola dirección, de derecha a izquierda o viceversa.

  • Se deberá de utilizar cables lo más cortos posibles, evitando así interferencias/ruidos y/o resistencias inesperadas.
  • Procuraremos mantener siempre un orden dentro de lo posible. Un diseño bien organizado dice mucho más que una maraña de cables.
  • Por último, si necesitas más espacio, siempre puedes acoplar más protoboard por cualquiera de los 4 lados con las pestañas que trae.
  • Algunos protoboards tienen separada la parte media de los buses, es por eso que se realiza esta conexión para darle continuidad a la corriente.
Limitaciones
  • Estos prototipos que montemos no pueden trabajar a frecuencias mayores de 20 Mhz. ya que entre las filas para la inserción de componentes hay capacidades parásitas que nos afectarían el funcionamiento del circuito.
  • También hay que tener cuidado de no usar intensidades de corriente muy altas por las conexiones de la placa.

Ordinogramas

También denominados diagramas de flujo de programas. Son representaciones gráficas que muestran la secuencia lógica y detallada de las operaciones que se van a realizar en la ejecución de un programa.

Ejemplo:

Diseñar un algoritmo que calcule el área de un triángulo utilizando como método de representación el ordinograma.


El diseño de todo ordinograma debe de reflejar :
  • Un principio o inicio que marca el comienzo de ejecución del programa y que viene determinado por la palabra "INICIO"
  •  La secuencia de operaciones, lo más detallada posible y siguiendo siempre el orden en el que se deberán ejecutar ( de arriba-abajo y de izquierda-derecha).
  • Un fin que marca la finalización de ejecución del programa y que viene determinado por la palabra "FIN".
La simbología utilizada en la construcción de ordinogramas es la siguiente:



Las reglas que hay que seguir para la confección de un ordinograma son las siguientes:
  1. Todos los símbolos utilizados en el diseño deben estar conectados por medio de líneas de conexión o líneas de flujo de datos.
  2. Queda terminantemente prohibido el cruce de líneas de conexión, pues ello nos indica que el ordinograma no está correctamente diseñado.
  3.  A un símbolo de proceso pueden llegarle varias líneas de conexión o flujo, pero del él solo puede salir una.
  4.  A un símbolo de decisión puede llegarle varias líneas de conexión o flujo de datos, pero de él solo puede salir una línea de entra las dos posibilidades existentes (verdadero o falso).
  5. A un símbolo de inicio  de proceso no llega ninguna línea de conexión o flujo y de él solo puede partir una línea de conexión.
  6. A un símbolo de proceso o ejecución pueden llegar muchas líneas de conexión, pero de él no puede partir ninguna.
 Ejemplo



Robot con 2 motores de CC y L293D

Propuesta

Aprender a controlar motores de corriente continua utilizando controladores basados en puentes H.

Material necesario

  • Cables para protoboard

  • Plataforma para robot móvil


  • Arduino Uno o similar. Esta sesión acepta cualquier otro modelo de Arduino. 
  • Placa Protoboard.

Esquema eléctrico
l293d_arduino_bb 
   
Programa para conseguir que el móvil se desplace hacia delante durante 1 s.
 
#define E1 8 // Enable Pin for motor 1 
#define I1 9 // Control pin 1 for motor 1
#define I2 10 // Control pin 2 for motor 1
#define E2 7 //Enable Pin for motor 2 
#define I3 6 //Control sentido de giro motor 2
#define I4 5 //Control sentido de giro motor 2 

int n=0;
void setup()
{
     for (int i = 0 ;<=13 ; i++)

 pinMode( i, OUTPUT);
  }
}

void loop()
{
digitalWrite(E1, HIGH); // Activamos Motor1
digitalWrite(I1, HIGH); // Arrancamos el motor 1 
digitalWrite(I2, LOW);

digitalWrite(E2, HIGH);  // Activamos Motor2
digitalWrite(I3, HIGH); //Arrancamos el motor 2
digitalWrite(I4, LOW);
delay(1000);

digitalWrite(E1, LOW); // Paramos Motor 1
digitalWrite(E2, LOW);  // Paramos Motor 1
delay(500); }