NINA-B302 (BLE de longo alcance) sendo comandado pelo ALEXA em conjunto com o NINA-W102 (WiFi e BLE)

O objetivo deste BLOG é apresentar uma ideia geral de como o NINA B302 possa ser comandado pelo assistente de voz ALEXA e assim acender ou apagar uma lampada "lamp" quando você falar "lamp on" ou "lamp off".O U-BLOX NINA B302 esta conectado a um COPROCESSOR U-BLOX NINA W102 (WIFININA) via SPI.

Por Miguel ALEXAndre Wisintainer

CIRCUITPYTHON

CircuitPython é uma linguagem de programação projetada para simplificar a experiência e o aprendizado de código em placas de microcontroladores de baixo custo.

https://learn.adafruit.com/pyportal-iot-plant-monitor-with-aws-iot-and-circuitpython

WIFININA - UBLOX NINA W102

WIFI COPROCESSOR baseado no NINA W102, o qual permite que você tenha acesso a INTERNET 802.11, via SPI.

U-BLOX NINA B302

O NINA-B30 possui Bluetooth 5 completo, um poderoso Arm® Cortex®-M4 com FPU,

e desempenho de energia de ponta. Bluetooth BLE 5.0.

ADADRUIT

A Adafruit foi fundada em 2005 pelo engenheiro do MIT, Limor "Ladyada" Fried. Seu objetivo era criar o melhor local on-line para o aprendizado de eletrônicos e para a fabricação dos melhores produtos projetados para fabricantes de todas as idades e níveis de habilidade.

SMARTCORE

A SmartCore fornece módulos para comunição wireless, biometria, conectividade, rastreamento e automação.

Nosso portifólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.

Mais detalhes em www.smartcore.com.br

ASSISTENTE ALEXA

A Amazon Alexa, por exemplo, é um serviço de assistente pessoal inteligente na nuvem onde pode ser solicitadas tarefas como realizar pesquisas, mandar executar uma lista de músicas ou questionar o horário atual. Segundo o site da Amazon Alexa, o serviço permite se conectar com dispositivos (AWS IoT Cor) e por meio da Web Service da Amazon, efetuar comandos de voz, interpretá-los e tomar uma ação correspondente.

PREPARANDO ADAFRUIT CIRCUITPYTHON PARA U-BLOX NINA B302

Com seu gravador SEGGER J-TAG, será necessário gravar o BOOTLOADER da Adafruit

Instale os drivers da Adafruit

https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython#windows-7-drivers-5-9

Conecte a USB no seu PC e os drivers serão instalados. Uma MSD vai aparecer, copie para ele o arquivo abaixo.

https://circuitpython.org/board/sparkfun_nrf52840_mini/

Este arquivo é o circuitpython Engine!

Instale

adafruit_drivers_2.3.4.0.exe

Altere em Adafruity_usbser.inf, caso contrário, o Windows não vai detectar o CDC (Serial)

USB\VID_1B4F&PID_5289&REV_0100&MI_00

Desconecte e conecte a USB no seu PC e os novos drivers serão instalados. Uma COM virtual aparecerá, na figura abaixo, apareceu COM55 e um MSD

A COM é para ser o terminal de comunicação serial com o PYTHON, o MSD (CIRCUITPY) é para transferir o SCRIPT PYTHON

Executando um script python

Execute o emulador de terminal Teraterm, abra a COM e tecle CONTROL-D, você verá as boas vindas do Python.

ou utilizares

Será necessário agora baixar os módulos (libraries) compilados para executar com programa para acesso ao AWS IoT Core.

Entre no link

https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases

E baixe a última versão dos módulo.

Descompacte na pasta "lib" do drive CIRCUITPY os arquivos abaixo (compilados) (mpy)

Libraries Necessárias

Na pasta root do drive CIRCUITPY devem estar o programa principal e os certificados para acesso ao servidor AWS IoT Core (MQTT)

Ver https://learn.adafruit.com/pyportal-iot-plant-monitor-with-aws-iot-and-circuitpython

Root

2 certificados serão necessários (obtidos na configuração da Coisa)

TRANSFORMANDO NINA W102 EM WIFI COPROCESSOR

