Motika By CVR | Micropython

Iniciar con Micropython


MicroPython es una implementación sencilla y eficiente del lenguaje de programación Python 3 que incluye un pequeño subconjunto de la biblioteca estándar de Python y está optimizado para ejecutarse en microcontroladores y en entornos restringidos.

MicroPython está repleto de funciones avanzadas, como un indicador interactivo, enteros de precisión arbitraria, cierres, comprensión de listas, generadores, manejo de excepciones y más. Sin embargo, es lo suficientemente compacto como para caber y funcionar con solo 256k de espacio de código y 16k de RAM.

MicroPython pretende ser lo más compatible posible con Python normal para permitirle transferir código con facilidad desde el escritorio a un microcontrolador o sistema integrado.

Mas informacion sobre Micropython aquí

GPIO(I/O) Motika Micropython

Los pines de proposito general disponibles en la placa Motika bajo el uso de Micropython se describen a continucación


imagen io micropython

Construyendo el Firmware
El firmware de Micropython se encuentra disponible para descarga directa, por lo que no es necesario construirlo ó usar alguna herramienta para dicho fin.

Puedes descargar el firmware desde la página oficial aquí.

Instalar el Firmware (Flashear)
Instalar imagen en la placa es bastante sencillo. Para esto usaremos una herramienta llamada esptool. Esta herramienta está escrita en python por lo que debemos instalar python en nuestro equipo (descarga python 3 aquí).

La herramienta esptool puedes descargarla en el siguiente enlace: https://github.com/espressif/esptool y está soportada por windows, linux, OS X y cualquier sistema operativo que pueda correr python.

Para instalar el firmware es muy importante poner la placa en modo flash, para esto usaremos los pines [flash] en la placa designados para dicho proposito. Usaremos el jumper para poner la placa en modo flash.

img motika jumper position



PASO 1:
Ejecutaremos el siguiente comando para borrar la memoria del microcontrolador:

esptool.py --port <serial-port-of-ESP8266> erase_flash
Descripción de los parámetros: <serial-port-of-ESP8266> El puerto serial (COMx Windows, ttyxxx Linux).

PASO 2:
Instalaremos la imagen con un simple comando en nuestra placa. Para lo que conectaremos nuestra placa a nuestro PC y abrimos una consola de de comandos (terminal) y digitamos el siguiente comando:
esptool.py --port <serial-port-of-ESP8266 --baud 460800 write_flash --flash_size=detect -fm dout 0 <micropython-firmware.bin>
Descripción de los parámetros:
<serial-port-of-ESP8266> : El puerto serial (COMx Windows, ttyxxx Linux)
<micropython-firmware>.bin (Ruta y nombre del archivo que contiene la imagen).

Ejemplo:
esptool.py --port COM5 --baud 460800 write_flash --flash_size=detect -fm dout 0 C:\micropython.bin
Una vez terminado el proceso podemos verificar que el firmware ha sido instalado correctamente abriendo un terminal serial ( configurar baudios en 115200), retirando el jumper [flash] y presionando el botón reset de la placa. En el terminal veremos el shel python de siempre:

imagen de lo que se va a mostrar en la terminal



Ahora estámos listos para iniciar a programar nuestra placa Motika usando Micropython, iniciemos con los siguientes tutoriales:

  1. Escribiendo código.
  2. Cargar código a la placa.
  3. Conectar a red wifi.
  4. Crear red wifi.
  5. Controlando cargas.
  6. Crear servidor HTTP para controlar cargas.
  7. Crear socket TCP-IP para controlar cargas
  8. Pines I/O de propósito general.

Escribiendo código
Podemos escribir nuestro código en cualquier editor, lo importante es tener en cuenta que el archivo donde escribimos nuestro código sea de extensión .py Es importante resaltar que nuestro archivo contenedor del script puede tener cualquier nombre, pero si queremos que nuestro script se ejecute en el inicio una vez la placa sea conectada nuestro archivo debe tener el nombre main.py

