<

Mensagens Recentes

Páginas: [1] 2 3 ... 10
1
Projetos / O Google lançou jogo que ensina a lógica de programação a crianças e graúdos
« Última Mensagem: por Boss Online Dezembro 08, 2017, 09:28:01 am »
O Google lançou jogo que ensina a lógica de programação a crianças e adultos

Hoje na página sua página principal, o Google lançou jogo que ensina lógica de programação para crianças. O programa é uma adaptação do logotipo do site de buscas – modificações que são conhecidas como “doodles” – e comemora os 50 anos da criação de linguagens de computação orientada para os mais pequenos. Introduzindo desta forma simples e divertida, toda a lógica da programação nas suas diversas linguagens.

O objetivo do jogo é fazer com que um coelho apanhe cenouras que estão espalhadas pela tela, para passar de nível. Para isso, é preciso programar qual o caminho o bichinho fará. Isso é feito organizando uma sequência de setas e outros comandos na tela. Quando se clica em “play”, o coelho vai saltando nas direções indicadas previamente.

Dentre as linguagens de programação voltadas para crianças estão o Logo, criado em 1967, e o Scratch. O objetivo desse tipo de código é ensinar a lógica usada para fazer aplicações para computador.

Atualmente já existem kits de robótica orientados para educação em que crianças e adultos podem utilizar esta “linguagem de programação por blocos” para colocar o robot a funcionar, um carrinho a desviar-se dos obstáculos e até controlado por Smartphone. Podem saber mais sobre estes Kits Educativos no site da ElectroFun, sendo uma otima alternativa para as crianças neste Natal! Além de divertido ajuda desde novos a desenvolverem as suas capacidades de raciocino e lógica para vencer desafios.

Pode para já praticar no Google montar bloco-a-bloco até o coelhinho chegar ao seu objetivo! Jogue aqui!

2
Projetos / Como Controlar a sua Casa pelo Smartphone? (Sem programação)
« Última Mensagem: por Boss Online Dezembro 08, 2017, 09:27:54 am »
Como Controlar a sua Casa pelo Smartphone? (Sem programação)



Olá a todos, hoje vamos ver como controlar a nossa casa, os nossos eletrodomésticos, luzes, portas, etc pelo Smartphone. Mas desta vez otimo para quem não sabe programar Arduino.


Vamos utilizar um produto da Sonoff que podem comprar na ElectroFun:


https://www.electrofun.pt/iot-e-domotica/sonoff-4ch-4-canais-interruptor-wifi


 



 


Como podem ver tem possibilidade de ligar de forma independente 4 canais distintos.


Após instalar a respetiva aplicação, poderão em tempo real, em, qualquer parte do mundo, controlar individualmente cada canal. E ainda se desejar programar um horário especifico de funcionamento, ideal para iluminação de jardim, sistemas de rega, etc.


Outros produtos interessantes da Sonoff AQUI.


3
Projetos / Como criar um Radar com o Arduino? [Video]
« Última Mensagem: por Boss Online Dezembro 08, 2017, 09:27:48 am »
Como criar um Radar com o Arduino? [Video]



Hoje vamos ver como podemos criar um fantástico Radar como nos filmes!


O nosso componentes principal que nos vai permitir criar um radar será o Sensor de Distância Ultrasónico HC-SR04.


Desta vez para criarmos o intarface animado em tempo real, vamos utilizar uma ferramenta nova o Processing. Podem fazer download e saber mais informações no site oficial: www.processing.org 


 


Mais uma vez vamos explicar como fazer este projeto. Abaixo poderão encontrar a lista de materiais utilizados, esquema de montagem e o código para o Arduino.


 



 


 


# Esquema de montagem:



 


 


 


# Código Utilizado no Arduino IDE:


#include <Servo.h>.
// Defines Tirg and Echo pins of the Ultrasonic Sensor
const int trigPin = 10;
const int echoPin = 11;
// Variables for the duration and the distance
long duration;
int distance;
Servo myServo; // Creates a servo object for controlling the servo motor
void setup() {
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
Serial.begin(9600);
myServo.attach(12); // Defines on which pin is the servo motor attached
}
void loop() {
// rotates the servo motor from 15 to 165 degrees
for(int i=0;i<=180;i++){
myServo.write(i);
delay(30);
distance = calculateDistance();// Calls a function for calculating the distance measured by the Ultrasonic sensor for each degree

Serial.print(i); // Sends the current degree into the Serial Port
Serial.print(","); // Sends addition character right next to the previous value needed later in the Processing IDE for indexing
Serial.print(distance); // Sends the distance value into the Serial Port
Serial.print("."); // Sends addition character right next to the previous value needed later in the Processing IDE for indexing
}
// Repeats the previous lines from 165 to 15 degrees
for(int i=180;i>0;i--){
myServo.write(i);
delay(30);
distance = calculateDistance();
Serial.print(i);
Serial.print(",");
Serial.print(distance);
Serial.print(".");
}
}
// Function for calculating the distance measured by the Ultrasonic sensor
int calculateDistance(){

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH); // Reads the echoPin, returns the sound wave travel time in microseconds
distance= duration*0.034/2;
return distance;
}

 


 


# Código Utilizado no PROCESSING:


import processing.serial.*; // Importa as bibliotecas para comunicação de Seriew
import java.awt.event.KeyEvent; // Importa as bibliotecas para ler a informação da entrada de serie
import java.io.IOException;
Serial myPort; // define o objeto Serial
// define as variaveis
String angle="";
String distance="";
String data="";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1=0;
int index2=0;
PFont orcFont;
void setup() {

size (1280, 720); // **Mudar isto para a sua resolução**
smooth();
myPort = new Serial(this,"COM3", 9600); // Começa a comunicação Serie
myPort.bufferUntil("."); // Lê o Serial Monitor até ao ponto final
orcFont = loadFont("OCRAExtended-30.vlw");
}
void draw() {

fill(98,245,31);
textFont(orcFont);
// Simula o movimento das linhas
noStroke();
fill(0,4);
rect(0, 0, width, height-height*0.065);

fill(98,245,31); // green color
// Chama as funções Radar, line, Object, Text
drawRadar();
drawLine();
drawObject();
drawText();
}
void serialEvent (Serial myPort) { // Começa a ler a informação de Serie
// lê a informação de Serie até ao caracter ".", esta informação é atribuida a uma string chamada "data".
data = myPort.readStringUntil(".");
data = data.substring(0,data.length()-1);

index1 = data.indexOf(","); //
angle= data.substring(0, index1);
distance= data.substring(index1+1, data.length());

// Converte as variaveis string em Integer
iAngle = int(angle);
iDistance = int(distance);
}
void drawRadar() {
pushMatrix();
translate(width/2,height-height*0.074); // Move as coordenadas iniciais para outro local
noFill();
strokeWeight(2);
stroke(98,245,31);
// Desenha os semicirculos
arc(0,0,(width-width*0.0625),(width-width*0.0625),PI,TWO_PI);
arc(0,0,(width-width*0.27),(width-width*0.27),PI,TWO_PI);
arc(0,0,(width-width*0.479),(width-width*0.479),PI,TWO_PI);
arc(0,0,(width-width*0.687),(width-width*0.687),PI,TWO_PI);
// Desenha as linhas dos angulos
line(-width/2,0,width/2,0);
line(0,0,(-width/2)*cos(radians(30)),(-width/2)*sin(radians(30)));
line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(radians(60)));
line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(radians(90)));
line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(radians(120)));
line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(radians(150)));
line((-width/2)*cos(radians(30)),0,width/2,0);
popMatrix();
}
void drawObject() {
pushMatrix();
translate(width/2,height-height*0.074); // Move as coordenadas iniciais para outro local
strokeWeight(9);
stroke(255,10,10); // red color
pixsDistance = iDistance*((height-height*0.1666)*0.025); // cobre a distancia entre o sensor e o objeto
// limiting the range to 40 cms
if(iDistance<40){
// Desenha o objeto de acordo com a distancia e o angulo
line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),(width-width*0.505)*cos(radians(iAngle)),-(width-width*0.505)*sin(radians(iAngle)));
}
popMatrix();
}
void drawLine() {
pushMatrix();
strokeWeight(9);
stroke(30,250,60);
translate(width/2,height-height*0.074); // Move as coordenadas iniciais para outro local
line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle))); // Desenha a linha de acordo com o angulo
popMatrix();
}
void drawText() { // Escreve o texto no ecra

pushMatrix();
if(iDistance>40) {
noObject = "Out of Range";
}
else {
noObject = "In Range";
}
fill(0,0,0);
noStroke();
rect(0, height-height*0.0648, width, height);
fill(98,245,31);
textSize(25);

text("10cm",width-width*0.3854,height-height*0.0833);
text("20cm",width-width*0.281,height-height*0.0833);
text("30cm",width-width*0.177,height-height*0.0833);
text("40cm",width-width*0.0729,height-height*0.0833);
textSize(40);
text("Object: " + noObject, width-width*0.875, height-height*0.0277);
text("Angle: " + iAngle +" °", width-width*0.48, height-height*0.0277);
text("Distance: ", width-width*0.26, height-height*0.0277);
if(iDistance<40) {
text("        " + iDistance +" cm", width-width*0.225, height-height*0.0277);
}
textSize(25);
fill(98,245,60);
translate((width-width*0.4994)+width/2*cos(radians(30)),(height-height*0.0907)-width/2*sin(radians(30)));
rotate(-radians(-60));
text("30°",0,0);
resetMatrix();
translate((width-width*0.503)+width/2*cos(radians(60)),(height-height*0.0888)-width/2*sin(radians(60)));
rotate(-radians(-30));
text("60°",0,0);
resetMatrix();
translate((width-width*0.507)+width/2*cos(radians(90)),(height-height*0.0833)-width/2*sin(radians(90)));
rotate(radians(0));
text("90°",0,0);
resetMatrix();
translate(width-width*0.513+width/2*cos(radians(120)),(height-height*0.07129)-width/2*sin(radians(120)));
rotate(radians(-30));
text("120°",0,0);
resetMatrix();
translate((width-width*0.5104)+width/2*cos(radians(150)),(height-height*0.0574)-width/2*sin(radians(150)));
rotate(radians(-60));
text("150°",0,0);
popMatrix();
}

 