Grave o seguinte BIN no NINA W102, o qual será transformado em um SPI COPROCESSOR WIFI. Você pode usar o esptools para gravar.

A versão do BIN de maior ou igual à 1.4.0.

https://github.com/adafruit/nina-fw/releases/tag/1.6.0

MONTAGEM

Conecte fisicamente o U-BLOX NINA B302 com o U-BLOX NINA W102 conforme circuito abaixo. Bom utilizar fios bem curtos. Os breakouts utilizados foram da Smartcore.

SINAIS	BREAKOUT B3	Pino NRF52X	BREAKOUT W1	Pino ESP32
CS	IO1	P0.13	IO28	5
READY	IO2	P0.14	IO7	33
RESET	IO21	P1.12	RESET	RESET
SCK	IO45	P0.07	IO29	18
MOSI	IO3	P0.15	IO31	14
MISO	IO8	P1.00	IO1	23
GPIO0	IO4	P0.16	IO27	0

EXECUTANDO PROGRAMA

Para edição do programa foi utilizado o MU, um editor Python simples para programadores iniciantes. Abra a COM onde está o U-BLOX NINA B302.

Control-C para a execução e Control-D inicia. Quando você salva a aplicação, a execução reinicia.

Agora é hora de testar o exemplo abaixo. Copie e cole o programa a seguir:

(code.py)

import microcontroller
import time
import json
import board
import busio
from digitalio import DigitalInOut
import neopixel
from adafruit_esp32spi import adafruit_esp32spi
from adafruit_esp32spi import adafruit_esp32spi_wifimanager
import adafruit_esp32spi.adafruit_esp32spi_socket as socket
import adafruit_minimqtt as MQTT
from adafruit_aws_iot import MQTT_CLIENT

### WiFi ###

secrets = {
    "ssid": "Andreia Oi Miguel 2.4G",
    "password": "xxxxxxxxx",
    "timezone": "America/New_York",  # http://worldtimeapi.org/timezones
    "broker": "https://xxxxxxxxxxxxxx-ats.iot.us-east-1.amazonaws.com",
    "client_id": "PyPortal"
}

# Get device certificate
try:
    with open("aws_cert.pem.crt", "rb") as f:
        DEVICE_CERT = f.read()
except ImportError:
    print("Certificate (aws_cert.pem.crt) not found on CIRCUITPY filesystem.")
    raise

# Get device private key
try:
    with open("private.pem.key", "rb") as f:
        DEVICE_KEY = f.read()
except ImportError:
    print("Certificate (private.pem.key) not found on CIRCUITPY filesystem.")
    raise

# If you are using a board with pre-defined ESP32 Pins:
esp32_cs = DigitalInOut(microcontroller.pin.P0_13)
esp32_ready = DigitalInOut(microcontroller.pin.P0_14)
esp32_reset = DigitalInOut(microcontroller.pin.P1_12)

SCK = microcontroller.pin.P0_07
MOSI = microcontroller.pin.P0_15
MISO = microcontroller.pin.P1_00

spi = busio.SPI(SCK, MOSI, MISO)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)

# Verify nina-fw version >= 1.4.0
assert (
    int(bytes(esp.firmware_version).decode("utf-8")[2]) >= 4
), "Please update nina-fw to >=1.4.0."

wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(esp, secrets, None)

### Code ###

topic = 'aws/things/PyPortal/shadow/update/accepted'

# Define callback methods which are called when events occur
# pylint: disable=unused-argument, redefined-outer-name
def connect(client, userdata, flags, rc):
    # This function will be called when the client is connected
    # successfully to the broker.
    print("Connected to MQTT Broker!")
    print("Flags: {0}\n RC: {1}".format(flags, rc))

    # Subscribe to topic circuitpython/aws
    print("Subscribing to topic {}".format(topic))
    aws_iot.subscribe(topic)


def disconnect(client, userdata, rc):
    # This method is called when the client disconnects
    # from the broker.
    print("Disconnected from MQTT Broker!")


def subscribe(client, userdata, topic, granted_qos):
    # This method is called when the client subscribes to a new topic.
    print("Subscribed to {0} with QOS level {1}".format(topic, granted_qos))

    # Create a json-formatted message
    message = {"message": "Hello from AWS IoT CircuitPython"}
    # Publish message to topic
    aws_iot.publish(topic, json.dumps(message))


