Controle ativado por voz com Android e NodeMCU

Em meu último tutorial: Quando o IoT encontra a Inteligência Artificial: Automação residencial com Alexa e NodeMCU exploramos como equipamentos ativados por voz como o Amazon Echo-Dot utilizando-se de um serviço da web (como o “Alexa”) podem controlar “dispositivos inteligentes” em nossas casas. Neste novo tutorial faremos o mesmo,  porém  em vez de usar o Alexa desenvolveremos nossa própria App em um smartphone Android controlando, tanto com botões quanto por voz, nossos dispositivos domésticos.

O diagrama de blocos nos dá uma geral do que pretendemos desenvolver:

Block Diagram.jpg

e o filme nos mostra como ficará o projeto final:

1: Lista de materiais (BoM)

Valores em USD, utilizados apenas como referência

  1. NodeMCU ESP8266-12E ($8.79)
  2. Mini BreadBoard ($1.00)
  3. 400-point Experiment Breadboard Breadboard ($ 4.97)
  4. 4-Channel Relay Module ($8.49)
  5. LEDs (vermelho, amarelo, verde e azul) ($1.00)
  6. 4 x Resistor (220 ohm)
  7. Male-Female Dupont Cables ($1.00)
  8. Fonte externa DC de 5V ou bateria

….. e naturalmente um telefone ou tablet Android (qualquer modelo com wifi servirá).

2: Conectando o NodeMCU à rede local de WiFi

Conectaremos o NodeMCU a rede WiFi local,  verificando seu endereço IP. Para isso, usaremos o pequeno programa abaixo, o qual fará parte do projeto final:
#include <ESP8266WiFi.h>
WiFiClient client;
WiFiServer server(80);
const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

void setup() 
{
  Serial.begin(115200);
  connectWiFi();
  server.begin();
}

void loop() 
{
}

