Una de las opciones que existen para crear test funcionales es Selenium y este puede ser controlado con Python usando selenium-python. Python hace más fácil el desarrollo de tus tests, ya que te permite probar cosas interactivamente. En este video te muestro cómo:
esp8266 a 160MHz con MicroPython
El módulo machine tiene la función freq que devuelve la frecuencia en hertz
>>> import machine
>>> machine.freq()
80000000
Esto es 80MHz, la frecuencia normal de trabajo del esp8266, pero podemos llevarlo al doble de su velocidad
>>> machine.freq(160000000)
Los valores intermedios no son permitidos
>>> machine.freq(100000000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: frequency can only be either 80Mhz or 160MHz
Para probar el cambio he aquí una pequeña función que cuenta ticks
import utime
def performance_test():
secs = utime.ticks_ms()
end_time = secs + 5000
count = 0
while utime.ticks_ms() < end_time:
count += 1
print("Count:", count)
Finalmente
>>> machine.freq(80000000)
>>> performance_test()
Count: 55596
>>> machine.freq(160000000)
>>> performance_test()
Count: 98702
Compilar MicroPython en Ubuntu 16.04
Una buena forma de ahorrar memoria con MicroPython es cargar tus propios módulos como frozen byte-code en la imagen misma, es decir en el binario que usás para flashear tu micro, para lo cual hay que compilar MicroPython con los módulos que necesitás.
Para empezar asegurate de tener instalado todo esto
sudo apt-get install make unrar-free autoconf \
automake libtool gcc g++ gperf \
flex bison texinfo gawk ncurses-dev \
libexpat-dev python-dev \
python-serial sed git unzip \
help2man wget bzip2 libtool-bin
Luego hay que descargar el ESP toolchain desde el repo de Git
git clone --recursive https://github.com/pfalcon/esp-open-sdk.git
Cambiar al directorio y compilar
cd esp-open-sdk
make
Una vez finalizada la compilación agregar el directorio bin al PATH
export PATH=/some/dir/esp-open-sdk/xtensa-lx106-elf/bin:$PATH
Finalmente bajar el repositorio de MicroPython
git clone https://github.com/micropython/micropython.git
cd micropython
git submodule update --init
Agregar tus módulos .py en ports/esp8266/modules
Y compilar MicroPython
make -C mpy-cross
cd ports/esp8266
make axtls
make
Esto generará el archivo build/firmware-combined.bin y es el que tenés que usar con esptool.py para flashear el micro.
Más info en la MicroPython Development Documentation.
Minirobots finalista del concurso Premio a la Educación 2017
Con Minirobots nos presentamos al Concurso Premio a la Educación que organizan Clarín y Zurich, y sobre un total de 185 proyectos presentados, quedamos seleccionados entre los 10 primeros.
Actualización: Ganadores del Concurso Clarín-Zurich 2018
El proyecto que presentamos fue una propuesta para capacitar a los docentes de la Escuela Nacional Ernesto Sábato de Tandil. El objetivo final de este proyecto es generar contenido didáctico en formato libre para enseñar a los alumnos a programar un robot usando Python.
La entrega de premios fue el 21 de diciembre y, si bien no logramos ganar ninguno, fue un paso importante para nosotros porque valida el trabajo que venimos haciendo y nos motiva a continuar.
Minirobots gamepad
Tenía unos pulsadores tipo arcade y se me ocurrió experimentar haciendo un gamepad gigante para controlar el robot que estamos haciendo en Minirobots. La idea de esto es explorar posibles juegos para los más chiquitos.
El pad tiene un Arduino Nano con un código muy simple y se conecta a la notebook por usb. Ahí hay un pequeño servidor Flask que escucha lo que le llega por serie y le envía comandos vía bluetooth al robot.
Impresora 3D en Minirobots
Para el proyecto con Minirobots necesitábamos una impresora 3D, así que luego de investigar alternativas y de haber probado la Trimaker Cosmos me decidí por una de estas. Es una máquina que se la ve muy bien construída, sencilla y con buenos materiales.
La calidad de la impresión es realmente excelente, la he comparado con otras y realmente supera a las Replikat XY y las FAR TecnoArt S II, también de Industria Argentina.
Tiene un volumen de impresión de 242x181x130mm y viene con una boquilla de 0.4mm. Se la puede conectar por USB y manejar remotamente con Octoprint, o guardar el .gcode en su tarjeta SD y realizar la impresión de forma totalmente autónoma.
NeoPixels en Raspi Zero W
Los NeoPixels se conectan en serie, por lo que podés controlar una gran cantidad de ellos simplemente con un pin. Aunque sólo tengas que usar un único LED RGB en tu proyecto, te conviene usar un Neopixel frente a un LED RGB tradicional, porque, te ahorrás 2 pines y porque los colores son realmente nítidos. Los he venido usando tanto con Arduino como con ESP8266, gracias a la lib de Adafruit. Hay por lo menos dos versiones: los WS2812 y los WS2812b. Estos últimos son la versión más nueva y los que muestro aquí.
Estos leds funcionan con 5v, así que usé uno de los pines de 5v de la Raspberry. Los pines 2 y 4 están conectados directamente a la fuente de alimentación por lo que pueden proveer tanta corriente como esta esté entregando. En el sitio pinout.xyz se puede ver esto y una descripción de cada pin.
La lib que hay que instalar se llama rpi_ws281x y hay que compilarla ya que no existe actualemente un empaquetado. Así que a instalar dependencias:
sudo apt-get update
sudo apt-get install build-essential python-dev git scons swig
Luego bajamos la lib y la compilamos:
git clone https://github.com/jgarff/rpi_ws281x.git
cd rpi_ws281x
scons
Finalmente la instalamos:
cd python
sudo python setup.py install
Listo, ahora ya podemos probarla
cd example
vi strandtest.py
Aquí editamos el valor de LED_COUNT según la cantidad de leds que tengamos y finalmente:
sudo python strandtest.py
Api genérica
Siempre ando necesitando una api para hacer pruebas, así que se me ocurrió hacer una genérica, donde no tengas que definir nada previamente, donde todo sea dinámico, tanto los endpoints como el formato de los documentos.
Surgió así generic-api, una api schemeless, que con Docker podés empezar a usarla con un simple comando:
$ docker run -d --name generic-api -p 5000:5000 lvidarte/generic-api:latest
La api persiste los datos usando shelve. Si te interesa conservar los datos por fuera del container simplemente agregá esto a la línea de docker:
-v `pwd`/data:/app/data
Los métodos que soporta son GET, POST y DELETE.
Veamos un ejemplo guardando autores y libros. Primero creamos el endpoint /authors simplemente agregando un autor:
$ curl localhost:5000/authors -d '{"name": "Asimov"}'
{
"_id": "1",
"name": "Asimov"
}
La api devuelve 201 y el documento insertado junto con su _id. Notar que no es necesario usar el header "Content-Type: application/json" ya que la api asume que le enviaremos jsons.
Ahora uso el id generado para referencialo y agregarle libros:
$ curl localhost:5000/authors/1/books -d '{"title": "Nemesis", "year": 1988}'
{
"_id": "1",
"title": "Nemesis",
"year": 1988
}
$ curl localhost:5000/authors/1/books -d '{"title": "Foundation and Earth", "year": 1987}'
{
"_id": "2",
"title": "Foundation and Earth",
"year": 1987
}
Si ahora pido /authors/1 veo el doc completo:
$ curl localhost:5000/authors/1
{
"_id": "1",
"books": {
"1": {
"_id": "1",
"title": "Nemesis",
"year": 1988
},
"2": {
"_id": "2",
"title": "Foundation and Earth",
"year": 1987
}
},
"name": "Asimov"
}
También puedo acceder a cualquier nivel del doc simplemente escribiendo el path:
$ curl localhost:5000/authors/1/books/2/title
"Foundation and Earth"
$ curl localhost:5000/authors/1/books/2/year
1987
Y lo puedo modificar usando POST:
$ curl localhost:5000/authors/1/books/2/year -d '1986'
1986
$ curl localhost:5000/authors/1/books/2
{
"_id": "2",
"title": "Foundation and Earth",
"year": 1986
}
Finalmente puedo borrar cualquier path:
$ curl -XDELETE localhost:5000/authors/1/books/2
$ curl localhost:5000/authors/1/books/2
{
"error": "2 not in authors/1/books"
}
Librería para motores de paso 28byj-48
Simple-Stepper es un pequeña lib para manejar steppers 28byj-48 que hice luego de mirar este video, donde se muestra el funcionamiento del motor. La lib es compatible con esp8266 y maneja tres tipos de secuencias: Wake Drive, Full Step y Half Step. No maneja aceleración, para eso está AccelStepper.
Aquí un ejemplo con un motor, haciendo un giro completo en sentido horario.
#include <SimpleStepper.h>
SimpleStepper stepper(SimpleStepper::FULLSTEP, D5, D6, D7, D8)
void loop ()
{
stepper.steps(stepper.getFullRotationSteps());
while ( ! stepper.ready())
{
stepper.step();
delay(3);
yield();
}
}
La lib funciona con varios motores en simultáneo, en github se puede ver un ejemplo con dos motores.
← Older | Newer →
