Arduino ALVIK


Introducción

Introducción

Qué es Arduino Alvik

3-411-796-2950742771.png

SOFTWARE                                                                                                                           

Tienes dos opciones para programar Arduino Alvik :

Utiliza ArduinoIDE si ya trabajas en el aula con este lenguaje, sino, te aconsejamos Micropyhon o mBlock

👁️👁️Cambiar de una opción a otra implica resetear el Bootloader.

🫵  Es mejor que te decidas qué opción quieres, opción A o B   🫵

2024-07-11 20_01_25-Microsoft PowerPoint - [Presentación1].png

HARDWARE                                                                                                                  

Es un robot con las siguientes características :

prj-00-robot-illustration.webp

prj-00-components.webp

AMPLIACIONES                                                                                                                  

Dispone de las siguientes conexiones

datasheet_connectors.png

En este curso lo utilizaremos para unir un servo

Además tiene uniones compatibles con piezas de construcción LEGO

423403-5-1000x1000.jpg

Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

PROGRAMAS PREDEFINIDOS                                                                                                         

Al arrancar ALVIK con el firmware que veremos en Python y mBlock da la posibilidad de ejecutar 3 programas predefinidos :

select-examples.gif

Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

CURIOSIDADES                                                                                                                  

A diferencia del típico sensor a distancia SR-04 que funciona por ultrasonidos, el VL53L7CX es mucho más complejo, va por luz (no realiza imágenes, sino por difracción de la luz por lo tanto respeta la privacidad) y nos proporciona muchas más información, la API que veremos nos da 5 distancias en distintas direcciones.

Introducción

Pensamiento computacional

¿Dónde se sitúa el Arduino Alvik dentro de la oferta de robótica? Como puedes ver en esta presentación, se sitúa dentro de los robots que se programan con código por lo tanto para un perfil de secundaria

Guía orientativa

Tenemos un grupo Telegram Robótica Educativa en Aragón, si estás interesado en unirte, envía un mensaje por Telegram (obligatorio) a CATEDU 623197587 https://t.me/catedu_es y te añadimos en el grupo

Micropython

Micropython

Preparar ALVIK para MicroPython: Actualizar el firmware de Alvik

Actualizar el firmware significa que nuestro Alvik le instalamos el interpretador de micropython y por lo tanto podremos:
- Programar en código con Python
- Programar en bloques con mBlock

Si ya tiene el firmware puedes saltarte esta página

Con este firmware no podemos programar con Arduino IDE

Antes de nada enciende el Alvik con esta precaución :

Primero nos aseguramos que el Alvik este APAGADO antes de conectarlo con el PC 
en caso contrario se puede perjudicar la bateríarobot-off.png
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Luego lo conectamos por cableconnecting-final.gif
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Y ahora ya podemos encender nuestro Alvik
alvik-on.png
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Actualizamos el FIRMWARE

Esto lo hacemos una vez, entramos en https://alvikupdate.arduino.cc/ damos a conectar y luego updated (si no sabes qué puerto es, desconecta y conecta y te fijas cual aparece)

Puede tardar varios ciclos, paciencia

2025-03-28 10_18_52-Arduino® Alvik Updater 🤖.png

Asegúrate de tener el ALVIK encendido

Hasta que sale esta pantalla de éxito

2025-03-26 11_59_36-Arduino® Alvik Updater 🤖.png

ATENCIÓN ¿Y SI DA PROBLEMAS?

Por ejemplo se ha quedado enganchado, lo has desconectado antes de hora... entonces la solución pasa pro utilizar un flasheador más potente

MicroPython Installer

Descargamos el programa y ejecutamos teniendo conectado el ESP32 del Alvik, (no hace falta encender el robot, pues sólo trabajamos con el ESP32) lo detecta y simplemente le damos a Instalar Micropython dentro del chip

Descargable en https://labs.arduino.cc/en/labs/micropython-installer

2024-07-04 19_17_33-MicroPython Installer.png

Si sigue puñetero y no detecta el Arduino Nano ESP32 tendrás que ponerlo en modo Bootoloader, haz los pasos 1, 2  y 3 de https://libros.catedu.es/books/arduino-alvik/page/preparar-alvik-para-arduino-ide-modo-bootloader  y vuelve a intentarlo con el MicroPython Installer

Al acabar de instalar, sale este mensaje :

2025-03-28 10_15_55-MicroPython Installer.png

Aconsejamos apagar y desconectar totalmente y volver a conectar (acuérdate que no hay que conectar el ALVIK en el PC con el ALVIK encendido, lo conectas con el PC apagado y luego lo enciendes, tal y como dice arriba del todo)

Entramos en https://alvikupdate.arduino.cc/ damos a conectar y luego updated (si no sabes qué puerto es, desconecta y conecta y te fijas cual aparece)

AQUÍ VA A TARDAR VARIOS, VARIOS CICLOS, paciencia, paciencia

2025-03-28 10_18_52-Arduino® Alvik Updater 🤖.png

Asegúrate de tener el ALVIK encendido

Hasta que sale esta pantalla de éxito

2025-03-26 11_59_36-Arduino® Alvik Updater 🤖.png

Micropython

Instalar Micropython

Conceptos previos:
- Los lenguajes de alto nivel, es decir el código, que es entendible por los humanos (C++, Java, Python...) son textos que se tienen que traducir al lenguaje entendible por el procesador MCU (Micro Controler Unit). Este lenguaje de bajo nivel que está escrito en binario  es difícil de entender para los humanos
- El Compilador es un programa que Interpreta este texto de lenguaje de alto nivel, y lo convierte en lenguaje de bajo nivel
- El Arduino Alvik se puede programar con Arduino IDE como con Micropytno, los dos son de alto nivel

Tanto Micropython como Arduino IDE son lenguajes de tipo CODIGO por lo tanto sólo se aconseja EN SECUNDARIA
Cuando permita lenguaje tipo BLOQUES como Scratch, ya será adecuado para PRIMARIA

¿Dónde se compila Micropython?

Como puedes ver en este vídeo en 21:20 Python se compila dentro del microcontrolador es decir, dentro del ESP32. A diferencia con otros lenguajes, como el C++, el ordenador tiene el compilador, y se lo da ya en binario.
2024-07-04 18_44_27-(1) Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.png
Fuente  vídeo Exploring the Arduino Nano ESP32 | MicroPython & IoT

¿Y a mi qué más me da?

Pues sí que importa....

Si programas ESP32 con Arduino IDE o Arduino Cloud (que está basado en C++) te has cargado el compilador Python que has puesto en "Actualizar firmware" del ESP32 luego si quieres programar en Python, tienes que volver a  "Actualizar firmware" 

¿Y con esto ya puedo crear mis programas con Micropython?

No, con esto tienes el compilador interpretador dentro del chip, pero necesitas un editor en tu PC y que se comunique con el Micropython del chip

Arduino Lab for Micropython

Tal y como dice la página https://docs.arduino.cc/micropython/ hay dos editores para cargar MicroPython en el Arduino Alvik

Nosotros en este curso elegimos Arduino Lab for Micropython por su sencillez y adaptación al Arduino Alvik

Tal y como dice aquí ES UN PROGRAMA PORTABLE, es decir, no hay que instalarlo, simplemente descomprimir y ejecutar

2024-07-04 09_56_30-Arduino Labs.png


Ejecutamos el programa en el lugar donde lo hemos descomprimido (o donde quieras llevarte la carpeta) :

2024-07-04 10_00_12-Arduino.Lab.for.MicroPython-win_x64.png

Primero nos aseguramos que el Alvik este APAGADO antes de conectarlo con el PC 
en caso contrario se puede perjudicar la bateríarobot-off.png
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Luego lo conectamos por cableconnecting-final.gif
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Y ahora ya podemos encender nuestro Alvik
alvik-on.png
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Al ejecutar el programa, vemos:

  1. Botón para conectar la placa
  2. Ejecutar o para el programa
  3. Gestor de fichero
  4. Donde escribimos el programa
  5. Ventana de estado

IDEOverview.png
Licencia CC-BYSA Fuente https://docs.arduino.cc/micropython/environment/code-editor/

En el gestor de ficheros encontramos

  1. Los archivos que hay en la placa:  Puedes ver y administrar scripts o datos guardados directamente en la placa.
  2. Los archivos que hay en tu equipo: lo que le permite seleccionar y administrar archivos para cargar o descargar.
  3. Descargar/Subir archivos: Utiliza esta opción para transferir archivos entre su equipo y la placa. Puedea cargar nuevos scripts o descargar registros de datos de su placa.
  4. Crear archivo/carpeta: Esta opción le permite crear nuevos archivos o carpetas directamente en la placa o en el directorio de su proyecto, lo que facilita la organización de su código y recursos.

IDEFileManager.pngLicencia CC-BYSA Fuente https://docs.arduino.cc/micropython/environment/code-editor/

Micropython

Hola mundo

Vamos a comenzar con nuestro primer programa en Arduino Lab for MicroPython, el clásico Hola mundo ponemos este programa:

from time import sleep

print("Hola mundo, soy un robot que me gusta chatear, ¿cual es tu nombre? ")
student_name = input("Tu nombre : ")
print("Mucho gusto , " + student_name + "! ¿ Cómo quieres llamarme?")
robot_name = input("Mi nombre ? : ")

print(f"{robot_name} es un fantástico nombre. Ya me siento un poco más humano.")

sleep(2) # Use sleep() to make interaction feel more natural
print(f"Okay, {student_name}, voy a ponerte a prueba:")
sleep(2)
print("¿ Has oido hablar que puedo nadar ?")
sleep(4)
print("Je je, es broma..... :D")
sleep(5)

Adaptado de  https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Pulsamos a conectar, nos pregunta por el puerto

2024-06-14 23_20_41-Arduino Lab for MicroPython.png

Runeamos y vamos contestando a sus preguntas

2024-06-14 23_22_58-Arduino Lab for MicroPython.png

Micropython

Empezando MicroPython de Alvik

Inspirado en el esquema del tutorial MicroPython Basics autora Francesca Sanfilippo & Karl Söderby

Hemos visto la función print visualiza un mensaje en la cónsola :

print('Hola mundo !')

Podemos introducir una variable, frase que contenga el texto, la función time.sleep(segundos) que hace una pausa, (para utilizar esta función se necesita importar la librería time con import time ) y dentro de un bucle while que se ejecuta mientras sea verdadero lo que le sigue, en este caso while True se ejecutará siempre:

import time    
frase = "Hola mundo !!"
 
while True:
   print(frase)   
   time.sleep(1)

Aquí se utiliza

import time

frase = "Hola mundo "
contador = 0

def funcion_contar():
    global contador
    contador = contador + 1

while True:
    funcion_contar()
    print(frase, contador)
    time.sleep(1)

El resultado:

2024-06-15 07_32_00-Arduino Lab for MicroPython.png

Aquí utilizamos el condicional if  con su auxiliar  else y la función exit para acabar el programa:

import time

frase = "Hola mundo "
contador = 0
maximo = 20

def funcion_contar():
    global contador
    contador = contador + 1

while True:
    funcion_contar()
    if contador>20 :
      exit
    else :
      print(frase, contador)
      time.sleep(1)

Lo que provoca que a los 20 finalice 

2024-06-15 07_44_37-Arduino Lab for MicroPython.png

Podemos usar en vez de variables numéricas, variables tipo array para los bucles :

Catedu = ['Javier', 'Santiago', 'Silvia', 'Berta', 'Cristina', 'Nacho', 'Arturo', 'Chefo', 'Vladi', 'Ruben', 'Pablo', 'JuanFran']

def printCatedus():
    for persona in Catedu:
        print(persona)

printCatedus()

2024-06-15 07_51_00-Arduino Lab for MicroPython.png

Con esto ya podemos avanzar, pero si quieres


Micropython

Introducción al Python

Página extraída de Federico Coca Guia de Trabajo de Microbit CC-BY-SA

Palabras reservadas

Son palabras reservadas que tienen un significado especial para el compilador y que no podemos usar para poner nombres a variables o funciones. Todas las palabras, excepto True, False y None se escriben en minúsculas. A continuación se da un listado de todas las palabras reservadas o keywords:

False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

El listado al principio nos puede resultar abrumador, pero imaginemos un lenguaje con tan solo esas palabras y entenderemos que no resultará tan complejo familiarizarse, al menos con las mas usuales.

Identificadores

Los identificadores son los nombres que se dan a variables, clases, métodos, etc. No podemos usar palabras reservadas para estos nombres.

Algunas reglas que nos pueden resultar útiles para nombrar identificadores son:

Nos va a resultar muy útil recordar lo siguiente:

Variables, constantes y literales

Variables

En programación, una variable es un nombre que se utiliza para referirse a una posición de memoria donde se almacena un valor. De forma más abstracta, puede considerarse como una caja que almacena un valor. El nombre de la caja es el nombre de la variable y el contenido su valor. Todas las variables constan de tres partes: un nombre, un tipo de dato y un valor. En la figura siguiente vemos tres variables de distintos tipos:

boxes.pngLicencia CC-BY-SA fuente

La variable name contiene la cadena Bob, la variable winner es cierta y la variable score contiene el valor 35.

Python no dispone de ningún comando para declarar variables. Una variable se crea cuando se le asigna valor por primera vez. La técnica de declarar variables es poner un nombre seguido del signo de asignación (=) y el valor asignado a la variable. En la declaración es importante tener claro que se distinguen mayúsculas de minúsculas y que no están permitidos los caracteres especiales.

En Python no se declara de forma explicita el tipo de la variable pues se trata de un lenguaje inferido. Las variables incluso pueden cambiar de tipo desde el que se establece al asignarle valor la primera vez. Es decir, si declaro valor = 5 inicialmente la variable será de tipo entero (int), pero si en el programa se realizan operaciones que al final hacen que valor = 1.33 ahora valor es de tipo float. Automáticamente sabe que valor es un número entero y declara la variable valor como un int.

Aunque no es necesario si es posible especificar el tipo de dato de una variable, haciendo:

x = str(22) # x será la cadena '22'
y = int(22) # y será el entero 22
z = float(22) # z será el número de coma flotante 22.0

Algunas reglas para nombrar variables que podemos tener en cuenta son:

Constantes

Una constante no es mas que un tipo especial de variable cuyo valor no puede modificarse.

En Python, las constantes suelen declararse y asignarse en un módulo (un nuevo archivo que contiene variables, funciones, etc y que se importa al archivo principal).

Veamos cómo declaramos constantes en un archivo separado y lo usamos en el archivo principal,

Creamos un archivo que nombramos constantes.py y que contendrá:

PI = 3.141592
FUERZA_GRAVEDAD = 9.82

Creamos el archivo principal main.py, que contendrá:

import constantes

print(constantes.PI)
print(constantes.FUERZA_GRAVEDAD)

En el ejemplo creamos el archivo de módulo constantes.py y asignamos el valor constante a PI y FUERZA_GRAVEDAD.

Después, creamos el archivo main.py e importamos el módulo constantes. Finalmente, imprimimos el valor de cada constante.

La convención es nombrarlas en mayúsculas para distinguirlas de las variables.

Literales

Numéricos

Los literales son representaciones de valores fijos en un programa. Pueden ser números, caracteres, cadenas, etc. Por ejemplo, "¡Hola, mundo!", 12, 23.0, "C", etc.

Los literales numéricos son inmutables (no pueden cambiar) y pueden pertenecer a uno de los tres tipos de datos numéricos posibles: Entero, Coma flotante y Complejo. Los tipos son:

Solamente hay dos literales booleanos True y False

Cadenas de caracteres

Los literales de caracteres son caracteres unicode encerrados entre comillas, por ejemplo S. Los literales cadenas de caracteres son cadenas de csaracteres encerradas entre comillas, por ejemplo Python es divertido.

Especiales

En Python existe un literal especial, None. Podemos usarlo, por ejemplo, para especificar una variable nula, por ejemplo:

var = None
print(var)
# El resultado será: None

Tipos de datos en Python

En Python, al igual que en programación en general, los tipos de datos especifican el tipo de datos que puede almacenarse en una variable.

Numéricos

Contienen valores numéricos y sabemos que:

Los tipos básicos de datos son:

Podemos realizar conversión de tipos así:

Cadenas

Contienen secuencias de caracteres. Una cadena es una secuencia de caracteres representada entre comillas simples o dobles.

Las cadenas pueden estar encerradas entre comillas simples ('...') o dobles ("...") con el mismo resultado. Podemos usar para incluir comillas en una cadena.

La función print() devuelve la cadena que encierra entre los paréntesis, omitiendo las comillas que la encierran.

En la imagen siguiente se ven varios ejemplos con cadenas utilizando como editor el IDLE que por defecto se instala con Python y que se abre desde una terminal simplemente invocando a Python.

cad1.png
Federico Coca Guia de Trabajo de Microbit CC-BY-SA

Una cadena raw (cruda) se interpreta tal como se escribe, es decir, se omiten los caracteres especiales expresados con . Las cadenas raw se escriben entrecomilladas y van precedidas del carácter 'r'. En la imagen vemos un ejemplo.

cad2.png
Federico Coca Guia de Trabajo de Microbit CC-BY-SA

Es posible aplicar la operación de multiplicar a textos haciendo que estos se repitan. En la imagen siguientes vemos ejemplos de concatenación y multiplicación, así como un error cometido.

cad3.png
Federico Coca Guia de Trabajo de Microbit CC-BY-SA

Secuencias

Contienen colecciones de datos, como las listas, las tuplas, las colecciones de datos (set) o los diccionarios.

Una lista es una colección ordenada de elementos similares o de distinto tipo separados por comas y encerrados entre corchetes [ ].

Tupla es una secuencia ordenada de elementos, igual que una lista. La única diferencia es que las tuplas son inmutables. Una vez creadas, las tuplas no pueden modificarse. En Python, se utilizan los paréntesis () para almacenar los elementos de una tupla.

Las colecciones de datos son un conjunto desordenada de elementos únicos. Una colección de datos se define por valores separados por comas dentro de llaves { }.

Un diccionario es una colección ordenada de elementos. Almacena los elementos como pares clave/valor. Siendo las claves identificadores únicos que se asocian a cada valor.

Estudiaremos estos últimos tipos mas extensamente cuando los necesitemos.

Los datos de tipo booleano solamente pueden contener True o False.

Dado que en programación Python todo es un objeto, los tipos de datos son en realidad clases y las variables son instancias(objeto) de estas clases.

Comentarios en Python

En los comentarios, pueden incluirse palabras que nos ayuden a identificar además, el subtipo de comentario:

# TODO esto es algo por hacer
# FIXME (arreglarme) esto es algo que debe corregirse
# XXX esto también, es algo que debe corregirse

Identation o sangría en Python

La sangría se refiere a los espacios al comienzo de una línea de código.

Mientras que en otros lenguajes de programación la sangría en el código es solo para facilitar la lectura, la sangría en Python es muy importante ya que se usa para indicar un bloque de código.

if 5 > 2:
    print("Cinco es mayor que 2")

Lo siguiente sería un error de sintaxis.

if 5 > 2:
print("Cinco es mayor que 2")

El número de espacios de la identation puede ser cualquiera siempre que al menos sea un espacio. Siempre hay que usar el mismo número de espacios en el mismo bloque de código.

Operadores en Python

Los operadores son símbolos especiales que realizan operaciones con variables y valores.

A continuación tenemos una lista de los diferentes tipos de operadores de Python:

Operadores aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas como sumas, restas, multiplicaciones, etc.

Operador Descripción Ejemplo
+ Suma o concatenación en textos 5+3=8, "Hola" + "Mundo" = "Hola Mundo
- Diferencia 6-3=3
* Multiplicación 3*3=9
/ División 6/2=3
// Parte entera de un cociente 10//3=3
% Resto de un cociente 10%3=1
** Potenciación 5**2=25
Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a variables.

Operador Descripción Ejemplo
= Asignación x=4, a = a + 1
+= Suma y asignación x+=1 equivale a x = x + 1
-= Diferencia y asignación x-=1 equivale a x = x - 1
*= Multiplicación y asignación x*=3 equivale a x = x * 3
/= División y asignación x/=3 equivale a x = x / 3
%= Asignación de restos x%=3 equivale a x = x % 3
**= Asignación de exponentes x**=3 equivale a x = x ** 3

Operadores de Comparación

Los operadores de comparación comparan dos valores/variables y devuelven un resultado booleano: Verdadero o Falso True o False.

Operador Descripción Ejemplo
== Igual a 2==3 retorna False
!= Distinto de 2!=3 retorna True
< Menor que 2<3 retorna True
> Mayor que 2>3 retorna False
<= Menor o igual que 2<=3 retorna True
>= Mayor o igual que 2>=3 retorna False

Operadores Lógicos

Los operadores lógicos se utilizan para comprobar si una expresión es Verdadera o Falsa. Se utilizan en la toma de decisiones.

Operador Descripción Ejemplo
and AND lógica a and b #True si a y b son ciertos
or OR lógica a or b #True si a o b son ciertos
not NOT lógica not a #True si el operador a es falso

En la figura siguiente vemos un ejemplo con lo que devuelve en cada caso.

logicos.png
Federico Coca Guia de Trabajo de Microbit CC-BY-SA

Operadores Bitwise

Los operadores bit a bit o bitwise actúan sobre los operandos como si fueran cadenas de dígitos binarios. Operan bit a bit, de ahí su nombre.

 

 

Operador Descripción Ejemplo
& AND bit a bit 5&6 # 101 & 110 = 110 = 4
| OR bit a bit 5 \| 6 # 101 \| 110 = 111 = 7
~ NOT bit a bit ~3 # ~011 = 100 = -4
^ XOR bit a bit 5^3 # 101^011 = 110 = 6
<< Desplazamiento izquierda 4<<1 # 100 << 1 = 1000 = 8
>> Desplazamiento derecha 4 >> 1 # 100 >> 1 = 010 = 2
Operadores especiales

El lenguaje Python ofrece algunos tipos especiales de operadores como el operador de identidad (identity) y el operador de pertenencia (membership).

En Python, is e is not se utilizan para comprobar si dos valores se encuentran en la misma parte de la memoria. Dos variables que son iguales no implica que sean idénticas. Algunos ejemplos aclaran mejor lo dicho.

x1 = 5
y1 = 5
x2 = 'Hello'
y2 = 'Hello'

print(x1 is not y1)  # False

print(x2 is y2)  # True

Vemos que x1 e y1 son enteros con los mismos valores, por lo que son iguales e idénticos. Lo mismo ocurre con x2 e y2 (cadenas).

En Python, in y not in son los operadores de pertenencia. Se utilizan para comprobar si un valor o variable se encuentra en una secuencia (cadena, lista, tupla, conjunto y diccionario).

En un diccionario sólo podemos comprobar la presencia de la clave, no del valor.

Micropython

Arduino Alvik API

Para acceder a las funciones de Arduino Alvik API tenemos que ejecutar las instrucciones:

alvik = ArduinoAlvik()
alvik.begin()

