Está en la página 1de 11

DIVISIÓN DE INGENIERÍA

EN
SISTEMAS
COMPUTACIONALES

Inteligencia artificial

PRACTICA 3

Integrantes:
Teodoro Gerardo Montero Hernández
Eloísa Ramos Pérez
Itzel Muñoz López

DOCENTE:
Ing. Vicente Minero Luna

Declaro que el siguiente trabajo de evaluación es el fruto de análisis y trabajo


personal. El uso de todos los recursos como citas, ilustraciones, scripts de
terceros, se menciona de forma clara y estricta su origen, tanto en el cuerpo del
texto como en la bibliografía. En este sentido, soy (somos) consciente(s) de que
el hecho de no respetar los derechos de autor y hacer plagio, son objeto de
sanciones universitarias y/o legales

San Martín Texmelucan, Puebla Noviembre de 2018


INTRODUCCIÓN
Esta asignatura está dedicada a estudio de los robots como elementos esenciales
de la automatización de la producción, tanto desde el punto de vista de su
modelado como de su simulación. Los robots son máquinas que integran
componentes mecánicos, eléctricos, electrónicos, y dispositivos sensoriales y de
comunicaciones, bajo la supervisión de un sistema informático de control en
tiempo real. El empleo de robots en la industria persigue dotar de la máxima
flexibilidad a los procesos productivos, manteniendo la productividad que se
consigue empleando máquinas automáticas especializadas. Si la robótica puede
considerarse hoy en día como una disciplina madura se debe en gran medida a la
implantación de los robots en la industria durante el siglo pasado. En la actualidad,
el ámbito de aplicación de la robótica trasciende del entorno industrial y crece en
importancia en otros sectores como el de servicios. La robótica industrial desde
sus períodos de iniciación y madurez estuvo muy orientada a las funciones de
manipulación. De hecho, suele considerarse un robot industrial esencialmente
como un robot manipulador. (2)

2
DESARROLLO
Una parte esencial de la robótica, es la de diseñar sistemas autónomos o
semiautónomos con capacidad para interaccionar con su entorno, modificándolo
y/o moviéndose a través de él. Para ello los robots están provistos de:

 Sensores: dispositivos de medición de diversos tipos que capturan la


información del entorno
 Actuadores: elementos motores que permiten mover partes del robot o el
robot mismo, para interaccionar con el entorno
 Controladores: elementos lógicos que reciben la información del entorno
mediante los sensores y que deciden las acciones que se deben ejecutar de
acuerdo a algoritmos previamente programados (normalmente utilizando lenguajes
como C)
Programar un robot es diseñar el controlador que gobierna el comportamiento del
robot. Debido a la creciente complejidad de la robótica, la modelización y la
simulación se están convirtiendo en técnicas esenciales para que los ingenieros
comprendan el comportamiento del sistema robótico, entendiendo la forma en la
que el controlador funciona a la hora de procesar la percepción del entorno
realizada por el robot, así como la gestión de su movilidad e interacción con dicho
entorno. La modelización y la simulación en robótica permiten mejorar el diseño
del sistema y eliminar errores antes de haber desarrollado ningún prototipo físico.
(3)

Un proceso ideal de programación en robótica incluye:

 La modelización de los sistemas de percepción y movilidad


 El diseño de los algoritmos de control y su validación mediante
simulaciones
 La programación de los controladores en código C generado directamente a
partir de los modelos de simulación

3
Figura 1.1 Simulación de robot

PROGRAMA EN WEBOTS SIMILADOR DE ROBOTS

Figura 1.2 Un robot Khepera III montado con una pinza

4
Figura 1.3 Agarra un palo naranja, se mueve y deja el palo.

5
Figura 1.4 Robot Khepera III moviéndose dentro de una arena mientras evitas las
paredes. Utiliza un algoritmo de vehículo de Braitenberg para evitar obstáculos.
DATO CURIOSO
El robot "Khepera III" es un robot de dos ruedas producido por K-Team. Está
montado por múltiples sensores incluyendo 8 sensores de distancia.
CODIGO DEL PROGRAMA DOCUMENTADO
#include <webots/robot.h>
#include <webots/distance_sensor.h> // Librerias utilizadas en la utilización del robot
#include <webots/motor.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define MAX_SENSOR_NUMBER 16
#define RANGE (1024 / 2)
#define BOUND(x, a, b) (((x)<(a))?(a):((x)>(b))?(b):(x))
#define GRIPPER_MOTOR_MAX_SPEED 2.0

static WbDeviceTag sensors[MAX_SENSOR_NUMBER];


static WbDeviceTag gripper_motors[3];
static WbDeviceTag left_motor, right_motor;
static const double matrix[9][2] =
{ {-2.67, -2.67}, {-10.86, 21.37}, {-16.03, 26.71}, {-37.4, 37.4}, {37.4, -32.06},
{26.71, -21.37}, {21.37, -10.86}, {-2.67, -2.67}, {-5.34, -5.34} };
static const int num_sensors = 9;
static const double range = 2000.0;
static int time_step = 0;
static const double max_speed = 19.1;

static void initialize()


