lunes, 10 de diciembre de 2018

Cambiando firmware a Orvibo B25

Hace unos meses me compré un enchufe Orvibo "S20", pero me llegó un Orvibo B25, que no era integrable directamente con HomeAssistant, así que se quedó en un cajón hasta que he tenido tiempo de abrirlo y ponerme a trastear.

Lo primero que se ve nada más abrirlo es que tiene un chip muy similar a un ESP8266... (OW8266-02Q)


Imagen del OW8266-02Q

Buscando algo de documentación y probando parece que tiene el mismo pinout que el WT8266-S1



Así que buscamos el datasheet de este último y nos ponemos a soldar cables para intentarlo hacerlo entrar en modo flash (https://www.seeedstudio.com/document/word/WT8266-S1%20DataSheet%20V1.0.pdf)

Los pines que hay que localizar son:

- 5V (para poder hacer las pruebas sin tener que enchufar a la corriente posteriormente)
- GND
- RX
- TX
- GPIO0 (Para entrar en modo download)
- GPIO2 (Para entrar en modo download)
- GPIO15 (Para entrar en modo download)


Esquemita para tener encima de la mesa

Empezamos soldando los 3 primeros (5V, TX y RX) que están localizados en la placa (están indicados por detrás). El GND lo soldé en el regulador de tensión AMS1117 que hay en la parte inferior porque haciendo pruebas de continuidad no tenía muy claro que alguno de los otros lo fuera.





Pasamos a los GPIO necesarios para entrar en modo "download". Esto hay que hacerlo directamente sobre el chip ESP:




A los pines GPIO0, GPIO2 y GPIO15.

Después conectamos los pines de la placa al FTDI de la siguiente manera:



Enchufe FTDI
5V 5V
GND GND
RX TX
TX RX
GPIO0 GND
GPIO2 3.3V
GPIO15 GND


Conectamos el FTDI a nuestro PC y buscamos el puerto usando dmesg. En mi caso es /dev/ttyUSB0, así que procedemos a intentar sacar el firmware original para tenerlo de backup.



Una vez sacado el firmware anterior, procedemos a buscar uno que funcione. En esta ocasión probé con varios "espurna" de la familia Itead pero en ningún caso funcionaba puesto que el pinout no coindicía (el del switch, relé y led).

La siguiente opción era buscar el pinout, para ello hice un programa de arduino para probar entradas y otro para probar salidas.

El software para testear entradas era simple, le decías un pin por el terminal serie, lo accionabas y te decía si cambiaba de estado o no. Así descubrí que el swtich se correspondía al GPIO14.

Para los de salida, algo similar. El software te pedía el pin y cuando lo introduces empieza a alternar entre "HIGH" y "LOW". Así fue posible encontrar el relé (tictac), y los leds azul y rojo.

Tabla resumen de un par de horas de trabajo
Así que continuamos creando un nuevo dispositivo en espurna con los datos del B25, quedando tal que así:


Finalmente se compila y se carga en el dispositivo con:

sudo esptool.py --port /dev/ttyUSB0 write_flash --flash_size 1MB --flash_mode dout 0x00000 espurna-1.13.3-orvibo-b25.bin

Desconectamos todo de la protoboard, probamos que todo funciona correctamente y se crea la red WiFi para configurar espurna. ¡Conseguido! Ahora procedemos a desoldar todos los cables que habíamos puesto previamente para poder cerrar jeje.

El pullrequests en el repo de espurna ya está hecho y aceptado (https://github.com/xoseperez/espurna/pull/1402), pero los binarios compilados todavía no incluyen el del Orvibo B25, así que lo dejo por aquí por si alguien quiere probar antes de que se publique la siguiente release.


Si tenéis alguna duda podéis preguntar en los comentarios.

jueves, 6 de diciembre de 2018

Deschinando un ESP-01/01S Relay v4.0

El otro día con tanta oferta durante el BlackFriday pedí cosas que ni recordaba, así que ayer llegó esto:



Como no podía ser de otra forma, pasé a "deschinarlo" para tener la toda la funcionalidad del ESP8266 controlada con el HomeAssistant.

Lo primero fue conectar el ESP-01 al programador serie de la siguiente forma:



Teniendo en cuenta que el pinout es el siguiente mirando la placa desde arriba:
(Imágenes sacadas de https://www.instructables.com/id/ESP0101S-RELAY-MODULE-TUTORIAL/)

Tras esto, conectamos el programador serie a nuestro PC y usando esptool extraemos el firmware original (¡Nunca se sabe para qué puede servir!):

sudo esptool.py --port /dev/ttyUSB0 read_flash 0x00000 0x100000 esp01_backup.bin


Esperamos a que termine y buscamos un firmware que ponerle a nuestro cacharrito. Hemos ido a lo fácil y espurna ya tiene uno compilado que funciona bien, así que descargamos el firmware desde https://github.com/xoseperez/espurna/releases/ , concretamente este (o la versión que haya en el momento que estés leyendo esto):

espurna-1.13.3-generic-esp01s-relay-40.bin

Ahora procedemos a flashearlo de nuevo con esptool.py, así que DESENCHUFAMOS Y VOLVEMOS A ENCHUFAR el programador serie a nuestro PC y ejecutamos el siguiente comando:

sudo esptool.py --port /dev/ttyUSB0 write_flash --flash_size 1MB --flash_mode dout 0x00000 espurna-1.13.3-generic-esp01s-relay-40.bin
Con esto comenzará a flashearse nuestro ESP01.


Una vez terminado el proceso, desenchufamos el ESP01 del programador, lo enchufamos en la placa con su relé y lo alimentamos a 5V:


Una vez conectada la fuente de alimentación, pulsamos el botón reset y ya debería activarse la WiFi del espurna para configurar todo. Está pendiente un minitutorial de esto, pero podéis ver las instrucciones oficiales que están bastante claras: https://github.com/xoseperez/espurna/wiki/Configuration#first-boot

Finalmente, activamos la integración con HomeAssistant y MQTT:



Configuramos los detalles en HomeAssistant, dentro del bloque switch:


Reiniciamos HomeAssistant y listo!


Si tenéis cualquier duda preguntad en los comentarios. Un saludo!

jueves, 10 de septiembre de 2015

Cómo empezar con NodeMCU (II)

Después de ver cómo cargar el firmware (necesario para empezar a funcionar) y cómo hacer nuestro primer "Hello World!", viene el momento de hacer algo más interesante.

En NodeMCU se pueden cargar archivos de scripts LUA y no tener que estar copiándolos y pegándolos en el terminal. Para ello vamos a escribir nuestro primer script que nos mostrará las redes WiFi de nuestro alrededor:
 function listap(t) -- (SSID : Authmode, RSSI, BSSID, Channel)  
    print("\n"..string.format("%32s","SSID").."\tBSSID\t\t\t\t RSSI\t\tAUTHMODE\tCHANNEL")  
    for ssid,v in pairs(t) do  
    local authmode, rssi, bssid, channel = string.match(v, "([^,]+),([^,]+),([^,]+),([^,]+)")  
    print(string.format("%32s",ssid).."\t"..bssid.."\t "..rssi.."\t\t"..authmode.."\t\t\t"..channel)  
    end  
   end  
 wifi.sta.getap(listap)  

Lo guardamos como show_aps.lua y ahora necesitamos un "uploader" para subir los archivos a nuestro cacharrito. Yo utilizo este:
https://github.com/kmpm/nodemcu-uploader

Hacemos un git clone al repositorio
 $ git clone https://github.com/kmpm/nodemcu-uploader.git  

Y lo usamos, compilando y subiendo el archivo previamente creado:
 $ sudo python nodemcu-uploader.py upload show_aps.lua:show_aps.lua --compile  
 Preparing esp for transfer.  
 Remove show_aps.lc  
 file.remove("show_aps.lc")  
 Transfering show_aps.lua as show_aps.lua  
 Compile show_aps.lua  
 node.compile("show_aps.lua")  
 Remove show_aps.lua  
 file.remove("show_aps.lua")  
 All done!  

Ahora nos volvemos a conectar a través de Putty y lo ejecutamos para ver el resultado:
 > dofile("show_aps.lc")  

Y nos mostrará algo como esto:

OJOCUIDAO! Después de compilarlo ya no tiene extensión .lua, ahora tiene extensión .lc

Ahora vamos a conectarnos a nuestra WiFi, una vez hemos visto que la tiene localizada. Abriendo Putty de nuevo (si has sido un prisas y ya lo has cerrado) y escribimos lo siguiente:
 > wifi.setmode(wifi.STATION)  
 > wifi.sta.config("SSID","password")  
 -- Esperamos unos segundos que se conecte  
 > print(wifi.sta.getip())  
 >> 192.168.1.XXX  

Y ya está conectado NodeMCU a nuestra red WiFi!

Podemos comprobarlo con un ping desde nuestra máquina a la IP que nos ha devuelto.

En la próxima entrada un pequeño servidor web con algún dato interesante para probar que todo funciona correctamente.

Un saludo!

martes, 8 de septiembre de 2015

Cómo empezar con NodeMCU (I)

Aprovechando que hoy es fiesta en Málaga, he empezado a preparar un minitutorial de NodeMCU.

NodeMCU es un kit de desarrollo basado en hardware y software libre que como principales cualidades tiene la capacidad de almacenar hasta 4MB y conexión WiFi, además de costar 6,5€.

Antes de nada avisar que este mini tutorial es para Linux, pues es el sistema operativo que utilizo como principal.

Lo primero que vamos a hacer es flashear el cacharrito con el firmware necesario para hacerlo funcionar. La mayoría vienen flasheados, pero así podemos tenerlo actualizalo con la última versión.

Descargamos el firmware oficial desde github:
https://github.com/nodemcu/nodemcu-firmware/releases
Descargamos, en el momento de escribir esta entrada el archivo nodemcu_integer_0.9.6-dev_20150704.bin

Después tenemos que tener la herramienta para flashear nuestro NodeMCU, llamada esptool que es software libre (nuevamente) y podemos descargar desde: https://github.com/themadinventor/esptool

esptool tiene una dependencia que debemos instalar previamente con:
 $ sudo pip install pyserial  

Y después instalamos el propio esptool:
 $ sudo python setup.py install  

Ahora conectamos nuestro cacharrito y para ver qué puerto se le ha asignado hacemos:
 $ dmesg | tail  

Y nos debe salir algo como esto:
 [ 1699.923283] usb 1-1.2: new full-speed USB device number 8 using ehci-pci  
 [ 1700.016382] usb 1-1.2: New USB device found, idVendor=1a86, idProduct=7523  
 [ 1700.016389] usb 1-1.2: New USB device strings: Mfr=0, Product=2, SerialNumber=0  
 [ 1700.016392] usb 1-1.2: Product: USB2.0-Serial  
 [ 1700.016801] ch341 1-1.2:1.0: ch341-uart converter detected  
 [ 1700.018752] usb 1-1.2: ch341-uart converter now attached to ttyUSB0  

Lo que nos indica que ha sido conectado en /dev/ttyUSB0

Procedemos a flashear con esptool y el firmware (.bin) previamente descargado:
 $ sudo esptool.py --port /dev/ttyUSB0 write_flash 0x00000 ~/nodemcu/firmware/nodemcu_integer_0.9.6-dev_20150704.bin   
 Connecting...  
 Erasing flash...  
 Wrote 462848 bytes at 0x00000000 in 45.5 seconds (81.4 kbit/s)...  
   
 Leaving...  

Y con esto ya tenemos el firmware cargado sobre el NodeMCU.

Ahora vamos a conectarnos a través del puerto serie (USB). Lo primero es tener un cliente instalado, yo tengo Putty (sí, el que se usaba para Windows, es software libre y también está para Linux) se instala con:
 $ sudo apt-get install putty  

Lo abrimos (recordad abrirlo con sudo para tener acceso al dispositivo USB)
 $ sudo putty  

y lo configuramos tal que así:


Pulsamos en "Open" y saldrá una pantalla en negro. Si nos dice que hay un problema de conexión posiblemente es que no lo hemos ejecutado con sudo o el dispositivo ha cambiado de posición (/dev/) y debemos mirarlo de nuevo con dmesg. Después de la pantalla en negro, pulsamos el botón de reset de la placa y nos saldrá una pantalla como esta:



¡Enhorabuena!, ya tenemos acceso a nuestro NodeMCU. Ahora sólo tenemos que escribir el programa que queramos hacer funcionar. Para empezar, por supuesto, no puede faltar el "Hello World!":

> print("Hello World!")
Hello World!



En las próximas entradas se profundizará un poco más sobre cómo conectar al WiFi y cargar scripts en él.

Fuentes:

jueves, 15 de enero de 2015

Renfe y sus "útiles" ventanillas

        Hoy vengo a quejarme sobre Renfe, más concretamente de su servicio de cercanías. Les pongo en situación: soy usuario del cercanías desde hace aproximadamente un año de la línea C1 de Málaga.

       Para sacar billetes o abonos hace falta hacerlo desde las taquillas automáticas o bien desde las ventanillas, en las cuáles te atiende un "simpático" empleado de Renfe. Normalmente la gente saca un billete sencillo o de ida y vuelta, cuyos importes rondan desde los 1,10 a los 5 y pico euros, depende del número de zonas. Gente como yo que lo usamos casi a diario tenemos que comprar o bien bonos (un pack de varios viajes) o abonos (mensuales) los cuáles ya suben de precio.

A continuación voy a describir la utilidad de las máquinas autoventa: Sólo aceptan tarjetas de crédito, débito, monedas y billetes de 5 y 10 euros, algo normal.

    Un día de los que tenía que renovar el abono, los tarjeteros de las dos máquinas autoventa que hay en mi estación habitual se estropearon (vaya puntería, además estuvieron así varios meses) y aquí viene mi primer problema: voy a la ventanilla a que el simpático empleado me atienda para comprar el abono y al ir a pagar con tarjeta me dice que no puedo, que en ventanilla no aceptan tarjetas. Finalmente saco un billete sencillo y en la estación de destino (en la que ya sí funcionaban los tarjeteros de las máquinas automáticas) saco mi abono normal, con el consiguiente gasto extra de haber tenido que comprar el billete sencillo anterior.

    Otro caso: hace unos días se me estropeó la tarjeta de crédito y tuve que ir al banco a sacar dinero (mientras me mandaban una nueva), a lo que me dieron un billete de 50 euros. Fui a la taquilla (porque recuerdo que las máquinas autoventa sólo aceptan billetes de hasta 10 euros) y al pagar me dice que no puedo, que sólo aceptan moneda fraccionaria hasta billetes de 10 euros (¡igualito que las máquinas!).

    Para terminar de joder la marrana, otra de las cosas que me sucedió hace unos meses fue que quería obtener una tarjeta "Renfe&tú no personalizada", para la que sólo se necesitan 2 euros y una ventanilla. Mi sorpresa: me enviaron a la estación central porque ellos no sabían emitirla... y más sorpresa aún, me presenté en la estación principal y me sueltan que ¡ellos tampoco pueden!

    Ahora viene aquí mi pregunta: aún sabiendo que mucha gente perdería su puesto de trabajo, ¿de verdad son necesarias estas ventanillas, las cuáles no solucionan ningún problema y además están haciendo que el precio del billete sea más alto? Si lo que quieren es tener un punto de información, deben saber que la tecnología ha avanzado mucho y existen unos "quioscos" que ¡son hasta multilingües!, cosa que dudo mucho de la gente que está en estas ventanillas.

Un saludo.

sábado, 15 de noviembre de 2014

Haciendo cositas con el Vag-Com

Hoy tocaba hacer un par de pruebas con el VagCom que arreglé hace un par de semanas.
Para empezar, hace unos cuantos años instalé el Tempomat (velocidad de crucero) pero nunca conseguí que funcionara, así que una vez arreglado el vagcom, me puse a trastear un rato con él.

Para ellos conectamos el cable al coche, al USB del portátil (recordad desconectaros de Internet) y abrimos el software.

Auto-Scan

Nos encontraremos con una pantalla en la que en principio vamos a usar las dos primeras opciones. Para empezar, vamos a hacer un escaneo automático de los distintos módulos del coche para ver los errores que nos suelta. Para ello seleccionamos la opción "Auto-Scan".


Y posteriormente tenemos que elegir el modelo que coche que tenemos, en mi caso un Golf IV, y pulsamos en "Start".


Lo dejamos un rato que vaya escaneando todos los módulos de los que dispone nuestro coche y al final nos saldrá un informe parecido a este:


En mi caso han salido un par de errores, uno en el sensor G68 (sensor de velocidad de la caja de cambios) y otro (que no se aprecia en la imagen) en la G2, aunque este segundo parece venir como problema adyacente del primero.

Pestillos automáticos

Otra de las opciones que es bastante interesante es el tema de los pestillos automáticos. Esto es, cuando pasas de 20km/h se cierran automáticamente y cuando sacas la llave del contacto, se abren.

La centralita se divide en módulos. Los coches, cuanto más nuevos y completos, más módulos tienen (normalmente).

Así que nos vamos a "Select":

Y ahí nos aparecerá un listado de todos los módulos. Aunque nuestro coche no tenga ese módulo, aparecerá en el listado y cuando entremos nos dará un error diciéndonos que no está disponible.

Nos vamos al módulo "46 - Central Conv.". Y después de cargar toda la información pulsamos en "10 - Adaptation".


Dentro de "Adaptation" tenemos canales. Para el BLOQUEO automático de puertas cuando se alcanzan los 20km/h tenemos que ir al canal 03, el valor establecerlo a 1 y guardar.

Para el desbloqueo automático al quitar la llave del contacto se hace exactamente igual, pero el canal 4:

Comprobación del Tempomat

Como ya dije antes, llevo bastantes años con el Tempomat instalado pero sin que funcione, así que le he hecho un checkeo para ver si todos los cables estaban bien conectados.
Para ello nos vamos al módulo "01 - Engine" y una vez allí vamos a "08 - Meas. Block":

Vamos al grupo 006 y en el tercer campo (Cruise Control) lo tendremos todo lleno de ceros.
Si activamos el Tempomat, los dos últimos deberían ponerse a 1:

Si pulsamos el freno, se tiene que poner a 1 el segundo 0 (siempre empezando por la izquierda):
Si pisamos el embrague, se debe cambiar el primer 0 a 1:
Pulsamos el botón de "Reset" en la maneta y se nos cambiará el tercer 0 a 1:
Y para terminar, pulsamos el botón de "Set" en la maneta y nos debe cambiar el cuarto 0 a 1:


Pues tras comprobar que todo estaba correctamente, sólo queda probar el cableado y el sensor G68, pero está en la caja de cambios y toca levantar el coche, así que hasta que tendré que posponerlo hasta el próximo cambio de aceite.

Prometo informar de lo que consiga, pues no he encontrado NINGUNA información sobre este sensor en español.

Un saludo!






martes, 4 de noviembre de 2014

Problemas con bluetooth HC-06 y ATtiny45 y 85

Últimamente estoy jugando bastante con el ATtiny45 y 85 porque al ser tan pequeñitos y no necesitar reloj externo, dan bastante juego.
El caso es que quería poder comunicarme con ellos a través de Bluetooth y compré el módulo HC-06, que está muuuy bien de precio (por unos 3.5€ en Ebay). Ejemplo: http://www.ebay.es/itm/221483856395

Primero lo conecté con un Arduino Nano para probarlo y ver cómo funcionaba. En el otro extremo usé el teléfono móvil (Android) con BlueTerm, que es perfecto para hacer pruebas.
La primera prueba fue un simple replicador, lo que yo escribía en el móvil me lo devolvía el Arduino.

Viendo que el módulo funcionaba, me dispuse a montarlo en el ATtiny. Primer problema: El ATtiny45 tiene muy poca memoria y la librería SoftwareSerial que utilicé en el Arduino para crear otro puerto serie ya no podría usarla. Tendría que apañármelas con el Serial que trae por defecto.

Así que cargué este programa en el ATtiny45 (http://www.plutec.net/2014/10/programando-un-attiny45-y-85.html):

 void setup() {  
  Serial.begin(9600);  
 }  
 void loop() {  
  Serial.println("HOLA");  
  delay(1000);  
 }  

Y me conecté con el móvil al otro extremo del Bluetooth, a ver qué recibía. El resultado fue desastroso:


Y ahí me quedé un par de días pensando, hasta que se lo comenté a Juanjo (un amigo y compañero de Hispasec) y me comentó que quizás modificando la velocidad del puerto serie se podría mejorar algo, así que al lío fui.
Me descargué el datasheet del HC-06 para ver si se podría modificar la velocidad de comunicación y cómo se hacía. Si alguien quiere mirarse el datasheet entero, es todo suyo. Yo me fui directamente a la página 15 que explica qué comandos usar para cambiar la velocidad, nombre y PIN del módulo. Aquí un resumen:

 Cambiar velocidad de comunicación:  
 Envía: AT+BAUD1  
 Respuesta: OK1200   
 Envía: AT+BAUD2   
 Respuesta: OK2400   
 Aquí la lista de velocidades disponibles:  
 1---------1200   
 2---------2400   
 3---------4800   
 4---------9600 (Por defecto)   
 5---------19200   
 6---------38400   
 7---------57600   
 8---------115200   
 9---------230400   
 A---------460800   
 B---------921600   
 C---------1382400  
 Cambiar el nombre del módulo:  
 Envío: AT+NAMEname   
 Respuesta: OKname  
 - Ejemplo:  
 Envío: AT+NAMEpepito  
 Respuesta: OKname  
 (El nombre está limitado a 20 caracteres)  
 Cambiar PIN del dispositivo:  
 Envío: AT+PINxxxx   
 Respuesta: OKsetpin  
 - Ejemplo:  
 Envío: AT+PIN5678  
 Respuesta: OKsetpin  
 El PIN por defecto es 1234  
 Para versiones del módulo mayor que la 1.5 hay comandos de paridad disponibles. 
 Mirar el datasheet.  

Pues bien, para cambiar la velocidad del módulo usé de nuevo el Arduino Nano y le cargué este sketch (no recuerdo de dónde lo saqué, así que no puedo poner los créditos, lo siento):

 #include <SoftwareSerial.h>  
 SoftwareSerial mySerial(4, 2); // RX, TX  
 String command = ""; // Stores response of the HC-06 Bluetooth device  
 void setup() {  
  // Open serial communications:  
  Serial.begin(9600); // Arduino - PC bauds
  Serial.println("Type AT commands!");  
  // The HC-06 defaults to 9600 according to the datasheet.  
  mySerial.begin(9600); //Arduino - BT bauds
 }  
 void loop() {  
  // Read device output if available.  
  if (mySerial.available()) {  
   while(mySerial.available()) { // While there is more to be read, keep reading.  
    command += (char)mySerial.read();  
   }  
   Serial.println(command);  
   command = ""; // No repeats  
  }  
  // Read user input if available.  
  if (Serial.available()){  
   delay(10); // The delay is necessary to get this working!  
   mySerial.write(Serial.read());  
  }  
 }  

Debemos conectar los pines 2 y 4 del Arduino al RX y TX del módulo BT, abrimos una consola serie y nos dirá:
 Type AT commands!
Para probar que están bien conectados los pines TX y RX podemos mandar el comando:
-> AT
<- OK
Nos debe responder OK, si esto no es así, posiblemente tengamos que intercambiar los cables RX y TX del Arduino al BT.
Pasamos a configurar el módulo BT con la siguiente frecuencia que admite: 19200
-> AT+BAUD5
<- OK19200

Cargamos el ATtiny con el sketch que puse al principio que sólo escribía "HOLA", pero modificando la frecuencia a 19200 y... PUMMM


No dice que el puerto serie del ATtiny sólo soporta velocidades de 9600, 38400 y 115200.

Antes de nada recordar que los puertos serie del ATtiny son el Analog Input 2 y el 3 (RX y TX respectivamente):

Cambiamos la frecuencia del HC-06 a 38400 y probamos con el ATtiny. El resultado es este:


Es mejor que con 9600, pero todavía se come algunos caracteres de fin de línea. Así que repetimos el proceso para 115200, con el siguiente resultado:


No he hecho mediciones y pruebas estadísticas (cosa que Juanjo me pidió), pero con estas vistas, creo que es suficiente.

Espero que os sirva para "algo". Cualquier duda, a los comentarios.