def unsubscribe(client, userdata, topic, pid):
    # This method is called when the client unsubscribes from a topic.
    print("Unsubscribed from {0} with PID {1}".format(topic, pid))


def publish(client, userdata, topic, pid):
    # This method is called when the client publishes data to a topic.
    print("Published to {0} with PID {1}".format(topic, pid))


def message(client, topic, msg):
    # This method is called when the client receives data from a topic.
    print("Message from {}: {}".format(topic, msg))


# Set AWS Device Certificate
esp.set_certificate(DEVICE_CERT)

# Set AWS RSA Private Key
esp.set_private_key(DEVICE_KEY)

# Connect to WiFi
print("Connecting to WiFi...")
wifi.connect()
print("******Connected******")

# Initialize MQTT interface with the esp interface
MQTT.set_socket(socket, esp)

# Set up a new MiniMQTT Client
client = MQTT.MQTT(broker=secrets["broker"], client_id=secrets["client_id"])

print("Ping: %d ms" % esp.ping("a1dl08fmj981lr-ats.iot.us-east-1.amazonaws.com"))

# Initialize AWS IoT MQTT API Client
aws_iot = MQTT_CLIENT(client)

# Connect callback handlers to AWS IoT MQTT Client
aws_iot.on_connect = connect
aws_iot.on_disconnect = disconnect
aws_iot.on_subscribe = subscribe
aws_iot.on_unsubscribe = unsubscribe
aws_iot.on_publish = publish
aws_iot.on_message = message

print("Attempting to connect to %s" % client.broker)
aws_iot.connect()

# Pump the message loop forever, all events
# are handled in their callback handlers
# while True:
#   aws_iot.loop()

# Start a blocking message loop...
# NOTE: NO code below this loop will execute
# NOTE: Network reconnection is handled within this loop
while True:
    try:
        aws_iot.loop()
    except (ValueError, RuntimeError) as e:
        print("Failed to get data, retrying\n", e)
        wifi.reset()
        aws_iot.reconnect()
        continue
    time.sleep(1)

Mande executar (Control-D)

Mensagem do Broker (Tópico Inscrito)

Utilzando AWS IoT Core test para publicar no Tópico

Se você salvar com nome code.py, toda vez que resetar U-BLOX NINA B302, ele já vai executá-lo.

FAZENDO INTERFACE COM ASSISTENTE DE VOZ ALEXA

AWS IoT Core

O AWS IoT Core é uma plataforma que permite que você conecte dispositivos a serviços da AWS e outros dispositivos, proteja dados e interações, processe e haja de acordo com os dados do dispositivo e permita que os aplicativos interajam com dispositivos mesmo quando estiverem off-line.

Os dados são armazenados em um local que recebe o nome de Thing Shadow, use tópicos para habilitar aplicativos e coisas para obter, atualizar ou excluir as informações do estado para uma Coisa.

Utiliza MQTT.

Amazon Alexa

O Amazon Alexa é um serviço de voz na nuvem da Amazon que permite que os desenvolvedores controlem por voz os serviços da Amazon conectados. Um aplicativo exemplo é o Amazon Echo, que é um assistente de controle de voz. Quando os usuários falam com o Amazon Echo, ele analisa a voz recebida e faz uma resposta apropriada. Neste exemplo, apresenta-se como conectar os serviços da Amazon (incluindo o Amazon Alexa, o AWS Lambda, o AWS IoT Core, o AWS IAM) e utilizar o Amazon Alexa para controlar a Lâmpada no U-BLOX NINA B302.

Skill

O Amazon Alexa Skills Kit (ASK) é um serviço de voz. Ele pode ser conectado a serviços da nuvem e o usuário pode controlar por voz os serviços conectados e receber resposta de voz. O recurso de análise de voz fornecido pelo Amazon Alexa está pronto para uso, faz com que os desenvolvedores possam se concentrar no design do serviço em nuvem e no modelo de interação do usuário.

Amazon AWS Lambda

O Amazon AWS Lambda é um serviço de computação. As linguagens de programação suportadas inclui o Node.js, o Python e o java. O Lambda permite que os usuários configurem os recursos requeridos pelo cálculo (como memória, tempo de computação).

