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](https://bricolabs.cc/wiki/guias/reciclando_baterias_de_portatil_recuperando_baterias_18650)
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:
### 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.](http://bateriasdelitio.net/?p=130)**.
### 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](https://www.bateriasdelitio.net/?p=54).
**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
# 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í](https://www.waveshare.com/w/upload/8/80/AlphaBot-Assembly-Diagram.pdf)
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:
- Parte delantera: La que tiene la cámara.
- Parte trasera la que tiene el siguelíneas.
## 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](https://giphy.com/gifs/starwars-3o7abrH8o4HMgEAV9e)
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:
# 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**](https://catedu.github.io/raspberry-muy-basico/). Concrétamente el [capítulo 3](https://catedu.github.io/raspberry-muy-basico/3-raspbian.html) 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](https://catedu.github.io/raspberry-muy-basico/11-conectando-desde-internet/112-instalar-remoteit-en-la-raspberry.html)
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](https://catedu.github.io/raspberry-muy-basico/4-primera-comunicacion.html).
3. OPCIONAL : COMUNICACIÓN VIA TEXTUAL Es interesante y útil [comunicarte con la Raspberry via texto por SSH](https://catedu.github.io/raspberry-muy-basico/5-ssh.html), [cambiar el usuario, contraseña](https://catedu.github.io/raspberry-muy-basico/6-cambiar-usuario-y-contrasena.html), y [aprender a apagar por comando](https://catedu.github.io/raspberry-muy-basico/7-apagar.html).
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](https://catedu.github.io/raspberry-muy-basico/8-vnc.html).
## ¿Cómo ejecuto un programa?
Vía [VNC de forma gráfica](https://catedu.github.io/raspberry-muy-basico/8-vnc.html), 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.
![]()[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1647866562689.png)
También se puede hacer de forma textual con el [protocolo SSH](https://catedu.github.io/raspberry-muy-basico/5-ssh.html) 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](https://catedu.github.io/raspberry-muy-basico/11-conectando-desde-internet.html) 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](https://retina.elpais.com/retina/2020/10/20/innovacion/1603209140_262809.html).
[De NASA/JPL/Cornell University, Maas Digital LLC](http://photojournal.jpl.nasa.gov/catalog/PIA04413), [Dominio público](https://commons.wikimedia.org/w/index.php?curid=565283)
# 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](https://twitter.com/hashtag/LaVi%C3%B1etaEcon%C3%B3mica?src=hash&ref_src=twsrc%5Etfw) de [\#ElDespertarLiberal](https://twitter.com/hashtag/ElDespertarLiberal?src=hash&ref_src=twsrc%5Etfw) de [@MasDeUno](https://twitter.com/MasDeUno?ref_src=twsrc%5Etfw) con [@carlos\_\_alsina](https://twitter.com/carlos__alsina?ref_src=twsrc%5Etfw) en [@OndaCero\_es](https://twitter.com/OndaCero_es?ref_src=twsrc%5Etfw) [\#Buenísima](https://twitter.com/hashtag/Buen%C3%ADsima?src=hash&ref_src=twsrc%5Etfw) - [@HUMORJMNIETO](https://twitter.com/HUMORJMNIETO?ref_src=twsrc%5Etfw) en [@abc\_es](https://twitter.com/abc_es?ref_src=twsrc%5Etfw) [pic.twitter.com/GYpRgBETPi](https://t.co/GYpRgBETPi)
>
> — Carlos Rodríguez Braun (@rodriguezbraun) [March 8, 2021](https://twitter.com/rodriguezbraun/status/1368818048161964032?ref_src=twsrc%5Etfw)
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](https://github.com/JavierQuintana/AlphabotPython/) 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**:
# 1.6 GPIO
Vamos a recordar lo que vimos [aquí](https://catedu.github.io/raspberry-muy-basico/2-gpio.html), dos cosas:
- Estos son los pines GPIO con la numeración BCM:
- Están diseñados para 3.3V sólo proporcionan 3mA cada pin luego NO conectes diréctamente componentes de 5V ni que consuman más corriente o de lo contrario ESTROPEARÁS LA RASPBERRY DE FORMA IRREVERSIBLE, o sea, directamente sólo LEDs con una resistencia de mínimo 1.1K tal [y como vimos aqui](https://catedu.github.io/raspberry-muy-basico/2-gpio.html), todo lo demás a través de chips drivers, por eso utilizamos este kit comercial.
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:
```shell
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
```Python
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](https://www.waveshare.com/w/upload/b/b1/AlphaBot_Schematic.pdf) y en P4 (pin 7 real del conector RPI1) no hay nada conectado.
# 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](https://catedu.github.io/programa-arduino-mediante-codigo/un_caso_especial_seales_pwm.html)) 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:
```Python
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.
# 1.8 Kit de prestamo
Si haces el curso, está disponible este préstamo para que lo puedas hacer: 
# 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](https://giphy.com/gifs/PoTqqMdi36IGA/html5)
# 2.1 Motores
Vamos a empezar por la parte importante de un rover:
[NASA/JPL-Caltech](https://mars.nasa.gov/resources/25691/perseverance-wiggles-a-wheel/)
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:
```Python
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:
```Python
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](https://catedu.github.io/raspberry-muy-basico/2-gpio.html)) 
## 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:
```Python
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)
```
# 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](https://github.com/JavierQuintana/AlphabotPython/)
---
```Python
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)
```
# 2.3 Libreria MOVIMIENTOS.py
Para simplificar nuestros programas podemos hacer una librería propia.
Esta librería la vamos a llamar **[MOVIMIENTOS.py](https://github.com/JavierQuintana/AlphabotPython/)** y su contenido sería lo visto en las páginas anteriores, añadiendo las variables definidas en **VARIABLES.py**:
```Python
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)
```
# 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](https://spaceplace.nasa.gov/mars-sojourner/sp/)*
Unos movimientos delante, atrás, derecha, izquierda y paro utilizando la librería anterior:
## Solución
- Ponemos el fichero MOVIMIENTOS.py [que hemos visto](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/23-libreria-movimientospy "2.3 Libreria MOVIMIENTOS.py") en la misma carpeta que vamos a crear este programa.
- En este programa importamos la librería de MOVIMIENTOS.py.
- Vamos llamando a las distintas funciones de movimientos, fijamos la velocidad al 50%, insertando entre ellas un tiempo de retraso de la librería time de 1 segundo.
¿Te atreves? Sino, mira la solución:
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1647867821028.png)
Fichero [2-6-Baile.py](https://github.com/JavierQuintana/AlphabotPython/)
# 2.5 Movimientos con tecla
Ahora vamos a hacer lo mismo, pero gobernado por el teclado:
- PARAR = tecla ESPACIO
- ADELANTE=FORDWARD = f
- ATRAS=BACKWARD = b
- DERECHA=RIGHT = r
- IZQUIERDA=LEFT = l
### Solución
- Ponemos el fichero MOVIMIENTOS.py [que hemos visto](https://libros.catedu.es/link/5730) en la misma carpeta que vamos a crear este programa.
- En este programa importamos la librería de MOVIMIENTOS.py.
- Vamos llamando a las distintas funciones de movimientos según la tecla pulsada, fijamos la velocidad al 30% para que nos de tiempo de gobernarlo, por pantalla va saliendo el mensaje del estado.
- Todo dentro de un bucle de manera que si pulsamos la tecla espacio sale del buble no sin antes parar el robot.
¿Te atreves a hacerlo tú solo? Venga!! no le des tantas vueltas
[From Gifer](https://gifer.com/en/6ZTm)
Sino, mira la solución:
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1647868576174.png)
Fichero [2-7-Movimientos-Teclas.py](https://github.com/JavierQuintana/AlphabotPython/blob/master/Movimientos-tecla.py)
# 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](https://mars.nasa.gov/)
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.
# 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 +](https://catedu.github.io/programa-arduino-mediante-codigo/resistencias_pullup_y_pulldown.html) 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](https://libros.catedu.es/link/5724) :
 
# 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](https://github.com/JavierQuintana/AlphabotPython/)
El programa es el siguiente:
```Python
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](https://github.com/JavierQuintana/AlphabotPython/)
```Python
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 (contador0):
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
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:
- Derecha GPIO 16
- Izquierda GPIO 19
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.
# 4.2 Test
Ejecutamos este pequeño programa:
Fichero [4-2-TestObstaculoIR.py](https://github.com/JavierQuintana/AlphabotPython/)
```cpp+lineNumbers:true
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:
# 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)
```
# 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!
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1647950337501.gif)
[Space Science Animation by European Space Agency ESA](https://www.pinterest.es/pin/490188740691582716/)
#### Solución
La solución no es única, una propuesta es hacerlo con las librerías que hemos aprendido:
- Ponemos las librerías fichero [MOVIMIENTOS.py](https://catedu.github.io/rover-marciano-alphabot/24-libreria-movimientospy.html) y [MOVIMIENTOSPASO.py](https://catedu.github.io/rover-marciano-alphabot/34-movimientospasopy.html) 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**
- Si no detecta nada, que sigua hacia delante.
- Si detecta algo, según los dos o uno, que de unos pasos atrás y que gire.
Ahora ya nuestro rover puede salir libre a recoger piedrecitas:
Fichero [Roomba.py](https://github.com/JavierQuintana/AlphabotPython/)
```Python
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)
```
# 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](https://catedu.github.io/programa-arduino-mediante-codigo/sensor_de_ultrasonidos.html) 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](https://www.seeedstudio.com/Grove-Ultrasonic-Ranger-p-960.html):
CHAPUZA : No tiene su [orden standard GND-Vcc-DATA1-DATA2](http://wiki.seeedstudio.com/Grove_System/) 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:
- Echo en el GPIO 5
- Trigger en el GPIO 17
Por lo tanto, viendo la teoría, una posible función en código Python para utilizarlo sería:
- Emitir un pulso alto por TRIG durante 15 microsegundos.
- Esperar el pulso alto de ECHO
- Cronometrar el pulso alto de ECHO
- La distancia será velocidad por tiempo o sea: la diferencia el tiempo del pulso ECHO multiplicado por la velocidad del sonido y dividido por 2 pues es el recorrido del sonido ida y vuelta.
```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
# 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](https://www.zmescience.com/space/china-rover-moon-02022016/)
# 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](https://www.flaticon.es/)
Con los rovers lunares no se utilizaron orbitadores, a pesar de que [existieron. pero se diseñaron para tomar fotos](https://es.wikipedia.org/wiki/Programa_Lunar_Orbiter). Los **Lunojods** se comunicaban diréctamente, y con los **Yutus** como estaban en la cara oculta de la luna, se utilizó [Queqiao](https://es.wikipedia.org/wiki/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](http://www.planetary.org/multimedia/space-images/charts/change-4-mission-profile.html), [CC BY-SA 3.0](https://commons.wikimedia.org/w/index.php?curid=74914690)
## 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](https://tinyurl.com/antenarover) ) 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](https://www.flaticon.es/)
### 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
# 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:
# 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:
```Python
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](https://libros.catedu.es/books/robotica-con-raspberry-y-python-alphabot/page/51-nec "5.1 NEC") y lo hemos sacado del código demo de la página [https://www.waveshare.com/wiki/AlphaBot](https://www.waveshare.com/wiki/AlphaBot) :
```Python
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<
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
# 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*:
- PARAR = tecla 5
- ADELANTE=FORDWARD = 8
- ATRAS=BACKWARD = 2
- DERECHA=RIGHT = 6
- IZQUIERDA=LEFT = 4
#### Solución
La solución es fácil con las librerías que hemos aprendido:
- Ponemos las librerías fichero [MOVIMIENTOS.py](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/24-baile "2.4 Baile") y ahora esta nueva [NEC.py](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/51-nec "5.1 NEC") 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**
- Utilizaremos los códigos que hemos optenido en [Test Control Remoto IR.](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/53-test-control-remoto-ir "5.3 Test Control Remoto IR")
- Un bucle, si no detecta la tecla 5 que haga los movimientos según las teclas del mando IR.
Fichero [Control-Remoto-IR.py](https://github.com/JavierQuintana/AlphabotPython/)
```Python
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
# 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](https://www.popularmechanics.com/space/g2874/nasa-giphy-page/)
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](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/4-sensor-obstaculos-ir "4 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.
# 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](https://www.waveshare.com/w/upload/b/b1/AlphaBot_Schematic.pdf):
## ¿Cómo está conectado con GPIO?
Pues con estos números:
- CS en GPIO 5
- Clock en GPIO 25
- Address en GPIO 24
- DataOut en GPIO 23
## ¿Cómo funciona este chip?
Pues léete [su manual de instrucciones](https://www.ti.com/lit/ds/symlink/tlc1543.pdf) 🥱🥱😴 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](https://www.ti.com/lit/ds/symlink/tlc1543.pdf)*
- Los 4 primeros pulsos de reloj por flanco de subida leen ADDRESS: B3 B2 B1 y B0 mientras tanto por DATAOUT está sacando los valores A9..A0 definido en una anterior ADDRESS que no vemos (los 10 primeros pulsos de CLOCK no tiene sentido esos valores de DOUT).
- Los rayados significan que igual da lo que haya pues no lo lee. Por ejemplo entre el pulso 5 y 10 del rejoj, no se está leyendo ADDRESS.
- Si te fijas, en los siguientes 10 pulsos de CLOCK (sólo aparece el primer pulso) ya empieza a salir por DATAOUT los valores del sensor definidos en ADDRESS como B3B2B1B0.
- Entre 10 pulsos de reloj y los otros 10 se necesita un tiempo de conversión A/D Conversion interval.
# 6.3 TLC1543.py y VARIABLES.py
Tal y como hemos visto en la [teoría del TLC1543 ¿Cómo está conectado?](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/62-tlc1543 "6.2 TLC1543") añadimos estas líneas al archivo **VARIABLES.py**
```Python
##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?](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/62-tlc1543) tenemos que obtener el bit de una posición dada de un número dado. [Aquí](https://repl.it/@javierquintana/ObtenerBitEntero) 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?](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/62-tlc1543) podemos hacer una librería que tenga una función **SENSORLINEA(cual)** que nos devuelva el valor que lee el sensor *cual*:
- Importamos las variables de **VARIABLES.py**
- Luego realizamos una función **SACADIRECCION** que active la salida ADDRESS según sus bits basándonos en la función **Damebit** que hemos visto.
- Activamos 4 golpes de reloj sacando la dirección **ADDRESS** con la función SACADIRECCION
- Hacemos 6 pulsos de **CLOCK** perdidos
- Hacemos 10 pulsos de CLOCK pero leyendo el valor **DATAOUT** y convirtiendo esos bits en un número decimal, ese será el valor que devolverá la función **SENSORLINEA(cual)**
- Grabamos esto en un archivo TLC1543.py
```Python
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<
¿Te atreves?:
Fichero [Testsiguelineas.py](https://github.com/JavierQuintana/AlphabotPython/)
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648026168581.png)
# 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?
- Leemos la lectura de los 5 sensores
- Ajustamos la velocidad de los motores según si hay lectura de línea negra y donde
- La potencia PWM no puede pasar de 0 a 100 por eso limitamos los valores
- Si no hay linea negra que vuelva hasta que recupera la línea negra:
Fichero [Siguelineas.py](https://github.com/JavierQuintana/AlphabotPython/)
```Python
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 ](https://www.waveshare.com/wiki/AlphaBot)lleva el software para hacerlo.
### 🐓🐓 No seas gallina !! 🐓🐓 Pruébalo.
- Cambia el código anterior las marchas es decir los GPIO.output de los motores, pon los HIGH por LOW y viceversa
- Y también el control de giro, es decir en vez de +incremento pon -incremento y viceversa
- ¿Funciona? ¡¡se vuelve loco !!!
### 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](https://es.wikipedia.org/wiki/Diego_Mar%C3%ADn_Aguilera)** 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](https://commons.wikimedia.org/w/index.php?curid=37026485)
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](https://www.pinterest.es/pin/39899146670679462/)*
Pero... pusieron **el timón delante**, no como **[Diego Marín Aquilera](https://es.wikipedia.org/wiki/Diego_Mar%C3%ADn_Aguilera)** 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](https://commons.wikimedia.org/w/index.php?curid=8602843)*
# 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.](https://catedu.github.io/programa-arduino-mediante-codigo/control_de_servomotores.html).
Los que tiene nuestro rover son más baratos:
Tiene 3 cables:
- Marrón a GND
- Naranja a 5V
- Rojo la señal de control
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:
# 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:
```Python
#### 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 :
```Python
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.
# 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](https://www.amazon.es/WPERSUVV-m%C3%B3dulos-creaci%C3%B3n-prototipos-Raspberry/dp/B07RM3RWSF/ref=sr_1_1_sspa?dchild=1&keywords=laser+diodo+arduino&qid=1615466315&sr=8-1-spons&psc=1&spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUFUWVVaMUQ3WldCSDQmZW5jcnlwdGVkSWQ9QTAzMTIzNTlVNDRRNlE2Wk1OQjQmZW5jcnlwdGVkQWRJZD1BMDIyMjI4NDJEWEtWSFpMWDRPS1gmd2lkZ2V0TmFtZT1zcF9hdGYmYWN0aW9uPWNsaWNrUmVkaXJlY3QmZG9Ob3RMb2dDbGljaz10cnVl), podriamos incluso imitar al vaporizador que esta montado en la Perserverante:
[NASA's Mars Curiosity rover landed on Mars in 2012. NASA/JPL-Caltech](https://mars.nasa.gov/msl/home/)
De momento nos vamos a conformar con hacer esto :
- Teclas 8 y 2 mueven el brazo robot en el eje x arriba y abajo
- Teclas 4 y 6 mueven el brazo robot en el eje z derecha e izquierda.
Fijaremos de antemano un incremento de 10ª cada vez que pulsamos la tecla. Veamoslo con un vídeo:
#### Solución
- Ponemos la librería del fichero BRAZO.py en la misma carpeta que vamos a crear este programa y la incorporamos en el programa con **import**.
- Importamos las variables también con import \* from VARIABLES
- Vamos incrementando los ángulos eje x y eje z según la tecla pulsada.
- Todo dentro de un bucle.
¿Te atreves? :
Fichero [Test-Brazo.py](https://github.com/JavierQuintana/AlphabotPython/)
```Python
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
# 8. Cámara
Los rover llevan más de una cámara:
[The Cameras on the Mars 2020 Perseverance Rover Nasa.gov](https://mars.nasa.gov/mars2020/spacecraft/rover/cameras/)
Nosotros.... una 🎥 😁 la [standard de la Raspberry](https://www.raspberrypi.org/products/camera-module-v2/):
# 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**:
```Python
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](https://www.youtube.com/watch?v=fCTc1sBQwi8) o [este tutorial](https://randomnerdtutorials.com/video-streaming-with-raspberry-pi-camera/) dependes de tener todas las librerías intaladas, por ejemplo *limmal* ...
La segunda opción WEBIOPI ([https://webiopi.trouch.com/](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](https://motion-project.github.io/index.html) .
# 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 ](https://catedu.github.io/raspberry-muy-basico/8-vnc/81-vnc-server.html) 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
```shell
sudo raspi-config
```
entra en la opción 5
Y activas la cámara y Remote SSH en las opciones P1 y P8 :
# 8.3 Motion
Vamos a ver lo que sale por la cámara de forma remota :
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648026812597.gif)
[Imagen de Gifer](https://gifer.com/en/Cfg)
# 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](https://sites.google.com/view/javierquintana/raspberry/alarma?authuser=0)
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648026877485.png)
[Parent detector](https://projects.raspberrypi.org/en/projects/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í](https://motion-project.github.io/motion_config.html)
## Cómo hacerlo
Abrimos una ventana de comandos, en SSH, [ya sabes cómo](https://catedu.github.io/raspberry-muy-basico/5-ssh.html) o en el mismo VNC de forma gráfica abre la ventana de comandos, y ejecutamos estas órdenes:
Instalamos MOTION :
```shell
sudo apt-get install motion
```
Editamos el fichero de configuración motion.conf con el editor nano
```shell
sudo nano /etc/motion/motion.conf
```
Buscamos estas líneas y las modificamos :
- stream\_localhost on lo cambiamos por off [si es on sólo localhost puede abrirlo, si es off pueden todos](https://raspberrypi.stackexchange.com/questions/108419/stream-raspberry-pi-camera-on-web-page):
- **stream\_localhost off**
- si vemos #stream\_port 8081 y como queremos abrirlo por ese puerto, le quitamos el hastag, o sea lo dejamos así,:
- **stream\_port 8081**
- Si vemos daemon off lo cambiamos por
- **daemon on**
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](https://raspberryparatorpes.net/instalacion/conectar-una-webcam-con-motion-en-raspberry-pi/) 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
```shell
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)
[](https://libros.catedu.es/uploads/images/gallery/2022-03/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](https://raspberrypi.stackexchange.com/questions/107868/motion-security/107872#107872)
## ¿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.
```shell
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.
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648027047268.jpg)
Entramos ahora en un ordenador a remote.it en nuestros "Devices" y pinchamos en el servicio que hemos creado:
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648027054061.jpg)
Y automáticamente nos abre el navegador con la webcam funcionando
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648027070952.jpg)
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648027074434.gif)
[Imagen de Gifer](https://gifer.com/en/Cfg)
### Vale, pero .. ¿y cómo se quita un servicio de Remoteit?
Entramos en al página web en el device en cuestión
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648027096098.jpg)
Y copiamos el ID del servicio que queremos borrar:
[](https://libros.catedu.es/uploads/images/gallery/2022-03/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
[](https://libros.catedu.es/uploads/images/gallery/2022-03/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](https://catedu.github.io/raspberry-muy-basico/11-conectando-desde-internet.html)
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
# 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](https://www.nasa.gov/press-release/la-nasa-ofrecer-una-retransmisi-n-en-espa-ol-para-el-aterrizaje-del-rover-mars)*
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 :
- Mover de forma remota el rover controlando paso a paso su posición.
- Mover el brazo robótico
- Ver la cámara
Luego juntamos 3 piezas del puzzle:
- [Movimientos paso a paso con las teclas](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/35-movimientos-con-paso "3.5 Movimientos con paso")
- [Movimiento brazo robótico](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/72-test-brazo "7.2 Test Brazo")
- [Cámara](https://libros.catedu.es/books/rover-marciano-alphabot-rasbperry-y-python/page/8-camara "8. Cámara")
## Resultado 🛰
... vale, vale, no es Marte 🪐, son los bajos de mi coche aquí en la Tierra 🌍.
## ¿Cómo se hace?
¿Te atreves?
- El proyecto es fácil pues es la unión de [Movimientos paso a paso con las teclas](https://libros.catedu.es/35-m2-movimientos-con-paso.md) y [Movimiento brazo robótico](https://libros.catedu.es/6-servos/72-test-brazo.md)
- Ver la cámara no implica ningún código Python especial, si está bien configurado, sólo es abrir una pantalla de tu navegador con la dirección URL adecuada.
Fichero [BajosCoche.py](https://github.com/JavierQuintana/AlphabotPython/)
```Python
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í](https://libros.catedu.es/books/robotica).
Guía orientativa
Tenemos un **grupo Telegram Robótica Educativa en Aragón**, [https://t.me/roboticaeducativaaragon](https://t.me/roboticaeducativaaragon)
[](https://padlet.com?ref=embed)
# Créditos
**Autoría:** Javier Quintana Peiró
Cualquier observación o detección de error en [soporte.catedu.es](https://catedu.es/soporte-catedu/)
Los contenidos se distribuyen bajo licencia **Creative Commons** tipo **BY-NC-SA** excepto en los párrafos que se indique lo contrario.
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648462225402.gif)
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648462299882.png)
[](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648462361893.png)