Los músculos de los robots

 

Los robots utilizan para moverse, sistemas eléctricos, neumáticos o bien hidráulicos. Los sistema hidráulicos son los más adecuados cuando se quieren transmitir grandes fuerzas. Piensa, por ejemplo, en las excavadoras o en los frenos de los coches, mediante los cuales a través de un pequeño esfuerxo en el pedal, podemos detener un vehículo que circula a gran velocidad y puede pesar varios miles de kilos.

Muchos brazos de robots utilizan cilindro hidráulicos para conseguir gran fuerza y mucha precisión. Esto es posible gracias a dos principios fisicos:

Los líquidos casi no pueden comprimirse.

Al aplicar presión a un líquido, ésta se transmite por igual en todas las direcciones.

Gracias a estos dos principios, si unimos dos jeringas idénticas mediante un tubo y las rellenamos de líquido, al apretar una, toda la fuerza aplicada se transmite a la otra. pero, si la otra es mayo, la fuerza que se transmite también será mayor.

Desplazamiento de los robots

 

Si nos limitamos a analizar cómo se desplazan los robots por tierra, comprobaremos que la mayoría de ellos disponen de ruedas, orugas o patas.

Cuando el desplazamiento se realiza mediante patas, es aconsejable que los robots tengan un mínimo de tres patas para garantizar su estabilidad. Algunos vehículos robotizados se han diseñado con un gran número de patas, al igual que muchos insectos, para aumentar su estabilidad  y que puedan desplazarse por terrenos muy abruptos.

Cuando el terreno presenta pequeños obstáculos o pendientes, las orugas son las más adecuadas, pero si el terreno es llano, resultan más apropiadas las ruedas.

Actualmente existen robots que pueden subir y bajar escaleras gracias a sensores de posición y ángulo que posibilitan que el robot equilibre su peso.

Los robots que tiene ruedas no emplean, para girar, el mismo sistema que los coches, en los que giran las ruedas delanterass. En los robots se hacen girar al ruedas laterales a distintas velocidades, tal como se representa en la figura correspondiente a un vehículo de tres ruedas.

¿Qué es la robótica?

 

El término robótica es dado por Isaac Asimov para describir la tecnología de los robots. Él mismo predijo hace años el aumento de una poderosa industria robótica, predicción que ya se ha hecho realidad.
El término robótica se definen desde diversos puntos de vista:

Las definiciones son tan dispares como se demuestra en la siguiente relación:

• Ingenio mecánico controlado electrónicamente, capaz de moverse y ejecutar de forma automática acciones diversas, siguiendo un programa establecido.
• Máquina de apariencia o comportamiento imita a las personas y sus acciones, por ejemplo en el movimiento de sus extremidades.
• Es una máquina que hace algo automáticamente en respuesta a su entorno.
• Esta compuesto de motores controlados por un programa de ordenador.
• Es un ordenador con músculos.

Es cierto, como acabamos de observar, que los robots son difíciles de definir. Sin embargo, no es necesariamente un problema el que no esté todo el mundo de acuerdo sobre su definición. Quizás, Joseph Engelberg (padre de la robótica industrial) lo resumió inmejorablemente cuando dijo: “Puede que no se capaz de definirlo, pero sé cuándo veo uno”.

En definitiva cuando hablamos de robots imaginamos una maquina con características propias a  la del ser humano, sin embargo esta es solo una parte de la robotica.

Sketch Robot seguidor de líneas

int VelocidadMotor1 = 5; //ENA

int VelocidadMotor2 = 9; //ENB

int Motor1A = 6; //IN2

int Motor1B = 7; //IN1

int Motor2C = 8; //IN4

int Motor2D = 10; //IN3

int infraPin = 1; // izquierdo - pin del infrarrojos utilizado como entrada digital

int infraPin1=4; // derecho

int valorInfra = 0; // Valor inicial de la lectura digital del infrarrojos izquierdo

int valorInfra1 = 0; // derecho