/* connecting WiFi */
void connectWiFi()
{
  Serial.println("Connecting to WIFI");
  WiFi.begin(ssid, password);
  while ((!(WiFi.status() == WL_CONNECTED)))
  {
    delay(300);
    Serial.print("..");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("NodeMCU Local IP is : ");
  Serial.print((WiFi.localIP()));
}

No monitor serial voce poderá ver o IP Address assignado por seu Modem ao NodeMCU:

Serial Monitor Comm Test

Tome nota do endereço (em meu acaso: 10.0.1.3). Necessitaremos deste endereço para a conexão ao aplicativo Android que será desenvolvido mais adiante.

3: Montando o HW

Assembling the HW

Usaremos um módulo de relé de 4 canais para controlar 4 LEDs, simulando 4 dispositivos domésticos. Siga as instruções a seguir e termine as conexões:

Conecte as entradas dos relés com os pinos do NodeMCU como mostrado no diagrama e definido no código como mostrado abaixo:

int relay1 = 14;
int relay2 = 15;
int relay3 = 3;
int relay4 = 1;

Nossos dispositivos inteligentes serão simulados pelos LEDs coloridos:

  • relé 1 ==> LED vermelho
  • relé 2 ==> LED amarelo
  • relé 3 ==> LED verde
  • relé 4 ==> LED azul

Nosso Android App irá enviar um comando em forma de string,  o qual deverá ser interpretado pelo código de maneira a ativar cada um dos relés. Definamos as strings para cada comando:

  • Relé 1:
    • Ligar: “r1on”;
    • Desligar: “r1off”;
  • Relé 2:
    • Ligar: “r2on”;
    • Desligar: “r2off”;
  • Relé 3:
    • Ligar: “r3on”;
    • Desligar: “r3off”;
  • Relé 4:
    • Ligar: “r4on”;
    • Desligar: “r4off”;

Definamos uma variável que irá receber os comandos (command) e a lógica associada a mesma:

String  command ="";

Assim, por exemplo, se o aplicativo Android enviar como um comando: “r1on”,  o relé 1 (relay1) deverá ser ativado:

if (command == "r1on")
{
  digitalWrite(relay1, LOW);
}

Observe que os relés usados no projeto são ativados com um nível baixo (LOW).

Utilizando alsoif, escreveremos os demais comandos (veja o codigo completo ao final).

Também definiremos “comandos de grupo” para ligar (“allon”) e desligar (“alloff”) simultaneamente todos os dispositivos. Por exemplo, para ativar ao mesmo tempo todos os relés, usaremos o comando “allon” como mostrado abaixo:

    if (command == "allon") 
    {
      digitalWrite(relay1,LOW);
      digitalWrite(relay2,LOW);
      digitalWrite(relay3,LOW);
      digitalWrite(relay4,LOW);
    }

A mesma lógica deverá ser empregada para o comando “alloff”.

Siga o diagrama elétrico acima para concluir a conexão de todo o HW.

Agora faça o download do código completo:

Home_Automation_NodeMCU_Android_Voice_V2_EXT.ino a partir de meu GitHub.

Entre com as credenciais de sua rede local de WiFi:

const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

Faça o upload do código em seu NodeMCU e pronto! Você poderá verificar no  Monitor Serial se o programa está em execução. Deixe o programa rodando para que se possa testar o aplicativo Android desenvolvido a partir do próximo passo.

CUIDADO: Quando fizer o upload do código, desligue a alimentação dos relés para não sobrecarregar o NodeMCU.

4: A App Android : “Designer Tab”

 Usaremos a aplicação on-line: MIT App Inventor para o desenvolvimento de nossaApp Android:

MIT V2 0

Componentes Principais da Screen1 (veja foto acima)

  • Entrada do endereço IP
    • TextBox denominado “IP_Address”
  • 8 botões ON / OFF, um para cada relé:
    • Relay_1_ON
    • Relay_2_OFF
    • Etc
  • 2 botões ON / OFF para todos os dispositivos:
    • All_Devices_ON
    • All_Devices_OFF
  • Botão de Entrada de Voz
    • Voice_Input
  • Componentes não visíveis:
    • Web1
    • SpeachRecognizer1
    • TextToSpeach1
  • Outros:
    • Caixa de texto:
      • Speach_To_Text
    • Label:
      • Comm_Status

Ao final o aplicativo deverá ficar assim:

Screenshot_2017-03-29-16-33-37

5: A App Android: Botões

Devemos criar na tab Blocks, 10 botões. Todos seguirão a mesma estrutura que os 2 mostrados na foto.

MIT V2 2

Esses blocos de 2 botões foram criados para:

  • Relay_1_ON. Click
  • Relay_1_OFF.Click

Estas funções são chamadas quando se “clica” em um desses botões. Por exemplo, quando você clica no botão Relay_1_ON, 3 ações serão executadas:

  1. Um comando será enviado no formato: http: / ip_address * / r1on
  2. Um “eco” no mesmo formato é esperado devido a “call Web1.Get”
  3. Uma “mensagem” sonora será lida pela App: no caso: “Relé 1 ligado”

* O IP_Address será o que você digitar na Tela 1. Utilizando-se o default (10.1.0.3), a mensagem real seria: http: /10.0.1.3/r1on

Voce poderá utilizar qualquer mensagem nesta etapa, ou deixá-la vazia (“”) caso não deseje um retorno auditivo.

6: O App Android: Reconhecimento de voz

Os blocos abaixo mostram a construção do código para o reconhecimento de voz de nosso aplicativo:

MIT V2 3

Note que para qualquer comando de voz, o comando enviado será sempre em  minúsculas (uso do bloco de texto downcase). Isso facilitará a decodificação do comando de voz pelo NodeMCU.

Por exemplo, se você deseja “ativar” o relé 1, uma palavra ou sentença deve ser enviada para ser reconhecida pelo código do NodeMCU. Enviaremos para isto um comando de voz em português: “Ligar UM”

if (command == "r1on"  || command == "ligar 1"    || command == "ligar um")
{
  digitalWrite(relay1,LOW);
}

Assim, quando digo “ligar um”, a App irá enviar: http: / 10.0.1.3/ligar um (ou http: / 10.0.1.3/ligar 1) e o NodeMCU colocará seu pino em LOW,  ativando o relé 1.

7: O App Android: Manipulação de erro

The Android App: Error Manipulation

Se ocorrer um erro, o bloco acima escreverá os detalhes referente ao mesmo na última linha do App (Comm_Status). Você somente irá ver-lo se ao criar o App usar a opção Responsive.

8: Testes finais

Final Test

Você poderá criar seu aplicativo passo a passo, como mostrado nas etapas anteriores ou utilizar o fonte de meu projeto (.aia) diretamente no MIT App Inventor:

MIT V2 1

Caso você não tenha experiência no desenvolvimento de aplicativos Android, poderá executar o arquivo .apk diretamente em seu dispositivo Android.

Ambos arquivos .aia e .apk poderão ser baixados de meu GitHub:

Home_Relay_Voice_Ctrl_V2.aia

Home_Relay_Voice_Ctrl_V2.apk

9: Conclusão

Como sempre, espero que este projecto possa ajudar outros a encontrarem o seu caminho no emocionante mundo da electrónica, robótica e do IoT!

Verifique o depositário no GitHub para obter os arquivos atualizados:

Home-Automation-with-Android-and-NodeMCU

Saludos desde el sur del mundo!

Até o próximo tutorial!

Obrigado

Marcelo

Anúncios

Quando o IoT encontra a Inteligência Artificial: Automação residencial com Alexa e NodeMCU

Exploraremos neste tutorial, como usar a Alexa, um assistente pessoal inteligente desenvolvido pela Amazon Lab126, popularizado pelo Amazon Echo e Echo-Dot.

Alexa é capaz de interação de voz, reprodução de música, fazer listas de tarefas, configurar alarmes, transmitir podcasts, tocar audiobooks e fornecer informações meteorológicas, de trânsito e outras informações em tempo real. Alexa também pode controlar vários dispositivos inteligentes usando-se como um hub de automação residencial. Vamos usar neste projeto, o “Echo-Dot”, que permite aos usuários ativar o dispositivo usando um wake-word (no caso, “Alexa”).

echo-dot features

No espaço da Domótica (automação residencial), Alexa pode interagir com vários dispositivos diferentes como Philips Hue, Belkin Wemo, SmartThings, etc. Em nosso caso, emularemos dispositivos do tipo WeMo, como estes mostrados abaixo (mas por apenas uma fração de seu preço):

WeMo

WeMo é uma série de produtos da Belkin International, Inc. que permitem aos usuários controlar eletrônicos domésticos de qualquer lugar. A suite de produtos inclui um interruptor, sensor de movimento, Insight Switch, interruptor de luz, câmera e app. O WeMo Switch (nosso caso aqui) pode ser conectado a qualquer tomada de casa, que pode ser controlada a partir de um iOS ou Android smartphone executando o WeMo App, via rede doméstica WiFi ou rede de telefonia móvel.

O diagrama abaixo mostra o que será desenvolvido em nosso projeto:

Home Automation Block Diagram V2E o vídeo abaixo, mostra como ficará o projeto ao final:

1: Lista de materiais (BoM)

Valores referenciais em USD

  • LEDs (vermelho e verde) ($1.00)
  • 2 x Resistor (220 ohm)
  • Fonte de alimentação externa de 5V DC ou batteria

2: Emulando o WeMo Switch

 wemo_echo_upnp

Os dispositivos WeMo utilizam UPnP para executar certas funções através da rede. A função de detecção do dispositivo começa com o Echo ou Echo-Dot (em nosso caso aqui) à procura de dispositivos WeMo utilizando UPnP. O dispositivo então responde ao Echo-Dot com seu URL utilizando HTTP sobre UDP. OEcho-Dot então solicita a descrição do dispositivo utilizando esse URL HTTP. A descrição é então retornada como uma resposta HTTP. Neste ponto, o Echo-Dot já “descobriu” o dispositivo. O Echo-Dot simplesmente se conectará ao WeMo através da interface HTTP e emitirá um comando do tipo “SetBinaryState”. O WeMo então “obedecerá”, retornando uma confirmação via HTTP. O diagrama  acima resume a comunicação entre o Echo-Dote o WeMo Switch.

Este tutorial não entrará em muito mais detalhes sobre este tópico. Procurei compilar informações obtidas em vários projetos da web, simplificando sua apresentação de maneira a apresentar uma visão geral sobre o uso da Alexa na automação residencial .

Algumas excelentes fontes de informação sobre o assunto poderão ser encontradas nos links abaixo:

HOW TO MAKE AMAZON ECHO CONTROL FAKE WEMO DEVICES, escrito por Rick Osgut

Building an IoT power switch with the ESP8266 (and control it with your Amazon Echo!)  escrito por  Wai Lun

Amazon Alexa + WeMos switch made with Arduino D1 Mini , codigos desenvolvidos por Aruna Tennakoon:

Projects using NodeMCU, conjunto de códigos desenvolvidos por Christopher Kuzma

Dito isto, com o que fui aprendendo nos diversos sites acima terminei chegando a um código de teste, o qual você poderá baixar desde meu GitHib: Alexa_LED_Control_V2_EXT.ino

Verifique se você possui todas as bibliotecas necessárias para executar o código, como: ESP8266WiFi.h, ESP8266WebServer.h e WiFiUdp.h. Caso não as tenha, você poderá obtê-las aqui:  Arduino core for ESP8266 WiFi chip.

3: Criando nosso WeMo Switch com o NodeMCU

Alex and NodeMCU

Para o nosso primeiro teste, conectemos um LED ao NodeMCU pino D1 como mostrado no diagrama abaixo:

Abra o arquivo  Alexa_LED_Control_V2_EXT.ino , o qual você baixou de meu GitHub e entre com suas credenciais de rede:

const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

Confirme se você definiu corretamente o pino onde o LED está conectado e dê um nome ao seu dispositivo. Alexa reconhecerá seu dispositivo por este nome:

String device_name = "lights";  // Name of device
int relayPin = D1;              // Pin to toggle

No meu caso, o dispositivo será denominado “lights“. Aqui neste primeiro exemplo o dispositivo acionará um único LED, mas o NodeMCU poderia estar conectado a um relé que por sua vez poderia ligar as luzes de meu laboratório, por exemplo.

Carregue o código no NodeMCU.

No monitor serial você pode ver a mensagem “Connecting to UDP” e “Connection Successful”. Isso significa que do lado NodeMCU tudo está OK.

Serial Monitor1

Estarei levando em consideração que voce já tenha o Echo-Dot instalado em sua rede., bem como o Alexa App em seu smartphone. Os procedimentos para a instalação de ambos é bem simples e basta seguir as instruções da Amazon fornecidas junto com o dispositivo.

Agora, necessitamos que a Alexa encontre seu dispositivo. Existem dois métodos para isso:

  • Utilizando o aplicativo Alexa no smartphone como mostrado nas fotos abaixo. Em nosso caso, a Alexa encontrará “1 Smart Home device”:  lights WeMo Switch.

Alexa app

  • Pedindo diretamente à Alexa através de um comando de voz, como por exemplo: “Alexa, Find connected devices” como poderá ser visto no vídeo abaixo:

Uma vez que a Alexa descobriu seu dispositivo, você poderá usar comandos de voz para o acionamento do dispositivo como mostrado abaixo:

4: Acionando vários dispositivos ao mesmo tempo

IMG_1224
Aprofundando um pouco mais,  desenvolveremos um sistema um pouco mais realista que acionará vários dispositivos ao mesmo tempo. Desta maneira, o projeto poderia ser usado em projetos envolvendo automação residencial  (domótica).

Usaremos um módulo de relé de 4 canais para controlar 2 lâmpadas e 2 tomadas.

Esta parte do projeto foi baseada em grande parte no tutorial de Charles Gantt,

How To: DIY Home Automation With NodeMCU and Amazon Alexa.

Siga as instruções abaixo:

Conecte as entradas dos relés com os pinos do NodeMCU conforme descrito abaixo:

int relayOne = 14;  // NodeMCU pin D5
int relayTwo = 15;  // NodeMCU pin D8
int relayThree = 3; // NodeMCU pin RX
int relayFour = 1;  // NodeMCU pin TX

Nossos “smart devices” serão 2 lâmpadas fixas (“Lights”)e 2 tomadas para uso geral (“Outlets”). Como vimos nas etapas anteriores, deveremos emular “WeMo Devices” e para fazer isso devemos nomeá-los como abaixo:

  • Light One
  • Light Two
  • Outlet One
  • Outlet Two

Em seguida, deveremos defini-los em nosso código para que a Alexa consiga encontrá-los. Também definiremos 2 comandos (on e off) e um número de porta de comunicação (“Port”) para cada dispositivo.

O formato geral deve ser:

lightOne = new Switch("Light One", 80, lightOneOn, lightOneOff);
lightTwo = new Switch("Light Two", 81, lightTwoOn, lightTwoOff);
outletOne = new Switch("Outlet One", 82, outletOneOn, outletOneOff);
outletTwo = new Switch("Outlet Two", 83, outletTwoOn, outletTwoOff);

Agora, você deve definir as 2 funções relacionadas a cada condição do dispositivo:

Para as lampadas:

void lightOneOn() {
  Serial.print("Switch 1 turn on ...");
  digitalWrite(relayOne, LOW);   // sets relayOne on
}

void lightOneOff() {
  Serial.print("Switch 1 turn off ...");
  digitalWrite(relayOne, HIGH);   // sets relayOne off
}

void lightTwoOn() {
  Serial.print("Switch 2 turn on ...");
  digitalWrite(relayThree, LOW);   // sets relayTwo on
}

void lightTwoOff() {
  Serial.print("Switch 2 turn off ...");
  digitalWrite(relayThree, HIGH);   // sets relayTwo Off
}

E para as tomadas:

void outletOneOn() {
  Serial.print("Socket 1 turn on ...");
  digitalWrite(relayFour, LOW);   // sets relayThree on
}

void outletOneOff() {
  Serial.print("Socket 1 turn off ...");
  digitalWrite(relayFour, HIGH);   // sets relayThree off
}

void outletTwoOn() {
  Serial.print("Socket 2 turn on ...");
  digitalWrite(relayTwo, LOW);   // sets relayFour on
}

void outletTwoOff() {
  Serial.print("Socket 2 turn off ...");
  digitalWrite(relayTwo, HIGH);   // sets relayFour off
}

Uma vez que estamos utilizando relés, poderíamos testar o projeto com  qualquer tipo de dispositivo real como TVs, geladeiras, etc. Obviamente que pelas especificações dos relés utilizados neste projeto, os dispositivos estariam limitados a 250VAC/10A ou 30 VDA/30A.

Em meu caso, decidi testar os 4 WeMo switches com dispositivos alimentados externamente com 5 V DC .

  • Como “Light 1”,  usarei um LED vermelho
  • Como “Light 2”, usarei um LED verde
  • Como “Outlet 2”, usarei um pequeno buzzer (pense em um rádio, aparelho de som…)
  • Como “Outlet 1”, usarei um pequeno ventilador

Abaixo o diagrama elétrico com as conexões:

Home Automation Electric Diagram

Com o HW pronto, baixe o código de meu GitHub: NODEMCU_ALEXA_WeMos_4X_Serial_Monitor_EXT.ino

Entre com suas credenciais de rede:

const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

E pronto!

Siga o mesmo procedimento como definido na etapa anterior para permitir que a Alexa encontre seus 4 dispositivos.

O vídeo abaixo mostra uma demonstração desta etapa:

5: Aplicação em Domótica (Automação Residencial)

Neste ponto do projeto, possuímos 4 dispositivos inteligentes funcionando adequadamente, os quais podem ser ativados e desativados individualmente. Mas suponha que queremos agrupá-los de maneira a serem utilizados em nossa casa. O que deveria ser feito?

Por exemplo, suponha que a nossa casa tenha 2 cômodos:

  • Quarto (“Bed Room”)
  • Sala (“Living Room”)

Agora, suponha que você queira ter uma lâmpada e uma tomada em cada habitação. O que devemos fazer, é agrupar nossos 4 dispositivos como mostrado no diagrama de blocos da introdução:

  • IMG_9708Quarto (Bed Room)
    • Light 2
    • Outlet 1 (Ventilador)
  • Sala (Living Room)
    • Light1
    • Outlet 2 (Buzzer)

Também criaremos outro grupo para lidar com todos os dispositivos, ativando / desativando todos os dispositivos ao mesmo tempo.

Criaremos uma versão 2 de nosso código onde teremos  3 novos “switches” que agora devem ser também  ser identificados pela Alexa. Para isto, adicionemos as seguintes linhas ao nosso código:

1. Definição das “Switches”:

Switch *allDevices = NULL;
Switch *bedRoom = NULL;
Switch *livingRoom = NULL;

2. Declaração dos “callbacks” para os novos grupos de dispositivos:

void allDevicesOn();
void allDevicesOff();
void bedRoomOn();
void bedRoomOff();
void livingRoomOn();
void livingRoomOff();
  1. No setup(), devemos associar os switches com os novos callbacks and Ports (Lembre-se que temos um máximo de 14 dispositivos que podem ser manipulados com este código):
allDevices = new Switch("All Devices", 84, allDevicesOn, allDevicesOff);
bedRoom = new Switch("Bed Room", 85, bedRoomOn, bedRoomOff);
livingRoom = new Switch("Living Room", 86, livingRoomOn, livingRoomOff);
  1. Adicionando “Switches upnp Broadcast Responder” ao setup():
upnpBroadcastResponder.addDevice(*allDevices);
upnpBroadcastResponder.addDevice(*bedRoom);
upnpBroadcastResponder.addDevice(*livingRoom);
  1. Adicionando as linhas ao loop():
allDevices->serverLoop();
bedRoom->serverLoop();
livingRoom->serverLoop();
  1. E finalmente, criemos as funções para os “grupos de dispositivos” com as ações a serem executadas quando a Alexa receber um comando de voz:
void allDevicesOn() 
{
  Serial.print("All Devices turn on ...");
  digitalWrite(relayOne, LOW);   // sets relay1 on
  digitalWrite(relayTwo, LOW);   // sets relay2 on
  digitalWrite(relayThree, LOW);   // sets relay3 on
  digitalWrite(relayFour, LOW);   // sets relay4 on
}

void allDevicesOff() 
{
  Serial.print("All Devices turn off ...");
  digitalWrite(relayOne, HIGH);   // sets relay1 off
  digitalWrite(relayTwo, HIGH);   // sets relay2 off
  digitalWrite(relayThree, HIGH);   // sets relay3 off
  digitalWrite(relayFour, HIGH);   // sets relay4 off
}

void bedRoomOn() 
{
  Serial.print("Bed Room turn on ...");
  digitalWrite(relayThree, LOW);   // sets relay3 on
  digitalWrite(relayFour, LOW);   // sets relay4 on
}

void bedRoomOff() 
{
  Serial.print("Bed Room turn off ...");
  digitalWrite(relayThree, HIGH);   // sets relay3 off
  digitalWrite(relayFour, HIGH);   // sets relay4 off
}

void livingRoomOn() 
{
  Serial.print("Living Room turn on ...");
  digitalWrite(relayOne, LOW);   // sets relay1 on
  digitalWrite(relayTwo, LOW);   // sets relay2 on
}

void livingRoomOff() 
{
  Serial.print("Living Room turn off ...");
  digitalWrite(relayOne, HIGH);   // sets relay1 off
  digitalWrite(relayTwo, HIGH);   // sets relay2 off
}

Este procedimento de 6 passos poderá ser utilizado para qualquer comando, dispositivo ou grupo de dispositivos que você deseja adicionar ao seu projeto.

Você poderá baixar o código completo desta etapa. desde meu GitHub:

NODEMCU_ALEXA_WeMos_4X_V2_EXT

Depois que o código é enviado e executado pelo NodeMCU, é hora de solicitar Alexa que “localize os novos dispositivos”. Como explicado anteriormente, você poderá fazê-lo usando um comando de voz ou pelo Alexa App. Em ambos casos, o resultado poderá ser verificado no aplicativo como mostrado abaixo. Sete dispositivos (“WeMo Switches”) deverão ser encontrados agora pela Alexa:

  • IMG_1261Living Room
  • Bed Room
  • All Devices
  • Outlet One
  • Outlet Two
  • Light One
  • Light Two

O vídeo abaixo mostra como nosso projeto completo de Automação Residencial funcionará:

6: Conclusão

Como sempre, espero que este projecto possa ajudar outros a encontrarem o seu caminho no emocionante mundo da electrónica, robótica e do IoT!

Verifique o depositário no GitHub para obter os arquivos atualizados:

Home-Automation-with-Alexa-and-NodeMCU

E não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

Saludos desde el sur del mundo!

Até o próximo tutorial!

Obrigado

Marcelo