Os três juntos (AMAZON ALEXA, LAMBDA, AWS IoT Core)

Os três elementos basicamente trabalham em conjunto:

(1) Quando um usuário diz "Lamp on" para o dispositivo de teste (que suporta Amazon Alexa), Amazon Alexa analisa o comando de voz de acordo com o esquema e o arquivo das declarações de amostra (fornecido pelo usuário antes) e gera intenção JSON.

(2) Amazon Alexa envia a intenção JSON para o AWS Lambda. De acordo com a intenção, o serviço Lambda envia uma mensagem de atualização para o serviço AWS IoT Core Shadow.

(3) O serviço AWS IoT Core Shadow atualiza o estado de sombra de acordo com a mensagem de atualização do serviço Lambda.

(3.1) Se o U-BLOX NINA B302 estiver on-line e tiver assinado o serviço de sombra, o U-BLOX NINA B302 ativa o LED.

(3.2) Em seguida, o Lambda gera a mensagem de resposta de texto e voz e envia para o Amazon Alexa.

(4) Finalmente, o usuário pode ouvir a mensagem de voz para indicar que o LED foi acionado com sucesso.

MONTANDO AS REGRAS NO ASSISTENTE DE VOZ ALEXA (Resumo)

Primeiramente cria-se uma skill na Amazon Alexa. Para isso, primeiro cadastra-se o nome de invocação. Esse nome de invocação é o nome que o Amazon Alexa irá identificar que se trata da skill criada. Em seguida, são criadas as ações ou intents, que o Amazon Alexa irá solicitar ao Amazon Lambda que seja executado cada comando.

Os comandos são criados na tela de intents. Para ativar a execução de um intent, podem ser criados diversos comandos. Ou seja, quando se quer que através de diversas maneiras de falar apenas uma específica ação seja executada, cria-se uma lista de comando para apenas um intent. Pode-se observar que o comando contém uma palavra entre chaves. Esta palavra chama-se slot. Um slot é uma espécie de variável, onde os seus valores podem ser previamente definidos.

Cada intent é uma ação. Cada ação pode ter um ou mais comandos. Cada comando pode ou não ter um slot. No comando de acender ou apagar o quarto verde vê-se que tem apenas um comando com um slot. Já na ação (intent) de acender ou apagar todas as luzes vê-se três comandos, ou três formas de chamar esta ação.

SERVIDOR LAMBDA

O AWS Lambda da Amazon é uma plataforma que permite que o usuário, ou cliente, pague apenas o que consumir. Disponibiliza processamento sempre que preciso, ou até quando agendado que seja executado automaticamente.

Com a alta disponibilidade, o usuário apenas fornece seu código, ou cria a sua Função do Lambda, como é chamado. Cada função é gerenciada pela Amazon, desde a disponibilidade de execução e segurança. Com o AWS Lambda pode-se conectar com outros serviços da Amazon, como o AWS IoT Core e a Amazon Alexa.

Principais pontos do programa

OBS: ASSISTENTE ALEXA CONVERSA COM LAMBDA QUE ENTÃO CONVERSA COM AWS IoT CORE E FINALMENTE O MÓDULO U-BLOX NINA B302.

AWS IoT Core (a coisa) (PyPortal)

A função da Amazon voltada para a Internet das Coisas (AWS IoT Core) permite conectar dispositivos à Internet para que se possam ser transmitidos dados, armazenados e analisados. Muitos tipos de objetos são usados nas aplicações para Internet das Coisas, desde câmeras de segurança a refrigeradores. Seja qual for o dispositivo desde que possa ser ligado, pode fazer parte do IoT. Essas aplicações tornaram dados antigamente inúteis em dados importantes para os usuários.

A Amazon oferece uma plataforma de Internet of Things (Internet das Coisas) onde se gerenciam dispositivos na nuvem facilmente. Podem-se criar aplicações que processam ou analisam informações de dispositivos conectados sem necessitar que o cliente tenha uma infraestrutura. O AWS IoT Core permite suporte ao protocolo HTTP e MQTT, que visa reduzir consumo de dados na rede. Estes protocolos utilizam suas respectivas portas para acesso aos serviços.