# Lista de Material:



4
Projetos / Como ligar um Relógio RTC e Sensor de Temperatura num Display OLED [Video]
« Última Mensagem: por Boss Online Dezembro 08, 2017, 09:27:42 am »
Como ligar um Relógio RTC e Sensor de Temperatura num Display OLED [Video]



Hoje desenvolvemos um mini projeto que responde às seguintes questões:


– Como ligar um Relogio Digital em Tempo real (RTC) ao Arduino?

– Como ligar um display colorido OLED ao Arduino?

– Como ligar um sensor de temperatura e humidade DHT11 ao Arduino?


Passo-a-passo vamos entao de seguida ver como fazer este projeto que responderá a estas perguntas. Abaixo poderão encontrar a lista de materiais utilizados, esquema de montagem e o código para o Arduino.


 



 


# Esquema de montagem:



 


# Livrarias Necessárias:


Poderá fazer download das livrarias necessária a este projetos nos links abaixo.


DS3231.h


dht.h


Adafruit_GFX.h


Adafruit_SSD1306.h


As restantes já vem na aplicação Arduino IDE.


 


# Código Utilizado:


 


#include <DS3231.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <dht.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2

 

#define LOGO16_GLCD_HEIGHT 16
#define LOGO16_GLCD_WIDTH 16

#if (SSD1306_LCDHEIGHT != 32)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

DS3231 rtc(SDA, SCL);
dht DHT;
#define DHT11_PIN 7

void setup() {

rtc.begin();

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // initialize with the I2C addr 0x3C (for the 128x32)
display.clearDisplay();
display.display();
delay(50);

}

 

void loop() {
int chk = DHT.read11(DHT11_PIN);

display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(1,0);
display.print(" ");
display.println(rtc.getTimeStr());

display.setTextSize(1);
display.setTextColor(WHITE);
display.print(" ");
display.print("Temp");
display.print(" ");
display.println("Humidade");

display.print(DHT.temperature);
display.print(" C");
display.print(" ");
display.print(DHT.humidity);
display.println(" %");
display.display();
delay(1000);
display.clearDisplay();

}

 


# Lista de Material:



5
Projetos / Como ligar um LDR ao Arduino? [Video]
« Última Mensagem: por Ivanov Online Dezembro 08, 2017, 09:27:35 am »
Como ligar um LDR ao Arduino? [Video]