void setup() {

delay(5000);

pinMode(infraPin, INPUT);

pinMode(infraPin1, INPUT);

pinMode(Motor1A,OUTPUT);

pinMode(Motor1B,OUTPUT);

pinMode(Motor2C,OUTPUT);

pinMode(Motor2D,OUTPUT);

pinMode(VelocidadMotor1, OUTPUT);

pinMode(VelocidadMotor2, OUTPUT);

analogWrite(VelocidadMotor1, 250); //motor izquierdo

analogWrite(VelocidadMotor2, 250); //motor derecho

digitalWrite(Motor1A, LOW);

digitalWrite(Motor1B, LOW);

digitalWrite(Motor2C, LOW);

digitalWrite(Motor2D, LOW);

}

void loop() {

valorInfra = digitalRead(infraPin); // valor de la entrada que lee el infrarrojo izquierdo

valorInfra1 = digitalRead(infraPin1); // derecho

// 0 = blanco / 1 = negro

if(valorInfra == 0 && valorInfra1 == 0){ // Hacia delante

digitalWrite(Motor1A, HIGH);

digitalWrite(Motor2D, HIGH);

delay(20); // Tiempo para control de velocidad

digitalWrite(Motor1A, LOW);

digitalWrite(Motor2D,LOW);

delay(20); // Tiempo para control de velocidad

}

if(valorInfra == 0 && valorInfra1 == 1){ // Giro derecha

digitalWrite(Motor1A, LOW);

digitalWrite(Motor2D,LOW);

delay(25);

digitalWrite(Motor1A, LOW);

digitalWrite(Motor2D,HIGH);

delay(20);

}

if(valorInfra == 1 && valorInfra1 == 0){ // Giro izquierda

digitalWrite(Motor1A,LOW);

digitalWrite(Motor2D, LOW);

delay(25);

digitalWrite(Motor1A,HIGH);

digitalWrite(Motor2D, LOW);

delay(20);

}

if(valorInfra == 1 && valorInfra1 == 1){ // STOP

digitalWrite(Motor1A, LOW);

digitalWrite(Motor1B, LOW);

digitalWrite(Motor2C, LOW);

digitalWrite(Motor2D, LOW);

}

}

Sketch para el control de un robot mediante del bluetooth

//Sketch para controlar el funcionamiento de un robot móvil mediante un teléfono móvil y utilizando la señal de bluetooth

#include <SoftwareSerial.h>
int pinE1=10;
int pinI1=9;
int pinI2=8;
int pinE2=11;
int pinI3=12;
int pinI4=13;
//Pin para el LED

SoftwareSerial ModuloHC05 (5, 6); //pin TX, pin RX
 

void adelante(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,HIGH);
digitalWrite(pinI2,LOW);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,HIGH);
digitalWrite(pinI4,LOW);
}
void atras(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,LOW);
digitalWrite(pinI2,HIGH);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,LOW);
digitalWrite(pinI4,HIGH);
}
void girarDerecha(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,HIGH);
digitalWrite(pinI2,LOW);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,LOW);
digitalWrite(pinI4,HIGH);
}
void girarIzquierda(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,LOW);
digitalWrite(pinI2,HIGH);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,HIGH);
digitalWrite(pinI4,LOW);
}

void parar(){
digitalWrite(pinE1,LOW);
digitalWrite(pinI1,HIGH);
digitalWrite(pinI2,LOW);
digitalWrite(pinE2,LOW);
digitalWrite(pinI3,HIGH);
digitalWrite(pinI4,LOW);
}
void setup() {

Serial.begin(9600);
ModuloHC05.begin(9600);
pinMode(pinE1,OUTPUT);
pinMode(pinI1,OUTPUT);
pinMode(pinI2,OUTPUT);
pinMode(pinE2,OUTPUT);
pinMode(pinI3,OUTPUT);
pinMode(pinI4,OUTPUT);
}

void loop() {
char dato;
if (ModuloHC05.available()) { //Llega algo por bluetooth?
dato=ModuloHC05.read(); //Leer el dato recibido
Serial.write(dato); //Mostrar el dato por el monitor serie

if (dato=='1') adelante(); //Si el dato recibido es "1", el robot avanza adelante
if (dato=='0') atras(); //Si el dato recibido es "0", el robot retrocede
if (dato=='3') girarDerecha(); //Si el dato recibido es "3" el robot gira a la derecha
if (dato=='2') girarIzquierda(); // Si el dato recibido es "2" el robot gira a la izquierda
if(dato=='5') parar(); //Si el dato recibido es "5", el robot se detiene
}


}

