Rover Marciano Alphabot Rasbperry Y Python

Introducción

Los Rovers son un buen elemento STEAM para poder usar en el aula ver propuestas didácticas de la NASA 🚀. Nuestra propuesta se enmarca dentro de nuestra hoja de ruta del pensamiento computacional 🤖.

Fotomontaje del paisaje de Marte tomado por el Curiosity © NASA

Objetivos

Para ello utilizaremos este robot que dota a la Raspberry de chasis, motor y sensores que dan autonomía de movimientos y posibilidad de control remoto ¡Hasta una cámara web con brazo robótico!! 😋

Requisitos de conocimientos

Requisitos materiales

Historia de los rovers

Rover es un vehículo para diseñado para moverse por un planeta o objeto astronómico Wikipedia

OBJETIVO LUNA

Los primeros rovers: Los Lunojods

Lunojod1, Rusia lo lanzó en noviembre 1970 y recorrió más de 10km por la luna, con 4 cámaras de TV, telescopio RX, espectómetro... la tapa se abría de día para recargar las batería y por la noche se cerraba para mantener los circuitos calientes con el refuerzo de una pila atómica. A pesar de que se perdió su rastro después de 11 días lunares (11 meses terrestres, a pesar de que se diseñó sólo para 3), en 2010 se volvío a localizar y aún se utiliza su reflector.

image-1647864613608.jpg

De Petar Milošević - Trabajo propio, CC BY-SA 3.0

En 1973 Rusia lanzó el Lunjod2, sólo duró 5 meses terrestres, debido a que en su aterrizaje rozó la pared de un crater lunar, lo que provocó que cayera polvo en sus radiadores provocando sobrecalentamientos, pero aún así recorrió 37 km, sólo superado por en el 2018 por la Oportunity.

De NASA/JPL-Caltech, Dominio público

Rusia sigue apostando por los rovers Lunares en vez de enviar humanos, (a lo mejor son más listos, ver Mi Opinión más abajo) actualmente tienen previsto enviar Luna-25.

Vehículos lunares

Para las misiones Apolo 15, 16 y 17 los astronautas usaron tres LRVs Lunar Roving Vehicle pesaban casi media tonelada y podían llevar otra media incluyendo dos astronautas a 13 km/h

Yutu

China envía dos rovers, el primero en el 2013 duró 31 meses y (diseñado para 3) y el segundo Yutu en el 2018, el único en la cara oculta de la luna, sigue en la actualidad funcionando.

OBJETIVO MARTE:

Primer éxito parcial Mars 3 y su rover PrOP-M

Rusia lanza los Mars, el primero se estampa en la superficie, pero el segundo Mars -3 aterriza el 2 de diciembre 1971, pero sólo transmitió 20 segundos, llevaban un rover, los PrOP-M y no sabemos si llegó a ser desplegado o no.

Su diseño era muy ingenioso:

PrOP-M_moving_on_skis.gif

By Soviet Space Program / VNIITransmash - https://www.planetary.org/space-images/Mars3_RoverAnim, Fair use, https://en.wikipedia.org/w/index.php?curid=69146870

¿Tan difícil es aterrizar en marte?

Para la tecnología de la época y lo difícil que es aterrizar en Marte fue para quitarse el sombrero, ten en cuenta que de casi 50 intentos de llegar a Marte, la mitad han fracasado y sólo 5 han llegado a poner un Rover.

Primer éxito confirmado: Mars Pathfinder y su Rover Sojourner

En 1996 la NASA lanza la Pathfinder con la técnica de frenar el aterrizaje con airbag, al desplegar, salió el rover Sojourner, lo puedes ver en la foto a la derecha examinando una roca. Realizó numerosos análisis de rocas y del clima de Marte

De NASA/JPL, Dominio público

La Curiosity un rover aún vivo

En 2011 NASA envió la Mars Science Laboratory (MSL) con su rover Curiosity. Aterrizó suavemente con paracaídas y retrocohetes y ha enviado numerosos datos sobre indicadores de posible vida en Marte.

Esta foto es un selfie en Marte :

De NASA/JPL-Caltech/Malin Space Science SystemsDerivative work including grading, distortion correction, minor local adjustments and rendering from tiff-file: Julian Herzog , Dominio público

Ha enviado fotos impresionantes como esta del Monte Sharp

De NASA/JPL-Caltech/MSSS, Dominio público

Tiene una pila atómica que aún le proporciona energía y a pesar de numerosos incidentes, la misión no ha finalizado, sigue moviéndose y aún puede enviarnos alguna foto, siguelo en Twitter.

Spirit

En el 2004 Nasa lanza este rover, preparado para perforar rocas y encontró sal, por lo que es una prueba indirecta de presencia de agua históricamente en Marte. Se diseñó para sobrevivir 3 meses y duró 7 años, y porque una tormenta de arena lo atrapó. Podemos ver una suya foto de una tormenta de arena:

By NASA from English Wikipedia, Public Domain

Perserverance

Esta misión está actualmente en curso, su aterrizaje (6/3/21) fué un éxito :

Y tiene muchas expectativas :

Tianwen-1

China, cómo no, quiere demostrar que tiene tecnología para aterrizar un rover en marte, ¿otra carrera 🤔? y en mayo del 2021 lo consigue. Este rover buscará vida anterior en el planeta marciano (+info)

Otros astros.

En 2014 ESA manda una sonda espacial Rosseta al cometa 67P, orbita alrededor del cometa y desprende la sonda Philae que aterriza en el cometa. Sus resultados desmontaron algunas teorías ampliamente aceptadas, como la creencia de que el agua de la Tierra viene de los cometas, técnicamente no fue un rover pues no se movía por la superficie, no me extraña, si parece el Everest :

ESA/Rosetta/MPS for OSIRIS Team MPS/UPD/LAM/IAA/SSO/INTA/UPM/DASP/IDA – CC BY-SA 4.0, CC BY-SA 4.0

Esto abre las posibilidades de exploración espacial a otros astros, por ejemplo, explorar el satélite Europa y encontrar vida en su mar interior.

Mi opinión

En 1957, con la Sputnik, despega la carrera espacial, que sus causas son :

Los logros de Rusia son indiscutibles, pero las prisas no son buenas, en el desastre de Nedelín murieron grandes cerebros de la ingeniería espacial rusa. (Recomiendo el libro Grandes desastres tecnológicos de Félix Ballesteros Rivas y Koldobica Gotxone Villar)

USA pudo despegar con ayuda de los antiguos ingenieros nazis (véase Von Braun ). Con una NASA con presupuesto ilimitado, USA pudo llegar al final de la loca carrera de llevar un hombre en la luna.

Loca en mi opinión, pues la relación logros/(coste económico y vidas) de enviar satélites y rovers es muchísimo más alto que enviar humanos. Una vez que se pierde interés, los humanos se reemplazan por robots, véase que después del programa espacial Apolo ya no se ha vuelto a la luna, y que después del desastre de las lanzaderas espaciales han vuelto a los cohetes no tripulados.

Un ejemplo de contradicción: La estación espacial internacional ha costado 100.000 millones $, frente al criticado acelerador CERN que ha costado 1.000 millones con mucho más logros científicos. La estación internacional se está quedando sin experimentos y mantenerlo cuesta 300 millones al año. Tener humanos por el espacio es muy caro.

Seguimos queriendo enviar un hombre en Marte, que se convertirá en otra loca carrera de vanidad ¿Cuánto dinero va a costar? ¿Qué logros científicos va a conseguir diferentes o mejores que los que hace un rover?. Volvemos a caer en los errores del pasado.

Presentación de ALPHABOT

Presentación de ALPHABOT

1. ALPHABOT

¿Qué buscamos?

Para hacer el rover marciano tenemos unas características que cumplir y resolver con ¿Arduino? ¿Raspberry? ...

Conclusión

Hay que utilizar una Raspberry con un kit robótico que permita lo que queremos conseguir.

Si pones las palabras Raspberry y Robot en cualquier buscador verás que hay muchas opciones y kits comerciales.

Elegimos el kit Alphabot para hacer nuestro rover marciano, pues veremos en VENTAJAS que sirve tanto para Raspberry y Arduino y tiene una buena dotación de sensores, en contra tiene importantes defectos de diseño, esto lo veremos en DESVENTAJAS pero con el precio que tiene, no se puede pedir más.

Una vez elegido el kit comercial, nos tenemos que ajustar al soporte que proporciona el fabricante y vemos que están escritos en Python un lenguaje muy adecuado en la enseñanza del pensamiento computacional, con muchas posibilidades y ajustado al nivel de nuestros propósitos.

¿Qué incluye el kit comercial ALPHABOT?

Fondo: Paisaje de Marte tomado por el Curiosity © NASA

Presentación de ALPHABOT

1.1 Ventajas

Ventaja 1: Raspberry, Arduino o ambos

Lo primero que nos gustó es su versatilidad de que sirve tanto para ARDUINO, como para la RASPBERRY. Tiene un regulador LM2596 que proporciona una tensión estable de 5V para las dos placas. En la figura puedes ver que simplemente cambiando los jumpers amarillos de lugar decides quien actúa el Arduino o la Rasbperry, incluso los dos a la vez !! puedes hacer que los motores vayan con Arduino y los sensores con Raspberry.

Incluso deja en la parte superior los conectores del Arduino con la posibilidad de poner una Shield.

Opción Arduino

Para trabajar con el Arduino tiene en la parte trasera dos conectores exclusivos:

Opción Arduino+ RASPBERRY

Tiene un interruptor UART SWITCH que permite establecer una comunicación serie entre Raspberry y Arduino, conectando D1 del Arduino con P TX de Raspberry y D0 del Arduino con P RX de Rasperry.

Opción sólo Raspberry

En este curso SÓLO VAMOS A TRABAJAR CON LA RASPBERRY por lo tanto no trabajaremos con el conector UART pues la Raspberry ya tiene Bluetooth y Wifi integrados.

Ventaja 2: Buena relación prestaciones/precio (no calidad/precio)

Nosotros no somos comerciales, ni intermediarios, sólo somos formadores. Cuesta aproximadamente unos 100€ se puede conseguir en: (ojo, que hay modelos sin Raspberry o con Raspberry)

Ventaja 3 Pilas 18650

No son las "normales AA o AAA" pero proporcionan 3.7V y más de 1.000mAh cada una lo que asegura la alimentación del robot+raspberry de forma autónoma, esto es importante si lo vamos a dejar en marte :

