Snap-MQTT.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Puente Snap - MQTT usando python\n",
    "#### David Ochoa\n",
    "#### ochoadavid at gmail.com\n",
    "#### http://github.com/ochoadavid/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Desde hace algunos años se han desarrollado sistemas gráficos para ayudar en la enseñanza de la programación. Se destaca en este sentido __Scratch__ y sus derivados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![Scratch](imagenes/Screenshot-ScratchPongGame1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__SNAP__ (https://snap.berkeley.edu/) uno de sus derivados mantiene el mismo estilo de programación en un sistema que se ejecuta en el navegador y se puede ejecutar desde el sitio o simplemente descargandolo y abriendolo localmente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"780\"\n",
       "            height=\"550\"\n",
       "            src=\"https://snap.berkeley.edu/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f62147df748>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame('https://snap.berkeley.edu/', width=780, height=550)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Existen interfaces desarrolladas para interactuar con algunos dispositivos:\n",
    "\n",
    "Use devices with Snap!:\n",
    "\n",
    "* Orbotix Sphero guide by Connor Hudson and Dan Garcia\n",
    "* Lego NXT package by Connor Hudson\n",
    "* Nintendo Wiimote package by Connor Hudson\n",
    "* Finch and Hummingbird robots package by Tom Lauwers\n",
    "* Parallax S2 robot package by Connor Hudson\n",
    "* LEAP Motion by Connor Hudson\n",
    "* Speech synthesis by Connor Hudson\n",
    "* Arduino package by Alan Yorinks\n",
    "* Arduino package by Bernat Romagosa/Citilab\n",
    "* Fischertechnik ROBOTICS TXT Controller by Richard Kunze\n",
    "* Snap! for Raspberry Pi by rasplay.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sin embargo resulta interesante tener una interfaz genérica para enviar mensajes a un __servidor MQTT__ (referido como __broker__) para controlar dispositivos que utilicen este protocolo. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Con este fin se desarrollo un “puente” en Python 3 que recibe mensajes de Snap y usando la librería paho-mqtt transmite estos mensajes para el servidor (broker). De ahí los dispositivos conectados al broker reciben los mensajes y actúan en consecuencia. En la platica se describirá la estructura de este puente, sus características y detalles del desarrollo. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## MQTT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "¿Qué es MQTT?\n",
    "\n",
    "__MQTT__ (Message Queuing Telemetry Transport) es un protocolo de conectividad maquina-a-maquina. Fue diseñado como un transporte de mensajes a través de _publicar_ y _subscribir_. Es útil para conexiones remotas donde pueda haber limitaciones de ancho de banda y/o equipos con poder de computo limitado, por lo que resulta un muy buen candidato para ser utilizado para _Internet de las cosas_ (IOT)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"780\"\n",
       "            height=\"550\"\n",
       "            src=\"http://mqtt.org/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f62147df7b8>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame('http://mqtt.org/', width=780, height=550)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Conceptos básicos de MQTT:\n",
    "    \n",
    "* Publicar/suscribir (Publish/Subscribe)\n",
    "* Mensajes (Messages)\n",
    "* Temas (Topics)\n",
    "* Servidor (Broker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### MQTT - Publicar/Suscribir\n",
    "\n",
    "El protocolo MQTT es un protocolo donde un __Cliente__ puede realizar dos acciones:\n",
    "* Publicar: el cliente manda un mensaje."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Suscribir: el cliente pide ser informado cuando un __Tema__ sea publicado.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### MQTT – Mensajes\n",
    "\n",
    "Los mensajes son los paquetes de información que queremos intercambiar entre diversos dispositivos. Pueden ser comandos o datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### MQTT – Temas (Topic)\n",
    "\n",
    "Los temas nos permiten categorizar los mensajes de tal manera que cuando un cliente publica estos sólo sean transmitidos a aquellos clientes subscritos a dicho tema.\n",
    "\n",
    "Los temas se representan con cadenas (strings) seguidas por una diagonal (__/__). Cada diagonal es un __nivel__ de tema. Por ejemplo, el tema para una lampara en el escritorio podría ser:\n",
    "## /escritorio/lampara"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "__Nota__: ¡MAYUSCULAS/minúsculas importan! (Escritorio $\\ne$ escritorio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### MQTT – Servidor (Broker)\n",
    "\n",
    "El servidor es el responsable de recibir los mensajes, filtrarlos y enviarlos a los clientes subscritos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![MQTT](imagenes/mqtt1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Características:__\n",
    "\n",
    "* Todos los clientes son iguales\n",
    "* Todos los clientes pueden publicar y/o suscribirse\n",
    "* El Broker concentra todos los mensajes y los distribuye a los clientes suscritos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Servidores en la web__:\n",
    "Algunos sitios web que ofrecen este servicio:\n",
    "* http://www.maqiatto.com/\n",
    "* https://www.hivemq.com/\n",
    "* https://www.cloudmqtt.com/\n",
    "* https://test.mosquitto.org/\n",
    "\n",
    "(Todos estos tienen algún servicio gratuito y algunos servicios pagados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Servidores locales__:\n",
    "Disponibles para descargar e instalar:\n",
    "* Mosquitto: __broker__ escrito en C. (https://mosquitto.org/)\n",
    "* Mosca: basado en Node.js. (https://github.com/mcollina/mosca)\n",
    "* emqttd: escrito en Erlang. (https://github.com/emqx/emqx)\n",
    "* Servidor de prueba en Python. (https://github.com/eclipse/paho.mqtt.testing/tree/master/interoperability)\n",
    "* Verne. https://vernemq.com/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"780\"\n",
       "            height=\"550\"\n",
       "            src=\"http://mosquitto.org/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f62147dfe80>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame('http://mosquitto.org/', width=780, height=550)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Puente Snap - MQTT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "La idea del puente es muy sencilla (en realidad el puente es muy sencillo): snap tiene soporte nativo para mandar hacer un __request__ via http. La información del tema y el mensaje se pasa como variable al request:\n",
    "![Bloque SNAP](imagenes/bloqueSNAP.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "El puente funciona de la siguiente manera: al iniciar se conecta como __cliente__ al Broker, después inicia un __servior http__ donde recibe estos mensajes y los publica al __Broker MQTT__. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Librerías utilizadas__:\n",
    "\n",
    "Además de las librerías para hacer un servidor __http__ sencillo utilizamos la librería `client` de `paho.mqtt`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "import http.server\n",
    "import socketserver\n",
    "import paho.mqtt.client as mqtt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__\\_\\_main\\_\\___:\n",
    "\n",
    "El programa principal se encarga de hacer las conexiones y declarar quien se encargará de recibir los mensajes.\n",
    "\n",
    "```\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"Snap-MQTT\")\n",
    "\n",
    "    client = mqtt.Client()\n",
    "    client.connect(\"192.168.4.1\")\n",
    "\n",
    "    client.on_connect = on_connect\n",
    "    client.loop_start()\n",
    "\n",
    "    handler = RequestHandler\n",
    "\n",
    "    httpd = socketserver.TCPServer((\"\", 1330), handler)\n",
    "\n",
    "    httpd.serve_forever()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Aviso de conexión__:\n",
    "\n",
    "El método `on_connect` se utiliza solamente para dar un aviso al usuario:\n",
    "\n",
    "```\n",
    "def on_connect(client, userdata, flags, rc):\n",
    "    print('Conectado a broker')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Receptor de mensajes__:\n",
    "\n",
    "El objeto `handler` de la clase `RequestHandler` se encarga de recibir el mensaje y enviarlo al Broker:\n",
    "\n",
    "\n",
    "```\n",
    "class RequestHandler(http.server.SimpleHTTPRequestHandler):\n",
    "    def do_GET(self):\n",
    "        path = self.path[1:]\n",
    "        topic, msg = path.split(\"?\")\n",
    "        print(topic, \" - \", msg)\n",
    "        client.publish(topic, msg, qos=1)\n",
    "        self.send_response(204)\n",
    "        self.end_headers()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Cliente suscrito a los mensajes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "El cliente que recibe el mensaje, al igual que el servidor __Mosquitto__, se encuentra en el RaspberryPi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Librería utilizada__:\n",
    "\n",
    "Unicamente es importada la librería `client` de `paho.mqtt` (en realidad también es utilizada `DigitalOutputDevice` de la librería `gpiozero`, pero como es propia del RaspberryPi, será importada en otro lugar)\n",
    "\n",
    "```\n",
    "import paho.mqtt.client as mqtt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__\\_\\_main\\_\\___:\n",
    "\n",
    "\n",
    "Después de declarar un estado inicial de los motores se conecta al Broker y se sobreescriben dos funciones de la clase. Finalmente se inicia un ciclo `while True:` que en cada iteración llama `client.loop(0.02)` y una función llamada monitor. \n",
    "\n",
    "```\n",
    "if __name__ == \"__main__\":\n",
    "    estado = {'pos0':0, 'pos1':0, 'pobj0':0, 'pobj1':0}\n",
    "\n",
    "    client = mqtt.Client()\n",
    "    client.connect(\"localhost\")\n",
    "\n",
    "    client.on_connect = on_connect\n",
    "    client.on_message = on_message\n",
    "\n",
    "    while True:\n",
    "        client.loop(0.02)\n",
    "        mueve(estado)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__client.loop(0.02)__\n",
    "\n",
    "Permite al cliente tomar el control de la computadora por `0.02` segundos (enviando y recibiendo los mensajes necesarios)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Función `on_connect()`__:\n",
    "\n",
    "En este caso la función `on_connect` se suscribe a los __temas__ que nos interesan.\n",
    "\n",
    "\n",
    "```\n",
    "def on_connect(client, userdata, flags, rc):\n",
    "    print(\"Conectado a broker\")\n",
    "    client.subscribe(\"rpi/motor0\")\n",
    "    client.subscribe(\"rpi/motor1\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Función `on_message()`__:\n",
    "\n",
    "\n",
    "Esta función es llamada cada que un mensaje llega al cliente (de aquellos a los que esta suscrito). La función actualiza las posiciones objetivo del estado cuando esto sucede.\n",
    "\n",
    "```\n",
    "def on_message(client, userdata, msg):\n",
    "    global estado\n",
    "    if msg.topic == \"rpi/motor0\":\n",
    "        estado['pobj0'] = int(msg.payload.decode())\n",
    "    elif msg.topic == \"rpi/motor1\":\n",
    "        estado['pobj1'] = int(msg.payload.decode())\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Función `mueve()`__:\n",
    "\n",
    "Esta función es la que ejecuta el movimento en cada ciclo.\n",
    "\n",
    "\n",
    "```\n",
    "pmap = [[True, True, False, False],\n",
    "        [False, True, True, False],\n",
    "        [False, False, True, True],\n",
    "        [True, False, False, True]]\n",
    "\n",
    "def mueve(es):\n",
    "    if es['pos0'] != es['pobj0']:\n",
    "        pin = es['pos0'] % 4\n",
    "        if es['pos0'] < es['pobj0']:\n",
    "            es['pos0'] += 1\n",
    "        elif es['pos0'] > es['pobj0']:\n",
    "            es['pos0'] -= 1\n",
    "        pout = es['pos0'] % 4\n",
    "        print('M0={}, obj={}'.format(es['pos0'], es['pobj0']))\n",
    "        for m, pi, po in zip(motor0, pmap[pin], pmap[pout]):\n",
    "            if po and not pi:\n",
    "                m.on()\n",
    "            elif not po and pi:\n",
    "                m.off()\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Para controlar un motor de pasos unipolar utilizamos cuatro salidas del gpio en forma de una lista, `motor0`, que contiene estas cuatro salidas:\n",
    "\n",
    "\n",
    "```\n",
    "from gpiozero import DigitalOutputDevice as Dod\n",
    "m0a = Dod(2, active_high=False)\n",
    "m0b = Dod(3, active_high=False)\n",
    "m0c = Dod(4, active_high=False)\n",
    "m0d = Dod(17, active_high=False)\n",
    "motor0 = [m0a, m0b, m0c, m0d]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Demostración"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ideas finales\n",
    "\n",
    "* ¡MQTT es realmente sencillo de usar!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* IOT -> \"Internet de los programas!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Seguridad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Preguntas?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¡Gracias!\n",
    "#### David Ochoa\n",
    "#### ochoadavid at gmail.com\n",
    "#### http://github.com/ochoadavid/"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}