Hoje vamos dar inicio à nossa secção de vídeos que preparamos para ajudar os nossos visitantes a se iniciarem no mundo do Arduino. Vamos começar por demonstrar como controlar a iluminação através do sensor de luz, o LDR. Após verem o video poderão realizar passo-a-passo o mesmo projeto em vossa casa. Abaixo poderão encontrar a lista de materiais utilizados, esquema de montagem e o código para o Arduino.



 


# Esquema de montagem:



# Código Utilizado:


int led = 2;
int LDR = A2;
int luminusidade;

void setup(){
pinMode(led, OUTPUT);
pinMode(LDR, INPUT);
}

void loop(){
luminusidade=analogRead(LDR);
if(luminusidade < 400){
digitalWrite(led, HIGH);
}
else{
digitalWrite(led, LOW);
}
delay(100);
}

 


# Lista de Material:



  • Arduino Nano

  • Led

  • Breadboard

  • Resistências

  • LDR (Sensor de luminosidade)

  • Kit Arduino Iniciação (opcional)

6
Projetos / Projetos do INETE com Arduino
« Última Mensagem: por Ivanov Online Dezembro 08, 2017, 09:27:28 am »
Projetos do INETE com Arduino



Como podemos ver já existem várias escolas a adoptar o Arduino como ferramenta base para a construção de diversos projetos em conjunto com os seus alunos. Sendo uma ferramenta bastante dinâmica, o Arduino permite desenvolver soluções para resolver vários problemas que muitos de nós enfrenta no dia-a-dia.


De seguida podemos ver alguns projetos interessantes criados pelos alunos do INETE:



 




7
Projetos / Qual a diferença entre Buzzer Ativo vs Buzzer Passivo
« Última Mensagem: por Ivanov Online Dezembro 08, 2017, 09:27:17 am »
Qual a diferença entre Buzzer Ativo vs Buzzer Passivo



O Buzzer Ativo e Buzzer Passivo visualmente eles podem ser idênticos, mas o funcionamento é muito diferente. O buzzer ativo é um produto mais complexo, de uso mais simples. Tem incorporado o circuito oscilador que produz o som e só requer energizar. O buzzer passivo é apenas um transdutor. Como um “alto falante” em miniatura.


Buzzer ativo




  • Mais fácil de testar e usar: ao energizar já apita continuamente.

  • Não é o mais apropriado para criar melodias. É mais apropriado para alarmes/avisos/sinalização.

  • Por norma a traseira do buzzer é lacrada com um pino maior (VCC) e outro menor (GND).


 


Buzzer passivo




  • Difícil de testar e usar: ao energizar só ouve um débil estalo. Parece um buzzer ativo com defeito.

  • É o mais apropriado para fazer melodias, porque tem o controlo sobre os tons gerados.

  • Por norma a traseira tem o PCB à mostra com os pinos do mesmo tamanho.

8
Projetos / Robot controlado por voz via WiFi
« Última Mensagem: por Ivanov Online Dezembro 08, 2017, 09:27:10 am »
Robot controlado por voz via WiFi



O diagrama de blocos abaixo nos dá uma geral sobre o projeto que desenvolveremos aqui:


WiFi_Robot_Block_Diagram


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


Por favor, considere que um de meus motores estava com muito pouco torque. Apesar de o resultado parecer estranho, o projeto funciona a contento. Assim que mudar o motor, atualizarei o vídeo. Obrigado.




1: Lista de materiais (BoM)



 



  1. NodeMCU ESP8266-12E

  2. 400-point Experiment Breadboard Breadboard

  3. H-Bridge L293D

  4. Motor Robot Car Chassis Kit

  5. Male-Female Dupont Cables

  6. Portable Charger 5VDC 3000mAh Power Bank

  7. Bateria 9V DC


….. e qualquer telefone ou tablet Android!






2: A Ponte-H L293D


L293D





Para “drivar” os motores usaremos o L293D.





De acordo com seu Datasheet, o L293D é um controlador do tipo half-H quádruplo de alta corrente. O L293D foi projetado para fornecer correntes bidirecionais de até 600 mA em tensões variando de 4,5 V a 36 V.


Usaremos o CI L293D diretamente com o NodeMCU, em vez de um Shield, como se vê mais comumente em projetos no mercado.