Entonces ya podemos usar las siguientes: (extraido de https://docs.arduino.cc/tutorials/alvik/api-overview/ )

Luego veremos en el apartado de programación del Arduino Alvik con código Arduino IDE que utilizaremos una biblioteca #include "Arduino_Alvik.h" que importa prácticamente las mismas funciones, ver https://libros.catedu.es/books/arduino-alvik/page/programas-arduino-ide-sin-iot 

FUNCION con sus Inputs Outputs
stop() para todas las funciones Alvik
is_on() true si esta encendido
false si esta apagado
is_target_reached() true si ha enviado M o R en el mensaje
get_ack() last_ack: el valor del último mensaje
stop() para todas las funciones Alvik
get_orientation() r: valor de balanceo p: valor de cabeceo y: valor de guiñada

get_accelerations()

 

ver uso en
https://libros.catedu.es/books/arduino-alvik/page/programas-de-ejemplo

 ax
ay
az

get_gyros()

ver uso en
https://libros.catedu.es/books/arduino-alvik/page/programas-de-ejemplo

 

 gx
by
gz
get_imu() las 6 anteriores
get_line_sensors()

left
center

right
brake() Frena el robot
get_battery_charge() battery_soc: el % de la batería
get_touch_any() touch_any es true si se ha apretado cualquier botón
get_touch_ok()
get_touch_cancel() 
get_touch_center()
get_touch_up()
get_touch_left()
get_touch_down()
get_touch_right()

touch_ok es true si se ha apretado ok etc...

 

ver ejemplos en

https://libros.catedu.es/books/arduino-alvik/page/robotica-para-infantil

y en 

https://libros.catedu.es/books/arduino-alvik/page/mensajes-a-telegram
get_color_raw()
get_color_label()
 color
get_version()
print_status()

versión del firmware
para actualizarlo ver https://docs.arduino.cc/tutorials/alvik/user-manual/#how-to-upload-firmware

 
set_behaviour(behaviour: int)
rotate(angle: float, unit: str = 'deg', blocking: bool = True)
move(distance: float, unit: str = 'cm', blocking: bool = True)
get_wheels_speed(unit: str = 'rpm') left_wheel_speed: the speed value
right_wheel_speed: the speed value
set_wheels_speed(left_speed: float, right_speed: float, unit: str = 'rpm')
set_wheels_position(left_angle: float, right_angle: float, unit: str = 'deg')
get_wheels_position(unit: str = 'deg') angular_velocity
drive(linear_velocity: float, angular_velocity: float, linear_unit: str = 'cm/s',angular_unit: str = 'deg/s')
get_drive_speed(linear_unit: str = 'cm/s', angular_unit: str = 'deg/s') linear_velocity: speed of the robot.
angular_velocity: speed of the wheels.
reset_pose(x: float, y: float, theta: float, distance_unit: str = 'cm', angle_unit: str = 'deg')
get_pose(distance_unit: str = 'cm', angle_unit: str = 'deg') x
y
theta
set_servo_positions(a_position: int, b_position: int)
set_builtin_led(value: bool)
set_illuminator(value: bool)
color_calibration(background: str = 'white')

rgb2hsv(r: float, g: float, b: float)

 h: hue value
s: saturation value
v: brightness value

get_color(color_format: str = 'rgb')

 r or h
g or s
b or v

hsv2label(h, s, v)

 color label: like "BLACK" or "GREEN", if possible, otherwise return "UNDEFINED"

get_distance(unit: str = 'cm')

 lee la distancia del sensor TOF:
ver ejemplo en https://libros.catedu.es/books/arduino-alvik/page/evita-obstaculos

left_tof: 45° to the left object distance
center_left_tof: 22° to the left object distance
center_tof: center object distance
center_right_tof: 22° to the right object distance
right_tof: 45° to the right object distance

get_distance_top(unit: str = 'cm')

 top_tof: 45° to the top object distance

get_distance_bottom(unit: str = 'cm')

 bottom_tof: 45° to the bottom object distance

on_touch_ok_pressed(callback: callable, args: tuple = ())

on_touch_cancel_pressed(callback: callable, args: tuple = ())

on_touch_center_pressed(callback: callable, args: tuple = ())

on_touch_up_pressed(callback: callable, args: tuple = ())

on_touch_left_pressed(callback: callable, args: tuple = ())

on_touch_down_pressed(callback: callable, args: tuple = ())

on_touch_right_pressed(callback: callable, args: tuple = ())

He intentado hacer programas con estas instrucciones, pero una vez pulsado la tecla, sigue llamando a callback continuamente

 

No veo su utilidad teniendo get_touch
Unidades

¿Qué es eso de bloking?
Por ejemplo en rotate(angle: float, unit: str = 'deg', blocking: bool = True)

Si es true, todos los eventos no influyen, es decir el microprocesador esta centrado en esa instrucción
Si es falso, el microprocesador es libre de hacer otra cosa a la vez

Utiliza true si quieres precisión o no quieres que nada interaccione con la acción que estas ejecutando

Micropython

Para saber más Python

Curso completo de Python 222pag pdf Descargar
Curso completo de Python 422pag Descargar
Curso completo de Python desde 0  Ver
Curso de Python desde 0 Ver
Manual de referencia Python Ver
Programación en Python Ver
Trabajando con ficheros en Python Ver
Programación orientada a objeto en Python Ver
un manual para aquellos usuarios con previos conocimientos de Python, como la programación modular y orientada a objetos.
También algunos conocimientos de las librerías tkinter  (Para crear interfaces gráficos y SQlite3 (para gestionar bases de datos).
 Descargar

Agradecimientos a Pere Manel http://peremanelv.com

MicroPython sin IoT


MicroPython sin IoT

GPIO del ESP32

Mapa de los pines en el Arduino Nano ESP32 

2024-07-07 20_10_30-Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.png
Extraído de Youtube Exploring the Arduino Nano ESP32

Como podemos observar, nuestro objetivo pues es el GPIO0

¿Dónde está físicamente los GPIO ?

Pues como podemos ver en este esquema el GPIO0 está en el pin BOOT1

2024-07-07 20_14_06-Alvik User Manual _ Arduino Documentation.png
Fuente CC-BY-SA https://docs.arduino.cc/tutorials/alvik/user-manual/

Como puedes observar, si cortocircuitas B1 = GPI0 = D15 con GND enciende el led RGB en color verdel esto pasa si Pones la placa en modo Bootloader.

MicroPython sin IoT

Parpadeo LED ESP32

Objetivo

Vamos a hacer que parpadee el RGB integrado que tiene el ESP32 concretamente el color verde. 

Programa
#extraido de https://youtu.be/R51tf66es9w?t=1540

from machine import Pin
import time

myLED = Pin(0,Pin.OUT)

while True:
  myLED.value(0)
  time.sleep(0.5)
  myLED.value(1)
  time.sleep(0.5)
Aclaraciones
¿Y si queremos que parpadee el RGB en color ROJO qué cambiamos?

Easy peasy, cambiamos myLED = Pin (0, Pin.OUT) por myLED = Pin (46, Pin.OUT)

Que como puedes ver coincide también con un pin de poner en modo Bootloader: el BOOT0

Curiosidad: Por eso si se resetea Arduino Alvik (al encender, o al hacer dos clicks en el botón) se encienden y se apagan varias veces el led RGB en colores rojo y verde, pues se están activando los BOOTs

¿Y si queremos que parpadee el led color VERDE que hay al lado del USB (LED BUILTIN) ? ¿Qué cambiamos?

Easy peasy, cambiamos myLED = Pin (0, Pin.OUT) por myLED = Pin (48, Pin.OUT)

Resultado:

MicroPython sin IoT

Parpadeo leds Alvik

El programa
from arduino_alvik import ArduinoAlvik
from time import sleep
import sys

alvik = ArduinoAlvik()
alvik.begin()
sleep(5)

while True:
  alvik.left_led.set_color(1, 0, 0)
  alvik.right_led.set_color(1, 0, 0)
  sleep(1)
  alvik.left_led.set_color(0, 0, 0)
  alvik.right_led.set_color(0, 0, 0)
  sleep(1)

Origen: CC-BY-SA https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Resultado

MicroPython sin IoT

Danza

Programa
from arduino_alvik import ArduinoAlvik
from time import sleep
import sys

alvik = ArduinoAlvik()
alvik.begin()
sleep(5)

while True:
  #Drive forward
  alvik.set_wheels_speed(10,10)
  sleep(2)
  #Turn left
  alvik.set_wheels_speed(0,20)
  sleep(2)
  #Turn right
  alvik.set_wheels_speed(20,0)
  sleep(2)
  #Drive backwards
  alvik.set_wheels_speed(-10,-10)
  sleep(2)

De CC-BY-SA https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Vídeo

Más caña

La instrucción  alvik.set_wheels_speed(0,20) significa que da 0 rpm a la rueda izquierda y 20rpm a la derecha, donde rpm significa revoluciones por minuto ¿y si multiplicamos todos los rpm por 10?

MicroPython sin IoT

Control con la mano

Aquí trataremos de hacer que ALVIK responda a la posición de nuestra mano a través de el sensor ultrasonidos que tiene en frente suyo. Tendrá que intentar permanecer en una distancia intermedia con lo que tiene enfrente suyo.

ESTE PROGRAMA ESTA POR DEFECTO (marcado con el led verde) cuando instalas el firmware). Ver https://libros.catedu.es/books/arduino-alvik/page/que-es-arduino-alvik

image.pngFuente https://docs.arduino.cc/tutorials/alvik/getting-started/ AuthorJose Garcia CC-BY-SA

from arduino_alvik import ArduinoAlvik
from time import sleep
import sys

alvik = ArduinoAlvik()
alvik.begin()
sleep(5)

#ESTABLECER VELOCIDAD

speed = 30

#IMPRIMIR VALORES Y ESTABLECER VARIABLES
while True:
    try:
        center = alvik.get_distance_top()
        print(center)
        sleep(0.01)

        #Si la mano esta cerca, Alvik se va hacia atras
        if center <= 12:
            alvik.set_wheels_speed(-speed, -speed)
        #Si la mano esta lejos, Alvik se acerca
        elif center <= 30 and center >= 18:
            alvik.set_wheels_speed(speed, speed)
        #Si la mano esta en una distancia de 12-18, Alvik se queda quieto
        else:
            alvik.set_wheels_speed(0, 0)

  #INTERRUPCIÓN DEL USUARIO
    except KeyboardInterrupt as e:
        print('over')
        alvik.stop()
        sys.exit()

MicroPython sin IoT

Sigue líneas

Vamos a crear un programa SIGUE LÍNEAS. El objetivo es que el robot ALVIK sea capaz de seguir cualquier trazado de líneas utilizando sus sensores IR

image.pngFuente https://docs.arduino.cc/tutorials/alvik/getting-started/ AuthorJose Gracia CC-BY-SA

Para poder conseguirlo simplemente tendremos que establecer distintas condiciones de que hacer dependiendo de que sensor del robot detecta el trazado negro.

En este programa también hemos hecho que el robot nos trasmita los valores de los distintos sensores y que el usuario pueda interrumpir el proceso (todo suponiendo que el robot está conectado al equipo).

from arduino_alvik import ArduinoAlvik
from time import sleep
import sys

alvik = ArduinoAlvik()
alvik.begin()
sleep(5)

#VELOCIDAD DEL ROBOT
base_speed = 30

#IMPRIMIR VALORES DE LOS SENSORES
while True:
    try:
        ir_left, ir_center, ir_right = alvik.get_line_sensors()
        print(ir_left, ir_center, ir_right)
        sleep(0.01)
        
        #Condiciones de giro, avance y parar
        if ir_center > 300:
            alvik.set_wheels_speed(base_speed, base_speed)
        elif ir_left > 300:
            alvik.set_wheels_speed(0, base_speed)
        elif ir_right > 300:
            alvik.set_wheels_speed(base_speed, 0)
        else:
            alvik.set_wheels_speed(0, 0)
          
  #INTERRUPCION DEL USUARIO
    except KeyboardInterrupt as e:
        print('over')
        alvik.stop()
        sys.exit()

No va muy preciso, el código es mejorable:

MicroPython sin IoT

Evita obstáculos

Programa

El núcleo del programa es la función api

get_distance(unit: str = 'cm')

Es sorprendente el sensor TOF como puede leer no sólo diréctamente sino a los lados :

El programa es extraido de https://docs.arduino.cc/tutorials/alvik/getting-started/ AuthorJose Garcia

from arduino_alvik import ArduinoAlvik
from time import sleep_ms
import sys

alvik = ArduinoAlvik()
alvik.begin()
sleep_ms(5000)  # waiting for the robot to setup
distance = 20
degrees = 45.00
speed = 50.00

while (True):

    distance_l, distance_cl, distance_c, distance_r, distance_cr  = alvik.get_distance()
    sleep_ms(50)
    print(distance_c)

    if distance_c < distance:
        alvik.rotate(degrees, 'deg')
    elif distance_cl < distance:
        alvik.rotate(degrees, 'deg')
    elif distance_cr < distance:
        alvik.rotate(degrees, 'deg')
    elif distance_l < distance:
        alvik.rotate(degrees, 'deg')
    elif distance_r < distance:
        alvik.rotate(degrees, 'deg')
    else:
        alvik.drive(speed, 0.0, linear_unit='cm/s')
Resultado

El código es mejorable, pues que rote 45 grados tantas veces puede hacer que se quede "enganchado" en una esquina, ver el final del vídeo:

MicroPython sin IoT

Programas de test

En el repositorio https://github.com/arduino/arduino-alvik-mpy/tree/main/examples podemos encontrar ejemplos para ver el uso de los diferentes sensores y actuadores, por ejemplo

Sensor name Part name Test program name
RGB Color detection APDS 9660 read_color_sensor.py
ToF 8x8 Array - up to 350 cm LSM6DSOX read_tof.py
IMU - 6 degree VL53L7CX read_imu.py
3x Line follower custom made line_follower.py
7x Touch sensor AT42QT2120 read_touch.py
Actuator name Part name Test program name
Geared motors w/ encoder GM12-N20VA-08255-150-EN wheels_positions.py
RGB LEDs RGB LEDs leds_settings.py
Detector de color

Modificación del read_color_sensor.py

from arduino_alvik import ArduinoAlvik
from time import sleep_ms
import sys

alvik = ArduinoAlvik()
alvik.begin()

while True:
    try:
        r, g, b = alvik.get_color()
        h, s, v = alvik.get_color('hsv')
        print(f'RED: {r}, Green: {g}, Blue: {b}, HUE: {h}, SAT: {s}, VAL: {v}')
        print(f'COLOR LABEL:')
        print ({alvik.get_color_label()})
        sleep_ms(1000)
    except KeyboardInterrupt as e:
        print('over')
        alvik.stop()
        sys.exit()

Detector TOF

Si ejecutamos read_tof.py

from arduino_alvik import ArduinoAlvik
from time import sleep_ms
import sys

alvik = ArduinoAlvik()
alvik.begin()

while True:
    try:
        L, CL, C, CR, R = alvik.get_distance()
        T = alvik.get_distance_top()
        B = alvik.get_distance_bottom()
        print(f'T: {T} | B: {B} | L: {L} | CL: {CL} | C: {C} | CR: {CR} | R: {R}')
        sleep_ms(100)
    except KeyboardInterrupt as e:
        print('over')
        alvik.stop()
        sys.exit()

Detecta hasta los obstáculos por arriba

Giro

Si ejecutamos read_imu.py

from arduino_alvik import ArduinoAlvik
from time import sleep_ms
import sys

alvik = ArduinoAlvik()
alvik.begin()

while True:
    try:
        ax, ay, az = alvik.get_accelerations()
        gx, gy, gz = alvik.get_gyros()
        print(f'ax: {ax}, ay: {ay}, az: {az}, gx: {gx}, gy: {gy}, gz: {gz}')
        sleep_ms(100)
    except KeyboardInterrupt as e:
        print('over')
        alvik.stop()
        sys.exit()

Vemos como el eje x cambia de -1  0  a 1 según la posición

MicroPython sin IoT

Robótica para infantil

Se puede hacer un robot tipo Beebot, Colby, Escornabot.
Si no conocéis estos robots mirar el curso de Aularagon

bee-bot-2591033446.jpgescornabot-4126551417.jpg

Podemos cargar el siguiente programa, modificado de https://github.com/arduino/arduino-alvik-mpy/blob/main/examples/touch_move.py

from arduino_alvik import ArduinoAlvik
from time import sleep_ms
import sys

alvik = ArduinoAlvik()
alvik.begin()

alvik.left_led.set_color(1, 0, 0)
alvik.right_led.set_color(1, 0, 0)

distancia = 15

movements = []


def blink():
    alvik.left_led.set_color(1, 0, 1)
    alvik.right_led.set_color(1, 0, 1)
    sleep_ms(200)
    alvik.left_led.set_color(1, 0, 0)
    alvik.right_led.set_color(1, 0, 0)


def add_movement():
    global movements

    if alvik.get_touch_up():
        movements.append('forward')
        blink()
        while alvik.get_touch_up():
            sleep_ms(100)
    if alvik.get_touch_down():
        movements.append('backward')
        blink()
        while alvik.get_touch_down():
            sleep_ms(100)
    if alvik.get_touch_left():
        movements.append('left')
        blink()
        while alvik.get_touch_left():
            sleep_ms(100)
    if alvik.get_touch_right():
        movements.append('right')
        blink()
        while alvik.get_touch_right():
            sleep_ms(100)
    if alvik.get_touch_cancel():
        movements = []
        for i in range(0, 3):
            val = i % 2
            alvik.left_led.set_color(val, 0, 0)
            alvik.right_led.set_color(val, 0, 0)
            sleep_ms(200)
        while alvik.get_touch_cancel():
            sleep_ms(100)


def run_movement(movement):
    if movement == 'forward':
        alvik.move(distancia, blocking=False)
    if movement == 'backward':
        alvik.move(-distancia, blocking=False)
    if movement == 'left':
        alvik.rotate(90, blocking=False)
    if movement == 'right':
        alvik.rotate(-90, blocking=False)
    while not alvik.get_touch_cancel() and not alvik.is_target_reached():
        alvik.left_led.set_color(1, 0, 0)
        alvik.right_led.set_color(1, 0, 0)
        sleep_ms(100)
        alvik.left_led.set_color(0, 0, 0)
        alvik.right_led.set_color(0, 0, 0)
        sleep_ms(100)

while alvik.get_touch_ok():
    sleep_ms(50)

while not (alvik.get_touch_ok() and len(movements) != 0):
    add_movement()
    sleep_ms(50)

try:
    while True:
        alvik.left_led.set_color(0, 0, 0)
        alvik.right_led.set_color(0, 0, 0)
        for move in movements:
            run_movement(move)
            if alvik.get_touch_cancel():
                break

        movements = []

        while not (alvik.get_touch_ok() and len(movements) != 0):
            alvik.left_led.set_color(1, 0, 0)
            alvik.right_led.set_color(1, 0, 0)
            alvik.brake()
            add_movement()
            sleep_ms(100)
except KeyboardInterrupt as e:
    print('over')
    alvik.stop()
    sys.exit()

El resultado es que perfectamente se puede usar como robótica en infantil
Los robots Beebot, Colby, Escornabot. utilizan la distancia de 15cm de desplazamiento, justo lo mismo que los palos depresores de lengua, luego fácilmente uno puede hacer un circuito :

MicroPython sin IoT

Manejando servos

Conexión

Se pueden conectar hasta dos servos, el A es el de arriba y el B es el de abajo

2024-07-11 13_06_45-Qué es Arduino Alvik _ Librería CATEDU.png

La api set_servo_positions

Nos permite controlar estos dos servos  indicando el primer argumento el ángulo (0-180) del A y en el segundo el del B set_servo_positions(a_position: int, b_position: int)

Programa

Extraído de https://docs.arduino.cc/tutorials/alvik/user-manual/#add-servo-motors 

from arduino_alvik import ArduinoAlvik

import time

alvik = ArduinoAlvik()

alvik.begin()

while True:
    alvik.set_servo_positions(0,0)
    time.sleep(2)
    alvik.set_servo_positions(90,180)
    time.sleep(2)
    alvik.set_servo_positions(180,90)
    time.sleep(2)
    alvik.set_servo_positions(90,0)
    time.sleep(2)
Resultado

MicroPython sin IoT

Más ejemplos

Los puedes encontrar en https://courses.arduino.cc/explore-robotics-micropython/

2025-03-28 14_18_30-Lessons _ Explore Robotics in MicroPyton.png

2025-03-28 14_19_02-Lessons _ Explore Robotics in MicroPyton.png

2025-03-28 14_19_56-Lessons _ Explore Robotics in MicroPyton.png

MicroPython con IoT


MicroPython con IoT

¿Qué es Internet de las cosas IoT?

El Internet de las cosas (Internet of Thing IoT) describe objetos físicos —o grupos de estos— con sensores, capacidad de procesamiento, software y otras tecnologías que se conectan e intercambian datos con otros dispositivos y sistemas a través de internet u otras redes de comunicación.​ El Internet de las cosas se ha considerado un término erróneo porque los dispositivos no necesitan estar conectados a la Internet pública. Sólo necesitan estar conectadas a una red y ser direccionables individualmente

Fuente Wikipedia IoT Internet de las cosas CC-BY-SA

De Drawed by Wilgengebroed on FlickrTranslated by Prades97 CC BY-SA 3.0

Estamos hablando de dispositivos que se conectan a internet de forma desatendida, por vía hardware (o mejor dicho firmware) a diferencia de un ordenador, tablet o móvil, donde tienes que configurar por software el dispositivo y hay un diálogo entre usuario y dispositivo sobre el uso de Internet (el software solicita tal página web, tales datos etc por voluntad del usuario o por diálogo con el usuario) Aquí los dispositivos están ya configurados de los datos que se comunican. Es decir "conectar y olvidar". 

Piensa en la diferencia entre un enchufe inteligente y un ordenador, el primero es lo que se considera dentro de IoT

Las formas "desatendidas" son un avance en la sociedad pero también puede generar problemas muy serios a nivel mundial, ver el caso Mirai

Las cosas claras. ¿asíncrono o síncrono?

Hay muchas herramientas IoT

MicroPython con IoT

Conectar a Wifi

Para ello necesitamos importar la librería network, crear un objeto network que se conecta a la wifi :

import network
import urequests


WIFI_NETWORK='NOMBREREDWIFI'  ## tu red wifi
WIFI_PASSWORD='CONTRASENA' ## la contraseña de la red wifi


wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(WIFI_NETWORK, WIFI_PASSWORD)

print("\nconectando.....")
if wlan.isconnected():
  print("Alvik se conectó a",WIFI_NETWORK)
else :
  print ("Alvik NO se conectó a",WIFI_NETWORK)

Tiene que salir este mensaje:

>>> 
raw REPL; CTRL-B to exit
>OK
conectando.....
Alvik se conectó a NOMBREREDWIFI
>

MicroPython con IoT

Crear bot en Telegram

2023-05-30 14_37_46-BotFather – (68).jpg

Entramos en nuestro Telegram y chateamos con el creador de los bots: @BotFather y nos saldrá esta pantalla:

2023-05-30 14_32_01-BotFather – (68).jpg

Si tecleamos /start nos sale las diferentes opciones

2023-05-30 14_33_30-BotFather – (68).jpg

Para crear un nuevo bot, tecleamos /newbot y nos preguntará el nombre del bot

Por cierto, el nombre tiene que acabar con las letras bot,

NOS PROPORCIONARÁ EL TOKEN DEL ROBOT, QUE TOMAREMOS NOTA

2023-05-30 14_39_59-BotFather – (68).jpg

Si tecleamos /mybots nos sale los diferentes bots creados y al pulsar en uno de ellos nos salen sus opciones

2023-05-30 14_36_25-BotFather – (68).jpg


MicroPython con IoT

Encontrar tu ID en Telegram

Buscar tu ID : chat privado

En este caso para que mi Bot me envié mensajes a mi usuario de Telegram directamente busco mi ID.

Vamos a chatear con @myidbot

2023-05-30 14_54_31-IDBot – (68).jpg

 y le preguntamos por nuestro identificador con /getid

TOMAMOS NOTA DE NUESTRO IDENTIFICADOR ID

2023-05-30 14_47_06-.jpg

Buscar ID de un grupo

En este caso tendríamos que añadir a @myidbot al grupo y ejecutar el comando en el chat del grupo /getgroupid saldrá un identificador negativo

Una vez conseguido el ID podemos eliminar @myidbot del grupo




MicroPython con IoT

Mensajes a Telegram

Una vez que tengamos el TOKEN y el ID lo ponemos en las líneas

telegramBot="MI_TOKEN"  ## el Token que sale de @BotFather
telegramChatId="MI_ID"    ## El ID del usuario de Telegram destinatario lo da @myidbot

y entones si ejecutamos la URL 

https://api.telegram.org/botMI_TOKEN/sendMessage?chat_id=MI_ID&text=MENSAJE_QUE_QUIERA_ENVIAR

Entonces aparece en mi Telegram desde mi bot el mensaje 

Con la librería urequest nos permite con la instrucción urequiest.get(url) nos permite ejecutar la llamada url

El siguiente programa envía por Telegram el botón que estemos pulsando en el Arduino Alvik :

from arduino_alvik import ArduinoAlvik
from time import sleep
import random
import sys
import network
import urequests
import time

alvik = ArduinoAlvik()
alvik.begin()


def enviarmensaje(mensaje):     
  url="https://api.telegram.org/bot"+telegramBot+"/sendMessage?chat_id="+telegramChatId+"&text="+mensaje
  respuesta = urequests.get(url)
  #print (type(respuesta))






WIFI_NETWORK=''  ## tu red wifi
WIFI_PASSWORD='' ## la contraseña de la red wifi
telegramBot=""  ## el Token que sale de @BotFather
telegramChatId=""    ## El ID del usuario de Telegram destinatario lo da @myidbot


wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(WIFI_NETWORK, WIFI_PASSWORD)

if wlan.isconnected():
  print("Alvik se conectó a",WIFI_NETWORK)
else :
  print ("Alvik NO se conectó a",WIFI_NETWORK)

while True:
  
  if alvik.get_touch_any():
    alvik.left_led.set_color(1, 0, 0)
    alvik.right_led.set_color(1, 0, 0)
  else:
    alvik.left_led.set_color(0, 1, 0)
    alvik.right_led.set_color(0, 1, 0)
      
  if alvik.get_touch_up() :
        enviarmensaje("arriba")
  if alvik.get_touch_down():
        enviarmensaje("abajo")
  if alvik.get_touch_left() :
        enviarmensaje("izquierda")
  if alvik.get_touch_right() :
        enviarmensaje("derecha")
  
  time.sleep(1)
Resultado

Para saber más...

 

MicroPython con IoT

Pin pong Telegram

Como paso previo a enviar y recibir mensajes, vamos a realizar los pasos de este vídeo

https://www.youtube.com/watch?v=eZkb9omr-sA

Paso 1: Librería uTelegram.py 

Del repositorio de Jordi Prats
https://github.com/jordiprats/micropython-utelegram/blob/master/utelegram.py

2024-07-06 22_09_11-micropython-utelegram_utelegram.py at master · jordiprats_micropython-utelegram.png

import time
import gc
import ujson
import urequests


class ubot:
    
    def __init__(self, token, offset=0):
        self.url = 'https://api.telegram.org/bot' + token
        self.commands = {}
        self.default_handler = None
        self.message_offset = offset
        self.sleep_btw_updates = 3

        messages = self.read_messages()
        if messages:
            if self.message_offset==0:
                self.message_offset = messages[-1]['update_id']
            else:
                for message in messages:
                    if message['update_id'] >= self.message_offset:
                        self.message_offset = message['update_id']
                        break


    def send(self, chat_id, text):
        data = {'chat_id': chat_id, 'text': text}
        try:
            headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
            response = urequests.post(self.url + '/sendMessage', json=data, headers=headers)
            response.close()
            return True
        except:
            return False

    def read_messages(self):
        result = []
        self.query_updates = {
            'offset': self.message_offset + 1,
            'limit': 1,
            'timeout': 30,
            'allowed_updates': ['message']}

        try:
            update_messages = urequests.post(self.url + '/getUpdates', json=self.query_updates).json() 
            if 'result' in update_messages:
                for item in update_messages['result']:
                    result.append(item)
            return result
        except (ValueError):
            return None
        except (OSError):
            print("OSError: request timed out")
            return None

    def listen(self):
        while True:
            self.read_once()
            time.sleep(self.sleep_btw_updates)
            gc.collect()

    def read_once(self):
        messages = self.read_messages()
        if messages:
            if self.message_offset==0:
                self.message_offset = messages[-1]['update_id']
                self.message_handler(messages[-1])
            else:
                for message in messages:
                    if message['update_id'] >= self.message_offset:
                        self.message_offset = message['update_id']
                        self.message_handler(message)
                        break
    
    def register(self, command, handler):
        self.commands[command] = handler

    def set_default_handler(self, handler):
        self.default_handler = handler

    def set_sleep_btw_updates(self, sleep_time):
        self.sleep_btw_updates = sleep_time

    def message_handler(self, message):
        if 'text' in message['message']:
            parts = message['message']['text'].split(' ')
            if parts[0] in self.commands:
                self.commands[parts[0]](message)
            else:
                if self.default_handler:
                    self.default_handler(message)

Y la cargamos dentro de nuestro ESP32, ejecutamos Arduino Lab for MicroPython, conectamos, vamos al gestor de archivos y lo llevamos dentro del ESP32 Alvik

2024-07-06 22_12_32-Arduino Lab for MicroPython.png

Paso 2 Archivo config.py

El archivo config.py no es más que el archivo que contiene la wifi y el token, se puede descargar de https://github.com/jordiprats/micropython-utelegram/blob/master/demo/config.py-demo o también se puede copiar y pegar de aquí mismo

wifi_config = {
    'ssid':'DEMO',
    'password':'PASSW0RD'
}

utelegram_config = {
    'token': 'TOKEN'
}

Ponemos los valores de nuestra wifi SSID, PASSWORD y TOKEN y borramos del nombre el -demo y lo dejamos como config.py

2024-07-06 23_01_23-Arduino Lab for MicroPython.png

y como antes, lo pasamos al ESP32 Alvik

2024-07-06 23_05_34-Arduino Lab for MicroPython.png

Se podría poner esa información en el código del programa principal main.py tal y como el programa de la página https://libros.catedu.es/books/arduino-alvik/page/mensajes-a-telegram 

Paso 3 Programa principal main.py

El programa lo podemos descargar de https://github.com/jordiprats/micropython-utelegram/blob/master/demo/main.py

o de aquí mismo

tal cual, no hay que poner nuestro ssid, ni password ni token pues lo "lee" de config.py


from config import utelegram_config
from config import wifi_config

import utelegram
import network
import utime

debug = True

sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.scan()
sta_if.connect(wifi_config['ssid'], wifi_config['password'])

if debug: print('WAITING FOR NETWORK - sleep 20')
utime.sleep(20)

def get_message(message):
    bot.send(message['message']['chat']['id'], message['message']['text'].upper())

def reply_ping(message):
    print(message)
    bot.send(message['message']['chat']['id'], 'pong')

if sta_if.isconnected():
    bot = utelegram.ubot(utelegram_config['token'])
    bot.register('/ping', reply_ping)
    bot.set_default_handler(get_message)

    print('BOT LISTENING')
    bot.listen()
else:
    print('NOT CONNECTED - aborting')

🤔No sé por qué hay que esperar 20 segundos en utime.sleep(20) 🤷‍♂️sospecho que necesita tiempo para estar preparado para "escuchar"

Y lo llevamos al ESP32 

2024-07-06 23_12_08-Arduino Lab for MicroPython.png

Ejecución

Pulsamos el main.py del ESP32 (no hace falta encender Alvik pues todas las instrucciones son sólo del ESP32), ESPERAR 20 SEGUNDOS hasta que aparezca BOT LISTENING

2024-07-06 23_14_35-Arduino Lab for MicroPython.png

Nos vamos a Telegram al usuario del bot que hemos creado, le tecleamos /ping y contesta el ESP32 pong

2024-07-06 23_17_14-JavierArduino — Mozilla Firefox.png

MicroPython con IoT

Recepción mensajes Telegram

Podemos ahora enviar un mensaje a ArduinoAlvik y que ejecute un programa por ejemplo el evita obstáculos:

from arduino_alvik import ArduinoAlvik   #### IMPORTAMOS LAS FUNCIONES DE ALVIK

from config import utelegram_config
from config import wifi_config
##### AÑADIMOS LIBRERÍAS PARA LOS OBSTÁCULOS
from time import sleep_ms
import sys

import utelegram
import network
import utime
################ añadimos urequest para enviar mensajes con url
import urequests

alvik = ArduinoAlvik()    #### CREAMOS UN OBJETO ALVIK
alvik.begin()             #### LO INICIALIZAMOS
################# VARIABLES PARA EVITAR OBSTÁCULOS
distance = 10
degrees = 45.00
speed = 50.00
############################################################
debug = True

sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.scan()
sta_if.connect(wifi_config['ssid'], wifi_config['password'])

if debug: print('WAITING FOR NETWORK - sleep 20')
utime.sleep(20)
########################################################################################
def get_message(message):
    bot.send(message['message']['chat']['id'], message['message']['text'].upper())
############################################################################################
def enviarmensaje(mensaje):                                     ###FUNCION ENVIAR MENSAJE CON URL ojo cambiar PONAQUITUID
  url="https://api.telegram.org/bot"+utelegram_config['token']+"/sendMessage?chat_id=PONAQUITUID&text="+mensaje
  respuesta = urequests.get(url)
###########################################################################################
def reply_ping(message):
    print(message)
    bot.send(message['message']['chat']['id'], 'voy')      ### CAMBIAMOS EL MENSAJE
    evitamosobstaculos()                                   ### y EVITAMOS OBSTÁCULOS
############################################################################################
def evitamosobstaculos():                                  ### FUNCIÓN EVITAR OBSTÁCULOS
  while (True):

    distance_l, distance_cl, distance_c, distance_r, distance_cr  = alvik.get_distance()
    sleep_ms(50)
    print(distance_c)

    if distance_c < distance:
      alvik.rotate(degrees, 'deg')
    elif distance_cl < distance:
      alvik.rotate(degrees, 'deg')
    elif distance_cr < distance:
      alvik.rotate(degrees, 'deg')
    elif distance_l < distance:
      alvik.rotate(degrees, 'deg')
    elif distance_r < distance:
      alvik.rotate(degrees, 'deg')
    else:
      alvik.drive(speed, 0.0, linear_unit='cm/s')
  
############################################################################################

if sta_if.isconnected():
    bot = utelegram.ubot(utelegram_config['token'])
    bot.register('/go', reply_ping)                        ### LA CONSIGNA SERÁ GO
    bot.set_default_handler(get_message)

    print('BOT LISTENING')
    enviarmensaje("preparado")
    bot.listen()
else:
    print('NOT CONNECTED - aborting')

Programando en bloques mBlock


Programando en bloques mBlock

Preparar el ALVIK para mBlock: Actualizar el firmware de Alvik

Actualizar el firmware significa que nuestro Alvik le instalamos el interpretador de micropython y por lo tanto podremos:
- Programar en código con Python
- Programar en bloques con mBlock

Si ya tiene el firmware puedes saltarte esta página

Con este firmware no podemos programar con Arduino IDE

Antes de nada enciende el Alvik con esta precaución :

Primero nos aseguramos que el Alvik este APAGADO antes de conectarlo con el PC 
en caso contrario se puede perjudicar la bateríarobot-off.png
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Luego lo conectamos por cableconnecting-final.gif
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Y ahora ya podemos encender nuestro Alvik
alvik-on.png
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

Actualizamos el FIRMWARE

Esto lo hacemos una vez, entramos en https://alvikupdate.arduino.cc/ damos a conectar y luego updated (si no sabes qué puerto es, desconecta y conecta y te fijas cual aparece)

Puede tardar varios ciclos, paciencia

2025-03-28 10_18_52-Arduino® Alvik Updater 🤖.png

Asegúrate de tener el ALVIK encendido

Hasta que sale esta pantalla de éxito

2025-03-26 11_59_36-Arduino® Alvik Updater 🤖.png

ATENCIÓN ¿Y SI DA PROBLEMAS?

Por ejemplo se ha quedado enganchado, lo has desconectado antes de hora... entonces la solución pasa pro utilizar un flasheador más potente

MicroPython Installer

Descargamos el programa y ejecutamos teniendo conectado el ESP32 del Alvik, (no hace falta encender el robot, pues sólo trabajamos con el ESP32) lo detecta y simplemente le damos a Instalar Micropython dentro del chip

Descargable en https://labs.arduino.cc/en/labs/micropython-installer

2024-07-04 19_17_33-MicroPython Installer.png

Si sigue puñetero y no detecta el Arduino Nano ESP32 tendrás que ponerlo en modo Bootoloader, haz los pasos 1, 2  y 3 de https://libros.catedu.es/books/arduino-alvik/page/preparar-alvik-para-arduino-ide-modo-bootloader  y vuelve a intentarlo con el MicroPython Installer

Al acabar de instalar, sale este mensaje :

2025-03-28 10_15_55-MicroPython Installer.png

Aconsejamos apagar y desconectar totalmente y volver a conectar (acuérdate que no hay que conectar el ALVIK en el PC con el ALVIK encendido, lo conectas con el PC apagado y luego lo enciendes, tal y como dice arriba del todo)

Entramos en https://alvikupdate.arduino.cc/ damos a conectar y luego updated (si no sabes qué puerto es, desconecta y conecta y te fijas cual aparece)

AQUÍ VA A TARDAR VARIOS, VARIOS CICLOS, paciencia, paciencia

2025-03-28 10_18_52-Arduino® Alvik Updater 🤖.png

Asegúrate de tener el ALVIK encendido

Hasta que sale esta pantalla de éxito

2025-03-26 11_59_36-Arduino® Alvik Updater 🤖.png

Programando en bloques mBlock

Instalando mBlock

mBlock es un programa especializado en el manejo de los robots de Makeblock (ver cursos de mBot en Aularagon), pero permiten muchas arquitecturas de placas pues los mismos robots de Makeblock estan basados en placas de hardware libre Arduino, ESP32...

Hay dos versiones, online y offline, las dos son buenas, no obstante
- Si tienes Windows o Mac preferimos la versión offline para no saturar la red en los centros, rapidez y comodidad. 
- Si utilizas Linux o Chromebook tienes que usar la versión online obligatoriamente pues no hay versión instalable.
Tanto una opción como la otra, permite tener los proyectos en la nube de Makeblock, compartir, embeberlos, etc...

Versión online                                                                                                

Para la versión web primero hay que instalar mLink driver nos vamos a https://mblock.cc/pages/downloads y abajo nos encontramos mLink para descargar, descarga el mLink correspondiente a tu sistema operativo : 

mlink-1.png
Licencia CC-BY -SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

Lo instalamos, y entonces pedirá instalar los drivers que son pequeños programas que comunican el PC con el harware del robot

mlink-drivers.png
Licencia CC-BY -SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

Si utilizas Chromebook lee la siguiente guía para conectar el robot

Una vez instalado ya podemos entrar en la web https://ide.mblock.cc/ para programar en bloques nuestro robot

Nota: La página https://ide.mblock.cc/  no suele estar bien situada en los buscadores si ponemos mBlock, la página que suele salir es esta https://www.mblock.cc/en/ y nos da dos opciones, trabajar con bloque, o con Python, elegimos bloques2024-05-16 23_50_10-mBlock - One-Stop Coding Platform for Teaching and Learning.png
Si has entrado sin querer en la URL  https://ide.makeblock.com/ no permite el logueo en Europa
En resumen, la URL correcta es  https://ide.mblock.cc/  

En este editor tenemos que loguearnos podemos crear un nuevo usuario, utilizando una cuenta de Google/Apple o registrarnos con un correo electrónico

2024-05-16 23_53_10-mBlock Block-Based IDE- Coding for Beginners.png

Versión offline Windows o Mac                                                                        

Vamos a https://mblock.cc/pages/downloads y descargamos la versión correcta a nuestro sistema operativo.

download-version.png
Licencia CC-BY -SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

En windows hacemos doble click en el archivo ejecutable descargado

installing-download.png
Licencia CC-BY -SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

Lo instalamos, y entonces pedirá instalar los drivers que son pequeños programas que comunican el PC con el hardware del robot

install-drivers.png
Licencia CC-BY -SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

Algunas veces la ventana de driver de la figura anterior esta escondida en el fondo, hay que minimizar ventanas para acceder a ella.

En MAC el archivo será un fichero mount con la extensión .dmg, por lo tanto hay que arrastar el icono a la carpeta de aplicaciones

install-mac.png
Licencia CC-BY -SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

Programando en bloques mBlock

Instalando la extensión ALVIK en mBlock

En mBlock instalar la extensión Alvik
  1. Pinchamos en el + de añadir dispositivo
  2. buscamos Alvik 
  3. apretamos al + de descargarlo (al finalizar desaparece el + )
  4. dos clicks y se instala

2025-03-25 23_34_33-mBlock v5.4.3.png
Licencia CC-BY-SA https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

COM-port.png

Se nos instalan una colección de instrucciones para controlar el ALVIK completamente 

2025-03-26 10_39_58-mBlock v5.4.3.png
Programando en bloques mBlock

Dos formas de programar en mBlock

DOS FORMAS DE PROGRAMAR EN MBLOCK :

OPCIÓN Programación en vivo

El programa reside en el ordenador, y en la placa hay instalado un Firmware para ir escuchando y ejecutando lo que manda el ordenador. 

OPCIÓN Programación cargar a la placa

Todos los programas editores de Arduino (tanto los que programan con código como el Arduino IDE) como los editores de programas gráficos en bloque (mBlock, Snap4Arduino, Arduinoblocks, ...) permiten cargar el programa en la placa.  Las ventajas y desventajas son las opuestas de trabajar en vivo.

EN VIVO ¿Qué es eso?                                                                                                                                                       
Existe una posibilidad de utilizar la placa "en vivo" frente a "cargar" el programa en la placa.
Es decir, interactuando con el ordenador. El programa está en el PC. En la placa hay un firmware que le dice que este a las órdenes del PC.  De esta manera podemos por ejemplo:
     - Enviar órdenes desde el ordenador a la placa.
                      Por ejemplo que al pulsar la tecla espacio que se encienda el led D13 
    - Enviar información desde la placa al ordenador
                  Por ejemplo que muestre por pantalla nos muestre la cantidad de luz, que registra el sensor LDR, etc...
Que nosotros sepamos, estos programas permiten la programación en vivo :
               - mBlock placas: Arduino, Microbit, Raspberry Pi, ... robots de Makeblock: mBot, Cyberpi...
                -EchidnaScratch CURSO DE ECHIDNA
VENTAJAS LA PROGRAMACIÓN EN VIVO PERMITE MUCHO JUEGO Y POSIBILIDADES A LA HORA DE ELABORAR PROYECTOS
INCONVENIENTES: Necesitas el ordenador encendido y conectado al robot.

Programando en bloques mBlock

Un ejemplo de programa en vivo

PROBANDO EN VIVO                                                                                                  
  1. Entramos en mBlok, en dispositivos
  2. Seleccionamos Alvik
  3. En vivo
  4. Conectar
  5. Nos saldrá una ventana pop-up en Windows saldrá COMx donde x es un número. En otros sistemas operativos /dev/tty.[yourSerialPortName] o algo así. En teoría tiene que funcionar con el puerto elegido, sino, elegiremos otro, suele ser el más alto.

2025-03-26 11_03_38-Configuración.png

A funcionar así de sencillo !!!!!

la primera vez, tarda algo en responder, paciencia

RETO Ves probando así de rápido la multitud de instrucciones gráficas para saber cómo funcionan

Programando en bloques mBlock

Un ejemplo de programa en carga

Como ejemplo de programa en carga 

  1. Creamos un sencillo programa con eventos de cuando botón ... es presionado ...
  2. Elegimos el botón Cargar
  3. Subir código

2025-03-26 12_38_48-mBlock v5.4.3.png

Ahora el robot es libre en movimientos no depende del ordenador, por lo tanto podemos desconectar el cable

Programando en bloques mBlock

Otro ejemplo de programa en carga : Evita obstáculos

Podemos hacer un evita obstáculos, en la página https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/ proponen este programa


Licencia CC-BY-SA fuente https://docs.arduino.cc/tutorials/alvik/getting-started-mblock/

Pero no gira, luego proponemos este https://planet.mblock.cc/project/5547662

2025-03-26 13_13_53-mBlock v5.4.3.png

Programando en bloques mBlock

Métodos para interactuar los objetos y el robot (dispositivo)

Si queremos que nuestro robot se pueda comunicar con el objeto o objetos que tenga mBlock, antes con mBlock 3.0 la comunicación era inmediata, fíjate en este script de una alarma:

embedded-image-xGEexnUg.jpeg

Mezcla en el mismo script:

Con mBlock 5.0 YA NO SE PUEDE, pero tenemos unos trucos

MÉTODO UTILIZAR VARIABLES GLOBALES

Se pueden crear variables, en cualquier objeto, y las lee cualquier objeto,

Este método se utiliza con la opción EN VIVO

variablesglobales.jpg

De esta manera si creamos una variable frase para todos los objetos:

frase3.jpg

Podemos usarla en el robot

frase1.jpg

y el programa del objeto que queramos, en este caso el oso panda lo puede visualizar

frase2.jpg

MÉTODO UTILIZAR MENSAJES

Cualquier objeto tiene a su disposición enviar mensajes a los otros

Este método se utiliza con la opción EN VIVO

mensajes.jpg

MÉTODO EXTENSIÓN BROADCAST = TRANSMITIR MENSAJES

Este método se utiliza con la opción EN CARGA

Es parecido al anterior, hay que ir al + que hay abajo para instalar extensiones

arduino-pelotahinchadistancia3.png

Buscar la extensión "Broadcast" e instalarla 

broadcast.jpg

Se instala primero descargándola con el + aquí

broadcast1.png

Y luego añadir una vez descargada

broadcast2.png

Entonces aparecen unas nuevas instrucciones

broadcast3.png

y se instalan unas instrucciones extras parecidas a las anteriores pero más potentes

El resto de objetos trabajan en modo vivo, es decir, si cambias un bloque, automáticamente se ven los efectos

A lo otros objetos TAMBIÉN hay que instalar la extensión BROADCAST

DESVENTAJA no se pueden transmitir mensajes de objetos a la placa. Sólo de la placa a los objetos

Programando en bloques mBlock

Un ejemplo interactuando con un objeto

Vamos a probar dos métodos anteriores, el de variable global y el envío de mensaje, por lo tanto vamos a trabajar EN VIVO

El Alvik va a enviar cuando pulse OK un mensaje COMENZAMOS a un objeto (un ovni) para que empiece a moverse y va grabando continuamente en dos variables globales ANGULOX y ANGULOY los ángulos del sensor de inclinación

2025-03-26 14_10_40-mBlock v5.4.3.png

En un objeto OVNI vamos a realizar un programa que se mueva según el ángulo. Como el ángulo va de 0 a 100 y el eje va de 0-250 luego lo multiplicaremos por dos para que se mueva con más margen.

2025-03-26 14_12_05-mBlock v5.4.3.png

El programa lo tienes aquí https://planet.mblock.cc/project/5548364

Y este es el resultado

Arduino IDE

Arduino IDE

¿Qué es Arduino IDE?

Necesitarás el entorno de desarrollo Arduino IDE (IDE, Integrated development environment) (aquí https://www.arduino.cc/en/Main/Software para descargártelo)


En Linux puede salir este mensaje "can't open device "/dev/ttyUSB0": Permission denied" donde 0 puede ser otro número, la solución aquí

Está constituido por un editor de texto para escribir el código, un área de mensajes, una barra de herramientas con botones para las funciones comunes, y una serie de menús.

Arduino utiliza para escribir el código fuente o programa de aplicación lo que denomina "sketch" (programa). Estos programas son escritos en el editor de texto. Existe la posibilidad de cortar/pegar y buscar/remplazar texto.

Arduino IDE

Preparar Arduino IDE para Alvik: Instalar Placa ESP32 y libreria Arduino Avik

Instalar placa Arduino ESP32 Boards by Arduino

Lo primero que tenemos que hacer es instalar la placa Arduino ESP32 tal y como dice esta captura

2024-07-04 11_15_28-sketch_jun3a _ Arduino IDE 2.3.2.png

O este vídeo a partir de 9:30 (pongo el vídeo pues es interesante si quieres aprender más sobre Arduino ESP32)

Instalar Librería Arduino_Alvik.h

Las funciones que tiene la librería son prácticamente las vistas en las APIs, ver https://libros.catedu.es/books/arduino-alvik/page/arduino-alvik-api 

Para ejecutarlo en el Arduino IDE tenemos que tener esta librería que es fácilmente instalable:

2024-07-11 21_10_55-Configuración.png

Tal y como dice https://docs.arduino.cc/tutorials/alvik/setting-alvik-arduino-ide/ 

 

Arduino IDE

Preparar ALVIK para Arduino IDE: Modo Bootloader

¿Qué es eso del Boodloader? Es un pequeño programa que esta en el microcontrolador (Arduino, ESP32, etc...) que permite que arranque la placa y espere las instrucciones del programa del usuario, digamos que es como un "pequeño sistema operativo de arranque" por ejemplo en el Arduino, se ejecuta en un poco de tiempo cuando arranca la placa o se resetea, y espera el programa IDE por el puerto USB, si llega (él comprueba que es un IDE y no otra cosa) lo almacena en un sitio de la memoria Flash y lo ejecuta, sino, pues ejecuta el que ya esta cargado. El bootloader hace que parpadee el led 13 de un Arduino UNO y se reserva un trozo de memoria para el Bootloader (en el Arduino UNO ocupa sólo 0.5K de los 32K que tiene disponibles el micro para ello). En nuestro caso el ESP32 Nano Arduino igual pero cuando cargamos el micropython nos cargamos ese bootloader por otro que tiene el compilador microPython. Lo de "quemar" o "flashear" el bootlader nos lo podemos encontrar en los cursos de Aularagón en el Zigbee de domótica con Raspberry, o a la hora de quemar el Nano Arduino como Arduino UNO en el curso de mClon

Tal y como dice en https://docs.arduino.cc/tutorials/alvik/setting-alvik-arduino-ide/

  1. cortocircuitar B1 y GND
    2024-07-11 20_11_20-Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.png
    Yo lo hago con un destornillador y toco las dos puntas, con cuidado de no tocar nada más.
  2. Mientras esta cortocircuitado PULSA EL BOTÓN RESET
    2025-03-27 18_35_58-oculto _ Librería CATEDU.png
  3. Soltar botón y cortocircuito pines B1 y GND y se queda el led de la placa ESP32 en color púrpura ver figura del paso 1, si no se queda púrpura, repetir el proceso paciencia
  4. Abrir el programa ARDUINO IDE PERO CERRAR OTROS
    (como el Arduino Create Agent que se queda en segundo plano abajo a la derecha , el MicroPython Installer....)
    image.png
  5. Asegurarse que esta instalado la placa Arduino ESP32 correctamente al menos la versión 2.013
    (ir a Tools-Boards-BoardManager) si hay una versión anterior, desinstalar el que hay (remove) e instalarlo de nuevo.
    2024-07-11 20_23_19-Configuración.png
  6. Ir a Tools-Port y seleccionar el puerto, habrá cambiado a uno nuevo, puede ser algo parecido a esto :
    2025-03-27 13_55_44-sketch_mar27a _ Arduino IDE 2.3.4.png
  7. Ir a Tools > Board - Arduino ESP32 Boards > Arduino Nano ESP32 (o esp32 > Arduino Nano ESP32 )
  8. Poner Tools-> Programmer- seleccionar ESPTOOL
    2024-07-11 20_22_12-.png
  9. Sketch > Upload Using Programmer 
    2024-07-11 20_27_00-.png
  10. Cuando salga este mensaje pasar al paso 11

     
    Leaving...
Hard resetting via RTS pin...
  11. Apretar el botón RESET y ya puedes o ejecutar un programa en Arduino IDE o instalar MicroPython

Curiosidad:
¿Por qué al poner la placa en modo Bootloader o cada vez que enciendo Arduino Alvik se enciende y se apaga el led RGB de al lado con los colores Rojo y Verde?
Solución https://libros.catedu.es/books/arduino-alvik/page/gpio-del-esp32-lD7

P: ¿No hay otra forma que no sea meter el destornillador y cortocircuitar los pines B1 y GND?
R: Si, hemos elegido la anterior pues nos parece más rápida y sencilla pero en https://github.com/arduino-libraries/Arduino_Alvik?tab=readme-ov-file#how-to-update-firmware-of-arduino-alvik-carrier tienes otro método utilizado el programa STM32 Cube Programer

Arduino IDE

Arduino IDE sin IoT: Un pequeña danza

En la pagina https://www.arduinolibraries.info/libraries/arduino_alvik o desde https://github.com/arduino-libraries/Arduino_Alvik podemos descargarnos multitud de ejemplos de código escrito en Arduino IDE para manejar este robot

Una pequeña danza

 Este sencillo programa hace mover el robot a una velocidad de 10 y va cambiando el giro de 45º a -45º cada segundo

#include "Arduino_Alvik.h"

Arduino_Alvik alvik;

void setup() {
  alvik.begin();
}

void loop() {
  alvik.drive(10, 45);
  delay(10000);
  alvik.drive(10, -45);
  delay(10000);
}
y da este error NO DEU dfu-util: No DFU capable USB device available Failed uploading: uploading error: exist status 74 ¿Por qué?

No has preparado convenientemente el ALVIK haz https://libros.catedu.es/books/arduino-alvik/page/preparar-alvik-para-arduino-ide-modo-bootloader 

Resultado

Arduino IDE

Arduino IDE sin IoT: Evita obstáculos

En la pagina https://www.arduinolibraries.info/libraries/arduino_alvik o desde https://github.com/arduino-libraries/Arduino_Alvik podemos descargarnos multitud de ejemplos de código escrito en Arduino IDE para manejar este robot

Evita obstáculos

 Este sencillo programa hace mover el robot evitando obstáculos

#include "Arduino_Alvik.h"

Arduino_Alvik alvik;

void setup() {
  alvik.begin();
  delay(5000);  // Waiting for the robot to setup
}

void loop() {
  float distance = 12.0;
  float degrees = 45.0;
  float speed = 10.0;

  float distance_l, distance_cl, distance_c, distance_r, distance_cr;
  
  alvik.get_distance(distance_l, distance_cl, distance_c, distance_r, distance_cr);
  delay(50);
  
  Serial.println(distance_c);

  if (distance_c < distance || distance_cl < distance || distance_cr < distance || distance_l < distance || distance_r < distance) {
    alvik.rotate(degrees);
  } else {
    alvik.drive(speed, 0.0);
  }
}
y da este error NO DEU dfu-util: No DFU capable USB device available Failed uploading: uploading error: exist status 74 ¿Por qué? No has preparado convenientemente el ALVIK haz https://libros.catedu.es/books/arduino-alvik/page/preparar-alvik-para-arduino-ide-modo-bootloader 
Resultado

Reto

Tienes muchos ejemplos en https://github.com/arduino-libraries/Arduino_Alvik/tree/main/examples
🫵🫵🫵🫵 ¿ A QUE ESPERAS? 🫵🫵🫵

Arduino IDE

Arduino IDE sin IoT: Coche a control remoto

Más adelante verás un coche teledirigido con el móvil y usando internet.

Pero en este caso vamos a usar DOS ARDUINOS ALVIKS uno como receptor y otro con envío de órdenes

La fuente de este programa lo puedes encontrar en https://github.com/arduino-libraries/Arduino_Alvik/blob/main/examples/remote_control/remote_control.ino

Se graban los dos programas en los dos alviks, y al apretar OK uno es el que envía la órdenes y el otro le apretamos CANCEL y es el receptor

Es muy curioso que la comunicación lo hace via Wifi pero sin usar ningún punto de acceso exterior, sino entre ellos comunicación  pareada (peer)

/*
    This file is part of the Arduino_Alvik library.

    Copyright (c) 2024 Arduino SA

    This Source Code Form is subject to the terms of the Mozilla Public
    License, v. 2.0. If a copy of the MPL was not distributed with this
    file, You can obtain one at http://mozilla.org/MPL/2.0/.
    
*/

// This example shows how to interface 2 Alvik robots via ESPnow.
// At startup, you can select if an Alvik is a trasmitter by pressing the "check button" or a receiver by pressing "cancel button". Use arrows to move the robot.

#include "Arduino_Alvik.h"
#include <esp_now.h>
#include <WiFi.h>

Arduino_Alvik alvik;

uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t myData;
esp_now_peer_info_t peerInfo;


int alvik_mode = -1; // 0 is receiver, 1 is sender

bool led_blink = false;


void setup() {
  Serial.begin(115200);
  while((!Serial)&&(millis()>3000));

  alvik.begin();

  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  while (alvik_mode == -1){
    if (alvik.get_touch_cancel()){
      alvik_mode = 0;
    }
    if (alvik.get_touch_ok()){
      alvik_mode = 1;
    }
  }
  if (alvik_mode == 0){
    esp_now_register_recv_cb(OnDataRecv);
  }
  else{
    memcpy(peerInfo.peer_addr, broadcastAddress, 6);
    peerInfo.channel = 0;  
    peerInfo.encrypt = false;
  
    if (esp_now_add_peer(&peerInfo) != ESP_OK){
      Serial.println("Failed to add peer");
      return;
    }
  }
}

void loop() {
  if (alvik_mode==0){
    alvik.left_led.set_color(led_blink, !led_blink, 0);
    alvik.right_led.set_color(!led_blink, led_blink, 0);
    delay(500);
  }
  else{
    if (alvik.get_touch_any()){
      if (alvik.get_touch_up()){
        myData = 'F';
        esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
      }
      if (alvik.get_touch_down()){
        myData = 'B';
        esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
      }
      if (alvik.get_touch_left()){
        myData = 'L';
        esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
      }
      if (alvik.get_touch_right()){
        myData = 'R';
        esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
      }
      if (alvik.get_touch_center()){
        myData = 'S';
        esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
      }
    }
    alvik.left_led.set_color(0, 0, led_blink);
    alvik.right_led.set_color(0, 0, led_blink);
    delay(100);
  }
  led_blink = !led_blink;
}

void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len){
  Serial.print(incomingData[0]);
  switch (incomingData[0]){
    case 'F':
      alvik.drive(7, 0);
      break;
    case 'B':
      alvik.drive(-7, 0);
      break;
    case 'L':
      alvik.drive(0, 45);
      break;
    case 'R':
      alvik.drive(0, -45);
      break;
    case 'S':
      alvik.brake();
      break;
  }
  Serial.println();
}

El resultado es expectacular

Arduino IDE

Internet de las cosas IoT

El Internet de las cosas (Internet of Thing IoT) describe objetos físicos —o grupos de estos— con sensores, capacidad de procesamiento, software y otras tecnologías que se conectan e intercambian datos con otros dispositivos y sistemas a través de internet u otras redes de comunicación.​ El Internet de las cosas se ha considerado un término erróneo porque los dispositivos no necesitan estar conectados a la Internet pública. Sólo necesitan estar conectadas a una red y ser direccionables individualmente

Fuente Wikipedia IoT Internet de las cosas CC-BY-SA

De Drawed by Wilgengebroed on FlickrTranslated by Prades97 CC BY-SA 3.0

Estamos hablando de dispositivos que se conectan a internet de forma desatendida, por vía hardware (o mejor dicho firmware) a diferencia de un ordenador, tablet o móvil, donde tienes que configurar por software el dispositivo y hay un diálogo entre usuario y dispositivo sobre el uso de Internet (el software solicita tal página web, tales datos etc por voluntad del usuario o por diálogo con el usuario) Aquí los dispositivos están ya configurados de los datos que se comunican. Es decir "conectar y olvidar". 

Piensa en la diferencia entre un enchufe inteligente y un ordenador, el primero es lo que se considera dentro de IoT

Las formas "desatendidas" son un avance en la sociedad pero también puede generar problemas muy serios a nivel mundial, ver el caso Mirai

Las cosas claras. ¿asíncrono o síncrono?

Hay muchas herramientas IoT

Arduino IDE

Arduino IDE con IoT: Escaneo Wifi

Desde https://github.com/espressif/arduino-esp32/blob/master/libraries/WiFi/examples/WiFiScan/WiFiScan.ino podemos encontrar este programa para escanear las redes wifi desde nuestro ESP32 Arduino

https://app.arduino.cc/sketches/54b6f875-2961-4ec5-8a48-608d9dde5feb?view-mode=preview

y da este error NO DEU dfu-util: No DFU capable USB device available Failed uploading: uploading error: exist status 74 ¿Por qué?

No has preparado convenientemente el ALVIK haz https://libros.catedu.es/books/arduino-alvik/page/preparar-alvik-para-arduino-ide-modo-bootloader 

Instalando la librería Wifi.h

Te dará un error de compilación pues no tiene esta librería. Puedes descargar la versión última desde https://www.arduino.cc/reference/en/libraries/wifi/

2024-07-04 11_41_25-WiFi - Arduino Reference.png

Una vez descargada (un fichero ZIP no lo descomprimas) en el editor Arduino IDE se instala desde este menú

2024-07-04 11_43_04-.png

Seleccionamos el fichero Zip que has descargado y ya tenemos la librería instalada

Compilamos

Antes de compilar CONECTAMOS NUESTRO ESP32

connecting-final.gif
Licencia CC-BY-NC-SA origen https://courses.arduino.cc/explore-robotics-micropython/lessons/getting-started/

No hace falta encender el robot Arduino Alvik

Y seleccionamos la placa que ha reconocido

2024-07-04 11_46_46-sketch_jul4a _ Arduino IDE 2.3.2.png

Y ya se puede compilar !!! no tiene que dar ningún fallo 

2024-07-04 11_47_46-sketch_jul4a _ Arduino IDE 2.3.2.png

Subirlo al ESP32

Pues si lo intentas subir

2024-07-04 11_51_03-sketch_jul4a _ Arduino IDE 2.3.2.png

y da este error NO DEU dfu-util: No DFU capable USB device available Failed uploading: uploading error: exist status 74 ¿Por qué?

Lee https://libros.catedu.es/books/arduino-alvik/page/modo-bootloader

Resultado

Le damos a subir, y en la ventana de Output da como correcto

2024-07-04 11_53_15-sketch_jul4a _ Arduino IDE 2.3.2.png

Y si nos vamos a la ventana del monitor serie

2024-07-04 11_54_32-.png

No nos sale nada !!! le das al botón de reset y ya sale :

2024-07-04 11_55_29-sketch_jul4a _ Arduino IDE 2.3.2.png

¿Puedo ahora ejecutar un programa en MicroPyhon?

No, tal y como dice aquí https://libros.catedu.es/books/arduino-alvik/page/instalar-micropython tienes que instalar el interpretador/compilador de Micropython dentro del ESP32, sino Arduino Lab for Micropython no se podrá conectar porque no lo encontrará.

Arduino IDE

Arduino IDE con IoT: Arduino Cloud

Esta plataforma https://docs.arduino.cc/arduino-cloud/ nos permite conectar nuestras placas (Arduino v4, ESP32, et...) con un panel de control Dashboard y así controlarlos a distancia por Internet. 

El mecanismo es sencillo, el ESP32 conectado por internet, pasa variables a un código (Sketch), a este conjunto se le llama Thing, y este se lo comunica a IoT CLOUD y la plataforma lo comunica a los paneles de control. Dashboard que se puede ver desde el PC o desde el móvil El proceso también funciona al revés.

2024-07-07 21_26_04-Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.pngExtraído de Youtube Exploring the Arduino Nano ESP32

  1. Creamos una cuenta en Arduino Cloud 
  2. Instalamos Arduino Create Agent
  3. Build the Thing es decir preparamos nuestra placa ESP32 con el Sketch
    1. Creamos the device
    2. Creamos the thing
    3. Añadimos las variables
    4. Creamos el scketch y lo grabamos en el ESP32
  4. Construimos un Dashboard o panel de control
PASO 1 LOGUEARSE EN ARDUINO CLOUD

En Plan permite una cuenta gratuita sólo se pueden 2 things ver https://cloud.arduino.cc/plans

PASO 2 ADRUINO CREATE AGENT

Arduino Create Agent te lo puedes descargar desde https://cloud.arduino.cc/download-agent, se descarga, se ejecuta, hay que seguir los pasos, se queda en segundo plano en el PC y no tienes que preocuparte

2024-07-07 21_55_42-Editing Page Arduino Cloud _ Librería CATEDU.png

PASO 3 Build the Thing: CREATE DEVICE

Primero añadimos un Device o placa en https://app.arduino.cc/devices

2024-07-07 21_50_29-Devices _ Arduino Cloud.png

Elegimos placa Arduino 

2024-07-07 21_52_49-Setup Device _ Arduino Cloud.png

Si falla, ponemos la placa en modo Bootloader (ver qué es eso en https://libros.catedu.es/books/arduino-alvik/page/instalar-micropython ) y entonces detectará el puerto

Conectamos nuestro Arduino Alvik y saldrá un diálogo con un TOKEN on Secret key que lo guardaremos ante todo no hacerlo público 

2024-07-07 22_43_26-Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.png

PASO 3 Build the Thing: CREATE THING

Una vez creada la placa, nos vamos a Thing, crear

2024-07-07 22_45_52-Things _ Arduino Cloud.png

Asociamos el Thing al Device, y le configuramos una red wifi (te predirá el Secret Key)

2024-07-10 14_17_16-Untitled Thing _ Arduino Cloud.png

PASO 3 Build the Thing: CREATE THING-VARIABLES

Luego añadimos variables, por ejemplo RGBverde que va a encender y apagar la luz verde, va a ser tipo Bool y Read&Write

2024-07-11 12_15_52-micosa-alvik Thing _ Arduino Cloud.png

PASO 3 Build the Thing: CREATE THING-SKETCH

Dentro de Thinks nos vamos a SKETCH

2024-07-11 12_17_56-micosa-alvik Thing _ Arduino Cloud.png

y vemos que ha creado un código thingProperties.h que tiene que tener el SSID de la wifi, su contraseña y la palabra clave de nuestro ESP32, podemos ponerlo manualmente o nos fijamos y  en Secret Tab estan ya puestos :

2024-07-16 10_28_00-DETECTOR CO2 Thing _ Arduino Cloud.png

2024-07-11 12_19_15-micosa-alvik Thing _ Arduino Cloud.png

El otro script es el nombre que hemos creado en Thing y vemos que :

¿Por qué es D13? ¿NO TENDRÍA QUE SER 48?

Eso ya lo hemos visto en https://libros.catedu.es/books/arduino-alvik/page/parpadeo-led-esp32

2024-07-07 20_14_06-Alvik User Manual _ Arduino Documentation.png
Fuente https://docs.arduino.cc/tutorials/alvik/user-manual/

/* 
  Sketch generated by the Arduino IoT Cloud Thing "Untitled"
  https://create.arduino.cc/cloud/things/34a0aae1-c7b9-42ab-92d4-0e37bd51031f 

  Arduino IoT Cloud Variables description

  The following variables are automatically generated and updated when changes are made to the Thing

  bool rGBverde;

  Variables which are marked as READ/WRITE in the Cloud Thing will also have functions
  which are called when their values are changed from the Dashboard.
  These functions are generated with the Thing and added at the end of this sketch.
*/

#include "thingProperties.h"

void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();

  /// MI CODIGO
  pinMode(D13,OUTPUT);
}

void loop() {
  ArduinoCloud.update();
  // Your code here 
  
  
  
}



/*
  Since RGBverde is READ_WRITE variable, onRGBverdeChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onRGBverdeChange()  {
  // Add your code here to act upon RGBverde change
  if (rGBverde){
    digitalWrite(D13,HIGH);
    
  }else{
    digitalWrite(D13,LOW);
    
  }
}

/*
  Since RGBrojo is READ_WRITE variable, onRGBrojoChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onRGBrojoChange()  {
  // Add your code here to act upon RGBrojo change
}

Lo subimos 

2024-07-11 12_32_16-micosa-alvik Thing _ Arduino Cloud.png

Ojo, tienes que tener el Arduino Arduino Create Agent paso 2

PASO 4 Dashboard

Creamos un panel de control

2024-07-11 12_38_29-Dashboards _ Arduino Cloud.png

Y le añadimos un Switch asociado a la variable RGBverde

2024-07-11 12_39_36-ENCENDER-LEDS-ARDUINO-ALVIK Dashboard _ Arduino Cloud.png

Podemos ver el dashboard en un teléfono móvil instalando la APP Arduino IoT Cloud Remote

2024-07-11 12_43_31-arduino cloud iot - Aplicaciones de Android en Google Play.png

Al loguearse con tu cuenta, ya nos aparece el Dashboard

Resultado

Arduino IDE

Arduino IDE con IoT: Coche teledirigido

Aprovechamos el programa que enciende y apaga un led por Arduino Cloud

Variables

Le añadimos tres variables más :

  1. velocidad tipo entero Read&Write
  2. giro tipo entero Read&Write
  3. distancia tipo float Read

2024-07-11 23_56_28-micosa-alvik Thing _ Arduino Cloud.png

Sketch

En thingProperties.h añade automáticamente estas variables y funciones, no tienes que añadirlas :

void onGiroChange();
void onVelocidadChange();
void onRGBverdeChange();

float distancia;
int giro;
int velocidad;
bool rGBverde;

Pero en la función principal, nosotros vamos a poner el siguiente código :

Nota: la instrucción 41 se han colocado dentro de loop() pero también se podría haber colocado dentro de onGiroChange();
onVelocidadChange();

#include "thingProperties.h"
#include "Arduino_Alvik.h"

Arduino_Alvik alvik;

float distances[5];


void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 
  
  alvik.begin();

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();

  /// MI CODIGO
  pinMode(D13,OUTPUT);
}

void loop() {
  ArduinoCloud.update();
  // Your code here 

  alvik.drive(velocidad,giro);
  alvik.get_distance(distances[0], distances[1], distances[2], distances[3], distances[4]);
  distancia=distances[2];
  
  
  
}



/*
  Since RGBverde is READ_WRITE variable, onRGBverdeChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onRGBverdeChange()  {
  // Add your code here to act upon RGBverde change
  if (rGBverde){
    digitalWrite(D13,HIGH);
    
  }else{
    digitalWrite(D13,LOW);
    
  }
}

/*
  Since RGBrojo is READ_WRITE variable, onRGBrojoChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onRGBrojoChange()  {
  // Add your code here to act upon RGBrojo change
}



/*
  Since Velocidad is READ_WRITE variable, onVelocidadChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onVelocidadChange()  {
  // Add your code here to act upon Velocidad change
}
/*
  Since Giro is READ_WRITE variable, onGiroChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onGiroChange()  {
  // Add your code here to act upon Giro change
}
Dashboard

Creamos un panel de control con:

2024-07-12 00_10_53-ENCENDER-LEDS-ARDUINO-ALVIK Dashboard _ Arduino Cloud.png

Resultado

Arduino IDE

GPIO del ESP32

Mapa de los pines en el Arduino Nano ESP32 

2024-07-07 20_10_30-Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.png
Extraído de Youtube Exploring the Arduino Nano ESP32

Como podemos observar, nuestro objetivo pues es el GPIO0

¿Dónde está físicamente los GPIO ?

Pues como podemos ver en este esquema el GPIO0 está en el pin BOOT1

2024-07-07 20_14_06-Alvik User Manual _ Arduino Documentation.png
Fuente CC-BY-SA https://docs.arduino.cc/tutorials/alvik/user-manual/

Como puedes observar, si cortocircuitas B1 = GPI0 = D15 con GND enciende el led RGB en color verdel esto pasa si Pones la placa en modo Bootloader.

Arduino IDE

Arduino IDE con IoT: ESP32 + Sensores externos + IoT

OBJETIVO

Ahora vamos a utilizar el ESP32 SIN EL ARDUINO ALVIK podemos sacar la placa microcontroladora y ponerlo en una placa protoboard y experimentar con sensores y actuadores estándares en el mercado :

2024-07-15 13_08_38-esp32 nano arduino at DuckDuckGo.png  + 2024-07-15 13_09_30-placa protoboard at DuckDuckGo.png

Para ver varias posibilidades, vamos a ver estos sensores y actuadores (recomendamos ver estas páginas actuadores y sensores)

+2024-07-15 13_11_03-semaforo arduino at DuckDuckGo.png+sensorluzarduino.jpg+CCS811-KEYSTUDUUDIO.png

ESQUEMA DE CONEXIONES

2024-07-07 20_14_06-Alvik User Manual _ Arduino Documentation.png

2024-07-15 14_47_48-New ESP32 Project - Wokwi Simulator.png

2024-07-15 14_08_38-(1) Exploring the Arduino Nano ESP32 _ MicroPython & IoT Cloud - YouTube.png

DEVICES 

Nos vamos a Arduino Cloud, y en DEVICES añadimos el ESP32 y obtenemos el TOKEN o palabra secreta (si has hecho la práctica anterior, no es necesario pues ya tenemos el TOKEN o palabra secreta) como es similar al caso anterior, no lo desarrollamos. (Nos pedirá también el SSID y la contraseña de la red wifi)

VARIABLES

Añadimos las siguientes variables :

EL SCKETCH -LIBRERIA CCS811

Primero añadiríamos la librería de keystudio https://fs.keyestudio.com/KS0457 pero no lo permite Arduino Cloud, viendo las instrucciones, vemos que son las mismas que en los ejemplos de esta librería la de DF que es la que instalamos :

2024-07-15 13_41_58-DETECTOR CO2 Thing _ Arduino Cloud.png

esto provoca la incorporación de la línea 1 #include <DFRobot_CCS811.h>

EL SCKETCH -EL CÓDIGO

#include <DFRobot_CCS811.h>
/* 
  Sketch generated by the Arduino IoT Cloud Thing "Untitled"
  https://create.arduino.cc/cloud/things/17c10209-3874-430a-877c-c082ff7dd38d 

  Arduino IoT Cloud Variables description

  The following variables are automatically generated and updated when changes are made to the Thing

  int cO2;
  int luz;
  bool luzdigital;
  bool rojo;

  Variables which are marked as READ/WRITE in the Cloud Thing will also have functions
  which are called when their values are changed from the Dashboard.
  These functions are generated with the Thing and added at the end of this sketch.
*/

#include "thingProperties.h"

//DFRobot_CCS811 CCS811(&Wire, /*IIC_ADDRESS=*/0x5A);
DFRobot_CCS811 CCS811;

void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();


  while(CCS811.begin() != 0){
        Serial.println("failed to init chip, please check if the chip connection is fine");
        delay(1000);
    }
  pinMode(1,OUTPUT);
  pinMode(0,INPUT);
  
}

void loop() {
  ArduinoCloud.update();
  // Your code here 
   if(CCS811.checkDataReady() == true){
        Serial.print("CO2: ");
        Serial.print(CCS811.getCO2PPM());
        cO2=CCS811.getCO2PPM();
        Serial.print("ppm, TVOC: ");
        Serial.print(CCS811.getTVOCPPB());
        Serial.println("ppb");
        
    } else {
        Serial.println("Data is not ready!");
    }
    luz = analogRead(A0);
    if (rojo){
      digitalWrite(1,HIGH);
    }else{
      digitalWrite(1,LOW);
    }
    luzdigital=digitalRead(0);
  
  
}





/*
  Since Rojo is READ_WRITE variable, onRojoChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onRojoChange()  {
  // Add your code here to act upon Rojo change
}
DASHBOARD

2024-07-15 14_16_36-CO2 Dashboard _ Arduino Cloud.png

Alternativa : en vez de luz tendría que llamarse "oscuridad" que sea luz pero que vaya al revés

RESULTADO

ALTERNATIVA:  Que el semáforo visualice los niveles peligrosos de CO2, por ejemplo el umbral del amarillo 600-1.000

¿Te atreves a poner un servomotor?

Créditos

Autor:

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