{

/ * necesario para inicializar Webots * /


wb_robot_init();

time_step = wb_robot_get_basic_time_step();

char sensors_name[5];
sprintf(sensors_name, "%s", "ds0");

int i;

6
for (i = 0; i < num_sensors; i++) {
sensors[i] = wb_robot_get_device(sensors_name);
wb_distance_sensor_enable(sensors[i], time_step);

if ((i + 1) >= 10) {


sensors_name[2] = '1';
sensors_name[3]++;

if ((i + 1) == 10) {
sensors_name[3] = '0';
sensors_name[4] = '\0';
}
} else {
sensors_name[2]++;
}
}

gripper_motors[0] = wb_robot_get_device("horizontal_motor");
gripper_motors[1] = wb_robot_get_device("left_finger_motor");
gripper_motors[2] = wb_robot_get_device("right_finger_motor");

left_motor = wb_robot_get_device("left wheel motor");


right_motor = wb_robot_get_device("right wheel motor");
wb_motor_set_position(left_motor, INFINITY);
wb_motor_set_position(right_motor, INFINITY);
wb_motor_set_velocity(left_motor, 0.0);
wb_motor_set_velocity(right_motor, 0.0);

const char *robot_name = wb_robot_get_name();


printf("The %s robot is initialized, it uses %d distance sensors\n", robot_name,
num_sensors);
}

void step(double seconds){


const double ms = seconds * 1000.0;
int elapsed_time = 0;
while (elapsed_time < ms){
wb_robot_step(time_step);
elapsed_time += time_step;
}
}

void braitenberg() {
while (1) {

7
int i, j;
double speed[2];
double sensors_value[num_sensors];

/ * Ejecutar simulación * /
wb_robot_step(time_step);

for (i = 0; i < num_sensors; i++) {


sensors_value[i] = wb_distance_sensor_get_value(sensors[i]);
}

/*
* El algoritmo de Braitenberg es realmente simple, simplemente calcula el
* velocidad de cada rueda sumando el valor de cada sensor multiplicado por
* Su peso correspondiente. Es por eso que cada sensor debe tener un peso.
* para cada rueda. */

for (i = 0; i < 2; i++) {


speed[i] = 0.0;

for (j = 0; j < num_sensors; j++) {

/*
* Necesitamos actualizar el valor del sensor para poder obtener
* valores negativos también. Esto permitirá que las ruedas vayan
*hacia atrás también.
*/
speed[i] += matrix[j][i] * (1.0 - (sensors_value[j] / range));
}

speed[i] = BOUND(speed[i], -max_speed, max_speed);


}

/ * Ajustar las velocidades del motor * /


wb_motor_set_velocity(left_motor, speed[0]);
wb_motor_set_velocity(right_motor, speed[1]);
}
}

void moveArms(double position) {

8
wb_motor_set_velocity(gripper_motors[0], GRIPPER_MOTOR_MAX_SPEED);
wb_motor_set_position(gripper_motors[0], position);
}

void moveFingers(double position) {


wb_motor_set_velocity(gripper_motors[1], GRIPPER_MOTOR_MAX_SPEED);
wb_motor_set_velocity(gripper_motors[2], GRIPPER_MOTOR_MAX_SPEED);
wb_motor_set_position(gripper_motors[1], position);
wb_motor_set_position(gripper_motors[2], -position);
}

void moveForwards(double speed) {


wb_motor_set_velocity(left_motor, speed);
wb_motor_set_velocity(right_motor, speed);
}

void turn(double speed) {


wb_motor_set_velocity(left_motor, speed);
wb_motor_set_velocity(right_motor, -speed);
}

void stop(double seconds) {


wb_motor_set_velocity(left_motor, 0.0);
wb_motor_set_velocity(right_motor, 0.0);
step(seconds);
}
// las posiciones donde el robot debe moverse
int main()
{
initialize();
stop(1.0);
moveForwards(12.8);
moveArms(-3.0);
step(1.0);
stop(1.0);
moveFingers(0.42);
step(1.0);
moveArms(0.0);
moveForwards(-12.8);
moveArms(0.0);
step(1.0);
stop(1.0);
turn(-2.4);

9
step(0.5);
moveForwards(12.8);
step(0.6);
stop(0.25);
moveArms(-1.6);
step(1.5);
moveFingers(0.0);
step(1.0);
moveArms(0.0);
moveFingers(0.0);
step(1.0);
moveForwards(-12.8);
step(1.0);
turn(-10.7);
step(1.0);
braitenberg();
return 0;
}

CONCLUSIÓN
Teodoro: la Robótica y la Automatización se diferencian en la forma en que trabajan, la
automatización solo sigue la tarea que se le programó, ya sea solo embotellar un
producto, sin importar si se logró o no. Mientras que la robótica utiliza su inteligencia para
realizar las tareas, adaptándose a la situación que se le presente para poder solucionarlo.
Pero a pesar de que la Robótica y la automatización cuenten con sus diferencias, siguen
estando muy relacionadas entre sí ya que sus principales objetivos es el de sustituir el
trabajo que las personas harían para así mejorar la producción de éste.

REFERENCIAS BIBLIOGRAFICAS
1. Webots, (2018) proyectos de webots. Consultado el 25 de noviembre
del 2018. Obtenido de https://cyberbotics.com/
2. Mathworks, (2018) Robotica con MATLAB y Simulink. . Consultado el
25 de noviembre del 2018. Obtenido de
https://la.mathworks.com/discovery/robotica.html

10
3. UNED, (2015) MODELADO Y SIMULACIÓN DE ROBOTS. Consultado el
25 de noviembre del 2018. Obtenido de
http://portal.uned.es/portal/page?
_pageid=93,36654445&_dad=portal&_schema=PORTAL&idAsignatura=
31105096

11