Pois bem, nosso robot terá duas rodas, acionadas por 2 motores DC:



  • Motor esquerdo (LEFT)

  • Motor direito (RIGHT)NodeMCU_L293D_Block_Diagram

  • Ligaremos os motores ao L293D e este ao NodeMCU, como mostra o diagrama em blocos anterior, onde 6 de seus GPIOs comandarão esses motores.





 
int rightMotor2 = 13;   // D7 - right Motor -
int rightMotor1 = 15;   // D8 - right Motor +
int leftMotor2 = 0;     // D3 - left Motor -
int leftMotor1 = 2;     // D4 - left Motor +
int eneLeftMotor = 12;  // D6 - enable Motor Left
int eneRightMotor = 14; // D5 - enable Motor Right
 

Por exemplo, para mover o robô para a frente,  girando o motor esquerdo (LEFT) no sentido apropriado, você deve colocar:



  • HIGH no pino D4 (motor esquerdo +) e

  • LOW no pino D3 (motor esquerdo -)


Para o motor direito (RIGHT) você deve fazer o oposto:



  • HIGH no pino D8 (motor direito +) e

  • LOW no pino D7 (motor esquerdo -)

  • The H-Bridge L293D

  • Devido à maneira como meus motores são montados, a combinação acima irá girar ambos motores no mesmo sentido, “empurrando” o robot para a frente.

  • Robot direction.jpg


  • O diagrama acima define (ou melhor, convenciona) como o robot deverá se mover. Isso é importante para a definição adequada de suas variáveis.


    Para controlar a H-Bridge corretamente, você também deverá trabalhar com os pinos de habilitação (“enable”). No exemplo anterior onde o robô se move para a frente, além dos 4 GPIOs discutidos, o robot só funcionaia se os pinos de habilitação (eneLeftMotor e eneRightMotor) estiverem ambos em HIGH. Poderá conectar esses pinos do L293D (1 e 9) diretamente a + VCC e esquecê-los. Eu não gosto disso, porque se necessitar por exemplo, parar rapidamente seu robot, esses pinos deveriam estar em necessariamente em LOW. Além disso, associar os pinos de habilitação a saídas PWM do NodeMCU, permitirá também controlar a velocidade do motor. Em nosso exemplo, usaremos estes pinos apenas com valores digitais tais como HIGH e LOW, o que ajustará a velocidade para MAX e ZERO, respectivamente.


    Asim, para se criar uma função que conduza nosso robot para a frente, devemos escrever um código como este:



 
void forwardMotor(void)  
{
  digitalWrite(eneLeftMotor,HIGH);
  digitalWrite(eneRightMotor,HIGH);
   
  digitalWrite(leftMotor1,HIGH);
  digitalWrite(leftMotor2,LOW);
  digitalWrite(rightMotor1,HIGH);
  digitalWrite(rightMotor2,LOW);
}
 

3: Movendo o robot noutras direções





Na etapa anterior, aprendemos como podemos mover o robot para a frente, pensemos agora como movê-lo em outras direções.


Definamos 5 possíveis comandos:


  1. STOP: Pare

  2. LEFT: Vire à esquerda

  3. RIGHT: Vire à direita

  4. REVERSE: Dê marcha à ré

  5. FORWARD: Vá para a frente


O primeiro comando “STOP” é simples de realizar. Todas as entradas da H-Bridge devem estar em LOW, desta forma os motores não se moverão:





 
void stopMotor(void)  
{
  digitalWrite(eneLeftMotor,LOW);
  digitalWrite(eneRightMotor,LOW);

  digitalWrite(leftMotor1,LOW);
  digitalWrite(leftMotor2,LOW);
  digitalWrite(rightMotor1,LOW);
  digitalWrite(rightMotor2,LOW);
}
 

Da mesma forma pensemos em fazer o robot tomar outra direção, digamos que “virar à ESQUERDA”. Considere que o robot está indo para a frente, se queremos virar à esquerda podemos pensar em duas situações:



  1. Parar o motor ESQUERDO, mantendo o motor DIREITO no sentido a frente (Forward): o robot executará uma trajetória de arco para a esquerda

  2. Inverter o sentido do motor ESQUERDO, mantendo o motor DIREITO no sentido a frente (Forward): o robot irá girar sobre seu eixo para a esquerda.