Fuente: Fotomontaje del original NASA.gov

¿Los rovers reales que pilas usan?

Pues.... atómicas, aquí vemos la cápsula de Plutonio-238 de 4.5Kg (el Pu-239 es el que se usa en las bombas atómicas) de la Curiosity que permite que este rover siga vivo desde 2011.

De Idaho National Laboratory - fuel module, CC BY 2.0

¿Por qué?

Porque generan calor.

En los rovers marcianos, al principio usaban paneles solares, pero las tormentas de arena hacen malas jugadas llenándolos de polvo (ya vistes lo que le ha pasado a la Spirit) por lo tanto ahora usan estas pilas atómicas.

Utilizan la diferencia de temperatura entre este bloque radiactivo y el medio para generar electricidad con un fenómeno que se llama Termopila donde una soldadura de cobre y hierro a diferente temperatura genera electricidad. En la Curiosity proporciona 2.5kWh/dia frente a los 0.58 kWh de los paneles solares de las Mars. A medidad que se va descomponiendo el Plutonio pierde potencia, pero eso será dentro de 14 años que proporcionará 0.1kWh.

La sonda Cassini, La Galileo, New Horizons... también usan este tipo de pilas, incluso las Voyager que siguen vivas desde 1977.

Los rovers lunares usan paneles solares, pero como la luna carece de atmósfera, las noches lunares son gélidas para la electrónica y necesitan de estas pilas atómicas pero para generar calor.

Animated gif of the Yutu rover driving on to the lunar surface. Image: CCTV

Presentación de ALPHABOT

1.2 Desventajas

Es importante que las conozcas:

Primera desventaja: CUIDADO CON LAS PILAS 18650

No son tan peligrosa como las pilas de Plutonio-238, pero tienen sus peligros. Le dedicamos una página especial

Segunda desventaja: No se puede utilizar la fuente de alimentación de la Raspberry con el chasis de abajo montado

Esto es importante mientras estamos programando este robot, hacer pruebas y depuraciones sin utilizar las pilas (son un engorro, sólo hay que ponerlas cuando ya lo tenemos todo depurado).

Se puede utilizar la fuente de alimentación de la Raspberry (output 3.000 mA) pero para conectarlo hay que quitar la placa de abajo

Y por supuesto levantar el robot para que no salga disparado conectado con el cable, que los motores trabajen en vacío y entonces sí que la fuente de alimentación lo puede soportar:

Tercera desventaja: FALLOS EN EL DISEÑO:

Cuarta desventaja: La documentación en Internet no es muy amplia y buena.

En resumen

Las desventajas de diseño se sufren en el momento de montarlo y las baterías hay que tener cuidado con respetar la polaridad, pero la desventaja más importante es como hemos visto anteriormente, no se puede acceder a la alimentación por USB con la tapa inferior montada luego tenemos dos opciones: * Alimentar Alphabot con las pilas. (única opción cuando está en movimiento). * Desmontar la tapa inferior y alimentarlo por USB. Si elegimos esta opción hay que dejar las ruedas en alto para que los motores trabajen en vacío.

Como el método de trabajo es programar (quitar tapa, pues las baterías no duran todo el rato que se está en la programación) y probar (poner tapa pues está en movimiento) este kit puede resultar...

Presentación de ALPHABOT

1.2.1 Ojo con las baterías 18650

Son las baterías que podemos encontrar en los portátiles, coches eléctricos... son de Litio, por lo tanto no tienen el efecto memoria de las Ni-Mh de las pilas recargables y tienen una alta capacidad.

¿Por qué no se utilizan en vez de las pilas recargables si son mejores?

Porque son PELIGROSAS :

EXPLOSIÓN

En este vídeo puedes ver la explosión que se genera por un simple cortocircuito (colocación de un pequeño metal encima), imagínate esta explosión en un recinto cerrado, en una linterna, en un armario... o peor: en clase con el alumnado.
El vídeo es más impresionante : https://www.youtube.com/watch?v=ZTzEHsJVZhA

La 18650 del mClon viene montado dentro de la caja PowerBank
¿Por qué? Por estos peligros, para evitar su manipulación. Si abres la caja powerbank y conectas la batería al revés o dejas que lo manipulen los alumnos es tu responsabilidad.

Si alguna vez quieres reciclar las baterías del portatil, tienes que evitar estos cortocircuitos, su explosión puede causar daños graves ver

Estas baterías no son aptas para que el alumnado los manipule luego en Alphabot ES IMPORTANTE QUE LAS BATERÍAS SÓLO LO MANIPULE EL DOCENTE.

CUIDADO CON NO INTERCAMBIAR LA POLARIDAD

OJO ESTAS PILAS SON PELIGROSAS SI SE CORTOCIRCUITAN O NO SE RESPETA LA POLARIDAD, PUEDEN LLEGAR INCLUSO A EXPLOTAR. Y para complicarlo, no se ve bien (los símbolos + y - de las 18650 soy muy pequeños) y en Alphabot hay una contradicción, los símbolos de fuera en la placa no coinciden con los símbolos de dentro grabados en el portapilas ¿cuales son los verdaderos?: Los de fuera. Para que quede claro aquí tienes un dibujo:

pub?w=996&h=849

CUIDADO CON LAS COMPRAS

Se pueden encontrar en tiendas online con cargador incluido. pero hay que tener precauciones.No te fies de las muy baratas, pues hay algunas que son falsas, LES PONEN HARINA..

BATERIAS PROTEGIDAS Y NO PROTEGIDAS

¿Qué es eso de la protección? La protección no quiere decir que estas protegido frente a una explosión, sino que están protegidas frente a que se descarguen del todo o esten mucho tiempo cargandose, alargando la vida de la batería. Añaden un chip entre la batería y el exterior que desconecta la batería cuando se alcanza valores críticos tanto por abajo cerca del 0% de carga como por arriba cerca del 100%.

Algunas están protegidas, pero lo normal es que no. Aquí para ver si la pila es protegida o no.

Las del AlphaBot NO ESTAN PROTEGIDAS  ¿Por qué? porque las protegidas miden 67mm y no caben tiene que ser de 65 mm.

Las del mClon NO ESTAN PROTEGIDAS  ¿Por qué? porque no caben en la caja powerbank, tiene que ser de 65 mm

Presentación de ALPHABOT

1.3 DIY

Este robot es delicado y difícil de montar, hemos elaborada este pequeña guia de montaje o puedes hacer caso a la guia oficial que te puedes descargar aquí

Ojo, que quede bien claro que nosotros estamos para ayudarte en tu formación, no somos comerciales de este robot. O sea, ésto mejor que no:

Pero te queremos animar:

Nomenclatura:

El Paquete de piezas

Encontramos todas estas piezas, destacamos: * Placa de raspberry con microSD, pincho adaptador y fuente de alimentación (no fotografiado) * Tornillería abundante algunos tornillos son minúsculos.

Vamos a por ello (Advertencia: empieza si tienes tiempo por delante):

Los motores

Ponemos primero los dos soportes:

Atornillamos el motor con los tornillos largos

conectamos el motor

repetimos los mismos pasos con el otro motor.

Medidor de velocidad

Ponemos la rueda de agujeros para el medidor de velocidad:

Tiene que ir en este agujero van muy ajustados luego no es necesario atornillarlos. ACONSEJAMOS NO METERLOS AÚN sino después de colocar el brazo robótico

conectamos el sensor:

con la placa

Sensor de siguelíneas

Hay tres tipos de barras, elegimos siempre las largas (no sé para que sirven las pequeñas)

atornillamos en la parte trasera del robot

Conectamos

y aún no atornillamos, tiene que ir atornillado al final, cuando pongamos la tapa inferior. El sensor tiene que estar atrapado con el tornillo entre la barra y la tapa inferior. Esta foto es para que veas cómo tiene que quedar al final, pero aún no lo hagas:

Sensor distancia IR

Colocamos un tornillo de plástico que servirá de arandela aislante pues si no se hace, al atornillar hace un cortocircuito y el sensor no funciona bien:

utilizando los tornillos un poco más largos:

Atornillamos en la parte delantera en los agujeros extremos :

Conectamos

Y por abajo también:

Arduino (opcional)

Si decidimos conectar un Arduino ahora es el momento:

Raspberry

Antes de colocarlo:

Pasamos el cable de la cámara por la ranura de la placa del robot para que salga al exterior:

Ponemos el cable de la cámara, levantamos el plástico negro sin arrancarlo:

Y colocamos el cable, con el lado azul tal como está en la foto y volvemos a apretar el plástico negro para que fije el cable a la Raspberry:

Ahora ya podemos colocar la Raspberry en el zócalo de los GPIO: (si además tienes puesto un Arduino, queda el Arduino entre la Raspberry y la placa).

Aprovechamos y ponemos las barras largas para proteger los distintos elementos (Las 2 barras de la parte delantera pueden ir en esa posición o en los otros dos agujeros más adelantados).

Brazo robótico

Esta parte es la más difícil !!!

via GIPHY

De momento algo sencillote: Conectar los servos CABLE MARRÓN A GND pasando los cables por el mismo agujero que están los cables de conexión del sensor de velocidad y el de proximidad:

El servo de abajo tiene que colocarse en esta pieza

entra ajustado pero entra:

colocamos la otra pieza:

Utilizamos los tornillos largos pero no los más largos y estrechos sino este:

Atornillamos:

Para el servo de arriba utilizamos un tornillo de punta pequeño:

Lo atornillamos en los dos lados del servo:

Y lo colocamos con la otra pieza:

CHAPUZA 1

Ahora vemos que la pieza de brazo del servo no se ajusta al hueco

La palabra "chapuza" es típica española, y también estos cuchillos albaceteños:

Los españoles estamos entrenados a resolver situaciones chapuzas:

El tornillo es uno en punta con arandela soldada:

CHAPUZA2

La parte que tiene que unir el servo de abajo con la plataforma de la placa tiene que ser con un brazo de servo QUE NO ENTRA:

Pero los maños no nos rendimos:

Esto no sé si está en los libros de ingeniería !!

Aún así hay que rebajar un poco más en los lados para que entre bien el brazo del servo blanco, puedes ver en la foto como con el cuchillo se ha rebajado un poco más a los lados para que la pieza blanca esté lo más prieta a la negra:.

Bien atornillado por la parte reversa (Nota: tendrás que agrandar los agujeros de la pieza blanca, un truco es utilizar un tornillo de punta, atornillarlo y destornillarlo):