Sketch para el control de un robot seguidor de luz

// Sketch de para el robot seguidor de luz

//El robot incorpora dos ldrs

int E1=12;

int I1=11;

int I2=10;

int E2=7;

int I3=8;

int I4=9;

int ldr1=0;

int nivelLuz1=0;

int nivelLuz2=0;

int ldr2=1;

void setup()

{

Serial.begin(9600);

pinMode(E1, OUTPUT);

pinMode(I1, OUTPUT);

pinMode(I2, OUTPUT);

pinMode(E2, OUTPUT);

pinMode(I3, OUTPUT);

pinMode(I4, OUTPUT);

}

void loop()

{

nivelLuz1=analogRead(ldr1);

Serial.println(nivelLuz1);

nivelLuz2=analogRead(ldr2);

Serial.println(nivelLuz2);

if (nivelLuz1>450 && nivelLuz2>450)

{

adelanteMotor1();

adelanteMotor2();

}

if (nivelLuz1<450 && nivelLuz2<450)

{

pararMotor1();

pararMotor2();

}

if (nivelLuz1<450 && nivelLuz2>450)

{

derechaMotor1();

pararMotor2();

}

if (nivelLuz1>450 && nivelLuz2<450)

{

pararMotor1();

izquierdaMotor2();

}

}

void adelanteMotor1()

{

digitalWrite(E1, HIGH);

digitalWrite(I1, HIGH);

digitalWrite(I2, LOW);

}

void adelanteMotor2()

{

digitalWrite(E2, HIGH);

digitalWrite(I3, HIGH);

digitalWrite(I4, LOW);

}

void pararMotor1()

{

digitalWrite(E1, LOW);

}

void pararMotor2()

{

digitalWrite(E2, LOW);

}

void atrasMotor1()

{

digitalWrite(E1, HIGH);

digitalWrite(I1, LOW);

digitalWrite(I2, HIGH);

}

void atrasMotor2()

{

digitalWrite(E2, HIGH);

digitalWrite(I3, LOW);

digitalWrite(I4, HIGH);

}

void derechaMotor1()

{

digitalWrite(E1, HIGH);

digitalWrite(I1, HIGH);

digitalWrite(I2, LOW);

}

void derechaMotor2()

{

digitalWrite(E2, LOW);

digitalWrite(I3, LOW);

digitalWrite(I4, LOW);

}

void izquierdaMotor1()

{

digitalWrite(E1, LOW);

digitalWrite(I1, LOW);

digitalWrite(I2, LOW);

}

void izquierdaMotor2()

{

digitalWrite(E2, HbIGH);

digitalWrite(I3, HIGH);

digitalWrite(I4, LOW);

}

Sketch para el control del robot polilla

/*Robot que incorpora como sensor una ldr*/

int E1=12;
int I1=11;
int I2=10;
int E2=7;
int I3=8;
int I4=9;
int ldr=0;
int nivelLuz=0;

void setup()
{
Serial.begin(9600);
pinMode(E1, OUTPUT);
pinMode(I1, OUTPUT);
pinMode(I2, OUTPUT);
pinMode(E2, OUTPUT);
pinMode(I3, OUTPUT);
pinMode(I4, OUTPUT);
}

void loop()
{
nivelLuz=analogRead(ldr);
Serial.println(nivelLuz);

if (nivelLuz>50 && nivelLuz<338)
{
adelante();
delay(1000);
}
if (nivelLuz>338 && nivelLuz<679)
{
atras();
delay(1000);
}
if (nivelLuz<50)
{
parar();
delay(1000);
}
}

void adelante()
{
digitalWrite(E1, HIGH);
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);
digitalWrite(E2, HIGH);
digitalWrite(I3, HIGH);
digitalWrite(I4, LOW);
}

void parar()
{
digitalWrite(E1, LOW);
delay(1000);
digitalWrite(E2, LOW);
delay(1000);
}

void atras()
{
digitalWrite(E1, HIGH);
digitalWrite(I1, LOW);
digitalWrite(I2, HIGH);
digitalWrite(E2, HIGH);
digitalWrite(I3, LOW);
digitalWrite(I4, HIGH);
}

