Descripción del proyecto
Este proyecto consta de la creación y el diseño de un robot Otto, el cual pasará diferentes pruebas enfrentándose a otros robots para definir cual de ellos es el mejor. Para ello, habrá que diseñar el modelo 3D del robot Otto, por lo que será necesario el Tinkercad y posteriormente el uso de la impresora 3D para crear las piezas diseñadas.
Una vez impresas las piezas será hora de montar el robot añadiendo también sus correspondientes motores que permitirán el movimiento de las ruedas y de los brazos, haciendo que estos últimos hagan una rotación de 180º y una vez acabado de montar será hora de centrarse en la programación del robot.
Esta programación o código será la que permitirá el funcionamiento de nuestro robot Otto en cuanto al movimiento de este se refiere, ya que a la hora de avanzar tendremos que haber programado un código, el cual se encontrará en una placa arduino.
Autores
- Christian Del Hoyo Sanz.
- Sergio Blasco Andrés.
Material necesario
- En cuanto a las piezas se refiere tendremos que usar las siguientes:
- Será necesario el uso de unos servos de 360º, para el movimieto de las ruedas.
- Además también necesitaremos otros servos pero estos de 180º,para permitir el movimiento de los brazos.
- ·Un arduino nano donde se encuentre el código necesario para el funcionamiento del robot Otto.
- ·Utilizaremos también un shield nano para, al igual que en el arduino nano, introducir el código que permitirá el funcionamiento del robot.
- Será necesaria solamente una pila que servirán como fuente de alimentación para todos los componentes del robot Otto.
- ·Un dispositivo Bluetooth que será esencial para el manejo de los robots Otto, ya que se controlaran a partir de Bluetooth con nuestros teléfonos móviles.
- ·Un sensor de distancia que será utilizado también para su manejo a distancia y a partir del Bluetooth.
- Por último, necesitaremos material para impresora 3D, para poder conseguir las piezas.
Material 3D
Una vez nos hayamos hecho con el material 3D será hora de imprimir en la impresora 3D las piezas del robot Otto que posteriormente colocaremos y montaremos, por lo que el listado de las piezas de arriba a abajo del robot Otto que serán necesarias será el siguiente:
1-La primera pieza a imprimir en el orden antes mencionado será la cabeza, esta será agujereada con el objetivo de poder colocar los servos de 180º, que más tarde serán los encargados de rotar los brazos, y atornillarlos sobre unos soportes para que estos se encuentren estables y no interrumpan el movimiento de los brazos.
2-La segunda pieza a imprimir será una pequeña lámina con figuras en forma de círculos y con la imagen de un tres que se colocará en la pieza anteriormente impresa con unos huecos en forma de círculos para encajen perfectamente y actúen como los ojos del robot Otto.
3-La tercera pieza a imprimir serán los brazos, las dimensiones y el diseño de los cuales será modificado y editado en el Tinkercad con el fin de hacerlos con la medida perfecta para que así se puedan acoplar de la mejor manera a los servos y no choquen contra ninguna pieza.
4-La cuarta pieza a imprimir será este pico que utilizaremos como arma, que estará situado en el brazo, encajándolo con la mano. Este pico le abrirá al robot la posibilidad, mediante el movimiento, de intentar golpear al robot enemigo y así poder tirarlo al suelo.
5-La quinta pieza a imprimir será el cuerpo, este será el lugar en el que se encuentre la pila que funcionará de fuente de alimentación para el robot y además también se encontrará la placa arduino en la que se encontrará el código que permitirá el movimiento de los servos.
6-La sexta pieza a imprimir serán las dos piernas, estas tendrán unos huecos diseñados para poder ubicar en ellos los cuatro servos, dos de 360º y otros dos de 180º, que serán atornillados y permitirán el movimiento de las piernas y ruedas. Además las piernas tendrán unos palos que proporcionarán estabilidad a las piernas cuando estas se encuentren rotadas por los servos.
7-La séptima pieza a imprimir serán las dos ruedas, estas se siturán justo debajo de las piernas y se atornillarán a los servos de 360º permitiendo así que el robot se pueda mover bien y sin dificultades por el tatami o medio en el que se encuentre.
Finalmente, tras imprimir y montar las piezas diseñadas en el Tinkercad, a excepción de la parte electrónica, el robot se verá así. Además el diseño del robot se podrá descargar mediante el siguiente enlace: https://www.tinkercad.com/things/1i8dMNqC6IT
Pruebas
Prueba 1: Esta prueba consiste en que dos robots Otto, situados en las partes ya marcadas en el tatami, se enfrenten uno contra el otro, hasta que uno de los dos consiga sacar fuera del tatami al robot adversario o consiga tumbarlo e incapacitarlo haciendo que no se pueda volver a levantar.
En el caso de que ninguno de los dos robots se encuentre fuera del tatami o sea tumbado por el robot adversario la prueba se repetirá, pero esta vez ganará el robot que consiga empujar a su adversario y este toque la parte negra del tatami.
Para esta prueba estará permitido un diseño en el que se añadan partes o extremidades en todos los robots para facilitar el hecho de tumbar al robot adversario o echarlo fuera del campo de batalla. Además, al no ser autónomos los robots, la forma en la que tendrán que ser manejados será por bluetooth mediante nuestros teléfonos móviles.
Diagrama del circuito
Después de montar el robot con las piezas anteriormente impresas colocaremos dentro del robot la parte electrónica o circuito, que estará formada por un arduino y un arduino nano, cuatro servos de 180º, dos servos de 360º y un dispositivo bluetooth.
Código del proyecto
Una vez acabado el montaje tanto de la parte electrónica como de las piezas impresas nos encargaremos de programar el código del proyecto.
A partir de este, podremos diseñar un mando a través de la página web App Inventor, el cual se conectará al bluethooth del circuito electrónico, y mediante este se podrán realizar distintos movimientos, como por ejemplo el cambio de forma del robot Otto pudiendo estar sobre las ruedas o de pie y también el movimiento de los brazos hacia arriba y abajo, y el movimiento de las ruedas hacia delante y detrás.
El código del proyecto es el siguiente:
#include <SoftwareSerial.h>
#include <Servo.h>
Servo BrazoI, BrazoD, PataI, PataD, PieI, PieD;
SoftwareSerial bt1(10, 11);
char val;
int Pos = 1, BI = 90, BD = 90;
void setup() {
// put your setup code here, to run once:
BrazoI.attach(6);
BrazoD.attach(7);
PataI.attach(4);
PataD.attach(5);
PieI.attach(2);
PieD.attach(3);
Serial.begin(9600);
BrazoI.write(BI);
BrazoD.write(BD);
PataI.write(85);
PataD.write(95);
PieI.write(90);
PieD.write(90);
Serial.begin(9600);
bt1.begin(9600);
}
void loop() {
// put your main code here, to run repeatedly:
if ( bt1.available() ) {
val = bt1.read();
delay(25);
Serial.println(val);
if ( val == ‘0’ )
{
Parar(Pos);
}
if ( val == ‘1’ )
{
Adelante();
}
if ( val == ‘2’ )
{
Atras();
}
if ( val == ‘3’ )
{
Izquierda(Pos);
}
if ( val == ‘4’ )
{
Derecha(Pos);
}
if ( val == ‘5’ )
{
Pos = Cambio(Pos);
}
if ( val == ‘6’ )
{
BrazoIAr();
}
if ( val == ‘7’ )
{
BrazoIAb();
}
if ( val == ‘8’ )
{
BrazoDAr();
}
if ( val == ‘9’ )
{
BrazoDAb();
}
}
}
void Parar(int Pos)
{
if (Pos == 2) {
PieI.write(90);
PieD.write(90);
PataI.write(175);
PataD.write(5);
} else {
if ( Pos == 1) {
PieI.write(90);
PieD.write(90);
PataI.write(85);
PataD.write(95);
}
}
}
void Adelante ()
{
PieI.write(130);
PieD.write(60);
}
void Atras ()
{
PieI.write(80);
PieD.write(100);
}
void Izquierda(int Pos)
{
if(Pos == 1){
PataI.write(85);
PieI.write(90);
for(int d=95; d>=65; d–){
PataD.write(d);
delay(40);
}
PieD.write(70);
}else{
if(Pos == 2){
PieI.write(90);
PieD.write(60);
}
}
}
void Derecha (int Pos)
{
if(Pos == 1){
PataD.write(95);
PieD.write(90);
for(int i=85; i<=115; i++){
PataI.write(i);
delay(40);
}
PieI.write(110);
}else{
if(Pos == 2){
PieI.write(120);
PieD.write(90);
}
}
}
int Cambio (int Pos)
{
if (Pos == 2) {
int x=5;
PieI.write(90);
PieD.write(90);
for(int i=175; i>=85; i–){
PataI.write(i);
PataD.write(x);
x = x + 1;
delay(20);
}
Pos = Pos – 1;
} else {
if ( Pos == 1) {
PieI.write(90);
PieD.write(90);
PataI.write(175);
PataD.write(5);
Pos = Pos + 1;
}
}
return Pos;
}
void BrazoIAr()
{
if (BI == 90) {
BI = BI – 45;
BrazoI.write(BI);
} else {
if (BI == 135) {
BI = BI – 45;
BrazoI.write(BI);
}
}
}
void BrazoIAb()
{
if (BI == 90) {
BI = BI + 45;
BrazoI.write(BI);
} else {
if (BI == 45) {
BI = BI + 45;
BrazoI.write(BI);
}
}
}
void BrazoDAr()
{
if (BD == 90) {
BD = BD + 30;
BrazoD.write(BD);
} else {
if (BD == 60) {
BD = BD + 30;
BrazoD.write(BD);
}
}
}
void BrazoDAb()
{
if (BD == 90) {
BD = BD – 30;
BrazoD.write(BD);
} else {
if (BD == 120) {
BD = BD – 30;
BrazoD.write(BD);
}
}
}
Mi Arduino 