Cargando código a la placa.
Existen diferentes alternativas para cargar el código a la placa como ESPlorer: https://github.com/4refr0nt/ESPlorer, ampy de Adafruit e incluso el webrepl integrado en el firmaware de micropython (permite programar el modulo de forma inalambrica. mas información en https://github.com/micropython/webrepl). pero particularmente recomendamos usar Thonny IDE por su facilidad y flexibilidad, pero es solo una recomendación, tu puedes usar el que más te guste.

Wifi
Motika está basada en el ESP8266, este microcontrolador cuenta con un chip wifi configurable el cual permite conectarse a una red wifi existente (MODO AP) o crear una red wifi desde el propio módulo (MODO STATION) permitiendo así comunicarnos con dispositivos externos mediante protocolos de comunicaciones IP . Toda la informacion sobre wifi en: https://docs.micropython.org/en/latest/esp8266/quickref.html#networking

Conceptos generales de wifi (esto puede ser un modal)



Conectar a red wifi.
(ver antes conceptos generales de wifi)

Conectar con una red wifi es muy fácil, para esto usaremos el siguiente código: 

            
             
import network

import time



wlan = network.WLAN(network.STA_IF)

wlan.active(True)

ssid = "nombre de la red"

password = "contraseña de la red"



if not wlan.isconnected():

        print('Conectando a red wifi...')

        wlan.connect(ssid, password)

        while not wlan.isconnected():

            print("Esperando conexion a red...")

            time.sleep(1)

            pass 



print("ip del modulo: ", wlan.ifconfig()[0])

print("Mascara de subred: ", wlan.ifconfig()[1])

print("Puerta de enlace: ", wlan.ifconfig()[2])


ssid = Nombre de la red wifi a la que se conectará
pwd = Clave de la red

Se configura el módulo como STATION para conectar a una red wifi existente y se activa la interfaz wifi en el módulo. Una vez establecida la configuración muestra por consola los datos de la misma.

Crear red wifi.
(ver antes conceptos generales de wifi)

                

import network
                    
ap = network.WLAN(network.AP_IF)

ap.active(True)

ssid = "Motika Wifi"
password = "redDeMotika"

ap.config(essid=ssid, password=password)

apConfig = ap.ifconfig()

print("Ip del modulo %s" % apConfig[0])
print("Puerta de enlace predeterminada %s" % apConfig[1])
print("Puerta de enlace: ", apConfig[2])

ssid = Nombre de la red wifi a la que se conectará
password = Clave de la red

Se configura el módulo como AP para crear redes wifi y luego se pasa la variable que contiene la configuración a la función ap.config(essid=ssid, password=password) encargada de establecer la configuración en el módulo. Con esto ya podríamos verificar la existencia de una nueva red wifi con nombre y clave establecidos en cualquier dispositivo con conexión wifi.

Creando Socket TCP/IP

Un socket TCP-IP permite la comunicación de nuestra placa con cualquier software o aplicación. Crear uno es bastante facil. 

                    

import machine
import network
import time
import socket

wlan = network.WLAN(network.STA_IF)
wlan.active(True)       

ssid = "ceenford-latinoamerica"
password = "44442832"
port = 23

if not wlan.isconnected():
        print('Conectando a red wifi...')
        wlan.connect(ssid, password)
        while not wlan.isconnected():
            print("Esperando conexion a red...")
            time.sleep(1)
            pass

addr = socket.getaddrinfo(wlan.ifconfig()[0], port)[0][-1]
s = socket.socket()

s.bind(addr)
s.listen(1)

print('listening on', addr)

while True:
    cl, addr = s.accept()
    print('client connected from', addr)
    cl_file = cl.makefile('rwb', 0)
    while True:
        
        print("Recibido: %s" % cl_file.read(1))

Primero establecemos la conexión a la red wifi, luego usamos la funcion socket.getaddrinfo() la cual recibe como parametro la ip y el puerto donde se escuchará la conexión.
Luego se crea el socket y se esperan conexiones desde dispositivos. Todos los datos recibidos se muestran luego por consola.