Utilizando los tornillos finos y cortos:

Es un buen momento para colocar la cámara. Levantamos la pieza negra sin arrancarla:

Ponemos el cable con el lado azul mirando hacia la cámara como en la foto y volvemos a colocar la pieza negra:

Truco: Al encender el robot, tiene que encenderse un led rojo de la cámara. Si no es así es que has conectado la cinta mal.

CHAPUZA3

Mete la cámara a presión y verás: ¡¡ Es más grande la cámara que el soporte !!. Queda torcido, no es muy estético pero está bien sujeto:

Ahora viene el PUNTO DÉBIL DE ESTE ROBOT la unión del brazo robótico con la placa. Ponemos el servo de abajo con la plataforma:

Utilizaremos un tornillo con arandela soldada:

Y bien apretado pero sin reventar el servo, ojo:

Ahora utilizaremos los tornillos más largos con tuerca que lo utilizaremos de arandelas o tuercas de plástico y tuerca normal :

CHAPUZA4

¿Por qué utilizar la arandela de plástico? porque si no se utiliza, las tuercas hacen cortocircuitos con las soldaduras de la placa, luego necesitamos levantar un poco la plataforma del brazo robótico de la placa:

Atornillamos los 4 (por eso decíamos que no había que poner los sensores de velocidad aún) :

Y ponemos las 4 tuercas por la parte de atrás bien prietas OJO SE NECESITA MAÑA abstenerse los que no tengan uñas y dedos gordos:

Ahora ya podemos colocar los sensores de velocidad, que no hace falta atornillarlos pues entran muy ajustados y prietos:

Tiene que quedar que vean bien los agujeros de las ruedas:

Ruedas

Ponemos la rueda loca en la parte trasera:

Atornillamos

Ponemos las ruedas traseras, las pilas:

Acuérdate de poner bien los jumpers amarillos !!:

Y fin !! ha sido difícil pero piensa que en la realidad cuesta más:

Presentación de ALPHABOT

1.4 Configuración

  1. INSTALAR SISTEMA OPERATIVO Tienes que instalar el sistema operativo Raspbian en la micro tarjeta SD (que ya tiene Python) para ello tienes que seguir los pasos de los apuntes de los apuntes Raspberry muy básico. Concrétamente el capítulo 3 si quieres manejar este robot via red local. Pero si además quieres controlar este robot remotamente por Internet, entonces te recomendamos intalar la imagen de Raspbian con los scripts de remote.it para poderlo manejar remotamente. Ver Capítulo 11-2 opción A
  2. CONECTARLO VIA WIFI Una vez instalado tienes que conectar la Raspberry a la wifi, para ello sigue los pasos marcados en el capítulo 4.
  3. OPCIONAL : COMUNICACIÓN VIA TEXTUAL Es interesante y útil comunicarte con la Raspberry via texto por SSH, cambiar el usuario, contraseña, y aprender a apagar por comando.
  4. OBLIGATORIO COMUNICACIÓN VIA GRÁFICA Es el método que se usará en este curso, por VNC lo tienes explicado en el capítulo 8.

¿Cómo ejecuto un programa?

Vía VNC de forma gráfica, creas un fichero con extensión .py le das dos cliks y ya está !! Se abre el editor de Python para que escribas tus programas. (pues Raspbian tiene Python de forma nativa). Se ejecuta con el botón Play (redondo verde de la figura) y se para con el rojo. Esta será la forma de trabajar en este curso. OJO ESTAMOS HABLANDO DEL ESCRITORIO DE LA RASPBERRY que desde tu ordenador lo estas viendo por VNC.

image-1647866562689.png

También se puede hacer de forma textual con el protocolo SSH ejecutando la orden python. Por ejemplo: Tenemos un programa llamado miprograma.py en la carpeta Aphpabot de la Raspberry luego las instrucciones serían en el terminal ssh:
cd ~/AlphaBot/
sudo python miprograma.py

Desde Internet

El curso se puede hacer perfectamente desde LA RED LOCAL accediendo a la Raspberry por una IP fija tal y como hemos explicado en los enlaces del principio de esta misma página.

Pero es educativo aprender a usar este rover totalmente a distancia desde Internet, simplemente sustituyendo la IP de la Raspberry por la dirección que nos proporciona Remote.it siguiendo estos pasos por lo tanto es recomendable instalar de antemano el sistema operativo con los comandos de Remote.it ya preinstalados.

O sea: ¿Puedo manejar mi Alphabot en Marte si ponen Internet? Si. No es ciencia ficción, hay un plan para poner Internet en la luna en 2024.

De NASA/JPL/Cornell University, Maas Digital LLC, Dominio público

Presentación de ALPHABOT

1.5 Vaya programación cutre!

Si eres un programador, te recomiendo que no sigas el curso, yo no soy un experto y seguro que estoy cometiendo muchos errores.

Hay dos formas de programar: sencilla pero no profesional y profesional pero no sencilla, pero, al igual que los coches, si funcionan bien, los dos llegan al destino.

Sólo nos falta poner el botijo 😁

#LaViñetaEconómica de #ElDespertarLiberal de @MasDeUno con @carlos__alsina en @OndaCero_es #Buenísima - @HUMORJMNIETO en @abc_es pic.twitter.com/GYpRgBETPi

— Carlos Rodríguez Braun (@rodriguezbraun) March 8, 2021

Como este curso está orientado para ayudar a los docentes a aplicar la robótica en el aula, preferimos ser sencillos pero que se entienda. Se admite comentarios, propuestas y los programas están en este Github para mejorar depuraciones.

Puedes optar por la programación profesional, en la página https://www.waveshare.com/wiki/AlphaBot tienes Software demo que te puedes descargar y puedes hacer las mismas propuestas, está programado en Python y utilizando programación orientada a objetos POO:

Presentación de ALPHABOT

1.6 GPIO

Vamos a recordar lo que vimos aquí, dos cosas:

En nuestro rover la conexión es la siguiente:

Librería RPI.GPIO

Necesitamos una librería GPIO que Raspbian lo tiene por defecto, pero por si acaso ejecuta estas instrucciones:

sudo apt-get install python-dev
sudo apt-get install pyton-rpi.gpio

Normalmente te dirá que las tienes instaladas en su última versión.
Para utlizar la librería, simplemente tenemos que poner esta instrucción:
import RPi.GPIO as GPIO

GPIO.setmode y GPI.setup

Hay dos formas de utilizar la numeración de las GPIO, respetando la misma numeración que los pines de la placa, entonces la instrucción que tenemos que poner en nuestros programas es GPIO.setmode(GPIO.BOARD) o utilización de la numeración BCM GPIO.setmode(GPIO.BCM)  nosotros elegiremos esta última por ser más sencilla, aunque tiene la desventaja de que si cambian en el futuro la numeraciones en los BCM nuestro programa no servirá.

Una vez definido qué numeración usamos, tenemos que especificar en nuestro programa si tal GPIO es entrada o salida, por ejemplo la siguiente instrucción define el GPIO número 4 como entrada (7 en numeración BOARD) GPIO.setup(4, GPIO.IN)

¿Qué es lo que hay conectado en cada puerto GPIO de este rover?

Pues aquí lo tienes, cada uno lo vamos a ver a lo largo de este curso :

Interfaces Puertos GPIO de la Raspberry Pi nomenclatura BCM
IN1 motores 12
IN2 motores 13
ENA motores 6
IN3 motores 20
IN4 motores 21
ENB motores 26
Sensor velocidad derecha 7
Sensor velocidad izquierda 8
Sensor IR obstáculos derecha 16
Sensor IR obstáculos izquierda 19
Sensor IR mando distancia 18
Siguelineas CS 5
Siguelíneas Clock 25
Siguelíneas Address 24
Siguelíneas DataOut 23
Servo brazo eje X 22
Servo brazo eje Z 27

Ejemplo de utilización de la librería RPI.GPIO

El siguiente ejemplo enciende un LED puesto en el GPIO 4, durante 2 segundos

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT) ## GPIO 4 como salida
GPIO.output(4,True) ##encendemos
time.sleep(2)        ## espera 2 segundos
GPIO.output(4,False)  ##APAGAMOS

No lo hagas pues en el 4 de este rover no hay puesto nada, mira el plano esquemático y en P4 (pin 7 real del conector RPI1) no hay nada conectado.

Presentación de ALPHABOT

1.7 PWM

¿Qué es?

Para entender el funcionamiento de los motores, primero tenemos que hablar de esta señal especial.

La RASPBERRY igual que el ARDUINO (ver cap 2.4 curso Arduino) no es capaz de generar señales ANALÓGICAS. Un truco es generar una señal cuadrada de pulsación variable PWM (Pulse Width Modulation, Modulación de Ancho de Pulso) de esta forma "simula" una señal analógica.

¿Cómo se genera utilizando PYTHON y los pines GPIO?

Se realiza primero creando una variable especial PWM con la instrucción:

p = GPIO.PWM(canal, frecuencia) donde canal es el número de pin GPIO donde queremos generar la señal PWM de frecuencia dada en Hz

Con esto está creado pero no genera los pulsos, para eso se hace con la instrucción:

p.start(dc) donde dc=duty cycle en % es decir desde 0.0 hasta 100.0, por ejemplo en la figura anterior, la a) sería dc=25 el b) dc=50 y la gráfica c) sería un dc=75.

Para parar p.stop()

Please! ¿Un ejemplo?

Claro, vamos a ver un ejemplo sencillo que es encender un LED cada 2 segundos en el GPIO número 12:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)  #definimos el GPIO12 como salida

p = GPIO.PWM(12, 0.5)
p.start(50)

Tampoco lo hagas en nuestro rover, pues en 12 está IN1 que controla los motores y ya veremos cómo se usa eso dentro de poco.

Presentación de ALPHABOT

1.8 Kit de prestamo

Si haces el curso, está disponible este préstamo para que lo puedas hacer: pub?w=960&h=720

Movimiento

Movimiento

2 Movimiento

El primer contacto con este robot va a ser controlar el movimiento.

Nomenclatura: Hacia delante es donde está la cámara.

Giphy GIF by NASA

Movimiento

2.1 Motores

Vamos a empezar por la parte importante de un rover:

NASA/JPL-Caltech

Los motores estan gobernados con los siguientes GPIO