Sketch para el control de robot controlado por ultrasonidos

#include <Servo.h>

Servo servoMotor;
int pinE1=13;
int pinI1=12;
int pinI2=11;
int pinE2=7;
int pinI3=6;
int pinI4=5;
const int PinTrig=10;
const int PinEcho=9;
const float VelSon=34000.0;
float distancia;
int distancia_45;
int distancia_90;
int distancia_135;

void setup(){
pinMode(pinE1,OUTPUT);
pinMode(pinI1,OUTPUT);
pinMode(pinI2,OUTPUT);
pinMode(pinE2,OUTPUT);
pinMode(pinI3,OUTPUT);
pinMode(pinI4,OUTPUT);
Serial.begin(9600);
pinMode(PinEcho,INPUT);
pinMode(PinTrig,OUTPUT);
Serial.begin(9600);
servoMotor.attach(3);
}

void adelante(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,HIGH);
digitalWrite(pinI2,LOW);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,HIGH);
digitalWrite(pinI4,LOW);
}

void atras(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,LOW);
digitalWrite(pinI2,HIGH);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,LOW);
digitalWrite(pinI4,HIGH);
}

void girarDerecha(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,HIGH);
digitalWrite(pinI2,LOW);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,LOW);
digitalWrite(pinI4,HIGH);
}

void girarIzquierda(){
digitalWrite(pinE1,HIGH);
digitalWrite(pinI1,LOW);
digitalWrite(pinI2,HIGH);
digitalWrite(pinE2,HIGH);
digitalWrite(pinI3,HIGH);
digitalWrite(pinI4,LOW);
}

void parar(){
digitalWrite(pinE1,LOW);
digitalWrite(pinI1,HIGH);
digitalWrite(pinI2,LOW);
digitalWrite(pinE2,LOW);
digitalWrite(pinI3,HIGH);
digitalWrite(pinI4,LOW);
}

long iniciarTrigger(){
digitalWrite(PinTrig,LOW);
delayMicroseconds(200);
digitalWrite(PinTrig,HIGH);
delayMicroseconds(100);
digitalWrite(PinTrig,LOW);
unsigned long tiempo= pulseIn(PinEcho,HIGH);
distancia=tiempo*0.000001*VelSon/2.0;
return(distancia);
}

void loop() {

distancia_90=iniciarTrigger();
servoMotor.write(90);
Serial.print(distancia);
Serial.print("cm");
Serial.println();

delay(100);
while(distancia_90>20)

{
adelante();
distancia_90=iniciarTrigger();
}
if(distancia_90<40)

{
delay(100);
parar();
delay(1000);
servoMotor.write(45);
distancia_45=iniciarTrigger();
delay(500);
servoMotor.write(135);
distancia_135=iniciarTrigger();
delay(500);
if(distancia_45>distancia_135)

{
girarDerecha();
delay(350);
}
else

{
girarIzquierda();
delay(350);
}
}
}

Sketch para leer la distancia de un sensor de ultrasonidos

Sketch para leer la distancia a un objeto obtenida en el sensor de ultrasonidos. Se ha creado una función la la intención de ahorrar código dado que vamos a utilizar este sensor en un robot móvil y así conseguimos simplificar el código.

#define EchoPin 2
#define TriggerPin 3

long distancia;

long tiempo;

void setup(){

Serial.begin(9600);

pinMode(TriggerPin, OUTPUT); /*activación del pin 9 como salida: para el pulso de ultrasonido*/

pinMode(EchoPin, INPUT); /*activación del pin 8 como entrada: tiempo del rebote del ultrasonido*/

}


void loop(){

distancia=medirDistancia();
}

//Función que nos devuelve la distancia al objeto

long medirDistancia()
{
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(100);
}

Sketch para controlar el movimiento de un servomotor

En este articulo voy a ir incluyendo sketch para controlar el funcionamiento de un servomotor

Código para girar el servomotor de 0º a 180º (0-90º-180º)

// Incluímos la librería para poder controlar el servo

#include <Servo.h>

// Declaramos la variable para controlar el servo
Servo servoMotor;

