Póster de la oferta formativa 2020-2021 de #elektronikadonbosco

Póster de la oferta formativa 2020-2021 de #elektronikadonbosco

Electrónica y Telecomunicaciones, los cimientos de una sociedad tecnológica y digitalizada. Presente y futuro. Sin embargo, no son suficientes para garantizar un mundo sostenible, justo, solidario y feliz.

Elektronika eta Telekomunikazioak, mundu teknologiko eta digitalizatu baten oinarriak. Oraina eta etorkizuna. Baina ez dira nahikoak mundu jasangarri, justu, solidario eta zoriontsu bat bermatzeko.

Poster by Olatz Idigoras Lertxundi

 

 

«Lanbide Heziketako ahotsak» bideo-erreportaia

«Lanbide Heziketako ahotsak» bideo-erreportaia

Elektronika eta Telekomunikazioak saileko ikasle ohi, ikasle eta irakasleen bideo-erreportaia. #elektronikadonbosco proiektuko azken urteetako bizipenak, sentipenak eta esperientziak lehenengo pertsonan kontatzen dituen 10 minutuko elkarrizketa multzoa.

Video reportaje de 10 minutos llamado «Lanbide Heziketako ahotsak» (Voces de la FP). Exalumnos, alumnos y profesores del Departamento de Electrónica y telecomunicaciones cuentan sus vivencias, experiencias, recuerdos, sentimientos y opiniones en primera persona.

 

SunnIT (proiektu bukatua)

SunnIT (proiektu bukatua)

Este proyecto nace de la idea de concienciar a la sociedad sobre la importancia de defendernos ante las radiaciones solares, para evitar lesiones dermatológicas así como quemaduras, enrojecimientos, incluso cáncer de piel.

Para ello se ha creado un dispositivo, el cual, mide las radiaciones solares en un punto fijo, como podría ser la playa, evalúa los datos recibidos. Estos datos son escalados y los manda a una página web. Cualquier persona podría registrarse en esta página web y desde ahí ver la cantidad de radiaciones solares que hay en el momento, incluso algún grafico de las radiaciones de últimas horas, días, semanas…

El robot consta de dos partes: por un lado la parte que han realizado nuestros compañeros de Zubiri Manteo, la parte informática. Y por otro lado la parte que hemos realizado los alumnos de Don Bosco, la parte electrónica.

La parte electrónica, consta de un sensor de radiación solar ML8511 el cual va conectado a un chip ATMega328p. Este microcontrolador se comunica con la página web vía Wi-Fi. Para ello, tenemos el modulo Wi-Fi ESP8266, el cual se conectaría a un router. Con la programación realizada en el ATMega238p, el modulo Wi-Fi enviaría los datos a la página web mediante unos comandos AT.

En cuanto a la parte informática está programada para poner en pantalla el dato recibido. Esta página web es pública, cualquiera podría registrarse. Una vez dentro, el usuario contesta a una serie de preguntas para determinar qué tipo de fototipo es el cliente. Hay cuatro tipos de fototipos, que determinan quienes pueden ser más propensos a lesiones dermatológicas. Cuando un usuario introduce email y contraseña para mirar las radiaciones solares del
momento, le saldrá un consejo en cuanto a protección solar e hidratación en base al fototipo del usuario.

De esta manera haríamos llegar a la sociedad un pensamiento más preventivo en cuanto a las radiaciones solares, haciéndoles llegar un mensaje de concienciación con el cáncer de piel con la tecnología avanzada del momento.

________________________________2. PLANIFICACIÓN DEL PROYECTO

El desarrollo del proyecto se ha realizado mediante diferentes fases. Cada una de ellas se ha planificado previamente, dividiéndola en tareas y subtareas. A continuación se expone esquemáticamente cada una de las fases para desarrollarlas posteriormente en el siguiente apartado.
_________________________3. ESTADO DEL ARTE DE LA TECNOLOGÍA

Para la construcción de este prototipo se han estudiado y analizado las siguientes tecnologías:

ATMega328p

Arduino es una plataforma de electrónica abierta para la creación de prototipos basada en software y hardware flexibles y fáciles de usar. Se creó para artistas, diseñadores, aficionados y cualquier interesado en crear entornos y objetivos interactivos.

Arduino puede tomar información del entorno a través de sus pines de entrada de toda una gama de sensores y puede afectar aquello que lo rodea controlando luces, motores y otros actuadores. El microcontrolador en la placa Aduino se programa mediante el lenguaje de programación Arduino y el entorno de desarrollo Arduino.

El ATMega328p AVR 8-bit es un circuito integrado de alto rendimiento que está basado en un microcontrolador RISC. Cuenta con 28 pines. De estos, 14 son digitales (de los cuales 6 pueden ser utilizados como salidas PWM), 6 entradas analógicas, un conector de alimentación, un cristal como oscilador de 16MHz y un botón de reinicio. Contiene todo lo necesario para apoyar el microcontrolador, simplemente conectarlo a un ordenador con un cable USB, o
alimentarla con un adaptador de corriente AC/DC para empezar.

Sensor de radiación solar ML8511

El módulo ML8511 es un sensor de luz ultravioleta (UV), que mide la cantidad de radiaciones solares y entrega una señal analógica que depende de la cantidad de luz UV que detecte en su entorno o alrededor.

Es usado en proyectos de monitoreo de condiciones ambientales como el índice de radiaciones ultravioleta. El sensor ML8511 detecta luz con una longitud de onda entre 280-390nm. Este rango es suficiente para cubrir tanto al espectro Ultravioleta-B (UV-B) como al Ultravioleta-A (UV-A).