Interfaces Puertos GPIO de la Raspberry Pi
IN1 P12
IN2 P13
ENA P6
IN3 P20
IN4 P21
ENB P26

Luego una de las primeras líneas que hay que poner en nuestros programas es traducir esos números a letras para que sea más facil utilizarlos en el código, y definir esos pines como pines de salida que van a gobernar a los motores:

import RPi.GPIO as GPIO

IN1=12;IN2=13;ENA=6;IN3=20;IN4=21;ENB=26

GPIO.setmode(GPIO.BCM);GPIO.setwarnings(False)
GPIO.setup(IN1,GPIO.OUT);GPIO.setup(IN2,GPIO.OUT);GPIO.setup(IN3,GPIO.OUT);GPIO.setup(IN4,GPIO.OUT)
GPIO.setup(ENA,GPIO.OUT);GPIO.setup(ENB,GPIO.OUT)

¿Qué significan IN1 IN2 IN3 IN4 ?

IN1 IN2 IN3 IN4 Descripción
1 0 0 1 Motores hacia delante
0 1 1 0 Motores hacia atrás
0 0 0 1 Giro derecha
1 0 0 0 Giro izquierda
0 0 0 0 Stop

¿Y qué significa ENA ENB?

ENA y ENB es la velocidad de los motores A y B respectivamente.

Su valor tiene que ser analógico pero los GPIO son digitales, así que tienen que ser señales PWM.

Si vamos a poner una frecuencia de 500Hz y una velocidad media, el código que tenemos que poner al principio de nuestro programa es:

PWMA = GPIO.PWM(ENA,500);PWMB = GPIO.PWM(ENB,500)
PWMA.start(50);PWMB.start(50)

Bueno, pero ... ¿Cómo son las conexiones?

En el AlphaBot están conectados los pines IN1 IN2 IN3 IN4 ENA ENB en los pines de un chip L298P que hace de driver a los motores (nunca conectes un motor a un GPIO de la Raspberry ya lo sabes)

Vale... ¿Y cómo se utiliza?

Podemos definir en nuestros programas unas funciones para simplificar código para utilizar los motores hacia delante, detrás y giros:

def FORDWARD():
    GPIO.output(IN1,GPIO.HIGH);GPIO.output(IN2,GPIO.LOW);GPIO.output(IN3,GPIO.LOW);GPIO.output(IN4,GPIO.HIGH)
def BACKWARD():
    GPIO.output(IN1,GPIO.LOW);GPIO.output(IN2,GPIO.HIGH);GPIO.output(IN3,GPIO.HIGH);GPIO.output(IN4,GPIO.LOW)
def LEFT():
    GPIO.output(IN1,GPIO.LOW);GPIO.output(IN2,GPIO.LOW);GPIO.output(IN3,GPIO.LOW);GPIO.output(IN4,GPIO.HIGH)
def RIGHT():
    GPIO.output(IN1,GPIO.HIGH);GPIO.output(IN2,GPIO.LOW);GPIO.output(IN3,GPIO.LOW);GPIO.output(IN4,GPIO.LOW)
def STOP():
    GPIO.output(IN1,GPIO.LOW);GPIO.output(IN2,GPIO.LOW);GPIO.output(IN3,GPIO.LOW);GPIO.output(IN4,GPIO.LOW)
Movimiento

2.2 Fichero VARIABLES.py

Debido a que vamos a utilizar varias variables que serán comunes a varias librerías que también vamos a crear, vamos a crear un fichero común a todos, de momento será este:

Cuando queramos incorporar estas variables pondremos esta instrucciónde Python from VARIABLES import *

VARIABLES.py

import RPi.GPIO as GPIO

DataMotorR = 7
DataMotorL = 8

IN1=12
IN2=13
ENA=6
IN3=20
IN4=21
ENB=26

##############CONFIGURACION GPIO ENTRADAS SALIDAS ####
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(IN1,GPIO.OUT)
GPIO.setup(IN2,GPIO.OUT)
GPIO.setup(IN3,GPIO.OUT)
GPIO.setup(IN4,GPIO.OUT)
GPIO.setup(ENA,GPIO.OUT)
GPIO.setup(ENB,GPIO.OUT)

GPIO.setup(DataMotorR,GPIO.IN)
GPIO.setup(DataMotorL,GPIO.IN)


########################### VELOCIDAD DE LOS MOTORES
PWMA = GPIO.PWM(ENA,500)
PWMB = GPIO.PWM(ENB,500)
Movimiento

2.3 Libreria MOVIMIENTOS.py

Para simplificar nuestros programas podemos hacer una librería propia.

Esta librería la vamos a llamar MOVIMIENTOS.py y su contenido sería lo visto en las páginas anteriores, añadiendo las variables definidas en VARIABLES.py:

import RPi.GPIO as GPIO

from VARIABLES import *


###########################FUNCIONES#######################
def FORDWARD(vel):
    GPIO.output(IN1,GPIO.HIGH)
    GPIO.output(IN2,GPIO.LOW)
    GPIO.output(IN3,GPIO.LOW)
    GPIO.output(IN4,GPIO.HIGH)
    PWMA.start(vel)
    PWMB.start(vel)

def BACKWARD(vel):
    GPIO.output(IN1,GPIO.LOW)
    GPIO.output(IN2,GPIO.HIGH)
    GPIO.output(IN3,GPIO.HIGH)
    GPIO.output(IN4,GPIO.LOW)
    PWMA.start(vel)
    PWMB.start(vel)

def LEFT(vel):
    GPIO.output(IN1,GPIO.LOW)
    GPIO.output(IN2,GPIO.LOW)
    GPIO.output(IN3,GPIO.LOW)
    GPIO.output(IN4,GPIO.HIGH)
    PWMA.start(vel)
    PWMB.start(vel)

def RIGHT(vel):
    GPIO.output(IN1,GPIO.HIGH)
    GPIO.output(IN2,GPIO.LOW)
    GPIO.output(IN3,GPIO.LOW)
    GPIO.output(IN4,GPIO.LOW)
    PWMA.start(vel)
    PWMB.start(vel)

def STOP():
    GPIO.output(IN1,GPIO.LOW)
    GPIO.output(IN2,GPIO.LOW)
    GPIO.output(IN3,GPIO.LOW)
    GPIO.output(IN4,GPIO.LOW)
Movimiento

2.4 Baile

Vamos a realizar un sencillo programa para romper el hielo, vamos a imitar los movimientos de la Sojourner

Crédito de imagen: Proyecto Mars Pathfinder

Unos movimientos delante, atrás, derecha, izquierda y paro utilizando la librería anterior:

Solución

¿Te atreves? Sino, mira la solución:

image-1647867821028.png
Fichero 2-6-Baile.py

Movimiento

2.5 Movimientos con tecla

Ahora vamos a hacer lo mismo, pero gobernado por el teclado:

Solución

¿Te atreves a hacerlo tú solo? Venga!! no le des tantas vueltas

From Gifer

Sino, mira la solución:

image-1647868576174.png
Fichero 2-7-Movimientos-Teclas.py

Velocidad

Velocidad

3 Control velocidad

El control de la velocidad y de la posición exacta de las ruedas es muy imporante en un rover. Nos permite tener el control para sortear los obstáculos y darle las instrucciones precisas de movimiento

NASA JPL

Nuestro robot tiene unos discos en los ejes de las ruedas, estos discos están agujereados :

Este sensor, el WYC-H206, es el encargado de detectar los agujeros, haciendo pasar una luz entre ellos, por lo que detecta agujero o no, y podemos contar el número y por lo tanto controlar su velocidad.

Velocidad

3.1 ¿Cómo funciona?

El WYC-H206 es un diodo emisor de IR por una parte y por otra es un sensor fotoeléctrico, que detecta los agujeros que hay enmedio de los dos, pasando por un pequeño adaptador 74x126 que adapta la señal para ser leida apropiadamente:

Están conectados a los siguientes GPIO: * Motor derecha GPIO7 * Motor izquierda GPIO8

Si te fijas en el esquema anterior, las resistencias, están con la configuración PULL-UP (aquí para saber + en el curso Arduino) ¿qué significa esto? pues que van al revés, cuando el circuito está encendido, o sea detecta agujero, estado ON transmite un 0 lógico, y al revés, cuando está apagado OFF transmite un 1 lógico, lo puedes ver mejor en estas fotografías, midiendo con un tester entre masa y el pin 8 BCM (pues es la rueda izquierda) o pin 24 del conector ver GPIO :

Velocidad

3.2 Prueba velocidad

En el siguiente vídeo vemos como cuando el sensor está encendido, el programa detecta un 0 y si el sensor está apagado, el programa detecta un 1:

Fichero Pruebasensorvelocidad.py

El programa es el siguiente:

import RPi.GPIO as GPIO

DataMotorR = 7
DataMotorL = 8

GPIO.setmode(GPIO.BCM)

GPIO.setup(DataMotorR,GPIO.IN)
GPIO.setup(DataMotorL,GPIO.IN)


for i in range(100000):
    print('\nMotor derecha   :',GPIO.input(DataMotorR))
    print('\nMotor izquierda :',GPIO.input(DataMotorL))

Segundo test de contador

En el segundo vídeo vídeo vemos como un simple contador puede detectar el paso del 1 al 0:

El programa es el siguiente:

Fichero Pruebasensorvelocidad-2.py

import RPi.GPIO as GPIO

DataMotorR = 7
DataMotorL = 8

GPIO.setmode(GPIO.BCM)

GPIO.setup(DataMotorR,GPIO.IN)
GPIO.setup(DataMotorL,GPIO.IN)

contador=0
repetido=0
num = 100
while (contador<num):
    if((GPIO.input(DataMotorR)==1)and(repetido==0)):
        contador=contador+1
        print('\nContador :',contador)
        repetido=1
    if(GPIO.input(DataMotorR)==0):
        repetido=0
Velocidad

3.3 Variables.py

Añadimos ahora las variables de paso siguientes a este fichero

VARIABLES.py

import RPi.GPIO as GPIO

DataMotorR = 7
DataMotorL = 8

IN1=12
IN2=13
ENA=6
IN3=20
IN4=21
ENB=26

##############CONFIGURACION GPIO ENTRADAS SALIDAS ####
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(IN1,GPIO.OUT)
GPIO.setup(IN2,GPIO.OUT)
GPIO.setup(IN3,GPIO.OUT)
GPIO.setup(IN4,GPIO.OUT)
GPIO.setup(ENA,GPIO.OUT)
GPIO.setup(ENB,GPIO.OUT)