Implementemos o caso 2 acima:


 
void leftMotor(void)  
{
  digitalWrite(eneLeftMotor,HIGH);
  digitalWrite(eneRightMotor,HIGH);
 
  digitalWrite(leftMotor1,LOW);
  digitalWrite(leftMotor2,HIGH);
  digitalWrite(rightMotor1,HIGH);
  digitalWrite(rightMotor2,LOW);
}
 

Os demais comandos seguirão a mesma lógica, como ilustra a tabela abiaxo:


Moving the Robot Around


4: Completando o HW


Completing the HW


Siga o diagrama acima e complete o HW de seu Robot.


Você poderá executar alguns testes simples para verificar que seu código está OK.  Para isto, introduziremos um “botão” para iniciar o seu robot. Vamos instalá-lo na porta D0 do NodeMCU como mostrado no diagrama elétrico anterior.


Você poderá utilizar o programa abaixo para testar os movimentos do seu robot:


 
// Set Motor Control Pins
int rightMotor2 = 13;    // D7 - right Motor -
int rightMotor1 = 15;    // D8 - right Motor +
int leftMotor2 = 0;    // D3 - left Motor -
int leftMotor1 = 2;    // D4 - left Motor +
int eneLeftMotor = 12;  // D6 - enable Mortor Left
int eneRightMotor = 14; // D5 - enable Mortor Right

int buttonPin = 16; // D0

void setup()
{
  Serial.begin(115200);

  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(eneLeftMotor, OUTPUT);
  pinMode(eneRightMotor, OUTPUT);
  pinMode(leftMotor1, OUTPUT);
  pinMode(leftMotor2, OUTPUT);  
  pinMode(rightMotor1, OUTPUT);  
  pinMode(rightMotor2, OUTPUT);  

  digitalWrite(eneLeftMotor,LOW);
  digitalWrite(eneRightMotor,LOW);
  digitalWrite(leftMotor1,LOW);
  digitalWrite(leftMotor2,LOW);
  digitalWrite(rightMotor1,LOW);
  digitalWrite(rightMotor2,LOW);
     
  while (digitalRead(buttonPin))  // Wait for button to be pressed to move on
  {  
  }
}

void loop()
{
  forwardMotor();
  delay (5000);
  stopMotor();
  delay (200);
  leftMotor();
  delay (3000);
  stopMotor();
  delay (200);
  forwardMotor();
  delay (5000);
  stopMotor();
  delay (200);
  rightMotor();
  delay (3000);
  stopMotor();
  delay (200);
  reverseMotor();
  delay (5000);
  stopMotor();
  delay (200);
}

/* command motor forward */
void forwardMotor(void)  
{
  digitalWrite(eneLeftMotor,HIGH);
  digitalWrite(eneRightMotor,HIGH);
   
  digitalWrite(leftMotor1,HIGH);
  digitalWrite(leftMotor2,LOW);
  digitalWrite(rightMotor1,HIGH);
  digitalWrite(rightMotor2,LOW);
}

/* command motor backward */
void reverseMotor(void)  
{
  digitalWrite(eneLeftMotor,HIGH);
  digitalWrite(eneRightMotor,HIGH);
 
  digitalWrite(leftMotor1,LOW);
  digitalWrite(leftMotor2,HIGH);
  digitalWrite(rightMotor1,LOW);
  digitalWrite(rightMotor2,HIGH);
}

/* command motor turn left */
void leftMotor(void)  
{
  digitalWrite(eneLeftMotor,HIGH);
  digitalWrite(eneRightMotor,HIGH);
 
  digitalWrite(leftMotor1,LOW);
  digitalWrite(leftMotor2,HIGH);
  digitalWrite(rightMotor1,HIGH);
  digitalWrite(rightMotor2,LOW);
}

/* command motor turn right */
void rightMotor(void)  
{
  digitalWrite(eneLeftMotor,HIGH);
  digitalWrite(eneRightMotor,HIGH);
 
  digitalWrite(leftMotor1,HIGH);
  digitalWrite(leftMotor2,LOW);
  digitalWrite(rightMotor1,LOW);
  digitalWrite(rightMotor2,HIGH);
}