La salida analógica está relacionado linealmente con la intensidad UV (mW/cm2 para ser convertido por un ADC y así trabajar con la medición (ver ilustración)




El módulo ESP8266

El módulo ESP8266 nos permite añadir conexión Wifi a nuestro Arduino. Ello nos posibilita el control inalámbrico en un entorno de bastantes metros y sin cables, bien a través de nuestra red local o (si configuramos el Router y tenemos IP fija) vía Internet desde cualquier parte con un ordenador o un móvil.

El módulo mide 1,5×2,5 cm y solo necesita dos hilos para funcionar, ya que se comunica vía serie con el Arduino. No hay una autentica comunicación Wi-Fi, solo es serie, pero es más que suficiente para recibir datos o enviar comandos a cualquiera de los pines del Arduino.

Al contrario que con el módulo HLK-RM04 que dispone de una página Web para configuración, el ESP8266 se configura por medio de comandos AT.

Funciona a 3,3V y a veces consume bastante. Con una fuente de alimentación y limitando la salida a 100mA, no es capaz de arrancar. Aunque después baja el consumo. Los que no tengan fuente con 3,3V, pueden usar las salidas de ese voltaje de una fuente de PC o incluso dos pilas de 1,5V en serie.

Los módulos más recientes, vienen con un firmware habilitado para comunicación a 9600. Tenía también más antiguos con firmware a 115200. Se cambia el firm y listo. Toda esta información y los comandos AT están en http://www.electrodragon.com/w/Wi07c.

Attiny85

El tiiny85 es la plataforma del Arduino llevada a un terreno mucho más pequeño. Este chip posee un tamaño muy reducido, lo que posibilita hacer muchos proyectos que de otra manera serían imposibles. Además, posee la cualidad de no necesitar ningún componente externo para funcionar salvo la fuente de alimentación.

El Attiny posee tres entradas analógicas y dos digitales que hacen un total de 8 patillas, sumando las de alimentación y RESET. Posee un cristal interno que le posibilita tener distintas frecuencias y no depender de uno externo.

Impresora 3D

Una impresora 3D es una máquina capaz de realizar “impresiones” de diseños en 3D, creando piezas o maquetas volumétricas a partir de un diseño hecho por ordenador. Surgen con idea de convertir archivos de 2D en prototipos reales o 3D. Comúnmente se ha utilizado en la prefabricación de piezas o componentes, en sectores como la arquitectura y el diseño industrial. En la actualidad se está extendiendo su uso en la fabricación de prótesis médicas, ya
que la impresión 3D permite adaptar cada pieza fabricada a las características exactas de cada paciente.

ATMega328p

Se ha decidido utilizar la placa Arduino Mega como centralita del proyecto, debido a su coste reducido y a los conocimientos adquiridos durante el curso para programar este tipo de dispositivos basados en el lenguaje de programación de alto nivel Processing. Abarca varios lenguajes diferentes de programación, entre ellos C++. Arduino es un hardware de software libre, lo que implica tener una comunidad detrás, la cual permite un aprendizaje autodidacta ante cualquier tipo de obstáculo o contra que se pueda encontrar.

Sensor de radiación solar ML8511

En este proyecto se ha utilizado el medidor de radiación solar ML8511.Se ha decidido utilizar este sensor debido a su coste, a su reducido tamaño, lo que nos permite realizar el Wareable, y las conexiones simples que tiene.

Modulo Wi-Fi ESP8266

Para realizar la comunicación del Arduino con la pagina web, se ha utilizado el modulo Wi-Fi ESP8266, ya que hoy en día la gran mayoría de la sociedad tiene un móvil con datos de navegación para introducirse en la página web.

Attiny85

En este proyecto hemos realizado un apartado privado, más preciso. Por eso mismo, hemos utilizado el Attiny85, que hace la misma función que ATMega328, con la única diferencia que el Attiny85 consta de un tamaño más reducido, y permite tener ropa sensorizada.


Impresoras 3D

La estructura de este proyecto se ha realizado con piezas imprimidas en 3D, ya que de este modo, conseguimos abaratar el precio considerablemente. Por otra parte, las piezas necesarias para complementar el dispositivo, han sido diseñadas en FreeCad.

__________________________4. DESCRIPCIÓN TÉCNICA DEL PROYECTO

La idea de este proyecto es dividirla en dos partes: la parte informática y la
electrónica. Pero dentro de nuestra parte electrónica, hemos decido dividirla en dos partes: (ver ilustración 2)







1- La primera parte consta del sensor de radiación solar. Este sensor hay que

2- La segunda parte del microcontrolador ATMega328p, que se encarga de

________________________________________________5. PRESUPUESTO

En la tabla que verán a continuación, tenemos inscritos los precios de todos los componentes que completan el dispositivo, para poder hacernos una idea del precio de SunIT antes de introducirlo en el mercado.

ATMega328p 3,62€

Sensor ML8511 12,95€

Componentes fuente de alimentación

Modulo Wi-Fi  4€

Cristal 16 MHz (+ 2 condensadores 22pF)

PRECIO PRODUCTOS 26,52€

Mano de obra 13,48€

TOTAL: 40€

La pulsera o la gorra seguiría lo siguiente:

Attiny85  1,95€

Sensor ML8511 12,95€

Módulo bluetooth  5,87€

PRECIO PRODUCTOS:  20,77€

Mano de obra: 40€

_________________________________6. DESARROLLO DEL PROTOTIPO

En esta fase se carga el programa anteriormente explicado en el Arduino virtual que nos ofrece el software de Proteus llamado ISIS y asi se ha podido comprobar el correcto funcionamiento del circuito.

Este software es de gran utilidad para la realización de este proyecto, ya que haciendo la simulación se da un gran paso ante la fabricación posterior, depurando los posibles fallos que puedan surgir.

La visualización se hace de forma automática, sin la necesidad de pulsar ningún botón o interruptor. En la simulación se puede apreciar como nuestra fuente de alimentación transmite la tensión necesaria y el correcto cableado para un buen funcionamiento del dispositivo.

Cablear y probar el circuito

En esta fase se ha de probar uno por uno todos los elementos del circuito físicamente. De este modo se puede saber si los componentes que se van a montar funcionan correctamente y si el diseño realizado en la fase anterior es correcto.

Acopio de material

Una vez hecha la simulación y comprobar su buen funcionamiento, se tiene que hacer la recopilación de componentes a utilizar.
Para este proyecto se han recopilado los siguientes materiales:

Prueba en protoboard

Aunque en la simulación en ISIS no haya salido como nosotros esperábamos, no debemos fiarnos y debemos comprobarlo en una protoboard antes de crear la placa.

Este punto es de una gran importancia ya que se dan un par de puntos muy importantes para el proyecto:

Diseño y fabricación de la PCB

En esta fase se hade diseñar y fabricar la placa siguiendo los puntos explicados a continuación:
Por desgracia, por normal general, el diseño realizado anteriormente en ISIS de la simulación del proyecto no suele ser valido a la hora de diseñar el circuito en Ares, por lo que se ha de modificar dicho diseño añadiendo las huellas y componentes que no estén disponibles en el diseño inicial.

Al utilizar el sensor de radiación ML8511 o el modulo Wi-Fi ESP8266, componentes los cuales no están en el repertorio de ISIS, hemos utilizado conectores (uno de 8 para ESP8266 y de 4 para ML8511).

Este es otro paso clave para la fabricación del proyecto, ya que hay varios factores a tener en cuenta, como el ancho de pistas, colocación de los componentes, anchura de vías…

Se ha diseñado una sola placa. Se ha decidido realizar un diseño parejo al del ISIS en cuanto a colocación de componentes, para que en caso de error, se nos agilice el proceso de arreglo.

Por suerte, Don Bosco dispone de una máquina capaz de crear circuitos impresos mediante fresado en muy poco tiempo. La maquina en cuestión es una Board-Master LPKF PromatS62.

Antes de comenzar la fabricación de nuestra PCB, tenemos que crear el archivo adecuado para que la maquina sea capaz de identificarlo. Para ello hemos utilizado el programa CircuitCAM, en el que se realizan los últimos retoques como el vaciado de los componentes para facilitar el soldeo (ver ilustración 3).



Una vez hemos creado el archivo, conectamos el ordenador con los esquemas a la LPKF. Una vez cargados estos archivos se le tiene que ordenar a lamaquina que comience a hacer los agujeros de los componentes en la placa, para a continuación, comenzar el proceso de metalización.

Construcción del prototipo

Para una mejor estética del proyecto hemos decidido realizar una carcasa, para el wareable (ver ilustración 4). Esta pieza ha sido diseñada en FreeCad, teniendo en cuenta las medidas que nos había salido la placa, lo que nos ocupa el LED en vertical, y una pequeña salida para sacar el sensor y poder colocarlo a gusto del cliente.

Soldadura de componentes en PCB

En esta fase, se ha soldado a nuestra pcb los conectores necesarios para poder conectar y desconectar el sensor y el microcontrolador con total comodidad. Por otro lado, el conector de alimentación, sus reguladores para adaptar la tensión a los componentes utilizados, y el modulo Wi-Fi (ver ilustración 5).

Al posicionar los componentes, se debe empezar colocando los más bajos primer, y a continuación ir poniéndolos conjuntamente con otros de un tamaño igual o similar. Esto se hace para que al apoyar la placa y comenzar a soldar, los componentes queden apoyados en la superficie y no caigan por su propio peso.

Para realizar las soldaduras, se ha utilizado una estación de soldadura, la cual dispone de estañadores de punta fina para poder realizar un trabajo más detallado y preciso.

Puesta en marcha

Una vez realizadas las soldaduras, el siguiente paso ha sido comprobar si nuestra PCB cumplía perfectamente su función.
Se ha comprobado que la señal llega a la página web, dado que constantemente estaba cambiando el dato recibido por el sensor que estaba en pantalla.

Construcción del prototipo

Para la construcción de este proyecto se han reunido las placas y las carcasas impresas en 3D. Simplemente se han insertado las placas en sus correspondientes carcasas para una mejor imagen de cara al público.

_____________________________7. CONCLUSIONES Y LÍNEAS FUTURAS

Conclusiones

Al terminar el prototipo se ha pensado una serie de mejoras tales como: Al mismo proyecto se le pueden añadir diferentes elementos de diseño y varias aplicaciones, ajustándose estas a las necesidades del cliente.

El objetivo principal de este proyecto ha sido fomentar la prevención de radiaciones solares, para disminuir el impacto del cáncer de piel en la sociedad.

En el mercado, vemos a SunIT en diferentes lugares:
_____________________8. FUENTES DE INFORMACIÓN Y BIBLIOGRAFÍA

Este ha sido un proyecto compuesto de unas tecnologías nuevas e innovadoras, por lo tanto, se ha tenido que recurrir a los siguientes enlaces para obtener algunos ejemplos e información para su correcto desarrollo:

Sensor de radiación solar ML8511:

http://media.digikey.com/pdf/Data%20Sheets/Rohm%20PDFs/ML8511-00FC_RefBrd_Manual-01.pdf

https://cdn.sparkfun.com/datasheets/Sensors/LightImaging/ML8511_3-8-13.pdf

Modulo Wi-Fi ESP8266:

Servidor Web con WIFI ESP8266

Usando el módulo WIFI ESP8266

Arduino y WIFI ESP8266

http://www.prometec.net/comunicaciones/Attiny85

http://www.rinconingenieril.es/ingenieros/attiny85-hola-mundo/?post=true

______________________________________________________9. ANEXOS

Dado que los anexos de nuestros componentes son bastante extensos, os dejamos aquí los links, por si necesitáis usar algún componente de estos, para que tengáis una referencia inicial.

http://www.atmel.com/images/atmel-8271-8-bit-avr-microcontroller-atmega48a-48pa-88a-88pa-168a-168pa-328-328p_datasheet_complete.pdf

https://cdn.sparkfun.com/datasheets/Sensors/LightImaging/ML8511_3-8-13.pdf

https://www.adafruit.com/images/product-files/2471/0A-ESP8266__Datasheet__EN_v4.3.pdf

http://www.atmel.com/images/atmel-2586-avr-8-bit-microcontroller-attiny25-attiny45-attiny85_datasheet.pdf

 

ITSASPEKOA

ITSASPEKOA

Don Boscon, departamentu bat baino gehiagoren artean eginiko proiektu bat da oraingoan azalduko duguna.

Mekatronika, Eraikuntza metalikoak eta elektronikako departamentuak parte hartu dute bertan, momentu oro hiru departamentuen arteko komunikazioa beharrezkoa izanda.

Itsaspeko bat eraikitzea izan da proiektu honen helburua, departamentu bakoitzari bere lana emanaz.

Post honetan, eraikuntza metaliko eta mekatronikako lanari buruz gainetik hitz egingo da, elektronikan zentratuz.

Eraikuntza fisikoari buruz, hona hemen argazki bat, hasiberria zenekoa:

Ikusi daiteken bezala, erdialdea bi zatitan bananduta dago: Goiko zatian bateriak, elektronika, bonbak, elektrobalbulak etab. joango dira, eta beheko aldea beste bi zatitan bananduta dago, urez beteko diren bi kamerakin.

Gure helburua, itsaspekoa WIFI bitartez kontrolatu ahal izatea izan da. WiFi bitartez tablet batetik antena batera egingo da komunikazioa. Antena hori, momentuz, buia batean egongo da eta bertatik RaspberryPi batera joango da seinalea. RaspberryPi-a, serie bitartez, Arduino batekin komunikatuko da, mikrokontroladoreak itsaspekoa kontrolatu dezan.

Orain arte funtzio desberdinak jarri zaizkio itsaspekoari:

  • Aurrerako martxa (propultsio motorea alde batera biratuz)
  • Atzerako martxa  (propultsioa beste aldera mugituz)
  • Ezker / Eskubi bira (servoa biratuz)
  • Servomotorea zentratu (servoa dagoen lekuan dagoela, erdira eramateko)
  • Eskuz kamerak bete ala hustu (bi kamerak banaka bete ala hustutzeko)
  • Automatikoki urperatu ala azaleratu  (bi kamerak batera bete ala hustutzeko)
  • Estabilizatu (ezarritako inklinazio gradu batetik pasatzean, automatikoki estabilizatzeko)
  • Flotabilidade neutroko puntua gogoratu eta bertara joan.

Proiektu irekia da, hurrengo urteetan hobetu ahal izateko. Adibidez, RaspberryPi-a kamera bat jarri ahal izateko prest dago. Ez dugu kamera hori estankoa uztea lortu (ura sartu ez dadin), baina egin ezkero, kamera jarri ahal zaio. Aurrerago aztertuko ditugu proiektuak izan ditzazken hobekuntza eta berritasunak.

Erabilitako konponenteak (click bakoitzaren gainean datasheet edo webgunera sartzeko)

1x ARDUINO UNO
1x RASPBERRYPI
2x L293D QUADRUPLE HALF-H DRIVERS
1x ULN2003A DARLINTONG TRANSISTOR ARRAY
1x MX2125 2-AXIS ACCELEROMETER MODULE
1x SERVO BMS-630MG
2x RELAY FINDER 40.31

Eskema

Eskeman ikusi dezakegunez 4 zati garrantzitsu dauzkagu:

1 – Azelerometroa: Azelerometro hau (MX2125), 2 ardatzeko azelerometro bat da, hau da, X eta Y ardatzak kontrolatzen ditu. Hala ere, proiektu honetarako X ardatza da kontrolatu behar izan dugun bakarra. Funtzionamendu teknikoa oso logikoa da: erdian gas bola bero bat dauka eta lau «termometro» eskin bakoitzean, beraz, azelerometroa biratzean, eta beroa goruntza joatean, termometro hoietako bat, bestea baino beroago egongo da. Pultsoaren luzeera jasoko dugu bueltan, hori jakinda, eta ariketa aritmetiko batzu egin ondoren, zenbat graduko inklinazioa daukagun azelerometroan, beraz, itsaspekoan ere, asmatu dezakegu.

2 – Bonbak + Elektrobalbulak: Mekatronika/konstrukzio metalikoen ikasleak aukeratu dituzte erabiliko diren motoreak, bonbak etab.. Pausu hau gure kasuan pixkat astuna izan da, azkeneko momentuko aldaketak egon zirelako, eskema eta plaka aldaraztera behartuz. Hasieran bonbak besterik eziran jarri behar, horretarako L293D driver bat erabiliko genuke hauek kontrolatzeko. 12V-koak direnez, 8. pinetik 12V sartuko ditugu, 5V 16. pinetik eta bi «Enable» pinetatik, 10KΩ-ko erresistentzi batetik pasata 5V. Enableak konektatuak egonda, 5Vkin sarrerak aktibatzean, irteerak aktibatuko dira 12V emanda. Bideo honetan L293D chip-aren funtzionamendua ikusi daiteke: hemen.

Proiektua aurrera zihoan einean bonbei, elektrobalbula batzu jarri behar genizkiela konturatu ginen, anti-retorno bezala, ura sartzen zen zulotik berriz ere ez ateratzeko. Hauek kontrolatzeko ULN2003A chip-a erabili dugu, pin komunetik (COM) 12V pasarazten ditugu, elektrobalbulara ere konektatuz, sarreran aktibatzen duguna, irteeran ikusten dugu. Pista berdina erabiltzen dugu bonbak eta elektrobalbulentzat, batera aktibatu eta desaktibatu nahi ditugu eta.
 

3 – Propultsio motorea: Gure kasuan hemen izan ditugu aldaketa gehienak, hasieran 12Vkoa zen, 5206 driver-a erabili behar genuen hasiera batean, baina gero aldaketak egon ziren eta 24Vko DC motore bat jartzea proposatu zen.

Azkenean, eta beste saiakera batzu eta gero, L293D batekin 5Vko Relay batzu aktibatzea aukeratu genuen. Relay-ak bi zati ditu, aktibatzekoa (alde batetik 5V eta bestetik 0V sartuz) eta aktuatzekoa (interruptore baten antzeko funtzionamendua du, alde bat 24Vra konektatzen dugu eta bestea motorearen alde batera). Motorea, alde batetik 24V baldin baditu eta bestetik 0V, martxan jarriko da.
4 – Nibel sentsoreak: Bi kameretan zenbateko ur nibela daukagun jakitea garrantzitsua da, batez ere «flotabilidade neutro» puntu hori lortzeko orduan. Esan beharra dago asko kostatu zitzaigula nahi edo behar genituen sentsore batzuk aurkitzea. Azkenean hauek aurkitu genituen.

Potentziometro baten funtzionamendua dauka. Erdian ikusten den flotadore hori gora ta behera mugitzen da, ur nibela non dagoen arabera. 10 eta 180Ω bitarteko erresistentzi baten konportamendua du, gero eta gorago, geroz eta erresistentzi txikiagoa dauka. Praktikoki, beste 180Ωko erresistentzi bat seriean jarrita, hauek bien tartetik, zatitzaile erresistibo baten moduan funtzionaraziz, nibela (flotadorea) zein puntutan dagoen kokatuta jakingo dugu.

Beranduago konturatu ginen ez ditula balore guztiak ematen, diskretoa dela eta 10 balore desberdin ematen ditula, horregatik Arduinon jarri ditugun 10 posizioak. Esan beharra dago, sentsore honek balore guztiak eman beharko zituela askoz erosoago eta hobeto egiteko flotabilidade neutroaren kalkulua.

Lau puntu hauetaz gain, servoa ikusi daiteke eskeman, baina honek ez dauka misterio haundirik konektatzeko orduan. Hanka bat 5Vra doa, bestea GNDra eta bestea, seinalea, Arduinoko PWM pin batera.

PROGRAMAZIOA:

    1. Programazioan 3 puntu desberdin daude:
  1. Android: Tablet baterako aplikazio bat egingo da Eclipse programa erabiliz. Programa honekin bisualizatu ahal izango dugu RaspberryPi-ra bidaltzen dugun komandoa.
  2. RaspberryPi: Access point bezala konfiguratuko dugu WIFI puntu bat sortuz, tabletetik konektatu ahal izateko, Arduinora komandoak bidaliz TX pinetik.
  3. Arduino(Eclipse): RaspberryPi-tik komandoak jasoko ditu RX pinetik, beste pinetatik aktuadoreak aktibatuz

Arduino

Arduino, erraz erabili daitezken Software eta Hardware malgutan oinarrituta, prototipoak sortzeko plataforma elektroniko irekia da. Lenguaia propio bat erabilita programatzen da. Hala ere, beste programazio lenguaiak erabili daitezke. Informazio gehiago, beraien web orrian, eta hemen deskargak.

Programa osoa hemen behean ikusi daiteke komentatua. Hasteko, esan beharra dago, programa gaur egiten hasiko bagina, agian beste modu batean planteatuko genukela, asko optimizatu daitekelako.

RaspberryPi

RaspberryPi, plaka bakarreko kostu txikiko ordenagailu bat da (SBC), eskoletan, konputazio zientzien irakaskuntzak suspertzeko, Erresuma Batuan RaspberryPi Fundazioak sortua.

Diseinuak System-on-a-chip Broadcom bat darama, ARM1176JZF-S 700MHzko prozesadore zentral bat daukana, VideoCore IV prozesadore grafiko bat eta 512MiB-eko memoria RAM bat.

Diseinuak ez du diska gogorrik, SD txartel bat erabiltzen bait da beharrezko datuak biltegiratzeko.

RaspberryPi-a, access point bezala funtzionarazten dugu, WIFI portu bat sortzeko eta gure tabletetik, inalanbrikoki komunikatu ahal izateko. Django zerbitzari bat instalatu da API-REST bat sortzeko. API-REST-a http bidezko petizioak filtratzen dituen funtzio-URL-en multzoa da.

Google Drive-n uzten ditugu jarraitu beharrezko pausuak Access Point-a lortzeko: hemen.

Android (Eclipse)

Eclipse software librearekin, javarekin programatzen, itsaspekoaren kontrolaren interfaz-a sortu dugu. Hauetako botoi bat pultsatuz, komando bat bidaltzen diogu RaspberryPi-ari, honek exekutatu dezan.Programa deskargatzeko linka hemen.

PROIEKTUAREN ETORKIZUNA:

Proiektuaren lehenengo urtea izan da, baina horrek ez du esan nahi dena hemen bukatzen denik.

Hasieran esan bezala, funtzio gehiago ipini ahal zaizkio itsaspekoari, adibidez, kamera bat. Horretarako prest daukagu RaspberryPi-a. Hemen enlazea. Honen arazoa, kamera guztiz estankoa (urik ez sartzea) izatea beharrezkoa dela, eta izan dugun denborarekin ezinezkoa izan dela hau lortzea. Beste aukera bat, goPro kamera bat jartzea izan liteke… baina aurrekontua asko igotzen zitzaigun. Halere, hona hemen tutorial bat goProa eta raspberryPi-a batera konektatzeko. Kamerarekin batera, argi bat jartzea interesgarria izango zen, itsas hondoan argi gutxi dagoenez, zaila izango zelako irudi onak ateratzea.

Beste gehigarri bat, ultrasoinuko sentsoreak ipintzea izango litzateke, bai azpikaldean, itsas hondora zenbat distantzia dagoen jakiteko, edota aurrean, atzean eta aldetan, oztopo batekin aurkitzen bada, talka egin aurretik, itsaspekoa geldiarazteko adibidez.

Buia nola kendu eta itsaspekoa libre uretan ibiltzea interesgarria izango zen, ultrasoinuen bidez urazpitik kontrolatruz edota beste modu batez.

Bestelako ideiak badaude, adibidez RFID irakurgailu batekin, objektuak edota pertsonak bilatzeko balioko zuen, elurretan bezala, itsasoan dabilen jendea (arrantzaleak, urpekariak, etab.), RFID TAG bat izango bazuten errazagoa izango zen horrelako herraminta batekin jendea itsaso azpian aurkitzea, urpekari bat uretara sartzea arriskutsua izan daiteken kasuetan (adibidez, 2014ko martxoan desagertutako Maylasia Airlineseko hegazkina galdu zenean, Bluefin-21 itsaspekoa hondoratu zuten, hegazkina eta jendearen gorpuak aurkitzeko).

Irudimena erabilita, hobekuntzak (bai programan, baita hardwarean ere) eta gehigarriak ipiniz, beste nibel sentsore batzuk bezala (zuzenak, diskretoen ordez, adibidez), proiektu ikaragarri batean bilakatu daiteke Itsaspekoa.

Mikel Tife (2ME3M) / IEFPS Don Bosco GLHBI

Robot «Cuadrúpedo AI» controlado por Android

Robot «Cuadrúpedo AI» controlado por Android

¿Que es un robot?

Un robot es un dispositivo electrónico y generalmente mecánico capaz de desempeñar tareas automáticamente, ya sea por medio de supervisión humana directa, a través de un programa predefinido o siguiendo un conjunto de reglas generales establecidas. Existen multitud de robots diseñados para cumplir diferentes objetivos: como brazos robóticos para el montaje de piezas en una fábrica, vehículos aéreos no tripulados o los robots móviles terrestres.

El “cuadrúpedo AI” nace de la idea de dos alumnos con ganas de hacer un proyecto visual, no nos valía un proyecto estanco, que no se moviese, que no llamase la atención, y ahí, aparece el Cuadrúpedo.

El robot esta construido con piezas de plástico, ABS o PLA. Nos decantamos por las piezas de plástico por la sencillez que nos ofrecían las impresoras 3D para crear piezas. Aparte las piezas de plástico son de gran ligereza y lo suficientemente robustas para la estructura del cuadrúpedo. Las piezas de plástico están impresas en las impresoras 3D del ikaslab, gracias a Tumaker.

Las uniones son los servos FUTABA S3003. Estos servos únicamente tienen tres conexiones, alimentación (5v) , masa y control Estos van unidos a las piezas de plástico con tornillos como se puede ver en la siguiente imagen:

Para las patas se corto goma con intención de que no se resbalase por el pavimento, sin esa goma el movimiento del cuadrúpedo habría quedado mermado en exceso. Al principio tuvimos problemas con esto, pensamos que sin goma los movimientos serian naturales y andaría normal, pero resulto que no, se resbalaba y se quedaba en el sitio sin avanzar. Para ello cortamos un trozo de goma y lo pegamos con loctite al ABS de la pata.

Una vez recopiladas todas las piezas el robot queda montado tal que así, únicamente el chasis sin nada de electrónica.

Mientras uno de los componentes del equipo iba montando el esqueleto del robot, el otro iba haciendo los esquemas en Isis y viendo el funcionamiento de este. Para el esquema se utilizo el Arduino Uno puesto que no encontramos la opción de sacar el Mega. El Isis nos proporciono una idea general de como iba a ser el proyecto pero muy virtual y de forma visual.

Para el proyecto se ha utilizado el Arduino mega 2560, principalmente por las salidas PWM de las cuales dispone. El cuadrúpedo esta formado por 9 motores,y esta placa nos los admitía. Ya que con el arduino UNO que habíamos pensado en un principio no tenia tantas salidas PWM para todos los motores.

Una vez teniamos la placa decidimos crear un escudo «shield» para el Mega, para tratar de manipular menos posible la placa de aprendizaje. Intentamos buscar esa Shield por internet pero no dimos con ella, por lo que en Ares nos dispusimos a diseñarla.
Como se ve en la siguiente imagen esta el archivo del diseño en Ares:

Una vez montada la electronica y formado el cuadrupedo nos dispusimos a hacer la parte logica del proyecto, La aplicacion que la controlaria y el codigo para los motores y el ultrasonico.

La tecnología principal de este proyecto es el Bluetooth. Nos decantamos por el bluetooth puesto que necesitábamos algo que no llevase cables y fuese inalámbrico, otro de los factores claves del bluetooth es su simplicidad y la facilidad que Internet ofrece a esta tecnología.

El cuadrúpedo se controla con el móvil mediante un modulo Bluetooth y con un programa creado y diseñado con la aplicación App inventor. El App inventor es una plataforma online para preparar programas, se programa mediante una forma visual y no en código.

Una vez creado el programa App inventor se procederá a su descarga, se nos bajara un archivo .apk  y lo pasaremos al dispositivo Android, únicamente solo con que ejecutemos ese apk se nos instala Nos aparecerá así en nuestro móvil:

La interfaz creada sera tal que asi y se vera de esta forma sencilla:

En el vídeo se observa el programa, y dependiendo los botones que se pulsen el  cuadrúpedo reaccionará de una manera u otra. El programa de Android esta formado por diferentes botones que se explican en el video, excepto dos botones, reset y stop. La primera función es que se quede en el suelo con las piernas abiertas, y stop, es un modo en el que el cuadrúpedo queda apoyado con las cuatro patas pero de forma relajada.

Dispone de un modulo ultrasónico HC-SR04 que permite al cuadrúpedo andar de forma libre, en modo solitario, pero cuando se encuentra con un objeto delante de el, esquivarlo de manera natural para poder seguir andando y moviéndose por el entorno que le rodea.

Según el programa cuando el ultrasónico detecta algún obstáculo a menos de 30cm el cuadrúpedo se dirige hacia atrás.

En el vídeo anterior se observa el programa Android, explicando brevemente lo que ocurre al pulsar los diferentes botones que forman el programa, con su correspondiente reacción del cuadrúpedo.

Como anexo os adjuntamos el programa que hemos utilizado:

#include <Servo.h>
Servo myservoA;  // create servo object to control a servo
Servo myservoB;
Servo myservoC;
Servo myservoD;
Servo myservoE;
Servo myservoF;
Servo myservoG;
Servo myservoH;
Servo myservoQ;
long medir1;
long medir2;
long medir3;
int TrigPin = 12;
int EchoPin = 13;
int A = 90;  //A – Cadera 1
int B = 90;  //B – Cadera 3
int C = 90;  //C – Cadera 5
int D = 90;  //D – Cadera 7
int E = 90;  //E – Pie 2
int F = 90;  //F – Pie 4
int G = 90;  //G – Pie 6
int H = 90;  //H – Pie 8
int Q = 90;
int incomingByte = 0;
#include <SoftwareSerial.h>
SoftwareSerial mySerial(19, 18); // RX, TX
void setup()
{
   // Open serial communications and wait for port to open:
  Serial.begin(9600);
  pinMode(TrigPin,OUTPUT);
  pinMode(EchoPin,INPUT);
  Serial.println(«Hello «);
  Serial.println(«attaching to port_b»);
  myservoA.attach(9);  // attaches the servo on pin 9 to the servo object
  myservoB.attach(8);  // attaches the servo on pin 9 to the servo object
  myservoC.attach(6);  // attaches the servo on pin 9 to the servo object
  myservoD.attach(7);  // attaches the servo on pin 9 to the servo object
  myservoE.attach(2);  // attaches the servo on pin 9 to the servo object
  myservoF.attach(3);  // attaches the servo on pin 9 to the servo object
  myservoG.attach(4);  // attaches the servo on pin 9 to the servo object
  myservoH.attach(5);  // attaches the servo on pin 9 to the servo object
  myservoQ.attach(11);
}
void loop()
{
  long distance;
  distance=medir();
  Serial.print(  medir() );//Serial display distance
  //Serial.print(«cm»);
  Serial.println();
  //delay(1000);
  if (Serial.available() > 0)
  {
    incomingByte = Serial.read();
    Serial.print(«He recibido:»);
    Serial.println(incomingByte,DEC);
  }
 if (incomingByte==0)
  {
    Serial.print(medir());//Serial display distance
    Serial.print(«dm»);
    Serial.println();
  // delay(500);
  }
  if(medir() ==0)
  {
    if (Serial.available() > 0) {
    incomingByte = Serial.read();
    Serial.print(«He recibido:»);
    Serial.println(incomingByte,DEC);
    // delay(500);
    }
  }
if((medir()<80) &( medir()>=30))
{
   cycle_Stop();
   Serial.println();
   cycle_girar();
   Serial.println();
   Serial.print(  medir2);
   Serial.print(«d2mD»);
   Serial.println();
   Serial.print(  medir3);
   Serial.print(«d3mD»);
   Serial.println();
   //delay(1000);
}
   while((medir2>=medir3)&(medir()<80) &( medir()>=30)&(incomingByte==55))
  {
    cycle_Derecha();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print(  medir());//Serial display distance
    Serial.print(«d1mD»);
    Serial.println();
    Serial.print(  medir2);
    Serial.print(«d2mD»);
    Serial.println();
    Serial.print(  medir3);
    Serial.print(«d3mD»);
    Serial.println();
   // delay(2000);
  }
   while((medir2<medir3)&(medir()<80) &( medir()>=30)&(incomingByte==55))
  {
    cycle_Izquierda();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print(  medir());//Serial display distance
    Serial.print(«d1mZ»);
    Serial.println();
    Serial.print(  medir2);
    Serial.print(«d1mZ»);
    Serial.println();
    Serial.print(  medir3);
    Serial.print(«d1mZ»);
    Serial.println();
    //delay(2000);
  }
 if (( medir()<30 )&(incomingByte==55))
  {
    while (( medir()<60 )&(incomingByte==55))
    {
    cycle_Atras();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print( medir() );//Serial display distance
    Serial.print(«d0m»);
    Serial.println();
   // delay(1000);
    }
  }
    while((medir() >=80)&(incomingByte==55))
  {
    cycle_Avance();
    distance=medir();
    Serial.print(medir());//Serial display distance
    Serial.print(«d2m»);
    Serial.println();
    //delay(3000);
    if (Serial.available() > 0 )
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
                       
    }                   
   }
  
   while (incomingByte==50)
   {
     cycle_Avance();
       if (Serial.available() > 0) {
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
       }
     
   }
  
 
     while (incomingByte==53){
      cycle_Stop();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
     
    }
  while (incomingByte==49){
      cycle_Atras();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
     
    }
   
     while (incomingByte==56){
      cycle_Derecha();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
       
    }
   while (incomingByte==52){
      cycle_Izquierda();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
   while (incomingByte==48){
      cycle_Reset();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
     while (incomingByte==54){
      cycle_Avance2();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
}
void   cycle_Avance(){
   for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(200);     // in steps of 10 degree
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(150);
    myservoC.write(90);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                                
    
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(200);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(30);
    myservoB.write(90);
    myservoC.write(150);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Avance»);
  }
void cycle_Stop(){
   myservoE.write( 0);
    myservoH.write(180);
    myservoF.write(0);
    myservoG.write(0);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
    //delay(1000);
    Serial.print(«Stop»);
  }
void cycle_Reset(){
    for(A = 90; A < 150; A += 1)  // goes from 30 degrees to 150 degrees
  {                           // in steps of 10 degree
  
    myservoE.write( 90);
    myservoH.write(90);
    myservoF.write(90);
    myservoG.write(90);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
   
    delay(20);    
                      // waits 15ms for the servo to reach the position
  }
 for(A = 150; A>=91; A-=1)     // goes from 150 degrees to 30 degrees
  {                              
    myservoF.write(90);
    myservoG.write(90);
    myservoE.write(90);
    myservoH.write(90);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
   
    delay(20);   
                      // waits 15ms for the servo to reach the position
  }
}
void   cycle_Atras(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(0);
    myservoH.write( 180);
    myservoF.write(40);
    myservoG.write(40);
    delay(200);     // in steps of 10 degree
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(150);
    myservoC.write(90);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                                
    
    myservoF.write(0);
    myservoG.write(0);
    myservoE.write(40);
    myservoH.write(140);
      delay(200);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(30);
    myservoB.write(90);
    myservoC.write(150);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Atras»);
}
void   cycle_Avance2(){
   for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(150);     // in steps of 10 degree
    myservoA.write(60);              // tell servo to go to position in variable ‘A’
    myservoD.write(120);
    myservoB.write(120);
    myservoC.write(60);
    delay(150);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(180);
    myservoA.write(120);              // tell servo to go to position in variable ‘A’
    myservoD.write(60);
    myservoB.write(60);
    myservoC.write(120);   
    delay(180);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Avance»);
  }