GPIO.setup(DataMotorR,GPIO.IN)
GPIO.setup(DataMotorL,GPIO.IN)


########################### VELOCIDAD DE LOS MOTORES
PWMA = GPIO.PWM(ENA,500)
PWMB = GPIO.PWM(ENB,500)
Velocidad

3.4 MOVIMIENTOSPASO.py

Vamos a hacer una pequeña función donde le pasemos dos argumentos por cada motor (en total 4 argumentos): velocidad y número de pasos. Tiene que hacer:

¿Te atreves? Sino, mira la solución:

Fichero MOVIMIENTOSPASO.py

import RPi.GPIO as GPIO
import time
import MOVIMIENTOS
from VARIABLES import *

###################################################################
#####################FUNCIóN AMBOS#################################
###################################################################
def BOTH(velR,numR,velL,numL):
    repetidoR=0
    repetidoL=0
    if (numR>0):
        GPIO.output(IN1,GPIO.HIGH)
        GPIO.output(IN2,GPIO.LOW)
    else:
        numR=-numR
        GPIO.output(IN1,GPIO.LOW)
        GPIO.output(IN2,GPIO.HIGH)
    if (numL>0):
         GPIO.output(IN4,GPIO.HIGH)
         GPIO.output(IN3,GPIO.LOW)
    else:
        numL=-numL
        GPIO.output(IN4,GPIO.LOW)
        GPIO.output(IN3,GPIO.HIGH)
    contadorR=0
    contadorL=0
    while ((contadorR<numR)or(contadorL<numL)):
        if (contadorR<numR):
            PWMA.start(velR)
        else:
            GPIO.output(IN1,GPIO.LOW)
            GPIO.output(IN2,GPIO.LOW)
            PWMA.start(0)
        if (contadorL<numL):
            PWMB.start(velL)
        else:
            GPIO.output(IN3,GPIO.LOW)
            GPIO.output(IN4,GPIO.LOW)
            PWMB.start(0)
        if ((GPIO.input(DataMotorR)==1)and(repetidoR==0)):
            contadorR=contadorR+1
            repetidoR=1
            print ('contador derecha = ',contadorR)
        if((GPIO.input(DataMotorL)==1)and(repetidoL==0)):
            contadorL=contadorL+1
            repetidoL=1
            print ('contador izquierda = ',contadorL)    
        if(GPIO.input(DataMotorR)==0):
            repetidoR=0
        if(GPIO.input(DataMotorL)==0):
            repetidoL=0

    MOVIMIENTOS.STOP()
Velocidad

3.5 Movimientos con paso

Vamos a hacer un programa que simulemos el gobierno real de un rover:

No va a ser tan profesional pero es un primer paso para ver la complejidad de su programación.

El programa utilizará la librería anterior MOVIMIENTOSPASO.py y gobernado con el teclado numérico:

Fijaremos de antemano las velocidades y el paso a 50 y 10 por ejemplo.

Solución

Fichero 3-5-Movimientos-paso.py

import RPi.GPIO as GPIO
import time

import MOVIMIENTOS
import MOVIMIENTOSPASO

velR=50
numR=10
velL=50

numL=10

print ('TECLAS ¡en minúscula!:\nPARAR = tecla 5\nADELANTE=FORDWARD = 8\nATRAS=BACKWARD = 2\nDERECHA=RIGHT = 6\nIZQUIERDA=LEFT = 4')
tecla='x'
while tecla!='5':
    tecla = input('\nPresiona una tecla y después enter : ')
    if tecla != '5':
        print ('\nHas presionado ', tecla)
        if tecla=='8':
            print ('\nadelante')
            MOVIMIENTOSPASO.BOTH(velR,numR,velL,numL)
        if tecla=='2':
            print ('\natrás')
            MOVIMIENTOSPASO.BOTH(velR,-numR,velL,-numL)
        if tecla=='6':
            print ('\nderecha')
            MOVIMIENTOSPASO.BOTH(velR,-numR,velL,numL)
        if tecla=='4':
            print ('\nizquierda')
            MOVIMIENTOSPASO.BOTH(velR,numR,velL,-numL)

    else:
        print ('\nFin, has apretado STOP')
        MOVIMIENTOS.STOP()

Sensores

Sensores

4 Sensor obstáculos IR

Los rovers tienen que ser autónomos en esquivar obstáculos, no pueden depender del control remoto desde la Tierra, no como la Sojourner que parece que tropieza con una roca:

Crédito de imagen: Proyecto Mars Pathfinder

Nuestro rover también, para ello tenemos dos sensores de infrarrojo para detectar los obstáculos.

Detecta pero no mide la distancia del rover al obstáculo. Si queremos más precisión tendría que ser con el sensor ultrasonidos que lo veremos más adelante.

Sensores

4.1 ¿Cómo funciona?

Lo primero que tenemos que hacer es ajustar su sensibilidad con el potenciómetro que tiene de tal manera que detecte de forma correcta un obstáculo:

ES MUY SENSIBLE el punto está justo cuando se apaga:

Tiene un led de infrarrojos que cuando hay un obstáculo delante del sensor, refleja esta radiacción y el otro LED (realmente no se podría decir que es LED pues no emite, se tendría que llamar unión PN semiconductor), es un sensor receptor que lo detecta. Un chip comparador LM393 detecta la señal y su sensibilidad se ajusta con el potenciómetro:

La salida DOUT de cada LM393 están conectados a los siguientes puertos GPIO:

Una vez más vemos que la resistencias del sensor están tipo PULL-UP luego cuando detecta emitirá un 0 lógico y cuando no detecta emitirá un 1 lógico.

Sensores

4.2 Test

Ejecutamos este pequeño programa:

Fichero 4-2-TestObstaculoIR.py

import RPi.GPIO as GPIO
import time

DR = 16
DL = 19

GPIO.setmode(GPIO.BCM)

GPIO.setup(DR,GPIO.IN)
GPIO.setup(DL,GPIO.IN)

for i in range(10000):
     print('\nSensor derecha :',GPIO.input(DR))
     print('\nSensor izquier :',GPIO.input(DL))

Y podemos ver en el vídeo que emite un 0 cuando detecta un obstáculo:

Sensores

4.3 Variables.py

Añadimos más variables a VARIABLES.py

Los comentados con más #:

import RPi.GPIO as GPIO

# MOTORES

IN1=12
IN2=13
ENA=6
IN3=20
IN4=21
ENB=26

# SENSOR VELOCIDAD MOTORES

DataMotorR = 7
DataMotorL = 8

#### SENSOR OBSTACULOS ####

IR DR = 16 
DL = 19

# CONFIGURACION GPIO ENTRADAS SALIDAS

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

# MOTORES

GPIO.setup(IN1,GPIO.OUT)
GPIO.setup(IN2,GPIO.OUT)
GPIO.setup(IN3,GPIO.OUT)
GPIO.setup(IN4,GPIO.OUT)
GPIO.setup(ENA,GPIO.OUT)
GPIO.setup(ENB,GPIO.OUT)

# VELOCIDAD DE LOS MOTORES

PWMA = GPIO.PWM(ENA,500) 
PWMB = GPIO.PWM(ENB,500)

# SENSOR VELOCIDAD MOTORES

GPIO.setup(DataMotorR,GPIO.IN)
GPIO.setup(DataMotorL,GPIO.IN)

#### SENSORES OBSTACULOS IR ####
GPIO.setup(DR,GPIO.IN)
GPIO.setup(DL,GPIO.IN)
Sensores

4.4 Evita obstáculos

Bueno ahora hay que hacer el típico programa que evite los obstáculos para que nuestro rover sea autónomo ¿a qué esperas? tiene ganas de salir ya solito, ¡ya es mayor!

image-1647950337501.gif

Space Science Animation by European Space Agency ESA

Solución

La solución no es única, una propuesta es hacerlo con las librerías que hemos aprendido:

Ahora ya nuestro rover puede salir libre a recoger piedrecitas:

Fichero Roomba.py

import RPi.GPIO as GPIO
import time
from VARIABLES import *
import MOVIMIENTOS
import MOVIMIENTOSPASO

while True:
    sensorR= not (GPIO.input(DR))
    sensorL= not (GPIO.input(DR))
    if not(sensorR and sensorL):
         MOVIMIENTOS.FORDWARD(50)
    if (sensorR and sensorL):
        MOVIMIENTOSPASO.BOTH(50,-10,50,-10)
    if (sensorR and not(sensorL)):
        MOVIMIENTOSPASO.BOTH(50,-5,50,-5)
        MOVIMIENTOSPASO.BOTH(40,-5,40,5)
    if (not(sensorR) and (sensorL)):
        MOVIMIENTOSPASO.BOTH(50,-5,50,-5)
        MOVIMIENTOSPASO.BOTH(40,5,40,-5)

 

Sensores

4.5 Posibilidad ultrasonidos

Se puede conseguir más precisión añadiendo un tercer sensor y mucho más preciso: El sensor de Ultrasonidos.

Mira en esta página para saber cómo se utiliza con el Arduino.

Básicamente se emite un pulso por el pin Trigger, él emite una señal de 40kHz y según el eco recibido saca por Output un pulso cuyo ancho es proporcional a la distancia:

Conexión en alphabot

En Alphabot se conectaría los cables en el conector blanco de abajo y el ultrasonidos con unos tornillos en los dos agujeros de la parte delantera:

El sensor de ultrasonidos tiene que estar adaptado a los cables compatibles con la Shield Grove de Arduino. Por ejemplo este:

CHAPUZA : No tiene su orden standard GND-Vcc-DATA1-DATA2 sino es GND-DATA1-DATA2-VCC o sea GND-Trg-Echo-5V luego habría que hacer alguna chapucilla de intercambiar cables, habría que elegir unos cables largos, cortarlos e intercambiarlos o poner cables Dupon H-H y conectar cada cable en su lugar correspondiente:

Para sujetar el sensor ultrasonidos al chasis habría que comprar un soporte:

Otra opción es quitar la cámara y poner el sensor de ultrasonidos:

EL KIT DE CATEDU NO PROPORCIONA EL SENSOR ULTRASONIDOS

Bueno, si aún así me decido ponerlo ¿cómo se programa?

Muy fácil, el conector blanco de abajo está conectado con los siguientes GPIO:

Por lo tanto, viendo la teoría, una posible función en código Python para utilizarlo sería:

