Fork me on GitHub

NeoPixels en Raspi Zero W

July 28, 2017

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

Read more »

Python Raspberry

Api genérica

July 17, 2017

Siempre ando necesitando una api para hacer pruebas, y como andaba con algo de tiempo se me ocurrió hacer una genérica, donde no tengas que definir nada previamente, donde todo sea dinámico, tanto los endpoints como los documentos. Me pareció además interesante como ejercicio, ¿cómo hacerla?, así fueron surgiendo Python, diccionarios, Flask, Docker...

Surgió así generic-api, una api schemeless, que además, al estar dockerizada, podés empezar a usar tirando 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"
}

Python Trabajos

Librería para motores de paso 28byj-48

July 17, 2017

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.

Arduino Trabajos esp8266

Minirobots

July 14, 2017

Hace más de un año arranqué con el proyecto minirobots cuyo fin es ayudar a los más chicos en sus primeros pasos con la programación. A finales del año pasado logré reunir un grupo de entusiastas para llevar esta aventura a un próximo nivel. Fue así que nos presentamos en el Fondo Semilla con este video y mucho papeleo extra. Finalmente resultamos ganadores y ahora nos encontramos en pleno desarrollo de un modelo que sea apto para llegar a los hogares.

El equipo está formado por seis personas

  • Arturo Gasca - Diseñador visual
  • Luciano Fortain - Diseñador de interfaces
  • Juan Caivano (pulpo) - DevOps
  • Emilce Bartoli - Análisis del impacto social
  • Juan Ignacio Alterio - Programación UI
  • Leo Vidarte - Programación firmware y backend

El prototipo con el que nos presentamos es un robotito que se programa visualmente en Logo, un lenguaje que fue creado para enseñar los conceptos básicos de la programación y con el cual se pueden repasar y reforzar conceptos de geometría, ya que se trata de programar la tortuga (así se llama el cursor que dibuja en Logo) para dibuje distintas figuras geométricas. En el siguiente video se puede ver cómo dibuja una estrella.

Más info en

Minirobots Trabajos

Curso de Python

July 12, 2017

Hace poco preparé este Curso de Python (144 slides) para compañeros de trabajo. El curso arranca con conceptos básicos del lenguaje como tipos y estructuras, funciones, decoradores, generadores, clases y excepciones. Luego se ven módulos como logging, queue, multiprocessing, threading, unittest y pdb. También hay ejemplos con Flask, PiCamera y GPIO Zero (Raspberry Pi) y finaliza con Tkinter y un ejemplo paso a paso de cómo desarrollar una versión sencilla del Juego de la Vida.

Charlas Python

Workshop sobre ESP8266

July 10, 2017

El año pasado entré a trabajar en el estudio de IoT de Globant. Entre otras cosas estuve investigando el ESP8266 y de ello surgió este Workshop sobre esp8266 para divulgar lo aprendido entre el resto de los compañeros.

El taller cuenta con una introducción al esp8266 y sus distintos módulos, incluyendo con los devkits más populares, como NodeMCU y Wemos D1. Luego hay una introducción a MicroPython y varios ejemplos de uso. Finalmente se analizan los mismos ejemplos con C++ usando la librería ESP8266 Core for Arduino.

Entre los ejemplos se ve manejo de LEDs, NeoPixels, switches, sensores de temperatura y humedad, pantallas OLED, lectores de SD y servos. Hay un ejemplo completo de una lámpara RGB WiFi con Python y cómo actualizar el firmware mediante OTA usando C++. También se muestra PlatformIO como IDE de desarrollo con C++ y Phant como servidor IoT.

El taller está orientado a programadores sin necesidad de conocimientos de electrónica.

Charlas Python esp8266

MicroPython - Lámpara RGB

August 26, 2016

Continuando las pruebas con MicroPython me puse a hacer una lámpara RGB controlable por wifi. Quería probar también eso de levantar mi propio access point y que los clientes se conectaran a él. Encontré que es bastante sencillo de hacer, simplemente puse lo siguiente en boot.py

# boot.py
import network

ap_if = network.WLAN(network.AP_IF)
ap_if.config(essid="RGBLamp", password="12345678")

while not ap_if.active():
    pass

Esto levanta una red wifi RGBLamp y pone a NodeMCU como gateway en el 192.168.4.1 :)

También metí en este archivo las dos líneas necesarias para levantar webrepl ya que desde la interfaz web es muy sencillo subir los archivos a NodeMCU.

import webrepl
webrepl.start()

boot.py es el primer archivo que lee MicroPython e inmediatamente después busca main.py para la ejecución del programa principal. El código me quedó así

La interfaz web quedó así, sencilla, en principio porque apunté a algo mini pero también porque me encontré con algunos problemas de falta de memoria al querer procesar un template más grande, lo que me hizo incluso tener que minimizar el template antes de subirlo a NodeMCU.

Como mencioné antes un par de veces tuve que darle vueltas al código para evitar el memory allocation failed dado que esp12e tiene algo así como 36 KB de RAM. Estuve leyendo un poco al respecto y encontré (nunca falta quien...) a alguien que dejó de usarlo por esto.

Python Trabajos esp8266

MicroPython - Instalación en NodeMCU

August 22, 2016

En este post de Adafruit descubrí que existe un firmware de MicroPython para NodeMCU. MicroPython es un proyecto que nació en Kickstarter y que consiste en una reescritura de Python3 para hacerlo más liviano y óptimo para correr en microcontroladores. Al igual que el firmware de Lua también cuenta con un intérprete que se accede vía serial (con screen o picocom) y vía web usando el módulo webrepl.

La instalación es sencilla, primero hay que instalar esptool mediante pip

$ sudo pip install esptool

Luego bajar el último firmware para ESP8266 y finalmente subirlo a NodeMCU borrando previamente el firmware anterior

$ esptool.py --port /dev/ttyUSB0 erase_flash
$ esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=8m -fm dio 0 esp8266-2016-05-03-v1.8.bin

El detalle de cada paso está bien documentado en la doc de MicroPython.

Finalmente se puede acceder a la consola usando screen

$ screen /dev/ttyUSB0 115200
MicroPython v1.8.3-35-g49dd532 on 2016-08-18; ESP module with ESP8266
Type "help()" for more information.
 >>>

Para levantar webrepl hay que primero conectarse a la red local. Aquí hay ejemplos de cómo hacerlo, pero básicamente es

>>> import network, time
>>> wlan = network.WLAN(network.STA_IF)
>>> wlan.active(True)
>>> wlan.connect('your-ssid', 'your-password')
>>> while not wlan.isconnected():
...    time.sleep_ms(50)
...
>>> print(wlan.ifconfig())
('192.168.0.15', '255.255.255.0', '192.168.0.1', '8.8.8.8')

Luego de eso iniciamos webrepl

>>> import webrepl
>>> webrepl.start()
WebREPL daemon started on ws://192.168.4.1:8266
WebREPL daemon started on ws://192.168.0.15:8266
Started webrepl in normal mode

No hace falta bajar el editor, se puede usar la versión online simplemente cambiando la IP.

Python esp8266

Alarma con Raspberry Pi

June 27, 2016

En la MagPi salió un suplemento, Beginner's Electronic Raspberry Pi, que tiene varios tutoriales usando la nueva lib de Python gpiozero. Me gustó especialmente el que muestra cómo hacer una alarma usando un sensor de movimiento, es realmente simple con gpiozero.

El código está sacado del ejemplo, simplemente cambié los pines del sensor y el buzzer para que me quedara más cómodo en mi diagrama.

El esquema de conexiones lo hice con Fritzing

Python Raspberry Trabajos

Older | Newer →