/* command motor stop */
void stopMotor(void)  
{
  digitalWrite(eneLeftMotor,LOW);
  digitalWrite(eneRightMotor,LOW);

  digitalWrite(leftMotor1,LOW);
  digitalWrite(leftMotor2,LOW);
  digitalWrite(rightMotor1,LOW);
  digitalWrite(rightMotor2,LOW);
}
 



Quando você pressionar o botão, o robot começará a fazer os movimentos definidos no loop (). Os movimentos continuarão até que você pressione “Reset” no NodeMCU. Pressionando o botão “verde” novamente, o ciclo se repetirá.


O código acima poderá ser baixado deste GitHub:


WiFi_Robot_NodeMCU_Android_Voice_Motor_tests






5: Montando o corpo do robot


body Assembly



  1. Use o Kit: Chassis, 2 Rodas, 2 Motores DC, 1 roda solta (coaster)

  2. Solde 2 fios de 10 cm (Vermelho e Preto) em cada polo do motor

  3. Fixe os motores ao chassi como mostrado na foto acima

  4. Monte o coaster

  5. Conecte os fios do motor à eletrônica (L293D)

  6. Fixe a bateria de 9V ao chassi

  7. Fixe a bateria de 5V sob o chassi


O robot deverá ficar com essa cara:


Body Final


6: Conectando o NodeMCU ao seu WiFi local



Conectemos o NodeMCU ao WiFi local, verificando seu endereço IP. Para isso, podemos utilizar o programa abaixo:




 
#include
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á observar o endereço IP dinâmico designado pelo Modem ao seu NodeMCU.


Connecting the NodeMCU to Local WiFi




Tome nota deste endereço de IP. Precisaremos dele para conectar o App Android.


O código acima poderá ser baixado deste GitHub:


NodeMCU_Connection_Test_EXT






7: Completando o código fonte para o NodeMCU



Para que nosso robô se mova, o NodeMCU deverá receber comandos provenientes do dispositivo Android. Para tal, definamos uma variável para receber estes comandos:


String  command ="";






Por exemplo, se a aplicação Android enviar como um comando: “forward” (a frente), o robot deverá avançar, invocando-se a função forwardMotor(). Veja abaixo:


 
if (command == "forward")
{
  forwardMotor();
}
 

O mesmo conceito deverá ser aplicado a todo os demais comandos e funções associadas tal como vimos no item 4:



  1. STOP: Pare

  2. LEFT: Vire à esquerda

  3. RIGHT: Vire à direita

  4. REVERSE: Dê marcha à ré

  5. FORWARD: Vá para a frente


Descarregue o código completo: WiFi_Robot_NodeMCU_Android_Voice_EXT deste GitHub.


Entre com as credenciais de sua rede local:


 


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




Carregue o código em seu NodeMCU e pronto! Você poderá verificar no Monitor Serial se o programa está em execução. Deixe o programa em execução para podermos testar o o aplicativo a ser desenvolvido na próxima etapa.





8: A App Android : “Designer Tab”


The Android App:


Usaremos o MIT App Inventor para o desenvolvimento de nossa App Android.


Principais componentes da Screen 1 (veja a foto anterior):



  • User Interface:

    • Input of IP Address

      • TextBox named “IP_Address”



    • 5 Command Buttons:

      • forward

      • reverse

      • right

      • left

      • stop



    • Voice Input Button

      • Voice_Input





  • Non Visible Components:

    • Web1

    • SpeachRecognizer1

    • TextToSpeach1



  • Other:

    • Text Box:

      • Speach_To_Text



    • Label:

      • Comm_Status

      • Screenshot_2017-04-02-14-36-34


      • 9: A App Android: Botões


        The Android App: Buttons





      • Na Tab “Blocks”, deveremos criar 5 Botões, um para cada comando. Todos eles seguirão a estrutura dos blocos acima.


        Estes blocos serão chamados quando o botão “forward” (“botão com a seta para cima”) é pressionado.


        Quando você clicar no botão, 3 ações serão executadas:



        1. Um comando será enviado no formato: http: / ip_address * / forward

        2. Um “eco” no mesmo formato é esperado

        3. Uma “mensagem” audível será executada pela App: no caso: “forward”


        * O IP_Address será a que você digitar no seu App. Por exemplo, se o IP address é 10.1.0.3, a mensagem completa seria: http: /10.0.1.3/forward


        Poderá utilizar qualquer mensagem, ou até mesmo deixar a mensagem vazia.






        10: A App Android: Reconhecimento de voz


        The Android App: Voice Recognition


         




      • Os blocos acima mostram o código de reconhecimento de voz para o nosso aplicativo.Note que, para qualquer comando de voz inserido, o resultado será um comando em letras minúsculas. Isso facilitará a descodificação do comando pelo NodeMCU.Por exemplo, se você deseja mover o robô para a frente, uma palavra ou sentença deverá ser enviada para ser interpretada pelo NodeMCU. No exemplo abaixo, o código reconheceria qualquer uma das palavras: “forward”, “frente” ou “a frente “.







 
