{"id":15163290,"url":"https://github.com/potier97/rfid-access-iot","last_synced_at":"2026-01-21T14:03:15.308Z","repository":{"id":250233494,"uuid":"833779459","full_name":"potier97/rfid-access-iot","owner":"potier97","description":"Simple proyect for RFID control Access with Iot devices and aws Cloud","archived":false,"fork":false,"pushed_at":"2024-08-05T04:45:38.000Z","size":3434,"stargazers_count":0,"open_issues_count":0,"forks_count":1,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-04-08T09:49:06.192Z","etag":null,"topics":["aws","esp8266","iot","iot-core","lambda","micropython","mqtt","python"],"latest_commit_sha":null,"homepage":"https://iot.nipoanz.com","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/potier97.png","metadata":{"files":{"readme":"readme.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-07-25T18:20:42.000Z","updated_at":"2024-08-05T04:45:42.000Z","dependencies_parsed_at":"2024-08-07T05:45:49.685Z","dependency_job_id":null,"html_url":"https://github.com/potier97/rfid-access-iot","commit_stats":{"total_commits":16,"total_committers":1,"mean_commits":16.0,"dds":0.0,"last_synced_commit":"8fb7ad919bf2c1e6ae1a17502efe1699e4f6903d"},"previous_names":["potier97/rfid-access-iot"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/potier97/rfid-access-iot","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/potier97%2Frfid-access-iot","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/potier97%2Frfid-access-iot/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/potier97%2Frfid-access-iot/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/potier97%2Frfid-access-iot/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/potier97","download_url":"https://codeload.github.com/potier97/rfid-access-iot/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/potier97%2Frfid-access-iot/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28634786,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-21T04:47:28.174Z","status":"ssl_error","status_checked_at":"2026-01-21T04:47:22.943Z","response_time":86,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["aws","esp8266","iot","iot-core","lambda","micropython","mqtt","python"],"created_at":"2024-09-27T02:22:39.086Z","updated_at":"2026-01-21T14:03:15.292Z","avatar_url":"https://github.com/potier97.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cp align=\"center\"\u003e\n  \u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\u003cimg src=\"./assets/image-6.png\" width=\"300\" alt=\"NPA Logo\" /\u003e\u003c/a\u003e\n\u003c/p\u003e\n\n# Rfid Iot Project\n\nste proyecto de IoT para control de acceso se centra en el uso de dispositivos RFID con ESP8266 y puertas controladas electrónicamente \"Servos\", integrados con los servicios de AWS para crear un sistema seguro, escalable y eficiente. Los componentes principales incluyen:\n\n\n - Dispositivos IoT: Lectoras RFID y controladores de puertas que se comunican con la nube.\n - AWS IoT Core: Actúa como broker MQTT para la comunicación entre dispositivos.\n - Funciones Lambda: Ejecutan lógica de negocio, como la validación de accesos y actualizaciones de registros.\n - DynamoDB: Almacena datos de acceso y registros de dispositivos.\n - API Gateway: Facilita la integración con aplicaciones externas para enviar y recibir datos.\n\nLos usuarios presentan sus tarjetas RFID, los dispositivos leen la información y envían los datos a la nube, donde se procesan y verifican mediante funciones Lambda. Dependiendo de la validación, se envían comandos para abrir o cerrar puertas, registrar accesos, y enviar notificaciones. Este sistema proporciona un control de acceso eficiente y seguro, aprovechando la infraestructura de AWS.\n\nEste proyecto está inspirado la siguiente publicación de AWS [Aquí](https://aws.amazon.com/es/blogs/iot/using-micropython-to-get-started-with-aws-iot-core/).\n\n\n## Infraestructura\n\nLa siguiente imagen muestra la infraestructura del proyecto, en la que se conecta un ESP8266 a un broker MQTT mediante AWS Iot Core. El ESP8266 se encarga de controlar la puerta y el lector RFID, mientras que la Raspberry Pi actúa como broker MQTT y se comunica con AWS IoT Core.\n\n\u003cp align=\"center\"\u003e\n  \u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\u003cimg src=\"./assets/image-34.png\" width=\"100%\" alt=\"NPA Logo\" /\u003e\u003c/a\u003e\n\u003c/p\u003e\n\nPara conocer más de la infraestructura implementada mediate Terraform, puede visitar esta [documentación](./terraform/readme.md).\n\n## TODO\n\n- [x] Implementar la logica para añadir/actualizar tarjetas RFID.\n- [x] Implementar la logica para eliminar tarjetas RFID anteriormente guardadas.\n- [x] Implementar la lógica de control de acceso mediante tarjetas RFID.\n- [x] Implementar las reglas en AWS IoT Core para invocar las funciones Lambda.\n- [x] Implementar base de datos en Dynamo para persistir la información de las tarjetas RFID.\n- [x] Implementar infraestructura en AWS paa mejorar mantenibilidad y escalabilidad.\n- [ ] Implementar la lógica de cambio de estado del lector RFID.\n- [ ] Implementar apis para la gestión de tarjetas RFID desde un portal web.\n- [ ] Implementar entidad de usuarios para asocial tarjetas RFID registradas.\n- [ ] Mejorar procesos de acceso mediante maquinas de estado.\n- [ ] Guardar información de acceso y eventos en la base de datos.\n\n\n\n## Instalar\n1. Clonar el repositorio:\n    ```sh\n    git clone https://github.com/potier97/rfid-access-iot.git\n    cd rfid-access-iot\n    ```\n\n2. Crear y activar el entorno virtual:\n    ```sh\n    python -m venv env\n    # En Windows\n    .\\env\\Scripts\\activate\n    # En macOS y Linux\n    source env/bin/activate\n    ```\n\n3. Instalar dependencias:\n    ```sh\n    pip install -r requirements.txt\n    ```\n\n\n## Tabla de Contenidos\n\n1. [Introducción](#introducción)\n2. [Requisitos](#requisitos)\n3. [Conexión Componentes](#conexión-componentes)\n3. [Instalación del Broker Mosquitto](#instalación-del-broker-mosquitto)\n4. [Ampy - Transferencia de Archivos](#ampy---transferencia-de-archivos)\n5. [Configuración Inicial del ESP8266](#configuración-inicial-del-esp8266)\n6. [Definición de Objetos - AWS IoT Core](#definición-de-objetos---aws-iot-core)\n7. [Implementar Reglas - AWS IoT Core](#implementar-reglas---aws-iot-core)\n8. [Contribuciones](#contribuciones)\n9. [Autor](#autor)\n10. [Licencia](#licencia)\n\n\n---\n## Introducción\nEl proyecto `RFID Access IoT` permite gestionar el acceso a una puerta utilizando tarjetas RFID. La información de acceso se gestiona a través de un **ESP8266** que se comunica con un **broker MQTT** alojado en una Raspberry Pi y, en futuras versiones, con AWS IoT Core.\n\nSe hace uso de la libreria `umqtt.simple` para la comunicación MQTT en el ESP8266, puede encontrar la documentación [aquí](https://pypi.org/project/micropython-umqtt.simple/).\n\nPuede encontrar documentación acercar de MQTT en este enlace de [AWS](https://aws.amazon.com/es/what-is/mqtt/)\n\n\n\n---\n## Requisitos\n - Raspberry Pi con Raspbian instalado\n - ESP8266 con MicroPython\n - Módulo RFID (MFRC522)\n - Servomotor\n - Tarjetas RFID\n - Mosquitto instalado en la Raspberry Pi\n - Conexión a Internet\n\n---\n## Conexión Componentes\n\nLa conexión de los componentes se realiza para dos dispositivos, uno para el control del servo (Puerta) y otro para el lector RFID. La conexión se realiza de la siguiente manera:\n\nTenga en cuenta los pines I/O de la ESP8266\n\n\u003cbr\u003e\n\u003cp align=\"center\" \u003e\n  \u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n  \u003cimg src=\"./assets/image-10.png\" alt=\"image\" /\u003e\n  \u003c/a\u003e\n\u003c/p\u003e\n\n### ESP8266 - Control Puerta (Un Dispositivo)\n\n\u003cbr\u003e\n\n| ESP8266     | Servo |\n|-------------|-------|\n| D5 (GPIO14) | Signal|\n| NN          | VCC   |\n| GND         | GND   |\n\n\n \u003e El servo se alimenta con 5V de una fuente independiente y se comparte la tierra (GND) con el ESP8266.\n\n Se conecta un led en el pin D0 (GPIO16) para indicar el estado del dispositivo.\n\n### ESP8266 - Lector RFID (Dos Dispositivos)\n\n\u003cbr\u003e\n\n| ESP8266     | Lector RFID |\n|-------------|-------------|\n| D5 (GPIO14) | SCK         |\n| D7 (GPIO13) | MOSI        |\n| D6 (GPIO12) | MISO        |\n| D2 (GPIO4)  | RST         |\n| D2 (GPIO5)  | SDA         |\n| GND         | GND         |\n| 3V3         | 3.3V        |\n\n \u003e El lector RFID se alimenta con 3.3V y se comparte la tierra (GND) con el ESP8266.\n\n Se conecta un led en el pin D0 (GPIO16) para indicar el estado del dispositivo.\n\n\n---\n## Instalación del Broker Mosquitto\n\n1. Instalar Mosquitto:\n    \n    ```sh\n    sudo apt update\n    sudo apt upgrade -y\n    sudo apt install -y mosquitto mosquitto-clients\n    ```\n\n2. Iniciar el servicio de Mosquitto:\n    \n    ```sh\n    sudo systemctl enable mosquitto\n    ```\n\n    **Importante**: Es necesario modificar el archivo ubicado en `/etc/mosquitto/mosquitto.conf` para habilitar la autenticación de usuarios y la comunicación por el puerto 1883. Para ello, edite el documento usando `nano`\n\n    \u003e sudo nano /etc/mosquitto/mosquitto.conf\n     Agruegue las siguientes líneas al final del archivo:\n        - listener 1883\n        - allow_anonymous true\n\n    Su archivo debería verse de la siguiente manera:\n\n    \u003cbr\u003e\n    \u003cp align=\"center\" \u003e\n    \u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n    \u003cimg src=\"./assets/image-2.png\" alt=\"image\" /\u003e\n    \u003c/a\u003e\n    \u003c/p\u003e\n\n    Iniciar o reinice el servicio el servicio: `start` o `restart`\n\n    ```sh\n    sudo systemctl start mosquitto\n    ```\n\n3. Comprobar que el servicio está en ejecución:\n    \n    ```sh\n    sudo systemctl status mosquitto\n    ```\n\n4. Hacer pruebas de conexión con el broker:\n    En una terminal, suscribirse a un tópico:\n\n    ```sh\n    mosquitto_sub -h localhost -t test\n    ```\n\n    En otra terminal, publicar un mensaje en el tópico:\n\n    ```sh\n    mosquitto_pub -h localhost -t test -m \"Hello, world!\"\n    ```\n\n    \u003e Deberías ver el mensaje en la terminal donde te suscribiste al tópico.\n\n\n\u003cbr\u003e\n\u003cp align=\"center\" \u003e\n  \u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n  \u003cimg src=\"./assets/image.png\" alt=\"image\" /\u003e\n  \u003c/a\u003e\n\u003c/p\u003e\n\n---\n## Ampy - Transferencia de Archivos\n\nPara transferir archivos al ESP8266, utilizaremos `ampy`. Para instalarlo, ejecuta el siguiente comando:\n```sh\npip install adafruit-ampy\n```\n\n- Para verificar que `ampy` se instaló correctamente, ejecuta el siguiente comando:\n```sh\nampy --help\n```\n\n- Trasferir archivos al ESP8266:\n```sh\nampy --port com6 put main.py\n```\n\n- Obtener la lista de archivos en el ESP8266:\n```sh\nampy --port com6 ls\n```\n\n- Obtener un archivo del ESP8266:\n```sh\nampy --port com6 get main.py\n```\n\n- Eliminar un archivo del ESP8266:\n```sh\nampy --port com6 rm main.py\n```\n\n## Configuración Inicial del ESP8266\n\nEl desarrollo d este proyecto se realiza de acuerdo a este otro proyecto: [ESP8266-MicroPython](https://bhave.sh/micropython-mqtt/).\n\n### Esp8266 + RPI (Local) - Control Puerta\n\nEste ejemplo consiste en la publicación de mensajes desde una ESP8266 que se conecta a un broker MQTT en una Raspberry Pi. Este captura los posible mensjaes a los que está suscrito y actúa en consecuencia.\n\nPrincipalmente, el ESP8266 se conecta a la red WiFi y al broker MQTT. Luego, se suscribe a un tópico y publica mensajes en otro tópico.\n\nLos mensajes a los que está suscrito son unicamente para `abrir o cerrar la puerta` y `bloquear o desbloquear la puerta`, que consiste en mover un servo a distintos grados.\n\n \u003cbr\u003e\n\u003cp align=\"center\" \u003e\n\u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n\u003cimg src=\"./assets/image-3.png\" alt=\"image\" /\u003e\n\u003c/a\u003e\n\u003c/p\u003e\n\nEl código del ESP8266 se encuentra en el archivo `door.py` y se puede transferir al ESP8266 utilizando `ampy`. Este consiste en una clase llamada `Door` y es explicada a continución:\t\n\n### Comandos MQTT\n - thing/door/open: Abre la puerta (mueve el servo a 180°).\n - thing/door/close: Cierra la puerta (mueve el servo a 0°).\n - thing/door/lock: Bloquea la puerta (desactiva el servo y apaga el LED).\n - thing/door/unlock: Desbloquea la puerta (activa el servo y enciende el LED).\n\nUna vez que el ESP8266 esté conectado al broker MQTT, enviará y recibirá mensajes para controlar la puerta. Asegúrate de que tu broker MQTT esté funcionando correctamente y que los temas MQTT estén configurados según tu necesidad.\n\nEjemplo de Publicación de Mensajes\nPuedes usar cualquier cliente MQTT para enviar mensajes a los temas correspondientes. Aquí hay un ejemplo usando mosquitto_pub:\n\n```bash\n# Abrir la puerta\nmosquitto_pub -h \u003cbroker_ip\u003e -t thing/door/open -m \"\"\n\n# Cerrar la puerta\nmosquitto_pub -h \u003cbroker_ip\u003e -t thing/door/close -m \"\"\n\n# Bloquear la puerta\nmosquitto_pub -h \u003cbroker_ip\u003e -t thing/door/lock -m \"\"\n\n# Desbloquear la puerta\nmosquitto_pub -h \u003cbroker_ip\u003e -t thing/door/unlock -m \"\"\n```\n\n \u003e Por el momento el mensaje a enviar es vacío, se espera que este se pueda enviar la información de la tarjeta RFID.\n\n\nLa clase Door controla la lógica del sistema de acceso. Aquí tienes una explicación de sus componentes principales:\n\n- **Constructor** (__init__): Inicializa los atributos del objeto Door, conecta al servidor MQTT y configura las suscripciones a los temas.\n\n```python\ndef __init__(self, mqtt_server, client_id, thing_name, servo_pin=14, led_pin=16):\n```\n\n- **Callback de Suscripción** (sub_cb): Maneja los mensajes recibidos y llama a las funciones correspondientes según el tema del mensaje.\n\n```python\ndef sub_cb(self, topic, msg):\n```\n\n- **Funciones de Manejo**: Controlan las acciones de abrir, cerrar, bloquear y desbloquear la puerta.\n\n```python\ndef handle_open(self):\ndef handle_close(self):\ndef handle_lock(self):\ndef handle_unlock(self):\n```\n\n- **Reconexión** (restart_and_reconnect): Reinicia el ESP8266 y reconecta al broker MQTT en caso de error.\n\n```python\ndef restart_and_reconnect(self):\n```\n\n- **Conexión y Suscripción** (connect_and_subscribe): Conecta al servidor MQTT y se suscribe a los temas necesarios.\n\n```python\ndef connect_and_subscribe(self):\n```\n\n- **Escucha de Mensajes** (listen): Mantiene el ESP8266 escuchando mensajes MQTT y maneja las excepciones.\n\n```python\ndef listen(self):\n```\n\nLa clase `main.py` inicializa el sistema y ejecuta la lógica principal.\n\n- **Ejecución Principal**: Crea una instancia de la clase Door y llama a la función listen para comenzar a escuchar los mensajes MQTT.\n\n```python\nif __name__ == '__main__':\n    client_id = ubinascii.hexlify(unique_id())\n    mqtt_server = '192.168.1.24'\n    thing_name = 'thing'\n    door_controller = Door(mqtt_server, client_id, thing_name)\n    door_controller.listen()\n```\n\n### Esp8266 + RPI (Local) - Control RFID\n\nEste sección muestra cómo utilizar un lector RFID para leer tarjetas y enviar la información al servidor MQTT. El sistema está diseñado para detectar tarjetas RFID y publicar el UID de la tarjeta en un tema MQTT. (Ejemplo Simple), este lo puede encontrar en el archivo `scripts/main_read_rfid.py`.\n\n \u003e El uso de RFID se basa en el proyecto de [Micropython RFID](https://github.com/cefn/micropython-mfrc522/blob/master/examples/read.py)\n\nEl código inicializa el LED y configura los pines para el lector RFID.\n\n```python\nfrom machine import Pin, SoftSPI, unique_id\nfrom time import sleep\nfrom ubinascii import hexlify\nfrom umqtt.simple import MQTTClient\nimport mfrc522\nimport ujson\n\n# Inicializa el LED\nled = Pin(16, Pin.OUT)\n\n# Configuración del lector RFID\nsck = Pin(14, Pin.OUT)\nmosi = Pin(13, Pin.OUT)\nmiso = Pin(12, Pin.IN)\n\n# Configuración del pin de interrupción\nprint(\"Escanea una tarjeta RFID...\")\n```\n\n#### Configuración del Cliente MQTT\nSe configura el cliente MQTT para conectarse al servidor y definir el tema donde se publicarán los mensajes.\n\n```python\t\n# Configuración del cliente MQTT\nmqtt_server = 'BROKER_IP'\nclient_id = hexlify(unique_id())\ntopic_pub = 'thing/rfid/open'\n\nclient = MQTTClient(client_id, mqtt_server)\nclient.connect()\n```\n\n#### Lectura de Tarjetas RFID\n\nSe configura el lector RFID y se define la función read_rfid para leer las tarjetas y obtener el UID.\n\nCuando se detecta una tarjeta, el código convierte el UID a formato hexadecimal y crea un mensaje JSON. Este mensaje se publica en el tema thing/rfid/open.\n\n```python\nspi = SoftSPI(baudrate=100000, polarity=0, phase=0, sck=sck, mosi=mosi, miso=miso)\nspi.init()\nrdr = mfrc522.MFRC522(spi, gpioRst=4, gpioCs=5)\n\n# Función para leer la tarjeta y obtener el UID\ndef read_rfid():\n  while True:\n    (stat, tag_type) = rdr.request(rdr.REQIDL)\n    if stat == rdr.OK:\n      (stat, uid) = rdr.anticoll()\n      if stat == rdr.OK:\n        print(\"Tarjeta detectada!\")\n        uid_hex = ''.join(['{:02X}'.format(x) for x in uid])\n        # Crear el mensaje JSON\n        message = ujson.dumps({\n            \"type\": \"0x%02x\" % tag_type,\n            \"uid\": uid_hex\n        })\n        # Publicar el mensaje en el tema MQTT\n        client.publish(\"thing/rfid/open\", message)\n        print(\"Mensaje publicado:\", message)\n        # Enciende el LED para indicar que se ha leído la tarjeta\n        led.value(1)\n        sleep(1)\n        led.value(0)\n\n# Ejecutar la lectura\nread_rfid()\n```\n\nEjemplo de implementación de la lectura de tarjetas RFID.\n\n \u003cbr\u003e\n\u003cp align=\"center\" \u003e\n\u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n\u003cimg src=\"./assets/image-4.png\" alt=\"image\" /\u003e\n\u003c/a\u003e\n\u003c/p\u003e\n\n### Implementación de la Lógica de Control de Acceso mediante Tarjetas de RFID\n\nEste apartado consiste en la configuración de las esp8266 para extender la lógica anterior en los controles primarios de acceso mediante los siguientes publicaciones sobre el broker MQTT, cabe agregar que la comunicación de este dispositivo se realiza en doble vía, es decir, este nodo se suscribe a unos topics para actualizar el estado del lector, y publica en otros para enviar la información de las tarjetas RFID que se detectan.\n\n### Comandos MQTT - Publicaciones\n - thing/rfid/open: Envia el UID y tipo de la tarjeta RFID para soliciar el acceso.\n - thing/rfid/update: Envia los datos de las tarjetas RFID para asociar a un usuario nuevo o actualizar la información de un usuario existente.\n - thing/rfid/remove: Envio de la información de la tarjeta RFID para eliminarla de la lista de permitidos y desasoaciarla de un usuario.\n\n### Comandos MQTT - Suscripciones\n - thing/rfid/status: Actualiza el estado del lector RFID `locked` - `ready` - `remove` - `update`.\n\n### Ejemplo - Estado update - Agregar Tarjeta\n\nEn este ejemplo se agrega una tarjeta RFID a la lista de permitidos, para ello se envía la información de la tarjeta al broker MQTT. Es recibido por la suscripción `thing/rfid/update`\n\n\n\u003e Para ejemplos practicos se agrega el UID de la tarjeta en memoria del dispositivo RFID.\n\n\n\u003cbr\u003e\n\u003cp align=\"center\" \u003e\n\u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n\u003cimg src=\"./assets/image-5.png\" alt=\"image\" /\u003e\n\u003c/a\u003e\n\u003c/p\u003e\n\n### Ejemplo - Estado ready - Abrir Puerta\n\nDe acuerdo al ejemplo anterior, al tener un UID de una tarjeta guarda en memoria, se cambia el estado a `ready` para que el lector RFID envie el UID de la tarjeta y su tipo a la suscripción `thing/rfid/open` para solicitar el acceso.\n\n\u003e Hay que tener por lo menos una tarjeta en memoria para que el sistema funcione, posteriormente el listado de aceptados persistirá en una base de datos en la Nube de AWS.\n\n\u003cbr\u003e\n\u003cp align=\"center\" \u003e\n\u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n\u003cimg src=\"./assets/image-7.png\" alt=\"image\" /\u003e\n\u003c/a\u003e\n\u003c/p\u003e\n\n### Ejemplo - Estado remove - Eliminar Tarjeta\n\nEl estado del lector se debe cambiar a `remove` para remover accesos de la lista de permitidos.\n\nEn este ejemplo se elimina una tarjeta RFID de la lista de permitidos, para ello se envía la información de la tarjeta en la publicación `thing/rfid/remove`\n\n\u003cbr\u003e\n\u003cp align=\"center\" \u003e\n\u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n\u003cimg src=\"./assets/image-8.png\" alt=\"image\" /\u003e\n\u003c/a\u003e\n\u003c/p\u003e\n\n\n### Ejemplo - Estado Bloqueado - No ejecuta acciones\n\nCuando se cambia al estado `locked` el lector RFID no ejecuta ninguna acción, esto se puede utilizar para bloquear el acceso a la puerta.\n\n\u003cbr\u003e\n\u003cp align=\"center\" \u003e\n\u003ca href=\"http://nipoanz.com/\" target=\"blank\"\u003e\n\u003cimg src=\"./assets/image-9.png\" alt=\"image\" /\u003e\n\u003c/a\u003e\n\u003c/p\u003e\n\n\n## Definición de Objetos - AWS IoT Core\n\nPara definir los objetos en AWS IoT Core, se debe crear un `Thing` y un `Policy` para el dispositivo. Para ello, se debe seguir los siguientes pasos:\n\n \u003e En este ejemplo se conecta una Raspberry Pi a AWS IoT Core y se ejecuta un [script](./rpi/mqtt_connect.py) en Python para publicar mensajes en distintos tópics de MQTT y nos conectamos al cliente MQTT de AWS para ejecutar pruebas.\n\n \u003e También puede ver este [tutorial](https://www.youtube.com/watch?v=W3XVYiZN610\u0026ab_channel=TodoMaker) para crear un dispositivo en AWS IoT Core.\n\n1. Ingresar a la consola de AWS y buscar el servicio `IoT Core`.\n2. En el menú lateral, seleccionar `All things` y hacer clic en `Object`.\n3. Hacer clic en `Create` y seleccionar `Create thing`.\n4. Ingresar el nombre del dispositivo, se selecciona en `Unnamed shadow (classic)` para asociar una sombra al dispositivo y hacer clic en `Next`.\n\n![alt text](./assets/image-11.png)\n\n![alt text](./assets/image-12.png)\n\n\u003e En este ejemplo el dispositivo se llama `rpi_obj_test`.\n\n5. Seleccionar `Auto-generate a new certificate (recommended)` y hacer clic en `Next`.\n\n![alt text](./assets/image-13.png)\n\n6. Se asocian las politicas al dispositivo, en este caso se selecciona `test_rpi` y luego se hace clic en `Create thing`.\n\n![alt text](./assets/image-14.png)\n\n\u003e Más adelante se definirá y  explicará la política `test_rpi` para el dispositivo.\n\n7. Se mostrará un modal para descargar los certificados y la clave privada del dispositivo. Descargar los archivos y hacer clic en `Done`.\n\n![alt text](./assets/image-15.png)\n\n \u003e Los archivos que serán utilizados son los terminados en:\n    - `....certificate.pem.crt`\n    - `....private.pem.key`\n    - `....AmazonRootCA1.pem`\n\nListo el dispositivo ha sido creado en AWS IoT Core y este podrá ser visualizado en la consola de AWS, en la sección `Things`.\n\n![alt text](./assets/image-16.png)\n\n\n### Creación de una Política\n\nPara crear una política, se debe seguir los siguientes pasos:\n\n1. En el menú lateral, seleccionar `Secure` y hacer clic en `Policies`.\n2. Hacer clic en `Create` y seleccionar `Create a policy`.\n3. Ingresar el nombre de la política, se selecciona `Advanced mode` y se ingresa la siguiente política:\n\n```json\n{\n  \"Version\": \"2012-10-17\",\n  \"Statement\": [\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:*\",\n      \"Resource\": \"*\"\n    }\n  ]\n}\n```\n\nLa politica creada `test_rpi` y que se asocia al dispositivo `rpi_obj_test` tiene la siguiente definición:\n\n![alt text](./assets/image-17.png)\n\nEsta política permite al dispositivo realizar cualquier acción en AWS IoT Core, la puede ver [aqui](/rpi/policy.json) y está definida así:\n\n \u003e Cambie `\u003cREGION\u003e` por la región de su cuenta de AWS y `\u003cACOUNT_ID\u003e` por el ID de su cuenta.\n\n```json\n{\n  \"Version\": \"2012-10-17\",\n  \"Statement\": [\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Connect\",\n      \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:client/MyRaspberryPi\"\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Publish\",\n      \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/$aws/things/MyRaspberryPi/shadow/update\"\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Subscribe\",\n      \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/$aws/things/MyRaspberryPi/shadow/update/delta\"\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Receive\",\n      \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/$aws/things/MyRaspberryPi/shadow/update/delta\"\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Publish\",\n      \"Resource\": [\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/open\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/update\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/remove\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/one\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/two\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/three\"\n      ]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Receive\",\n      \"Resource\": [\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/open\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/update\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/remove\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/one\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/two\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/three\"\n      ]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": \"iot:Subscribe\",\n      \"Resource\": [\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/open\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/update\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/remove\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/one\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/two\",\n        \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/three\"\n      ]\n    }\n  ]\n}\n```\n\nLa politica funciona de la siguiente manera:\n\n\n\n- Permite al dispositivo suscribirse al tópico `$aws/things/MyRaspberryPi/shadow/update/delta`.\n- Permite al dispositivo publicar mensajes en los tópicos `thing/rfid/open`, `thing/rfid/update`, `thing/rfid/remove`, `thing/rfid/one`, `thing/rfid/two` y `thing/rfid/three`.\n- Permite al dispositivo recibir mensajes en los tópicos `thing/rfid/open`, `thing/rfid/update`, `thing/rfid/remove`, `thing/rfid/one`, `thing/rfid/two` y `thing/rfid/three`.\n- Permite al dispositivo suscribirse a los tópicos `thing/rfid/open`, `thing/rfid/update`, `thing/rfid/remove`, `thing/rfid/one`, `thing/rfid/two` y `thing/rfid/three`.\n\n\n#### Conectar al Broker de AWS IoT\nPermite que el dispositivo MyRaspberryPi se conecte al broker de AWS IoT. Sin este permiso, el dispositivo no podrá establecer una conexión con el servicio de IoT.\n\n  - `iot:Connect`: Politica para conectar dispositivos al broker MQTT de AWS IoT.\n  - `Resource`: ARN del cliente MQTT de AWS IoT, este debe tener la estructura `arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:client/\u003cCLIENT_ID\u003e`, en el que client_id es el ID del dispositivo definido en la conexión del dispositivo, [Ejemplo](./rpi/mqtt_connect.py#14).\n\n  ```json\n  {\n    \"Effect\": \"Allow\",\n    \"Action\": \"iot:Connect\",\n    \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:client/MyRaspberryPi\"\n  }\n  ```\t\n\n#### Publicar Mensajes en un Tema Específico\n\nPermite que el dispositivo MyRaspberryPi publique mensajes en el tema específico para actualizar su estado (shadow). Este tema se utiliza para mantener el estado reportado del dispositivo.\n\n - `iot:Publish`: Politica para publicar mensajes en un tópico específico.\n \n```json\n{\n\"Effect\": \"Allow\",\n\"Action\": \"iot:Publish\",\n\"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/$aws/things/MyRaspberryPi/shadow/update\"\n}\n```\t\n\n#### Suscribirse a un Tema para Recibir Actualizaciones del Shadow\n\nPermite que el dispositivo MyRaspberryPi se suscriba a las actualizaciones del shadow, específicamente al tema update/delta. Esto es esencial para recibir notificaciones cuando hay cambios en el shadow del dispositivo.\n\n - `iot:Subscribe`: Politica para suscribirse a un tópico específico.\n\n```json\n{\n  \"Effect\": \"Allow\",\n  \"Action\": \"iot:Subscribe\",\n  \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/$aws/things/MyRaspberryPi/shadow/update/delta\"\n}\n```\n\n#### Recibir Mensajes de un Tema Específico\n\nPermite que el dispositivo MyRaspberryPi reciba mensajes del tema update/delta. Es complementario al permiso de suscripción y asegura que el dispositivo puede procesar los mensajes que llegan a ese tema.\n\n- `iot:Receive`: Politica para recibir mensajes de un tópico específico.\n\n```json\n{\n  \"Effect\": \"Allow\",\n  \"Action\": \"iot:Receive\",\n  \"Resource\": \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/$aws/things/MyRaspberryPi/shadow/update/delta\"\n}\n```\n\n#### Publicar en Varias Temas\n\nPermite que el dispositivo publique mensajes en varios temas relacionados con RFID. Cada tema puede corresponder a diferentes eventos o datos asociados con el uso de RFID en el dispositivo.\n\n - `iot:Publish`: Politica para publicar mensajes en varios tópicos.\n\n```json\n{\n  \"Effect\": \"Allow\",\n  \"Action\": \"iot:Publish\",\n  \"Resource\": [\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/open\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/update\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/remove\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/one\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/two\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/three\"\n  ]\n}\n```\n\n#### Recibir Mensajes de Varias Temas\n\nPermite que el dispositivo reciba mensajes de varios temas relacionados con RFID. Esto asegura que el dispositivo puede escuchar y procesar información proveniente de diferentes eventos RFID.\n\n - `iot:Receive`: Politica para recibir mensajes de varios tópicos.\n\n```json\n{\n  \"Effect\": \"Allow\",\n  \"Action\": \"iot:Receive\",\n  \"Resource\": [\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/open\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/update\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/remove\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/one\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/two\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topic/thing/rfid/three\"\n  ]\n}\n```\n\n#### Suscribirse a Varias Temas\n\nPermite que el dispositivo se suscriba a varios temas relacionados con RFID. La suscripción a estos temas asegura que el dispositivo puede recibir mensajes cuando ocurren eventos específicos relacionados con RFID.\n\n - `iot:Subscribe`: Politica para suscribirse a varios tópicos.\n\n```json\n{\n  \"Effect\": \"Allow\",\n  \"Action\": \"iot:Subscribe\",\n  \"Resource\": [\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/open\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/update\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/remove\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/one\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/two\",\n    \"arn:aws:iot:\u003cREGION\u003e:\u003cACOUNT_ID\u003e:topicfilter/thing/rfid/three\"\n  ]\n}\n```\n\n#### Publicación de Mensajes - AWS IoT Core Ejemplo\n\nPara publicar mensajes en AWS IoT Core, se hace uso del [Script](./rpi/mqtt_connect.py).\n\nLa estructura del ejemplo se  organiza de la siguiente manera:\n\n![alt text](/assets/image-18.png)\n\nSe configura un entorno virtual y se instalan las dependencias necesarias, en este caso `paho-mqtt`.\n\ny se descargan y se copian los certificados y la clave privada del dispositivo en la misma carpeta del script `mqtt_connect.py`.\n\n\nEl script se suscribe a los tópicos: \n  - `thing/rfid/one`\n  - `thing/rfid/two`\n  - `thing/rfid/three`\n  - `$aws/things/MyRaspberryPi/shadow/update`\n\n\nEl código se estructura de la siguiente manera:\n\n- Configuración de Certificados y Conexión\n\nDefine las rutas a los certificados y el endpoint del broker de AWS IoT.\n\n```python\nca_path = \"AmazonRootCA1.pem\"\ncert_path = \"certificate.pem.crt\"\nkey_path = \"private.pem.key\"\nmqtt_endpoint = \"\u003cendpoint\u003e.iot.\u003cregion\u003e.amazonaws.com\"\nclient_id = \"MyRaspberryPi\"\n```\n\n- Temas para Publicación y Suscripción\n\nEspecifica los temas para actualizar y recibir actualizaciones del shadow, así como otros temas para suscripción.\n\n```python\nshadow_update_topic = \"$aws/things/MyRaspberryPi/shadow/update\"\nshadow_delta_topic = \"$aws/things/MyRaspberryPi/shadow/update/delta\"\ntopics_to_subscribe = [\n    \"thing/rfid/one\",\n    \"thing/rfid/two\",\n    \"thing/rfid/three\"\n]\n\n```\n\n- Callbacks de Conexión y Mensajes\n\nConfigura funciones callback para manejar la conexión y la recepción de mensajes.\n\n```python\ndef on_connect(client, userdata, flags, rc, properties=None):\n    print(f\"Conectado con el código {rc}\")\n    client.subscribe(shadow_delta_topic, qos=0)\n    for topic in topics_to_subscribe:\n        client.subscribe(topic, qos=0)\n\ndef on_message(client, userdata, message):\n    print(f\"Mensaje recibido en el tema {message.topic}: {message.payload.decode()}\")\n```\t\n\n- Configuración del Cliente MQTT y Conexión\n\nConfigura el cliente MQTT con TLS/SSL y lo conecta al endpoint de AWS IoT.\n\n```python\nclient = mqtt.Client(client_id=client_id, protocol=mqtt.MQTTv5)\nclient.tls_set(ca_certs=ca_path, certfile=cert_path, keyfile=key_path, cert_reqs=ssl.CERT_REQUIRED, tls_version=2, ciphers=None)\nclient.on_connect = on_connect\nclient.on_message = on_message\nclient.connect(mqtt_endpoint, port=8883)\nclient.loop_start()\n```\n\n- Bucle Principal para Publicar Mensajes\n\nPublica mensajes en los temas definidos y actualiza el estado del shadow cada 5 segundos.\n\n```python\ntry:\n    while True:\n        for topic in topics_to_subscribe:\n            message = {\n                \"timestamp\": time.time(),\n                \"data\": f\"Este es un mensaje de prueba del topic: {topic}\"\n            }\n            publish_message(topic, message)\n        state = {\n            \"device\": {\n                \"status\": \"active\",\n                \"uptime\": time.time()\n            }\n        }\n        update_shadow_state(state)\n        time.sleep(5)\nexcept KeyboardInterrupt:\n    client.loop_stop()\n    client.disconnect()\n```\t\n\n\n#### Ejemplo Funcional\n\nEjecución del Script en la Raspberry Pi.\n\n![alt text](/assets/image-19.png)\n\nSe ejecuta el script y se observa la conexión al broker de AWS IoT Core y la suscripción a los tópicos definidos.\n\nSe publican mensajes relacionados a los tópicos `thing/rfid/one`, `thing/rfid/two` y `thing/rfid/three` y  se escuchan al mismo tiempo.\n\nMientras que en la consola se suscribe al tópico `thing/rfid/one` para visualizar los mensajes publicados.\n\n![alt text](/assets/image-20.png)\n\nAhora se publica un mensaje desde la consola de AWS IoT Core en el tópico `thing/rfid/one` y se visualiza en la terminal de la Raspberry Pi.\n\n![alt text](/assets/image-21.png)\n\nY se ve el mensaje publicado desde el script de la RPI\n\n![alt text](/assets/image-22.png)\n\n---\n## Implementar Reglas - AWS IoT Core\n\nEn AWS IoT Core, las reglas permiten procesar mensajes MQTT y tomar acciones en función de los datos recibidos. En este caso vamos a hacer un ejemplo de definición de una regla para invocar una función Lambda.\n\n### Creación de una Función Lambda\n\nCreamos una función lambda desde la consola de AWS llamada `test_invoked_from_iot_core` y escogemos las opciones que se muestran en la imagen  \n\n![alt text](/assets/image-23.png)\n\n\nEl contenido de la función lambda es el siguiente:\n\n```js\nexport const handler = async (event, context) =\u003e {\n  const { uid, type  } = event;\n\n  if (!uid || !type ) {\n    console.log(\"Invalid input, id and tipo are required\");\n    return {\n      statusCode: 400,\n      body: JSON.stringify({ message: \"Invalid input, id and tipo are required\" }),\n    };\n  }\n    \n  console.log(uid);\n  console.log(type);\n  \n  const response = {\n    statusCode: 200,\n    body: JSON.stringify('Success'),\n  };\n  return response;\n}\n```\n\n![alt text](assets/image-25.png)\n\n\n\u003e Este ejemplo unicamente muestra en la consola el UID y el tipo de la tarjeta RFID que se recibe en el mensaje. Esto se visualizará por medio de CloudWatch.\n\nDefinimos el código de la lambda para recibir el mensaje proveniente del topic `+/rfid/open` y dentro de esta publicación vamos a recibir en el contenido del mensaje el UID de la tarjeta RFID y el tipo de tarjeta. y tendrá la estructura de la siguiente manera:\n\n```json\n{\n  \"uid\": \"0x1234567890\",\n  \"type\": \"0x01\"\n}\n```\n\n \u003e El comodin `+` se utiliza para recibir mensajes de cualquier tópico que termine en `/rfid/open`. Esto nos ayuda a que el sistema sea manenible a medida que se agregan más dispositivos. Recuerde que la primera parte del tópico es el nombre del dispositivo, y este deberia ser único para cada dispositivo.\n\nDesde el cliente MQTT de AWS IoT Core se publica un mensaje en el tópico `thing/rfid/open` enviando el mensaje con el UID y el tipo de la tarjeta RFID.\n\n![alt text](/assets/image-24.png)\n\n#### Creación de una Regla\n\nPara crear una regla desde la consola de AWS IoT Core, se selecciona en `Rules` desde el menu de Message Routing, y se hace clic en `Create`. Se define el nombre de la regla y la descripción.\n\n![alt text](/assets/image-26.png)\n\nEn la definición de la sentencia SQL se seleccion la versión SQL `2016-03-23` y se define la sentencia SQL para filtrar los mensajes que se reciben en el tópico `+/rfid/open y que tengan el contenido del mensaje con el UID y el tipo de la tarjeta RFID.\n\n```sql\nSELECT * FROM '+/rfid/open' WHERE uid \u003c\u003e NULL AND type \u003c\u003e NULL\n```\n\n\u003e Si quiere más información sobre la sentencia SQL puede ver la documentación [aquí](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-reference.html)\n\n![alt text](/assets/image-27.png)\n\n\nLuego se selecciona las acciones que va a realizar al invocar esta regla\n\n![alt text](/assets/image-28.png)\n\nAqui se define: \n - El servicio que se va a llamar, este caso una función lambda \n - La función lambda que se va a invocar que corresponde a `test_invoked_from_iot_core`.\n - La versión de la función lambda, por defecto se selecciona la última versión.\n\n\u003e Documentación de como generar una acción con una función lambda [aquí](https://docs.aws.amazon.com/iot/latest/developerguide/lambda-rule-action.html)\n\n\u003e También se pueden definir más de una acción al ejecturar la regla\n\n\nAsi mismo se puede definir una acción de error, en el caso de que la regla falle.\n\nPor último se muestra un resumen de la regla, en esta se valida que todas las opciones sea correcta, luego de esto se hace clic en `Create`.\n\n![alt text](/assets/image-29.png)\n\n#### Ejecución de la Regla\n\nSe publica un mensaje en el tópico `thing/rfid/open` con el contenido del mensaje con el UID y el tipo de la tarjeta RFID.\n\n![alt text](/assets/image-30.png)\n\nEn los registros de CloudWatch se visualiza el mensaje que se recibe en la función lambda.\n\n![alt text](/assets/image-31.png)\n\n\nSe puede ver que el mensaje se recibe correctamente y se visualiza en la consola de CloudWatch.\n\nAhora se publica un mensaje en el tópico `thing/rfid/open` con el contenido de UID  y type vacio.\n\n![alt text](/assets/image-32.png)\n\nSe visualiza en los registros de CloudWatch que el mensaje se imprime un mensaje de error.\n\n![alt text](/assets/image-33.png)\n\nSi no se envía el mensaje con el UID y el tipo de la tarjeta RFID, la función lambda no se ejecutará.\n\n---\n## Conexión de ESP8266 a AWS IoT Core\n\nPara conectar el ESP8266 a AWS IoT Core, se puede orientar en el siguiente [tutorial](https://www.youtube.com/watch?v=DEBmpVPnZb0\u0026t=726s\u0026ab_channel=Shilleh) para conectar un ESP8266 a AWS IoT Core.\n\nEs importante mencionar que la versión del `firmware` del ESP8266 corresponde al `v1.19.1` y lo puede encontrar en el siguiente link [ESP8266 Firmware](https://micropython.org/download/esp8266/).\n\nPara las conexión a AWS IoT Core se debe tener en cuenta que es necesario tener el certificado y la clave privada del dispositivo, recuerde que estos se generan al momento de crear o definir el dispositivo.\n\n - `certificate.pem.crt`\n - `private.pem.key`\n\nEstos los puede pasar a la memoria del ESP8266 utilizando `ampy`\n\n```sh\nampy --port com6 put \u003cORIGEN-ARCHIVO\u003e certificate.pem.crt\nampy --port com6 put \u003cORIGEN-ARCHIVO\u003e private.pem.key\n```\n\n\u003e No hay mecesidad de convertirlos, ya que estos son leidos y son codificados en base64. esto por medio del método `read_cert` de la clase `door.py`. Este lo puede encontrar en el archivo [door.py](./scripts/door.py#L178).\n\n\u003e Puede guiarse de este [tutorial](https://medium.com/dev-jam/tutorial-part-2-aws-iot-rules-lambda-function-dynamodb-40a7d4ea35b9) para realizar la conexión del ESP8266 a AWS IoT Core, así mismo este ofrece una definición de las reglas para la invocación de funciones lambda de acuerdo a comportamientos esperados.\n\n---\n## Contribuciones\n\n1. Hacer un fork del repositorio.\n2. Crear una nueva rama (`git checkout -b feature-nueva-funcionalidad`).\n3. Hacer commit de los cambios (`git commit -am 'Agregar nueva funcionalidad'`).\n4. Hacer push a la rama (`git push origin feature-nueva-funcionalidad`).\n5. Crear un Pull Request.\n\n\n## Autor\n\n- [Nicolas Potier](https://github.com/potier97/)\n\n## Licencia\nEste proyecto está bajo la Licencia MIT.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpotier97%2Frfid-access-iot","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpotier97%2Frfid-access-iot","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpotier97%2Frfid-access-iot/lists"}