```cpp+lineNumbers:true

TRIG = 17 ECHO = 5

GPIO.setup(TRIG,GPIO.OUT,initial=GPIO.LOW) GPIO.setup(ECHO,GPIO.IN)

def Distance(): GPIO.output(TRIG,GPIO.HIGH) time.sleep(0.000015) GPIO.output(TRIG,GPIO.LOW) while not GPIO.input(ECHO): pass t1 = time.time() while GPIO.input(ECHO): pass t2 = time.time() return (t2-t1)*34000/2

```

Control Remoto

Control Remoto

5 Control remoto

Los rovers evidentemente no se pueden gobernar con un mando a distancia, pero sí que se gobiernan con señales de radio. Vamos a simular estas órdenes de radio con el mando de infrarrojos.

All image credits: Chinese Academy of Sciences / China National Space Administration / The Science and Application Center for Moon and Deepspace Exploration / Emily Lakdawalla

Control Remoto

5.0 Comunicación con los rovers

Un camino: a través de un satélite

Los rovers marcianos envían la señal a alguno de los satélites artificiales que giran alrededor de Marte, que se llaman "orbitadores" que envían la señal a la Tierra. Fíjate el retardo de comunicaciones!! debido a lo que le cuesta la luz en recorrer esta distancia, por eso es importante que el rover sea lo más autónomo posible.

Iconos de Flaticon

Con los rovers lunares no se utilizaron orbitadores, a pesar de que existieron. pero se diseñaron para tomar fotos. Los Lunojods se comunicaban diréctamente, y con los Yutus como estaban en la cara oculta de la luna, se utilizó Queqiao, un satélite que está el el Punto de Lagrance, es decir, una órbita geoestacionaria común de la Tierra y de la Luna.

De Loren Roberts for The Planetary Society, CC BY-SA 3.0

Otro camino: Directamente.

Hay rovers que además de usar la comunicación anterior, tienen dos antenas, una que apunta a la Tierra de forma automática (por cierto española ) y otra que apunta a todas las direcciones. Las dos envían la información diréctamente a la Tierra en una banda 7-8 GHz de la "Red del Espacio profundo".

Iconos de Flaticon

La Red del Espacio profundo

Lo forman 3 antenas que están repartidas en la Tierra, más o menos 120º para que siempre sean visibles desde el rover, sondas, etc... (ya te puedes imaginar que si fuera una antena, la rotación de la Tierra lo ocultaría) Una antena está en California, otra está en Camberra y otra ¡¡Está en Madrid!! concretamente en Robledo de Chavela de 70m de diámetro. Yo tuve la suerte de estar allí cuando era estudiante y tenía pelo 😢

Un vídeo explicativo de las comunicaciones con Perserverance

Control Remoto

5.1 NEC

Alphabot tiene un receptor LFN0038K compatible con el protocolo estandard NEC y el mando emisor que acompaña a este kit también es compatible con él. Encima, para complicarnos más las cosas, tiene configuración PULL-UP como el resto de sensores de este robot, por lo que si recibe del mando a distancia un 1 lógico, él transmite un 0 y viceversa.

Una señal con el protocolo NEC es una especie de señal PWM donde un '0' es es un ciclo de 1.125ms la emisión de una señal de 0.565ms y un '1' lógico o mismo pero en un intervalo de 2.25ms, se ve mejor con un dibujo:

El protocolo establece que primero se emite 9ms de una señal alta, y luego 4.5ms de señal baja para empezar el envío de una señal de 8 bits, empezando por el bit más bajo LSB hasta el más alto MSB y luego su complemento. Todo en una señal de 38kHz donde se modula primero la dirección y luego el comando. Mejor con un dibujo ¿no?

Cada comando se envía una sola vez al menos que mantengas el botón pulsado más de 110ms. El formato de duplicación es según este dibujo:

Control Remoto

5.2 VARIABLES.py y NEC.py

El sensor IR está unido al GPIO número 18 luego añadimos en el fichero variables.py las siguientes líneas:

IR = 18
GPIO.setup(IR,GPIO.IN,GPIO.PUD_UP)

lo de PUD_UP es porque su configuración es en PULL-UP

LIBRERIA NEC.py

Creamos este fichero que lo ponemos en la misma carpeta que nuestros ejercicios, el código es complejo, sigue los pasos explicados en el protocolo NEC y lo hemos sacado del código demo de la página https://www.waveshare.com/wiki/AlphaBot :

import RPi.GPIO as GPIO
from VARIABLES import *

def getkey():
    if GPIO.input(IR) == 0:
        count = 0
        while GPIO.input(IR) == 0 and count < 200:  #9ms
            count += 1
            time.sleep(0.00006)

        count = 0
        while GPIO.input(IR) == 1 and count < 80:  #4.5ms
            count += 1
            time.sleep(0.00006)

        idx = 0
        cnt = 0
        data = [0,0,0,0]
        for i in range(0,32):
            count = 0
            while GPIO.input(IR) == 0 and count < 15:    #0.56ms
                count += 1
                time.sleep(0.00006)

            count = 0
            while GPIO.input(IR) == 1 and count < 40:   #0: 0.56mx
                count += 1                               #1: 1.69ms
                time.sleep(0.00006)

            if count > 8:
                data[idx] |= 1<<cnt
            if cnt == 7:
                cnt = 0
                idx += 1
            else:
                cnt += 1
#        print (data)
        if data[0]+data[1] == 0xFF and data[2]+data[3] == 0xFF:  #check
            return data[2]

        if data[0] == 255 and data[1] == 255 and data[2] == 15 and data[3] == 255:
            return "repeat"
Control Remoto

5.3 Test Control Remoto IR

Vamos a ejecutar un sencillo programa que nos vaya diciendo los códigos que lee las diferentes teclas utilizando la función key de la librería NEC.py

Fichero Test-ControlRemoto-IR.py

import RPi.GPIO as GPIO
import time

from VARIABLES import *

import MOVIMIENTOS
import MOVIMIENTOSPASO
import NEC

while True:
    key=NEC.getkey()
    if (key != None):
        print (key)

Lo que nos sale por pantalla son los siguiente códigos de las diferentes teclas del mando siguiente:

Estos son los valores (ordenados tal y como están en el mando)

Tecla Valor Tecla Valor Tecla Valor
CH- 69 CH 70 CH+ 71
<< 68 >> 64 > 67
- 7 + 21 EQ 9
0 22 100+ 25 200+ 13
1 12 2 24 3 94
4 8 5 28 6 90
7 66 8 82 9 74
Control Remoto

5.4 Control remoto

Vamos a simular la comunicación entre Tierra y el rover. Vamos a hacer un control remoto del robot !! con la ventaja de que no vas a tener el retardo que sufren los de la NASA.

Vamos a definir las siguientes teclas

gobernado por el teclado numérico:

Solución

La solución es fácil con las librerías que hemos aprendido:

Fichero Control-Remoto-IR.py

import RPi.GPIO as GPIO
import time

from VARIABLES import *

import MOVIMIENTOS
import NEC

vel=50

print ('TECLAS :\nPARAR = tecla 5\nADELANTE=FORDWARD = 2\nATRAS=BACKWARD = 8\nDERECHA=RIGHT = 6\nIZQUIERDA=LEFT = 4')

key=0
while key!=28:
    key=NEC.getkey()
    if (key != None):
        if key==24:
            print ('\nadelante')
            MOVIMIENTOS.FORDWARD(vel)
        if key==82:
            print ('\natrás')
            MOVIMIENTOS.BACKWARD(vel)
        if key==90:
            print ('\nderecha')
            MOVIMIENTOS.RIGHT(vel)
        if key==8:
            print ('\nizquierda')
            MOVIMIENTOS.LEFT(vel)
        if key==28:
            print ('\nFin, has apretado STOP')
            MOVIMIENTOS.STOP()

Siguelíneas

Siguelíneas

6 Módulo siguelíneas

ORBITAS

Esta claro que un rover de verdad no va a tener que seguir una línea pintada en el suelo. Pero, las sondas que lo transportan a los astros, sí que tiene que seguir unas órbitas o líneas imaginarias. Nosotros lo vamos a simular con una línea pintada en el suelo.

La programación básica es la misma siempre: si te desvías, corrige.

Philae rover's orbit in comet 67P

Pero no es fácil elegir la órbita :

NUESTRO ROBOT SIGUELINEAS

Nuestro robot tiene un módulo con 5 sensores al color :

Tiene un funcionamiento similar al Sensor obstáculos IR. El receptor tiene un sensor de reflexión de infrarrojos ITR20001/T. Un led emite luz IR contínuamente, la luz infraroja es reflejado por un obstáculo y lo recibe el receptor.

La salida del sensor es analógica y es sensible al color y la distancia del objeto detectado.

Tiene 5 canales de sensores. Chequeandolos se puede juzgar la posición de la línea oscura que esté en el suelo.

Siguelíneas

6.2 TLC1543

Este robot no nos lo pone fácil con el siguelíneas ¿Por qué? Porque los 5 sensores (IR1..IR5) están conectados a un conversor analógico digital TLC1543 tal y como puedes ver en su esquema eléctrico:

¿Cómo está conectado con GPIO?

Pues con estos números:

¿Cómo funciona este chip?

Pues léete su manual de instrucciones 🥱🥱😴 aburrido ¿verdad?

Te lo resumimos :

  1. Este chip se activa por nivel bajo del CS.
  2. En ese momento LEE LA DIRECCIÓN definida por ADDRESS (empezando por el bit más alto MSB) donde ADDRESS es un número entre 0 y 4 en binario que corresponde canal o sensor infrarrojo que se quiere leer A0 hasta A4 (que corresponden a los sensores IR1 hasta IR5).
  3. Los primeros 4 pulsos de CLOCK son para leer ADDRESS (en el flanco de subida). En la ilustración Accesss Cycle B.
  4. Los otros 6 no valen para nada. En la ilustración Sample Cycle B.
  5. Los siguientes 10 pulsos se emite por DATAOUT (empezando por el bit más alto MSB) el valor leído del sensor de infrarojos que has seleccionado en ADDRESS. En la ilustración Previous Conversion Data, es decir, está sacando la conversión de los valores leidos anteriormente que no están en la ilustración.

Mentirijillas: Realmente el punto 4 no es verdad, lo que pasa es que si has leído el punto 5 durante los 10 pulsos de reloj está sacando la lectura del IR definido por ADDRESS de los 10 anteriores. Lo que es verdad es que la primera lectura de todas, esos 6 pulsos no valen para nada.

