{"id":40,"date":"2019-04-22T14:55:00","date_gmt":"2019-04-22T14:55:00","guid":{"rendered":"https:\/\/blogs.etsii.urjc.es\/dseytr\/?p=40"},"modified":"2019-05-04T11:17:37","modified_gmt":"2019-05-04T11:17:37","slug":"prograr","status":"publish","type":"post","link":"https:\/\/blogs.etsii.urjc.es\/dseytr\/prograr\/","title":{"rendered":"ProgrARM"},"content":{"rendered":"
\n<\/div>\n

\n<\/a><\/span><\/h4>\n
\n

\n
\nProgrARM<\/span><\/span><\/div>\n
\nPor M\u00e1ximo Garc\u00eda-Cesto y Pablo Mench\u00e9n GRUPO 5<\/span><\/div>\n
\n
<\/span><\/span><\/div>\n<\/h2>\n

\n\u00cdndice de contenidos:<\/span><\/span><\/h1>\n

\n
\n1.   Introducci\u00f3n<\/span><\/span><\/div>\n
\n2.   Lista de
\nmateriales<\/span><\/span><\/div>\n
\n3.   <\/span><\/span>Construcci\u00f3n<\/span><\/span><\/div>\n
\n       3.1.   Servidor y pantalla<\/span><\/span><\/div>\n
\n                3.1.1.  Montaje del Hardware<\/span><\/span><\/div>\n
\n                          3.12.  Software<\/span><\/span><\/div>\n
\n       3.2.   Mano rob\u00f3tica<\/span><\/span><\/div>\n
\n                3.2.1.  Montaje del Hardware<\/span><\/span><\/div>\n
\n                3.2.2.  Software<\/span><\/span><\/div>\n
\n4.   Resultados<\/span><\/span><\/div>\n
\n5.   Bibliograf\u00eda y c\u00f3digo<\/span><\/span><\/span><\/div>\n
\n<\/div>\n<\/h2>\n

\n1. Introducci\u00f3n <\/span><\/span><\/h1>\n

\n
\n
<\/span><\/span><\/div>\n

Hoy en d\u00eda un gran porcentaje de las industrias usan
\nm\u00e1quinas para automatizar la creaci\u00f3n de productos; el gran problema de estas
\nm\u00e1quinas es que son muy complicadas de usar y la mayor parte de industrias
\nnecesitan un equipo de t\u00e9cnicos que den las instrucciones a estas m\u00e1quinas.<\/span><\/span><\/p>\n

\nNuestra idea es crear un prototipo de brazo rob\u00f3tico
\nque pueda ser usado por cualquiera.<\/span><\/span><\/div>\n
\nLa gran diferencia entre nuestra propuesta y cualquier otro
\nbrazo mec\u00e1nico es que vamos a integrar un software sencillo e intuitivo para que cualquier persona, independientemente de sus conocimientos sobre cualquier
\nrama de ingenier\u00eda, pueda crear una serie de \u00f3rdenes y mand\u00e1rselas al brazo
\npara que este las ejecute.<\/span><\/span><\/div>\n
\nA mayor escala, este brazo rob\u00f3tico podr\u00eda formar parte de
\ncualquier cadena de montaje, lo que supondr\u00eda reducir enormemente el gasto en
\npersonal, pues cualquier persona podr\u00eda crear un programa para el brazo.<\/span><\/span><\/div>\n
\nAdem\u00e1s, este se conectar\u00e1 a una red dom\u00e9stica mediante
\nWIFI, por lo que no necesitar\u00e1 cables exceptuando los de alimentaci\u00f3n. El
\nusuario podr\u00e1 subir las instrucciones mediante una aplicaci\u00f3n web desde cualquier
\nordenador siempre que est\u00e9 conectado a la red. Adem\u00e1s podr\u00e1
\nalmacenar las instrucciones para reutilizarlas<\/span>. <\/span><\/span><\/div>\n
\nTanto para ejecutar un programa cargado
\nen el brazo como para conectarse a la red, el brazo contar\u00e1 con una pantalla
\nt\u00e1ctil en la que el usuario podr\u00e1 realizar estas acciones.<\/span><\/span><\/div>\n
\nEl proceso para que un usuario suba un programa a la mano
\nser\u00e1 el siguiente:<\/span><\/span><\/div>\n
\nEl usuario usar\u00e1 una pantalla t\u00e1ctil situada en la base del
\nbrazo para conectar este a una red WIFI.<\/span><\/span><\/div>\n
\nUna vez conectado, podr\u00e1 cargar las instrucciones desde cualquier
\nordenador de la red escribiendo en un navegador la ip que le proporcionar\u00e1 la pantalla. Al hacer esto, se cargar\u00e1 una p\u00e1gina web que permitir\u00e1 al usuario crear
\nuna secuencia de acciones.<\/span><\/span><\/div>\n
\nCuando el usuario termine de crear la cadena de \u00f3rdenes que
\nquiere mandar al brazo, mandar\u00e1 estas instrucciones al brazo mediante la
\naplicaci\u00f3n web y estas acciones se almacenar\u00e1n como un programa en el brazo.<\/span><\/span><\/div>\n
\nDesde la pantalla t\u00e1ctil del brazo, el usuario podr\u00e1 seleccionar
\nlas acciones que acaba de mandar y el brazo las ejecutar\u00e1.<\/span><\/span><\/div>\n
\nEl proyecto contar\u00e1 de las siguientes tres partes:<\/span><\/span><\/div>\n
\nUn microcontrolador encargado de funcionar como servidor, que
\nse conectar\u00e1 a una red dom\u00e9stica para proporcionar al usuario la aplicaci\u00f3n web
\nen donde poder construir la lista de acciones.<\/span><\/span><\/div>\n
\nUn microcontrolador encargado de administrar las tareas que
\nmanda el usuario por pantalla y de gestionar los proyectos que hay que guardar
\nen la mano.<\/span><\/span><\/div>\n
\nUn microcontrolador encargado de administrar los movimientos
\ndel brazo.<\/span><\/span><\/span><\/span><\/div>\n
\n<\/div>\n<\/h2>\n

\n2. Lista de materiales<\/span><\/span><\/h1>\n

\n
\nEn este proyecto ya cont\u00e1bamos con el 60% de los materiales por lo que el total salio entorno a 80\u20ac<\/span><\/span><\/div>\n
\nA continuaci\u00f3n ponemos la lista de materiales completa:<\/span><\/span><\/div>\n
\n
<\/span><\/span><\/div>\n
\nPLA -15\u20ac<\/span><\/span><\/div>\n
\n2x Arduino Mega -30\u20ac<\/span><\/span><\/div>\n
\nPantalla tactil TFT -13\u20ac<\/span><\/span><\/div>\n
\nLector tarjetas SD – 2\u20ac<\/span><\/span><\/div>\n
\nStepper -14\u20ac<\/span><\/span><\/div>\n
\n2x Servos MG996R -15\u20ac<\/span><\/span><\/div>\n
\n4x Servos MG996R  – 30\u20ac<\/span><\/span><\/div>\n
\nNodeMcu -7,69\u20ac<\/span><\/span><\/div>\n
\nAdafruitMotoshield v2 – 24,8\u20ac<\/span><\/span><\/div>\n
\nPotenciometro Bourns – 4,89\u20ac<\/span><\/span><\/div>\n
\nRodamientos – 7\u20ac<\/span><\/span><\/div>\n
\nMiscelania(Cables,tornillos etc) – 15\u20ac<\/span><\/span><\/div>\n
\nTOTAL=~165\u20ac<\/span><\/span><\/div>\n
\n<\/div>\n<\/h2>\n

\n3. Construcci\u00f3n<\/span><\/h1>\n

\n3.1 Servidor y pantalla<\/span><\/span><\/h1>\n

\n
\nEn esta parte hemos abordado las funcionalidades relativas a
\nla creaci\u00f3n del servidor junto con la pantalla.<\/span><\/span><\/div>\n
\nPor lo tanto, lo primero fue crear la
\np\u00e1gina web que enviar\u00eda el servidor.<\/span><\/span><\/div>\n
\nLa p\u00e1gina web ha sido uno de los puntos m\u00e1s complicados. Nos
\nhemos basado en la famosa aplicaci\u00f3n de programaci\u00f3n Scratch, pues esta est\u00e1
\npensada para que ni\u00f1os aprendan a programar, luego es f\u00e1cil e intuitiva. La
\nidea es hacer que cada acci\u00f3n que pueda realizar el brazo rob\u00f3tico sea un bloque y
\nque el usuario pueda arrastrar estos bloques y ponerlos uno debajo del otro
\npara crear una cadena de acciones.<\/span><\/span><\/span><\/span><\/div>\n
\n
<\/span><\/div>\n
\n<\/span><\/a>Como en todas las p\u00e1ginas webs, los lenguajes usados han
\nsido HTML, CSS y JavaScript.<\/span><\/span><\/div>\n
\nDespu\u00e9s de varias versiones y cambiar varias veces el
\nprototipo de la p\u00e1gina web, incluimos una consola en la parte izquierda de la
\np\u00e1gina, para que el usuario tuviera informaci\u00f3n sobre si el programa tuviera errores, si se ha compilado bien el programa y si este se ha subido bien
\na la mano.<\/span><\/span><\/div>\n
\nEl resultado final de la p\u00e1gina ha sido el siguiente:<\/span><\/span>
\n
<\/span><\/span><\/div>\n
\n
\n<\/a><\/div>\n
\n<\/div>\n

Dado que los Arduinos no son especialmente potentes, la
\np\u00e1gina web compila directamente los bloques que pone el usuario y crea una
\nsalida en formato de texto, que es la que posteriormente se subir\u00e1 al Arduino.<\/span><\/span><\/div>\n

\nDe esta forma conseguimos que sea el propio navegador el que
\ncopile el proyecto y no se haga esta operaci\u00f3n en el Arduino. La mano recibe y
\nalmacena solamente la salida del programa.<\/span><\/span><\/div>\n
\nUna vez ten\u00edamos el programa montado, ten\u00edamos que hacer un
\nservidor en el NodeMCU que, cuando el usuario se conectara a su ip, enviara la
\npagina web que hab\u00edamos hecho. Aqu\u00ed tuvimos un gran problema. La librer\u00eda que
\nusamos para hacer el servidor, ESP8266 Web Server, no puede mandar grandes
\ncantidades de datos. Nuestra aplicaci\u00f3n web tiene m\u00e1s de 1500 l\u00edneas de c\u00f3digo
\nluego el nodeMCU no pod\u00eda enviar esa cantidad de datos y se reiniciaba. Para
\nresolver este problema usamos tecnolog\u00eda AJAX. 
\nEn vez de enviarle la p\u00e1gina completa de una sentada al cliente, el
\nservidor le manda primero una p\u00e1gina intermedia. Esta p\u00e1gina se encarga de ir
\npidiendo al servidor cachos de la p\u00e1gina grande e ir recopil\u00e1ndolos (con
\ntecnolog\u00eda Ajax, para poder realizar peticiones y recibir informaci\u00f3n sin
\ncambiar de p\u00e1gina). Cuando el servidor le ha enviado la p\u00e1gina completa, la
\np\u00e1gina intermedia une todos los trozos de la p\u00e1gina grande y la ejecuta.
\nComo el servidor tarda bastante en enviar la p\u00e1gina completa, aprovechamos para
\nmeter con CSS y HTML en la p\u00e1gina intermedia un mensaje: \u201cCargando, espere por
\nfavor\u201d y un s\u00edmbolo de que la p\u00e1gina se est\u00e1 cargando.<\/span><\/span><\/div>\n
\nNo es un m\u00e9todo perfecto, y la p\u00e1gina tarda incluso un
\nminuto en cargar, pero acaba cargando y era el \u00fanico m\u00e9todo que se nos ocurr\u00eda.<\/span><\/span><\/div>\n
\nUna vez enviada la p\u00e1gina, el nodeMCU tiene que estar alerta
\npues, en cualquier momento, el cliente le puede mandar la informaci\u00f3n del
\nprograma. La informaci\u00f3n se sube a trav\u00e9s de una petici\u00f3n. El cliente mete en
\nla url de la petici\u00f3n el nombre del programa y una tira de caracteres cuyo
\nsignificado es cada acci\u00f3n que tiene que realizar la mano.<\/span><\/span><\/div>\n
\nCon esto finaliza la creaci\u00f3n del servidor. Pero todav\u00eda
\nfalta unir al nodeMCU que hace de servidor con el Arduino que maneja la
\npantalla y el lector de tarjetas SD.<\/span><\/span><\/div>\n
\nLa idea de la pantalla t\u00e1ctil surge al necesitar un m\u00e9todo
\npara que el usuario elija que programa desea ejecutar en la mano. A dem\u00e1s de
\nesto, la pantalla t\u00e1ctil nos permite que el usuario teclee en ella el nombre de
\nla red y la contrase\u00f1a de la red
\nWIFI.<\/span><\/span><\/div>\n
\nComo podemos comprobar, la pantalla deber\u00eda tener un sistema
\npara poder administrar una gran cantidad de botones puesto que para teclear una
\ncontrase\u00f1a o un nombre necesitamos un teclado con muchas teclas, y para poder
\nseleccionar que programa ejecutar hacen falta m\u00e1s botones todav\u00eda. Por ello, lo
\nprimero que hicimos fue crear un sistema de creaci\u00f3n y gesti\u00f3n de botones que,
\nuna vez creado, nos permitir\u00eda crear y destruir muchos botones por pantalla.<\/span><\/span><\/div>\n
\nCreamos una funci\u00f3n que nos permit\u00eda,
\ncon solo llamarla, que apareciera un teclado por pantalla, que dejara escribir
\nal usuario lo que quisiera y que, cuando este diera a aceptar, devolviera lo
\nque el usuario hubiera escrito.<\/span><\/span><\/div>\n
\nCon este sistema creamos de manera muy f\u00e1cil un bot\u00f3n para
\nconectar el Arduino a una red WIFI. Cuando el usuario pone el nombre y la
\ncontrase\u00f1a, el Arduino manda al NodeMCU (El servidor que hemos visto
\npreviamente) esta informaci\u00f3n a trav\u00e9s de los pines de trasmisi\u00f3n serial.<\/span><\/span><\/div>\n
\nCuando el NodeMCU se conecta a la red, manda al Arduino la
\nIP que tiene en la red y empieza a ejecutar el servido que hemos descrito
\npreviamente.<\/span><\/span><\/div>\n
\nCuando el NodeMCU recibe informaci\u00f3n sobre un nuevo programa
\nque haya hecho el usuario en la p\u00e1gina web (descrito previamente), le pasa esta
\ninformaci\u00f3n al Arduino que, al recibirla, la mete dentro de la tarjeta SD.<\/span><\/span><\/div>\n
\nPor \u00faltimo, para poder seleccionar un programa y que la mano
\nlo ejecute, el Arduino lee de la tarjeta SD la informaci\u00f3n sobre el programa pulsado y a trav\u00e9s de otro puerto serial, env\u00eda la
\ninformaci\u00f3n a el tercer Arduino (el que controla la mano rob\u00f3tica).<\/span><\/span><\/div>\n
\nLo m\u00e1s complicado de hacer la pantalla ha sido que, como los
\nArduino no tiene mucha potencia, tardan mucho en refrescar la pantalla. Esto
\nhace que tengas que pensar bien que parte de la pantalla tienes que refrescar o
\nen que momento justo tienes que modificar algo en pantalla para que tarde lo
\nmenos posible en recargar la pantalla. En los ordenadores actuales no hay ese
\nproblema pues pueden refrescar una pantalla entera muchas veces por segundo.<\/span><\/span><\/span><\/span><\/div>\n
\n<\/div>\n<\/h2>\n

3.2 Mano rob\u00f3tica<\/b><\/span>
\n
<\/span><\/span>
\n3.2.1 Montaje del Hardware<\/span><\/span><\/p>\n

\n
<\/span><\/span><\/div>\n

\n
\n<\/div>\n
\nLo primero de todo fue redise\u00f1ar alguna piezas del modelo.<\/span><\/div>\n
\n
<\/span><\/div>\n
\n<\/span><\/a><\/div>\n
\n
<\/span><\/div>\n
\nA continuaci\u00f3n imprimimos las piezas en la impresora 3D, este proceso nos llevo mucho tiempo pues son piezas muy grandes y cualquier problema o ajuste de la impresora supone rehacer la pieza de nuevo.<\/span><\/div>\n
\nUna vez impresas las piezas, montamos la pinza, con la ayuda de una dremel lijamos todas las superficies para que encajara bien y a\u00f1adimos engrasaste a las piezas<\/span><\/div>\n
\n
<\/span><\/div>\n
\n<\/span><\/a><\/div>\n
\n
<\/span><\/div>\n
\nLo siguiente fue montar la base, en este paso tuvimos que esperar a que nos llegaran algunos materiales (rodamientos, motores etc), en este paso hicimos lo mismo que el anterior , con la ayuda de la dremel lijamos y taladramos algunos agujeros para que entraran los tornillos, soldamos el potenciometro y por ultimo engrasamos todas las piezas.<\/span><\/div>\n
\n
<\/span><\/div>\n
\n<\/span><\/a><\/div>\n
\n
<\/span><\/div>\n
\nY como ultimo paso ensamblamos los brazos, colocamos los servos ,soldamos los cables de estos para alargarlos,con la dremel ajustamos todo y engrasamos,por ultimo unimos todas las partes.<\/span><\/div>\n
\n
<\/span><\/div>\n
\n<\/span><\/div>\n
\n<\/span><\/a><\/div>\n
\n<\/div>\n
\n<\/div>\n
\n<\/span><\/div>\n<\/h2>\n
\n3.2.1 Software<\/span><\/span><\/div>\n
\n
<\/span><\/div>\n

El c\u00f3digo del brazo consiste en esperar a recibir las instrucciones en un String con un formato especifico, parsear el string, almacenar las instrucciones para ejecutarlas en orden y una vez descompuestas las instruccio<\/span><\/span><\/span>n<\/span>es, estas se ejecutan.<\/span><\/p>\n

La mayor parte del c\u00f3digo son variables de control y algunas de calibrado del brazo, y el almacenamiento de la las instrucciones y su descomposici\u00f3n es din\u00e1mico para aprovechar al m\u00e1ximo la memoria de este.<\/span><\/span><\/span><\/p>\n

\n
<\/span><\/span><\/div>\n
\n
<\/span><\/span><\/div>\n
\n4. Resultados<\/b><\/span>
\n
<\/b><\/span>
\n
<\/b><\/span><\/div>\n
\n<\/div>\n
\n
\n