void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);

// Iniciamos el servo para que empiece a trabajar con el pin 9
servoMotor.attach(9);
}

void loop() {

// Desplazamos a la posición 0º
servoMotor.write(0);
// Esperamos 1 segundo
delay(1000);

// Desplazamos a la posición 90º
servoMotor.write(90);
// Esperamos 1 segundo
delay(1000);

// Desplazamos a la posición 180º
servoMotor.write(180);
// Esperamos 1 segundo
delay(1000);
}

Girando grado a grado el servomotor

Para ello incrementa el ángulo de 0 a 180º a razón de 1º cada 15ms, posteriormente realiza la operación contraria de 180º a 0º, para finalmente reiniciar el bucle.

#include <Servo.h>

Servo myservo; // crea el objeto servo

int pos = 0; // posición del servo

void setup() {
myservo.attach(9); // vincula el servo al pin digital 9
}

void loop() {
//varia la posición de 0 a 180, con esperas de 15ms
for (pos = 0; pos <= 180; pos += 1)
{
myservo.write(pos);
delay(15);
}

//varia la posicion de 0 a 180, con esperas de 15ms
for (pos = 180; pos <= 0; pos -= 1)
{
myservo.write(pos);
delay(15);
}
}

Movimiento del servomotor 0º-45º-90, movimiento pensado para colocar un sensor de ultrasonidos en el servomotor y así poder controlar el movimiento de un robot móvil

// Incluímos la librería para poder controlar el servo
#include <Servo.h>

// Declaramos la variable para controlar el servo
Servo servoMotor;

void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);

// Iniciamos el servo para que empiece a trabajar con el pin 9
servoMotor.attach(9);
}

void loop() {

// Desplazamos a la posición 0º
servoMotor.write(00);
//Esperamos 1 segundo
delay(1000);

// Desplazamos a la posición 90º
servoMotor.write(45);
// Esperamos 1 segundo
delay(1000);

// Desplazamos a la posición 180º
servoMotor.write(90);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 90º
servoMotor.write(45);
// Esperamos 1 segundo
delay(1000);

}

Sketch del puente levadizo

Descripción del proyeco: Puente levadizo controlado por Arduino

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)

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

¿Que es un RCX?

El bloque RCX es la parte central del Lego Mindstorms, ya que aquí se encuentra toda la parte lógica y electrónica que permite la mayoría de las acciones del robot, almacenándose hasta 5 programas que se pueden cargar en su memoria interna, y guardándose allí el firmware básico para el control de los distintos dispositivos que se pueden conectar al bloque.

El bloque RCX tiene tres versiones oficiales: 1.0, 1.5 y 2.0, las cuales presentan mejoras en el software sin verse afectado mayormente el hardware que se vende con el bloque, sin embargo, la parte electrónica de los bloques no es compatible, ya que las tres versiones poseen distintas regulaciones de voltaje, pero aún así no afecta el hardware que posee el bloque.[13]

Microcontrolador

Su microcontrolador interno es Hitachi H8/3292, que funciona a 5 volts y una velocidad aproximada de 16 Mhz, siendo esa su velocidad máxima para la serie de Hitachi H8/3000. Posee una memoria ROM de 16 Kb, una memoria RAM externa de 32 Kb y posee un decodificador Analógico Digital que permite transformar las distintas entradas de energía en bits. Su empaque original es de un circuito impreso, que carece de zócalos de conexión, y se encuentra soldada a la base del circuito impreso del bloque. Este microcontrolador puede procesar varias instrucciones por segundos, pero su mayor desventaja comparado con el Lego Mindstorms NXT es la baja capacidad de mantener hilos de procesos, es decir, no puede ejecutar dos instrucciones al mismo tiempo, y a pesar que el programador o usuario compruebe que si puede, no es así, sino que la velocidad de proceso impide distinguir el retardo producido.

Entradas y salidas

Como medio de entradas posee tres conectores que permite capturar la información que proviene del los distintos sensores. Las entradas se conforma por un bloque de 2x2, que sus cabezas se encuentran rodeadas de un material conductor que permite la lectura del sensor. Las entradas se ubican en la parte superior de la pantalla de LCD, son de color gris y se distinguen por los números 1, 2 y 3.