Extraido del Datacheet

Siguelíneas

6.3 TLC1543.py y VARIABLES.py

Tal y como hemos visto en la teoría del TLC1543 ¿Cómo está conectado? añadimos estas líneas al archivo VARIABLES.py

##SENSOR SIGUELINEAS

CS = 5
Clock = 25
Address = 24
DataOut = 23

##SENSOR SIGUELINEAS

CS = 5
Clock = 25
Address = 24
DataOut = 23

Script Damebit

En la teoría del TLC1543 ¿Cómo funciona? tenemos que obtener el bit de una posición dada de un número dado. Aquí hay un pequeño script para hacerlo (dale al play para ejecutarlo):

TLC1543.py

Tal y como hemos visto en la teoría del TLC1543 ¿Cómo funciona? podemos hacer una librería que tenga una función SENSORLINEA(cual) que nos devuelva el valor que lee el sensor cual:

import RPi.GPIO as GPIO
import time

from VARIABLES import *

#######################################################
#función de manipulación de bits
#ver https://repl.it/@javierquintana/ObtenerBitEntero
#######################################################
def SACADIRECCION(x,n):
  if (x & (1<<n)):
    GPIO.output(Address,GPIO.HIGH)
  else:
    GPIO.output(Address,GPIO.LOW)

######################################################
#función de obtener lectura del sensor siguelíneas
#cual = el número del siguelíneas a leer 0-4
######################################################
def SENSORLINEA(cual):
  #activo el chip
  GPIO.output(CS,GPIO.LOW)
  for i in range(4):
    #Pongo en Address el bit de cual empezando por MSB 
    SACADIRECCION(cual,3-i)
    #Flanco de subida de Clock para que lo lea
    GPIO.output(Clock,GPIO.LOW)  
    GPIO.output(Clock,GPIO.HIGH)
  #ahora 6 pulsos perdidos
  for i in range(6):
    GPIO.output(Clock,GPIO.LOW)  
    GPIO.output(Clock,GPIO.HIGH)
  #vamos a darle un tiempo para que calcue la convesión A/D
  #A/D Conversion Interval =
  time.sleep(0.001)
  #leemos el número
  #formula valor = sumatorio (potenciasde2 * bit leido)
  #potenciasde2 = 2 elevado al peso del bit
  #el peso del primer bit es MSB luego 9 y acaba en 0 o LSB
  valor=0
  for i in range (10):
    GPIO.output(Clock,GPIO.LOW)  
    GPIO.output(Clock,GPIO.HIGH)
    valor=valor+GPIO.input(DataOut)*(2**(9-i))
  #desactivamos el chip
  GPIO.output(CS,GPIO.HIGH)
  return valor
Siguelíneas

6.4 Test-Sigue-lineas

Podemos hacer un test para ver cómo funciona este siguelíneas y cómo funciona la librería

¿Te atreves?:

Fichero Testsiguelineas.py
image-1648026168581.png

Siguelíneas

6.5 Siguelineas

Vamos a realizar un programa que siga la línea: * Pero ¡¡AL REVÉS!!! ¿por qué marcha hacia atrás? (o sea, la cámara mira hacia la parte trasera del sentido de la marcha): mira al final de la página.

Fijaremos de antemano una velocidad pequeña de 25% y un incremento de velocidad de diferencia en los motores de 10% cuando no está centrado para que gire hasta que se centre. Veamoslo con un vídeo:

Solución

La solución es fácil con la librería TLC1543.py donde la función SENSORLINEA(cual) nos da el valor que lee los sensores IR. Recuerda que TLC1543.py en la misma carpeta que vamos a crear este programa y las incorporamos en el programa con import. * También incorporamos las variables definidas en VARIABLES.py

¿Te atreves?

Fichero Siguelineas.py

import RPi.GPIO as GPIO
import time

import TLC1543

from VARIABLES import *
from random import randint

x=[0,0,0,0,0]
vel=25
blanco=14
incremento=10
tiempo = 0.2


##hacia DELANTE        
GPIO.output(IN1,GPIO.LOW)
GPIO.output(IN2,GPIO.HIGH)
GPIO.output(IN3,GPIO.HIGH)
GPIO.output(IN4,GPIO.LOW)