if (command == "forward" || command == "frente" || command == "a frente")  
{
  forwardMotor();
}
 



Assim, por exemplo quando digo “frente”, a App enviará : http: / 10.0.1.10/frente e o NodeMCU tomará o que é recebido após o “/”,  a palavra “frente” que será interpretada como um comando do tipo “forward”. Com este comando, a função forwardMotor () será invocada.





11: A App Android: Manipulação de erros


The Android App: Error Manipulation


Se ocorrer um erro, por exemplo, quando você diz um comando de voz não reconhecido pelo NodeMCU, o bloco acima irá gravar os detalhes do erro na última linha (Comm_Status) do App, conforme mostrado abaixo:


Screenshot_2017-04-02-14-36-50


12: Teste final


Final Test


Você poderá criar seu aplicativo passo a passo, como mostrado nas etapas anteriores ou fazer o upload do meu projeto completo (.aia) no MIT App Inventor, modificando-o de acordo a suas necessidades. Além disso, caso não tenha experiência no desenvolvimento de aplicativos para Android, poderá executar o arquivo .apk diretamente em seu dispositivo Android.


Ambos, os arquivos .aia e .apk podem ser baixados de meu GitHub:


WiFi_Voice_Robot_Ctrl_V2.aia


WiFi_Voice_Robot_Ctrl_V2.apk


O video abaixo mostra alguns testes de motores utilizando-se do App:




9
Projetos / Controle ativado por voz com Android e NodeMCU
« Última Mensagem: por Boss Online Dezembro 08, 2017, 09:26:54 am »
Controle ativado por voz com Android e NodeMCU



O diagrama de blocos sumariza o que pretendemos desenvolver:


Block Diagram.jpg


e o vídeo mostra como vai ficar o projeto final:




1: Lista de materiais (BoM)




  1. NodeMCU ESP8266-12E

  2. Mini BreadBoard

  3. 400-point Experiment Breadboard Breadboard

  4. 4-Channel Relay Module

  5. LEDs (vermelho, amarelo, verde e azul)

  6. 4 x Resistor (220 ohm)

  7. Male-Female Dupont Cables

  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
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). Somente irá ver-lo se ao criar o App usar a opção Responsive.





8: Testes finais


Final Test


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 não tenha experiência no desenvolvimento de aplicativos Android, poderá executar o arquivo .apk diretamente no seu dispositivo Android.


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


Home_Relay_Voice_Ctrl_V2.aia


Home_Relay_Voice_Ctrl_V2.apk



10
Projetos / Quando o IoT encontra a Inteligência Artificial: Automação residencial com Alexa e NodeMCU
« Última Mensagem: por Boss Online Dezembro 08, 2017, 09:26:43 am »
Quando o IoT encontra a Inteligência Artificial: Automação residencial com Alexa e NodeMCU



Neste tutorial, vamos explorar 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 V2


E o vídeo abaixo, mostra como ficará o projeto ao final:



1: Lista de materiais (BoM)



  • NodeMCU ESP8266-12E



  • Echo Dot (2nd Generation) – Black



  • Mini BreadBoard



  • 400-point Experiment Breadboard Breadboard



  • 4-Channel Relay Module



  • LEDs (vermelho e verde)



  • 2 x Resistor (220 ohm)



  • 5V 2 Terminals Electronic Continuous Sound Buzzer



  • Male-Female Dupont Cables



  • DC 5V 0.2A Cooling Fan



  • 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 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:


NodeMCU and LED


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


Estou a levar em consideração que já tenha o Echo-Dot instalado em sua rede., bem como o Alexa App no 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 lâmpadas:


 
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á:



Páginas: [1] 2 3 ... 10