Las salidas del bloque RCX son para energizar los motores que se pueden conectar al robot y así darle movimiento. El voltaje que provee es de 9 volts, haciendo que cada motor que se conecte al bloque pueda moverse acorde a las instrucciones del programa. Las salidas de energía se encuentran en la parte inferior de la pantalla de LCD, son de color negro y se distinguen por las letras A, B y C.

Pantalla LCD

La pantalla de LCD que trae el Lego Mindstorms permite visualizar tres series de datos:

• Superior, detección en las entradas de los sensores y el nivel de carga de las baterías.
• Central, zona alfanumérica que permite ver el contador, temporizador o valores registrados por un sensor.
• Inferior, indica el sentido de movimiento de los motores.
• Lateral izquierdo, muestra si hay conexión inalámbrica mediante el puerto infrarrojo

En su modo de operación, la pantalla de LCD posee un contador de ejecución de despliegue las veces y el tiempo que se ha ejecutado el programa, indica el número del programa que se está ejecutando y muestra la imagen de una persona que se encuentra de dos posibles formas, en estado de detención, la representación de la persona está detenida, y cuando se ejecuta un programa, ésta se encuentra en movimiento.

Además, si se selecciona un sensor, permite ver el valor registrado por el sensor, en una medida de RAW que se despliega sin importar el tipo de sensor que se encuentre conectado a la entrada.

Si el bloque no posee el firmware básico, no se muestra el contador de programa ni se ejecutan los programas 2, 3, 4 y 5, sólo permitiendo que el primer programa muestre que funciona la salida de corriente y entrada de datos. Además, la persona se mantiene fija aunque se encuentre en ejecución el programa 1 del bloque.

Esta salida de LCD ayuda al programador en caso que quiera hacer reemplazo del framework, ya que permite la salida de datos en pantalla, para generar una salida de estado de cualquier elemento interno del bloque.

Puerto infrarrojo y comunicación

En la parte delantera del bloque RCX, el Lego Mindstorms trae un puerto infrarrojo que le permite la comunicación con el computador para transferir el firmware y los programas. Funciona a una frecuencia de 37 Khz, que se asemeja a un control remoto de un televisor, transmitiendo datos a una velocidad aproximada de 2.400 bps, lo que implica que cada bit se transmite a 417 us.[14]

Una de las cualidades del puerto infrarrojo es la capacidad de conectarse a otro dispositivo que posea el puerto, como Palms, computadores portátiles y algunos modelos de teléfonos móviles, lo que permite realizar pequeñas plataformas de comunicaciones para lugares recónditos o muy pequeños.

La distancia de separación entre el RCX y el receptor es como máximo a 30 cm, funcionando a su máxima capacidad desde la base de la torre y sin objetos que interfieran la visual entre ambos instrumentos. Sin embargo, la distancia es menor debido a la contaminación lumínica que puede existir en el cuarto.

Alimentación eléctrica

La alimentación eléctrica del bloque es mediante 6 baterías AA de 1,5 volts, las cuales se conectan en la parte posterior del bloque. Las baterías se conectan en paralelo y proporcionan energía tanto al bloque como a los motores que se conectan al mismo bloque.

Una advertencia que se realiza en el manual de Lego Mindstorms es el reemplazo de las baterías, que ella alimenta a la pila que se encuentra dentro del bloque, permitiendo almacenar los distintos programas y el firmware básico. Si el reemplazo demora más de 1 minuto, la información almacenada se pierde. Otra advertencia que se realiza a los usuarios es que se evite utilizar baterías recargables debido a que entregan menor o mayor potencia el bloque, produciendo que el sistema eléctrico sea susceptible a fallos.

Se puede programar la desconexión de la alimentación eléctrica mediante el software incluido en el juego de Lego Mindstorms, donde se puede especificar el tiempo de apagado, desde 1 minuto hasta 99 minutos, e inclusive deshabilitar el apagado automático. Además, el mismo programa indica el nivel de carga que poseen las baterías del robot, mostrado por una barra de color verde cuando está cargado y ésta varía hasta rojo cuando se descarga completamente.