while True:
    lineanegra=0
    #Leemos los siguelíneas
    for i in range(5):
        x[i]=TLC1543.SENSORLINEA(i)
        if (x[i]90):
            velA=90
        if (velB90):
            velB=90
        ##activamos motores
        print ('con linea negra SENSORES=',x[0],'-',x[1],'-',x[2],'-',x[3],'-',x[4],'-VELA=',velA,'VELB=',velB);
        PWMA.start(velA)
        PWMB.start(velB)
        #time.sleep(tiempo)
    else:           ##no tiene linea negra pues marcha atrás y que lo busque
        GPIO.output(IN1,GPIO.HIGH)
        GPIO.output(IN2,GPIO.LOW)
        GPIO.output(IN3,GPIO.LOW)
        GPIO.output(IN4,GPIO.HIGH)
        while (lineanegra==0):
            velA=randint(vel-incremento,vel+incremento)
            velB=vel-(velA-vel)  #el opuesto
            print ('SIN linea negra VELA=',velA,'VELB=',velB);
            PWMA.start(velA)
            PWMB.start(velB)
            time.sleep(tiempo)
            for i in range(5):
                x[i]=TLC1543.SENSORLINEA(i)
                if (x[i]

 

¿Por qué en este ejercicio ALPHABOT va al revés?

Por que los sensores siguelineas por la parte de atrás del sentido de la marcha PRODUCE UNA REALIMENTACIÓN POSITIVA es decir, cuando detecta que hay que girar, gira, pero la cola se mueve demasiado deprisa que produce que pierda la línea. Controlarlo es posible pero es difícil la demo de Alphabot lleva el software para hacerlo.

🐓🐓 No seas gallina !! 🐓🐓 Pruébalo.

Chocheando un poco.. esto me recuerda a una vieja historia..

Si los pioneros de la aviación americanos lo tuvieron difícil, más lo tuvieron los españores. Se lo podríamos preguntar al pastor del pueblo Coruña del Conde: Diego Marín Aquilera que en 1793 inventó un artilugio que volaba de forma controlada... la pena es que la Inquisición, el cura del pueblo junto con los lugareños no tenían ni idea que este español hubiera hecho historia, y que la aviación hubiera adelantado más de 100 años. Pensaban que eso era obra del demonio 😈 por lo tanto quemaron todos sus inventos 😱😣 🤦 🤦‍♂️.

De Eulogia Merle - Fundación Española para la Ciencia y la Tecnología, CC BY-SA 4.0

Aaayyyy 😓 si en España hicieramos caso a los genios que tenemos ...

Esa mala suerte no lo tuvieron los hermanos Wright que en 1903 volaron su primer artilugio:

Gregg Bryant saved to Aircraft-Vintage Pinterest

Pero... pusieron el timón delante, no como Diego Marín Aquilera que observaba bien las aves. Esto provocaba una realimentación positiva (al levantar el timón, levantaba el morro, y esto provocaba que se levantase aún más, y viceversa a la hora de bajarlo). Los hermanos Wright patentaron su invento y gastaron todo su dinero en abogados para defender que nadie copiase su control, pero la verdad es que ... que nadie lo hizo.

La industria de la aviación detectó el fallo y los elementos de control van por detrás del ala principal, esto crea una realimentación negativa, por lo tanto mayor estabilidad en el vuelo y ... la ruina de los hermanos Wright.

🤔 ¿En el diseño de este Alphabot habrá participado algún descendiente de los hermanos Wright? 🤔

Mentirijilla: En algunas ocasiones se usa el timón delante: En los cazas para conseguir giros muy rápidos aprovechando esa realimentación positiva como este Saab 39 Gripen:

Editado de De Ernst Vikne - originally posted to Flickr as JAS Gripen, CC BY-SA 2.0

Servos

Servos

7 Servos

Los servos son motores con una reductora, un sensor de posición y un circuito de control del ángulo de giro. Son utilizados en los brazos robóticos y como puedes ver juegan un importante papel en los rovers por ejemplo en el actual Perseverance :

Para saber más de servos te recomendamos el capítulo de servomotores del curso de Arduino de Aularagón..

Los que tiene nuestro rover son más baratos:

Tiene 3 cables:

La señal de control tiene que emitir un pulso alto durante un intervalo de al menos 20mseg, que según su duración en estado alto, se traduce en un ángulo de rotación del servo:

Servos

7.1 BRAZO.py y VARIABLES.py

En Alphabot el servo de abajo del brazo robot (lo llamaremos eje z por ser el responsable del giro del eje vertical) está conectado al GPIO 27 y el servo de arriba (lo llamaremos x) al GPIO 22 luego añadiremos estas líneas en nuestro fichero VARIABLES.py. Lo configuramos como salida y que inicialmente esten no activos para que no se mueva el brazo en el comienzo:

#### SERVOS BRAZO ROBOT
SERVOEJEX = 22
SERVOEJEZ = 27

####### SERVOS BRAZO ROBOT
GPIO.setup(SERVOEJEX, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(SERVOEJEZ, GPIO.OUT, initial=GPIO.LOW)

BRAZO.py

Realmente el control de un servo se hace con una modulación PWM que ya hemos visto. La función que modula la señal PWM es ChangeDutyCycle y se le da el argumento en % entre 0 y 100. Si queremos 180º necesitamos un pulso de 2.5ms por lo que en 20ms corresponde a 12.5% por lo tanto la fórmula es % = 2.5+10*(angulo/180).

Esta función simplemente le indicamos el ángulo y otro argumento, si es 1 es el eje x y si es 0 es el eje z :

import RPi.GPIO as GPIO
import time

from VARIABLES import *

servox = GPIO.PWM(SERVOEJEX,40)
servoz = GPIO.PWM(SERVOEJEZ,40)
servox.start(0)
servoz.start(0)

def ANGULO(angle,x):
    if (x):
        servox.ChangeDutyCycle(2.5 + 10.0 * angle / 180)
    else:
        servoz.ChangeDutyCycle(2.5 + 10.0 * angle / 180)

Los servos tiemblan algo, es normal, no pienses que un robot barato esté bien calibrado.

Servos

7.2 Test Brazo

Vamos a realizar una función que controle con el teclado el brazo robótico, si le pusieramos un diodo laser, podriamos incluso imitar al vaporizador que esta montado en la Perserverante:

NASA's Mars Curiosity rover landed on Mars in 2012. NASA/JPL-Caltech

De momento nos vamos a conformar con hacer esto :

Fijaremos de antemano un incremento de 10ª cada vez que pulsamos la tecla. Veamoslo con un vídeo:

Solución

¿Te atreves? :

Fichero Test-Brazo.py

import RPi.GPIO as GPIO
import time

from VARIABLES import *

import BRAZO

angulox=90
anguloz=90
incremento=20
print("Teclas 8 y 2 SERVOX\n Teclas 4 y 6 SERVOZ")
while True:
    BRAZO.ANGULO(angulox,1)
    BRAZO.ANGULO(anguloz,0)
    tecla=input("Mueve el brazo : ")
    if (tecla=="8"):
        angulox=angulox-incremento
    if (tecla=="2"):
        angulox=angulox+incremento
    if (tecla=="4"):
        anguloz=anguloz+incremento
    if (tecla=="6"):
        anguloz=anguloz-incremento

 

Cámara

Cámara

8. Cámara

Los rover llevan más de una cámara:

The Cameras on the Mars 2020 Perseverance Rover Nasa.gov

Nosotros.... una 🎥 😁 la standard de la Raspberry:

Cámara

8.1 ¿Qué vamos a hacer?

Manejar la cámara web es fácil si queremos que salga por la salida HDMI de la Raspberry, simplemente ejecutando el siguiente código Python, sale la imagen por el puerto HDMI, en este caso durante 10 segundos Pero no sale por VNC ni por SSH:

from picamera import PiCamera
from time import sleep
camera = PiCamera()
camera.start_preview()
sleep(10)
camera.stop_preview()

Pero nosotros necesitamos que retransmita = streaming las imágenes, pues el robot se mueve, y no tiene instalado un monitor, luego lo tiene que hacer vía red.

Encontrarás en Internet varias formas de hacerlo:

  1. Utilizando un programa en Python
  2. Utilizando MJPG STREAMER bajo un programa servidor WEBIOPI
  3. Utilizando Motion (recomendamos)

La primera opción video o este tutorial dependes de tener todas las librerías intaladas, por ejemplo limmal ...

La segunda opción WEBIOPI (https://webiopi.trouch.com/) siguen con la versión 0.7.1 sin actualizar luego no lo recomendamos

Vamos a usar Motion, un programa diseñado para manejar la cámara en estos contextos y sí que está actualizado (actualmente por la 4.3.1) y muy extendido en el uso de cámaras web, lo que nos da unas garantías de no tener problemas, su página web oficial es https://motion-project.github.io/index.html .

Cámara

8.2 Configuracion

Lo primero que tienes que hacer es activar la cámara y Remote GPIO

¿Recuerdas? En el capítulo 8.1 de Raspberry básico ya activamos VNC Server y SSH, ahí también están la opciones de activar la cámara y Remote GPIO.

Si estás utilizando la Raspberry pero no de forma gráfica con VNC sino textual con SSH el comando a utilizar es

sudo raspi-config

entra en la opción 5

Y activas la cámara y Remote SSH en las opciones P1 y P8 :

Cámara

8.3 Motion

Vamos a ver lo que sale por la cámara de forma remota :

image-1648026812597.gif

Imagen de Gifer

MOTION

Esta librería open-source muy utilizado en sistemas de alarma con la Raspberry

(🤔🤔🤔🤔 hacer un sistema de videovigilancia📹 de mi casa 🏠a distancia 📡 y monitorizar 📺 por muy bajo coste... 🤔 que envíe una foto a mi email cuando detecte un movimiento) puedes verlo aquí cómo se hace: https://sites.google.com/view/javierquintana/raspberry/alarma?authuser=0

image-1648026877485.png

Parent detector

Pero nosotros NO nos interesa que detecte movimiento, sino que simplemente haga streaming.

Para esto, simplemente modificaremos el fichero de configuración de la librería motion.conf. Es muy típico modificar ficheros de configuración tipo texto en los softwares abiertos, lo que muestra su versatilidad y potencialidad. Puedes ver las diferentes posibilidades de configuración de Motion aquí

Cómo hacerlo

Abrimos una ventana de comandos, en SSH, ya sabes cómo o en el mismo VNC de forma gráfica abre la ventana de comandos, y ejecutamos estas órdenes:

Instalamos MOTION :

sudo apt-get install motion

Editamos el fichero de configuración motion.conf con el editor nano

sudo nano /etc/motion/motion.conf

Buscamos estas líneas y las modificamos :

Si estuvieran estas líneas webcam_localhost on y webcam_port 8080 las borramos, o mejor las dejamos como comentarios poniendo delante un hastag # así #webcam_localhost on #webcam_port 8080.

En esta página podemos ver otra configuración de motion.conf para el mismo propósito de streaming.

Grabamos el fichero: pulsando Ctrl+X se sale pero preguntará si queremos grabar el fichero con el mismo nombre, le decimos que sí

Finalmente ejecutamos motion con esta orden

sudo motion

Si queremos que se ejecute de forma automática cuando arranque la raspberrypi editamos el fichero /etc/rc.local y al final le ponemos esa instrucción. Es decir

sudo nano /etc/rc.local y añadimos sudo motion al final (he puesto un comentario mi script optativo)

image-1648026975944.jpg

¿Cómo se ve desde la red local?

Pues abrimos un navegador y ponemos la dirección a través del puerto que le hemos dicho en stream_port o sea 8081

http://---LA-DIRECCION-DE-LA-RASPBERRY--:8081

es decir si la dirección es 192.168.1.25 entonces tecleamos http://192.168.1.25:8081

Si queremos un protocolo seguro https mirar esta página

¿Y desde Internet?

Opción instalar un nuevo servicio

No se puede hacer gráficamente en la página Remote.it no sabemos por qué. Hay que hacerlo con comandos con SSH.

sudo remoteit add -h

Nos sale una lista de servicios que podemos añadir, tecleamos el ID del servicio que queremos añadir en este caso vemos en la figura que el 7 es HTTP.

Nos pide el puerto, ponemos 8081 el mismo que en Motion

Un nombre para el servicio, le hemos puesto webcam, y hecho lo que tienes que hacer en la Raspberry.

image-1648027047268.jpg

Entramos ahora en un ordenador a remote.it en nuestros "Devices" y pinchamos en el servicio que hemos creado:

image-1648027054061.jpg

Y automáticamente nos abre el navegador con la webcam funcionando

image-1648027070952.jpg

image-1648027074434.gif

Imagen de Gifer

Vale, pero .. ¿y cómo se quita un servicio de Remoteit?

Entramos en al página web en el device en cuestión

image-1648027096098.jpg

Y copiamos el ID del servicio que queremos borrar:

image-1648027112867.jpg

Y ejecutamos la orden sudo remoteit remove --id y la ID que queremos borrar es decir en mi caso :

sudo remoteit remove --id 80:00:00:00:01:0A:18:DF

image-1648027124853.jpg

Opción cutre con VNC

Si lo anterior por alguna razón fallara o remote.it quita el servicio HTTP, puedes ver la cámara por VNC.

Tienes que acceder a la Raspberry desde Internet con VNC mira estos apuntes

Una vez accedido por VNC remotamente podemos abrir el navegador de la misma Raspberry y la IP de él mismo es 127.0.0.1 luego abrir

http://127.0.0.1:8081

ojo en el navegador de la Raspberry no en tu ordenador.

 

Proyecto final

Proyecto final

9 PROYECTO FINAL

Para finalizar, vamos a JUNTAR las piezas y hacer nuestro rover un verdadero explorador espacial !! bueno, al menos en lo principal:

Fotomontaje nasa.gov Credits NASA

Con tu creatividad y con las diferentes piezas que hemos visto puedes hacer otros proyectos.

En este proyecto queremos simular el funcionamiento real de un rover :

Luego juntamos 3 piezas del puzzle:

Resultado 🛰

... vale, vale, no es Marte 🪐, son los bajos de mi coche aquí en la Tierra 🌍.

¿Cómo se hace?

¿Te atreves?

Fichero BajosCoche.py

import RPi.GPIO as GPIO
import time

from VARIABLES import *

import BRAZO
import MOVIMIENTOS
import MOVIMIENTOSPASO


velR=30
numR=10
velL=30
numL=10

angulox=90
anguloz=90
incremento=20
print("Teclas 8 y 2 SERVOX\n Teclas 4 y 6 SERVOZ")
print ('TECLAS ¡en minúscula!:\nADELANTE=FORDWARD = f\nATRAS=BACKWARD = b\nDERECHA=RIGHT = r\nIZQUIERDA=LEFT = l')
tecla='x'

print ('Mira la cámara en http://192.168.1.25:8080')

while True:
    BRAZO.ANGULO(angulox,1)
    BRAZO.ANGULO(anguloz,0)
    tecla=input("Mueve el brazo o movimiento: ")
    if (tecla=="8"):
        angulox=angulox-incremento
    if (tecla=="2"):
        angulox=angulox+incremento
    if (tecla=="4"):
        anguloz=anguloz+incremento
    if (tecla=="6"):
        anguloz=anguloz-incremento
    if tecla=='f':
        print ('\nadelante')
        MOVIMIENTOSPASO.BOTH(velR,numR,velL,numL)
    if tecla=='b':
        print ('\natrás')
        MOVIMIENTOSPASO.BOTH(velR,-numR,velL,-numL)
    if tecla=='r':
        print ('\nderecha')
        MOVIMIENTOSPASO.BOTH(velR,-numR,velL,numL)
    if tecla=='l':
        print ('\nizquierda')
        MOVIMIENTOSPASO.BOTH(velR,numR,velL,-numL)

 

Grupo Robotica Educativa Aragon

Toda la información aquí. 

Guía orientativa

Tenemos un grupo Telegram Robótica Educativa en Aragón, https://t.me/roboticaeducativaaragon

Muro

https://padlet.com/CATEDU/alphabot

Hecho con Padlet

Créditos

Autoría: Javier Quintana Peiró

Cualquier observación o detección de error en soporte.catedu.es

Los contenidos se distribuyen bajo licencia Creative Commons tipo BY-NC-SA excepto en los párrafos que se indique lo contrario.

image-1648462225402.gif

image-1648462299882.png

image-1648462361893.png