void   cycle_Izquierda(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  {
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(180);     // in steps of 10 degree
    myservoA.write(60);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
    delay(180);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(150);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(60);
    myservoB.write(90);
    myservoC.write(150);   
    delay(150);             // waits 15ms for the servo to reach the position
  }
    Serial.print(«Izquierda»);
}
void  cycle_Derecha(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  {
    myservoE.write(0);
    myservoH.write( 180);
    myservoF.write(40);
    myservoG.write(40);
    delay(200);     // in steps of 10 degree
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(120);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                               
    
    myservoF.write(0);
    myservoG.write(0);
    myservoE.write(40);
    myservoH.write(140);
      delay(200);
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(120);
    myservoC.write(90);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«derecha»);
}
long medir(void)
{
  
  long dist,duration;
  digitalWrite(TrigPin,HIGH);//TrigPin prepare high of more than 10us
  delayMicroseconds(11);
  digitalWrite(TrigPin,LOW);
  duration = pulseIn(EchoPin, HIGH);//EchoPin received high start counting until the receiver to the low,return to the count valu
  dist = duration/29/2;//Calculating the distance  cm
                           // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  return dist;
}
void cycle_girar(){
  
  myservoQ.write(0);   //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir2=medir();
  delay(200);        //Retardo entre coordenadas
  myservoQ.write(90);  //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir1=medir();
  delay(200);  //Retardo entre coordenadas
  myservoQ.write(179); //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir3=medir();
  delay(200);        //Retardo entre coordenadas
  myservoQ.write(90);  //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
   Serial.print(«girar»);

 

  }