Cuando se descarga la batería del robot, este emite un sonido constante hasta que se presiona la tecla de apagado, indicando que las baterías se han agotado.

Robot seguidor de líneas de LEGO

Índice

1. Propuesta de trabajo.
2. Memoria técnica.
3. Lista de piezas.
4. Problemas encontrados y solución adoptada.
5. Valoración del proyecto.

Propuesta de trabajo

Diseño y construcción de un robot móvil con dos motores cuya finalidad será seguir una línea negra dibujada en un circuito.

Descripción técnica de la solución adoptada

• Descripción general del objeto

El móvil diseñado tiene como función seguir una trayectoria definida por una línea negra. 

Partiendo de piezas lego, se crea la estructura del móvil. Este poseerá dos motores que serán nuestros actuadores y dos sensores de luz.

Su funcionamiento es simple: los sensores medirán constantemente si siguen la línea y mandarán la información a la unidad de control. Cuando uno de ellos capte un color diferente, la unidad de control enviará una orden a los motores que modificarán su giro para reajustar la trayectoria. 

• Descripción técnica de la solución adoptada

• Estructura resistente.

El móvil consta de una estructura principal sobre la que se sitúan los mecanismos de transmisión del movimiento y la unidad de control. Además encontramos dos estructuras acopladas. La primera situada al frente del móvil sostiene los dos sensores. La segunda en la zona posterior tiene incorporada una rueda loca.

• Mecanismos de transmisión de movimiento. 

Encontramos dos motores. Por motivos de espacio, se encuentra uno más adelantado que el otro. Cada motor posee su sistema de poleas, teniendo uno de ellos una correa más largas. Todas las poleas tienen el mismo radio por lo que  ambos motores girarán a la misma velocidad. Cada motor transmite su movimiento a una de las ruedas. Por último posee una rueda loca en la parte posterior del móvil.

• Circuito eléctrico.

La unidad de control que usamos es un bloque RCX que es la parte central del Lego Mindstorms, ya que aquí se encuentra toda la parte lógica y electrónica que permite la mayoría de las acciones del robot, almacenándose hasta 5 programas que se pueden cargar en su memoria interna, y guardándose allí el firmware básico para el control de los distintos dispositivos que se pueden conectar al bloque, leer más. A la unidad de control encontramos enlazados dos sensores de luz. Los sensores de luz permite a nuestro robot distinguir entre luz y obscuridad, midiendo la intensidad de la luz le permite a nuestro robot "ver" en blanco y negro. En nuestro caso, el sensor emite una luz y luego mide que tanto rebota o refleja esta luz en las superficies. Este modo lo podemos usar para diferenciar el brillo de los colores en una superficie.

Lista de piezas

• Diversas piezas de lego.
• Dos motores.
• Dos sensores de luz.
• Cuatro poleas de igual tamaño.
• Dos gomas elásticas (una mayor y otra menor).
• Tres ruedas.
• Bloque RCX.

Problemas encontrados y soluciones adoptadas

Durante la programación hemos debido ajustar la velocidad de los motores para que la potencia fuese suficiente para moverse con fluidez pero sin que fuese excesiva. Si el móvil se mueve demasiado rápido, los sensores no tienen suficiente tiempo para medir el color y modificar la trayectoria, saliéndose de la línea.

Valoración

Este proyecto es muy entretenido de realizar. Es fácil de construir ya que partimos de piezas lego prefabricadas. La única complicación es la creación del programa donde debemos añadir los valores que nos interesan para seguir la línea.

CONTROL Y ROBÓTICA

Durante milenios el hombre ha creado herramientas, que con un largo proceso de perfeccionamiento se han ido modificando hasta obtener herramientas más cómodas, y eficaces.

En el trabajo artesanal, el hombre tenía como funciones la de motor, operario y controlador del sistema.

Posteriormente ha creado máquinas herramientas que se encargan de realizar las duras tareas manuales.

En el trabajo mecánico, el hombre a pasado a trabajar como operario y a controlar el sistema, dejando a las máquinas herramientas las funciones de motor.

En la actualidad ha creado sistemas automáticos.

En el trabajo automático, el hombre a pasado a supervisar el sistema. El resto de tareas se realizan sin intervención humana.

Control y robótica

Librosvivos.net