Controlando Cargas:
Motika, cuenta con 4 relés mecánicos en placa con posibilidad de control de 8 canales de relé (P4-P7) y hasta 16 canales (agregando módulo de expansión de 8 canales extra) completamente aislados del microcontrolador y controlados por el módulo de expansión PCF8574. permitiendo el control de las cargas haciendo uso de solo 2 pines del microcontrolador (I2C). A continuación el código de muestra para el control de cargas mediante el uso de relés.

Para facilitar el uso de los relés en placa hemos desarrollado un script que se encarga del control de los mismos. Este script debe ser importado al archivo principal del proyecto para cargar sus funciones.
A continuación el escript motikaRelayControl.py 

                

from machine import Pin, I2C

relayControllerAddr = 32

last_byte = 0

i2c = I2C(scl=Pin(0), sda=Pin(2), freq=100000) 

    
def writeToPCF(byte): #escribe los datos al pcf8574 modulo vía i2c
    i2c.writeto(relayControllerAddr,byte.to_bytes(1, 'big'))
    print(byte.to_bytes(1, 'big'))

def get_io():
    return i2c.readfrom(relayControllerAddr, 1)

def on_io(pin): #enciende un rele en especifico, pasar "all" como parametro para encender todos los relays
    global last_byte
    last = last_byte
    
    bases = [1,2,4,8,16,32,64,128]

    if pin == "all":
        global last_byte
        writeToPCF(255)
        last_byte = 255
    elif pin > 0 and pin < 9:
        global last_byte
        nuevo = (bases[pin-1] | last)
        writeToPCF(nuevo)
        last_byte = nuevo
    

def off_io(pin): #apaga un rele en especifico, pasar "all" como parametro para apagar todos los relays
    global last_byte
    last_off = last_byte
    bases_off = [254,253,251,247,239,223,191,127]
    if pin == "all":
        global last_byte
        writeToPCF(0)
        last_byte = 0
    elif pin > 0 and pin < 9:
        global last_byte
        nuevo_off = (bases_off[pin-1] & last_off)
        writeToPCF(nuevo_off)
        last_byte = nuevo_off

Una vez cargado el script podemos controlar cargas haciendo uso de los relés integrados en la placa.

El siguiente codigo activa y desactiva cada uno de los relé de forma secuencial. 

                

from machine import Pin, I2C
from motikaRelayControl import *
import time

on_io(1)
time.sleep(0.5)
on_io(2)
time.sleep(0.5)
on_io(3)
time.sleep(0.5)
on_io(4)
time.sleep(0.5)
off_io(1)
time.sleep(0.5)
off_io(2)
time.sleep(0.5)
off_io(3)
time.sleep(0.5)
off_io(4)
time.sleep(0.5)

Controlando cargas vía TCP-IP

Por ultimo, dejaremos un ejemplo completo en el que se mostrará como controlar cargas desde el modulo Motika desde cualquier cliente TCP/IP por medio de la red wifi.

Recuerda que esta es solo una pequeña aplicación para instruirte sobre como funciona la placa, pero con tu imaginación podrás hacer cualquier cosa.

                

from machine import Pin, I2C
from motikaRelayControl import *
import machine
import network
import time
import socket

wlan = network.WLAN(network.STA_IF)
wlan.active(True)       

ssid = "ceenford-latinoamerica"
password = "44442832"
port = 23

if not wlan.isconnected():
        print('Conectando a red wifi...')
        wlan.connect(ssid, password)
        while not wlan.isconnected():
            print("Esperando conexion a red...")
            time.sleep(1)
            pass

addr = socket.getaddrinfo(wlan.ifconfig()[0], port)[0][-1]
s = socket.socket()

s.bind(addr)
s.listen(1)

print('listening on', addr)

while True:
    cl, addr = s.accept()
    print('client connected from', addr)
    cl_file = cl.makefile('rwb', 0)
    while True:
        
        recvByte = cl_file.read(1)
        
        if recvByte == b'A':
            on_io(1)
        elif recvByte == b'a':
            off_io(1)
        elif recvByte == b'B':
            on_io(2)
        elif recvByte == b'b':
            off_io(2)
        elif recvByte == b'C':
            on_io(3)
        elif recvByte == b'c':
            off_io(3)
        elif recvByte == b'D':
            on_io(4)
        elif recvByte == b'd':
            off_io(4)