Mecatronizando: dezembro 2016

sábado, 31 de dezembro de 2016

NodeMcu na rede Wi-Fi com Arduino

Programando NodeMcu na rede wireless (Access point)

Utilizando a IDE do Arduino

É possível implementar um código utilizando o NodeMcu na rede wireless por meio da IDE do próprio Arduino, aumentando assim as possibilidades de função desse módulo.

Vamos realizar um projeto utilizando um código bem simples de como acionar um LED pela rede wi-fi local.

Vamos utilizar um esquema como o abaixo, usando a saída D0 do módulo.
Separe:

O módulo ESP
1 resistor 150 ohms
1 LED (qualquer cor)

fonte: próprio autor

Abra o IDE do Arduino e copie o código abaixo e cole para verificar o funcionamento do circuito.

/*
 * NodeMCU/ESP8266/ access point e web server simples
 * Elaborado por Tony Emerson Marim em 31/12/2016.
 * mecatronizando@gmail.com *
 * controlando saída(acionando LED)
 */
#include <ESP8266WiFi.h>
#include <WiFiClient.h> 
#include <ESP8266WebServer.h>

const char *ssid = "NOME DA REDE";
const char *password = "SENHA DA REDE";
int stateLED = LOW;

ESP8266WebServer server(80);

void handleRoot() {
    response();
}

void handleLedOff() {
  stateLED = LOW;
  digitalWrite(LED_BUILTIN, stateLED);
  response();
}

void handleLedOn() {
  stateLED = HIGH;
  digitalWrite(LED_BUILTIN, stateLED);
  response();
}

const String HtmlHtml = "<html><head>"
    "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" /></head>";
const String HtmlHtmlClose = "</html>";
const String HtmlTitle = "<h1>MECATRONIZANDO: NodeMcu WebServer </h1><br/>\n";
const String HtmlLedStateLow = "<big>Estado do LED <b>DESLIGADO</b></big><br/>\n";
const String HtmlLedStateHigh = "<big>Estado do LED <b>LIGADO</b></big><br/>\n";
const String HtmlButtons = 
    "<a href=\"LEDOn\"><button style=\"display: block; width: 100%;\">ON</button></a><br/>"
    "<a href=\"LEDOff\"><button style=\"display: block; width: 100%;\">OFF</button></a><br/>";

void response(){
  String htmlRes = HtmlHtml + HtmlTitle;
  if(stateLED == LOW){
    htmlRes += HtmlLedStateLow;
  }else{
    htmlRes += HtmlLedStateHigh;
  }

  htmlRes += HtmlButtons;
  htmlRes += HtmlHtmlClose;

  server.send(200, "text/html", htmlRes);
}

void setup() {
    delay(1000);
    Serial.begin(9600);
    Serial.println();

    WiFi.softAP(ssid, password);

    IPAddress apip = WiFi.softAPIP();
    Serial.print("visit: \n");
    Serial.println(apip);
    server.on("/", handleRoot);
    server.on("/LEDOn", handleLedOn);
    server.on("/LEDOff", handleLedOff);
    server.begin();
    Serial.println("HTTP server beginned");
    pinMode(LED_BUILTIN, OUTPUT);
    digitalWrite(LED_BUILTIN, stateLED);
}

void loop() {
    server.handleClient();
}

Grave no NodeMcu e vamos acessar agora o Browser para acionar o LED por meio da Internet, especifique um endereço de IP para seu módulo, o meu foi configurado com 192.168.0.105.

fonte: próprio autor

No vídeo abaixo é possível ver o funcionamento do circuito.

Curtiu? Compartilhe, acompanhe nossa FanPage!

Inscreva-se no Canal!

Os arquivos relacionados a esse post, podem ser baixados por esse LINK!

sexta-feira, 30 de dezembro de 2016

Cubo de LEDs

LEDs

Os componentes semi-condutores, ficam em uma situação intermediária entre os condutores e os isolantes, e essa situação pode ser alterada conforme o processo adotado (contaminação ou dopagem).

Graças a suas características os materiais semi-condutores são a base do funcionamento de diodos e aí encaixa-se os LEDs, que são diodos emissores de luz (LED - light emitter diode).

fonte: http://www.e360.es

É um componente do tipo bipolar, constituídos por lados distintos denominados anodo e catodo.

fonte: wikipidia

Assim como os diodos, os LEDs trabalha conforme a sua polarização, permitindo ou não a passagem da corrente elétrica e consequentemente transformando-a em luz, resultado possível graças ao componente principal do LED, o chip semicondutor.

fonte: https://www.electronica-pt.com/led

Nos exemplos estamos falando de LEDs convencionais, encontrados facilmente em qualquer loja de eletrônicos da cidade.

Inventado em 1963 por Nick Holonyac, tinha baixa intensidade luminosa e somente uma cor, a vermelha, e utilizado para indicação de estado dos aparelhos, demonstrava visualmente quando um equipamento encontrava-se ligado ou desligado. No final dos anos 60, foi introduzido no mercado o LED amarelo e somente por volta de 1975 surgiu o LED verde.

As possibilidades de substituição de lâmpadas convencionais por LEDs só começou a tornar possível durante os anos 80, quando a tecnologia Al In GaP possibilitou que LEDs vermelhos e âmbar atingissem melhores níveis de intensidade luminosa. No início dos anos 90, com o surgimento da tecnologia InGaN, as possibilidades aumentaram e as famílias de LEDs ganharam proporção com as cores azul, verde e ciano, até a obtenção do LED branco e consequentemente todo aspecto de cores, e no final dos anos 90 juntamente com o final da década veio o primeiro LED com tecnologia Luxeon, uma revolução na tecnologia desse componente que não tratava-se mais de produzir intensidade luminosa, passando a se tratar de fluxo luminoso, na ordem de 30 a 40 lumens.

fonte: http://www.directlight.com.br/perfil/sobre-led/

Atualmente os LEDs atingem a marca de 120 lumens de fluxo luminoso e com potência que varia de 1 à 5 watts.

Curiosidades sobre os LEDs

Dependendo da aplicação do LED, sua vida útil é bem longa, dependendo de uma manutenção mínima depois de 50.000 horas;
Baixíssima manutenção;
Trabalho com tensões baixas, sem oferecer risco ao usuário;
Ecologicamente correto, não utiliza mercúrio, que causa dano à natureza.

O cubo de LED

Utilizando esse componente, basta uma rápida pesquisa no Google para encontrarmos uma infinidade de equipamentos que fazem uso do LED para diferentes funções. Um dos equipamentos montados com ele que é muito interessante, pois além de bonito, requer programação microcontrolada é o Cubo de LED, é possível realizar a construção desses "ornamentos" de diversos tipos e tamanhos.

Cubo de LED 4x4x4

Vou apresentar um cubo de LED 4x4 passo a passo para que seja possível sua construção. Para esse projeto você vai precisar de:

1 Arduino Uno ( ou similar)

4 resistore 100 ohms

64 LEDs ( da cor que preferir)

1 placa universal perfurada (eu utilizei uma 14x10 cm, mas pode ser de sua preferência)

1 botão ON/OFF (opcional)

1 LED indicador de funcionamento (opcional)

1 resistor 220 ohms (opcional)

1 conector Jack (opcional)

1 fonte externa 1A

fio de cobre estanhado (tipo cabo fi 0,6mm - cabo de telefonia)

A elaboração da caixa para o circuito ou a estrutura do cubo pode ser feita como preferir, eu utilizei pedaços de acrílico de aproximadamente 10x10 cm, com insulfilm no interior.

Construção da torre de LEDs - camadas

As "camadas" de LEDs foram montadas utilizando um gabarito conforme a figura.

fonte: próprio autor

As distâncias devem ser feitas de maneira que um catodo do LED consiga alcançar o catodo do outro para que seja inserido solda ligando-os.

fonte: próprio autor

Durante a montagem, é importante observar um leve grau no anodo permitindo que as camadas possam ser "empilhadas".

fonte: próprio autor

Elaborar furações na caixa de maneira que os anodos (sustentação) dos LEDs passem pela caixa de apoio.

fonte: próprio autor

Inserir com cuidado todos os anodos na placa por baixo do suporte e soldar, pode-se fixar também a placa no suporte utilizando cola quente.

fonte: próprio autor

Esquema de ligação

O esquema de ligação está separado em camadas então deve-se ter bastante atenção na hora de ligá-los com solda.

fonte: próprio autor

Finalizado conforme desejar, agora vamos trabalhar o código fonte para a sequencia dos LEDs.

O código fonte

Foi elaborado alguns movimentos com os LEDs dentro do Cubo, podendo ser alterados conforme a necessidade do usuário. Para testar o projeto, copie e cole o código na IDE do Arduino.

/*
 //** Código **/
// Elaborado por Tony Emerson Marim em 30/12/2016.
/** mecatronizando@gmail.com **/ 
/* 4x4x4 CUBO DE LED
  Configurar : 
  Colunas
  [(x,y)-Pin]
  (1,1)-13
  (1,2)-12
  (1,3)-11
  (1,4)-10
  (2,1)-9
  (2,2)-8
  (2,3)-7
  (2,4)-6
  (3,1)-5
  (3-2)-4
  (3-3)-3
  (3,4)-2
  (4,1)-1
  (4,2)-0
  (4,3)-A5
  (4,4)-A4
  Camadas
  [camada-Pin]
  a-A0
  b-A1
  c-A2
  d-A3
*/
//Declaração das colunas de LEDs
  int coluna[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
//Declaração das camadas de LEDs
  int camada[4]={A3,A2,A1,A0};

  int time = 250;
 
void setup()
{
  //Configurar coluna de saída
  for(int i = 0; i<16; i++)
  {
    pinMode(coluna[i], OUTPUT);
  }
  //Configurar camadas
  for(int i = 0; i<4; i++)
  {
    pinMode(camada[i], OUTPUT);
  }
  //Padrão aleatório
  randomSeed(analogRead(10));
}

void loop()
{
  turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  delay(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  delay(time);
  aroundEdgeDown();
  turnEverythingOff();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  delay(2000);
}

///////////////////////////////////////////////////////////Desliga tudo
void turnEverythingOff()
 {
   for(int i = 0; i<16; i++)
   {
     digitalWrite(coluna[i], 1);
   }
   for(int i = 0; i<4; i++)
   {
     digitalWrite(camada[i], 0);
   }
 }
 
////////////////////////////////////////////////////////////Liga tudo
void turnEverythingOn()
{
  for(int i = 0; i<16; i++)
  {
    digitalWrite(coluna[i], 0);
  }
  //turning on layers
  for(int i = 0; i<4; i++)
  {
    digitalWrite(camada[i], 1);
  }
}
///////////////////////////////////////////////////////Desliga colunas
void turnColumnsOff()
{
  for(int i = 0; i<16; i++)
  {
    digitalWrite(coluna[i], 1);
  }
}
/////////////////////////////////////////////////////////////Liga Agito
void flickerOn()
{
  int i = 150;
  while(i != 0)
  {
    turnEverythingOn();
    delay(i);
    turnEverythingOff();
    delay(i);
    i-= 5;
  }
}
//////////////Ativar e desativar tudo por camada para cima e para baixo
void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
  int x = 75;
  for(int i = 5; i != 0; i--)
  {
    turnEverythingOn();
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(camada[i-1], 0);
      delay(x);
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(camada[i], 1);
      delay(x);
    }
      for(int i = 0; i<4; i++)
    {
      digitalWrite(camada[i], 0);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(camada[i-1], 1);
      delay(x);
    }
  }
}
//////////////////////////Ligar e desligar tudo pela coluna lateralmente
void turnOnAndOffAllByColumnSideways()
{
  int x = 75;
  turnEverythingOff();
  //Liga as colunas
  for(int i = 0; i<4; i++)
  {
    digitalWrite(camada[i], 1);
  }
  for(int y = 0; y<3; y++)
  {
    //Ligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Desligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Ligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Desligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
  }
}
/////////////////////////////////////////Subir e descer coluna em espiral
void layerstompUpAndDown()
{
  int x = 75;
  for(int i = 0; i<4; i++)
  {
    digitalWrite(camada[i], 0);
  }
  for(int y = 0; y<5; y++)
  {
    for(int count = 0; count<1; count++)
    { 
      for(int i = 0; i<4; i++)
      {
        digitalWrite(camada[i], 1);
        delay(x);
        digitalWrite(camada[i], 0);
      }
      for(int i = 4; i !=0; i--)
      {
        digitalWrite(camada[i-1], 1);
        delay(x);
        digitalWrite(camada[i-1], 0);
      }
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(camada[i], 1);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(camada[i-1], 0);
      delay(x);
    }
  }
}
////////////////////////////////////////////////////////////Desligar Pisca
void flickerOff()
{
  turnEverythingOn();
  for(int i = 0; i!= 150; i+=5)
  {
    turnEverythingOff();
    delay(i+50);
    turnEverythingOn();
    delay(i);
  }
}
///////////////////////////////////////////Espiral para baixo
void aroundEdgeDown()
{
  for(int x = 200; x != 0; x -=50)
  {
    turnEverythingOff();
    for(int i = 4; i != 0; i--)
    {
      digitalWrite(camada[i-1], 1);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[9], 0);
      digitalWrite(coluna[10], 0);
      
      digitalWrite(coluna[0], 0);
      delay(x);
      digitalWrite(coluna[0], 1);
      digitalWrite(coluna[4], 0);
      delay(x);
      digitalWrite(coluna[4], 1);
      digitalWrite(coluna[8], 0);
      delay(x);
      digitalWrite(coluna[8], 1);
      digitalWrite(coluna[12], 0);
      delay(x);
      digitalWrite(coluna[12], 1);
      digitalWrite(coluna[13], 0);
      delay(x);
      digitalWrite(coluna[13], 1);
      digitalWrite(coluna[15], 0);
      delay(x);
      digitalWrite(coluna[15], 1);
      digitalWrite(coluna[14], 0);
      delay(x);
      digitalWrite(coluna[14], 1);
      digitalWrite(coluna[11], 0);
      delay(x);
      digitalWrite(coluna[11], 1);
      digitalWrite(coluna[7], 0);
      delay(x);
      digitalWrite(coluna[7], 1);
      digitalWrite(coluna[3], 0);
      delay(x);
      digitalWrite(coluna[3], 1);
      digitalWrite(coluna[2], 0);
      delay(x);
      digitalWrite(coluna[2], 1);
      digitalWrite(coluna[1], 0);
      delay(x);
      digitalWrite(coluna[1], 1);
    }
  }
}
/////////////////////////////////////////////////////////Pisca aleatório
void randomflicker()
{
  turnEverythingOff();
  int x = 10;
  for(int i = 0; i !=750; i+=2)
  {
  int randomcamada = random(0,4);
  int randomcoluna = random(0,16);
  
  digitalWrite(camada[randomcamada], 1);
  digitalWrite(coluna[randomcoluna], 0);
  delay(x);
  digitalWrite(camada[randomcamada], 0);
  digitalWrite(coluna[randomcoluna], 1);
  delay(x); 
  }
}
////////////////////////////////////////////////////////////Gotas caindo
void randomRain()
{
  turnEverythingOff();
  int x = 100;
  for(int i = 0; i!=60; i+=2)
  {
    int randomcoluna = random(0,16);
    digitalWrite(coluna[randomcoluna], 0);
    digitalWrite(camada[0], 1);
    delay(x+50);
    digitalWrite(camada[0], 0);
    digitalWrite(camada[1], 1);
    delay(x);
    digitalWrite(camada[1], 0);
    digitalWrite(camada[2], 1);
    delay(x);
    digitalWrite(camada[2], 0);
    digitalWrite(camada[3], 1);
    delay(x+50);
    digitalWrite(camada[3], 0);
    digitalWrite(coluna[randomcoluna], 1);
  }
}
/////////////////////////////////////////////////////Diagonal
void diagonalRectangle()
{
  int x = 350;
  turnEverythingOff();
  for(int count = 0; count<5; count++)
  {
    //top left
    for(int i = 0; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[3], 1);
    digitalWrite(camada[2], 1);
    delay(x);
    turnEverythingOff();
    //medio
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[1], 1);
    digitalWrite(camada[2], 1);
    delay(x);
    turnEverythingOff();
    //Centro baixo
    for(int i = 8; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[0], 1);
    digitalWrite(camada[1], 1);
    delay(x);
    turnEverythingOff();
    //Meio baixo
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[0], 1);
    digitalWrite(camada[1], 1);
    delay(x);
    turnEverythingOff();
    //Centro esquerda
    for(int i = 0; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[0], 1);
    digitalWrite(camada[1], 1);
    delay(x);
    turnEverythingOff();
    //Centro
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[1], 1);
    digitalWrite(camada[2], 1);
    delay(x);
    turnEverythingOff();
    //Alto direita
    for(int i = 8; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[2], 1);
    digitalWrite(camada[3], 1);
    delay(x);
    turnEverythingOff();
    //Alto centro
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[2], 1);
    digitalWrite(camada[3], 1);
    delay(x);
    turnEverythingOff();
  }
  //Alto esquerda
  for(int i = 0; i<8; i++)
  {
    digitalWrite(coluna[i], 0);
  }
  digitalWrite(camada[3], 1);
  digitalWrite(camada[2], 1);
  delay(x);
  turnEverythingOff();
}
//////////////////////////////////////////////////////////////Hélice
void propeller()
{
  turnEverythingOff();
  int x = 90;
  for(int y = 4; y>0; y--)
  {
    for(int i = 0; i<6; i++)
    {
      //Liga camada
      digitalWrite(camada[y-1], 1);
      //a1
      turnColumnsOff();
      digitalWrite(coluna[0], 0);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[10], 0);
      digitalWrite(coluna[15], 0);
      delay(x);
      //b1
      turnColumnsOff();
      digitalWrite(coluna[4], 0);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[10], 0);
      digitalWrite(coluna[11], 0);
      delay(x);
      //c1
      turnColumnsOff();
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[7], 0);
      digitalWrite(coluna[8], 0);
      digitalWrite(coluna[9], 0);
      delay(x);
      //d1
      turnColumnsOff();
      digitalWrite(coluna[3], 0);
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[9], 0);
      digitalWrite(coluna[12], 0);
      delay(x);
      //d2
      turnColumnsOff();
      digitalWrite(coluna[2], 0);
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[9], 0);
      digitalWrite(coluna[13], 0);
      delay(x);
      //d3
      turnColumnsOff();
      digitalWrite(coluna[1], 0);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[10], 0);
      digitalWrite(coluna[14], 0);
      delay(x);
    }
  }
  //d4
  turnColumnsOff();
  digitalWrite(coluna[0], 0);
  digitalWrite(coluna[5], 0);
  digitalWrite(coluna[10], 0);
  digitalWrite(coluna[15], 0);
  delay(x);
}
//////////////////////////////////////////////////////Espiral para fora
void spiralInAndOut()
{
  turnEverythingOn();
  int x = 60;
  for(int i = 0; i<6; i++)
  {
    //spiral in clockwise
    digitalWrite(coluna[0], 1);
    delay(x);
    digitalWrite(coluna[1], 1);
    delay(x);
    digitalWrite(coluna[2], 1);
    delay(x);
    digitalWrite(coluna[3], 1);
    delay(x);
    digitalWrite(coluna[7], 1);
    delay(x);
    digitalWrite(coluna[11], 1);
    delay(x);
    digitalWrite(coluna[15], 1);
    delay(x);
    digitalWrite(coluna[14], 1);
    delay(x);
    digitalWrite(coluna[13], 1);
    delay(x);
    digitalWrite(coluna[12], 1);
    delay(x);
    digitalWrite(coluna[8], 1);
    delay(x);
    digitalWrite(coluna[4], 1);
    delay(x);
    digitalWrite(coluna[5], 1);
    delay(x);
    digitalWrite(coluna[6], 1);
    delay(x);
    digitalWrite(coluna[10], 1);
    delay(x);
    digitalWrite(coluna[9], 1);
    delay(x);
    /////////////////////////////////////// Apaga espiral anti-horário
    digitalWrite(coluna[9], 0);
    delay(x);
    digitalWrite(coluna[10], 0);
    delay(x);
    digitalWrite(coluna[6], 0);
    delay(x);
    digitalWrite(coluna[5], 0);
    delay(x);
    digitalWrite(coluna[4], 0);
    delay(x);
    digitalWrite(coluna[8], 0);
    delay(x);
    digitalWrite(coluna[12], 0);
    delay(x);
    digitalWrite(coluna[13], 0);
    delay(x);
    digitalWrite(coluna[14], 0);
    delay(x);
    digitalWrite(coluna[15], 0);
    delay(x);
    digitalWrite(coluna[11], 0);
    delay(x);
    digitalWrite(coluna[7], 0);
    delay(x);
    digitalWrite(coluna[3], 0);
    delay(x);
    digitalWrite(coluna[2], 0);
    delay(x);
    digitalWrite(coluna[1], 0);
    delay(x);
    digitalWrite(coluna[0], 0);
    delay(x);
    ///////////////////////////////////////Espiral sentido horário
    digitalWrite(coluna[0], 1);
    delay(x);
    digitalWrite(coluna[4], 1);
    delay(x);
    digitalWrite(coluna[8], 1);
    delay(x);
    digitalWrite(coluna[12], 1);
    delay(x);
    digitalWrite(coluna[13], 1);
    delay(x);
    digitalWrite(coluna[14], 1);
    delay(x);
    digitalWrite(coluna[15], 1);
    delay(x);
    digitalWrite(coluna[11], 1);
    delay(x);
    digitalWrite(coluna[7], 1);
    delay(x);
    digitalWrite(coluna[3], 1);
    delay(x);
    digitalWrite(coluna[2], 1);
    delay(x);
    digitalWrite(coluna[1], 1);
    delay(x);
    digitalWrite(coluna[5], 1);
    delay(x);
    digitalWrite(coluna[9], 1);
    delay(x);
    digitalWrite(coluna[10], 1);
    delay(x);
    digitalWrite(coluna[6], 1);
    delay(x);
    //////////////////////////////////////////////Apaga espiral no sentido horário
    digitalWrite(coluna[6], 0);
    delay(x);
    digitalWrite(coluna[10], 0);
    delay(x);
    digitalWrite(coluna[9], 0);
    delay(x);
    digitalWrite(coluna[5], 0);
    delay(x);
    digitalWrite(coluna[1], 0);
    delay(x);
    digitalWrite(coluna[2], 0);
    delay(x);
    digitalWrite(coluna[3], 0);
    delay(x);
    digitalWrite(coluna[7], 0);
    delay(x);
    digitalWrite(coluna[11], 0);
    delay(x);
    digitalWrite(coluna[15], 0);
    delay(x);
    digitalWrite(coluna[14], 0);
    delay(x);
    digitalWrite(coluna[13], 0);
    delay(x);
    digitalWrite(coluna[12], 0);
    delay(x);
    digitalWrite(coluna[8], 0);
    delay(x);
    digitalWrite(coluna[4], 0);
    delay(x);
    digitalWrite(coluna[0], 0);
    delay(x);
  }
}
//////////////////////////////////////Um LED por vez
void goThroughAllLedsOneAtATime()
{
  int x = 15;
  turnEverythingOff();
  for(int y = 0; y<5; y++)
  {
    //0-3
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(camada[count-1], 1);
      for(int i = 0; i<4; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count-1], 0);
    }
    //4-7
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(camada[count], 1);
      for(int i = 4; i<8; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count], 0);
    }
    //8-11
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(camada[count-1], 1);
      for(int i = 8; i<12; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count-1], 0);
    }
    //12-15
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(camada[count], 1);
      for(int i = 12; i<16; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count], 0);
    }
  }
}

No video abaixo está a demonstração do Cubo 4x4x4 montado e funcionando.

Curtiu? Compartilhe siga nossa FanPage!

Inscreva-se no canal!

Caso queira o projeto completo pode ser baixado nesse LINK!!!

Bons estudos.

quinta-feira, 22 de dezembro de 2016

Potências com NodeMCU

NodeMCU : chaveamento de potências

Em continuidade ao circuito que foi iniciado anteriormente (CLIQUE AQUI), vamos implementar agora alguns componentes para que seja realizado um chaveamento entre diferentes potências.

Nesse projeto vamos trabalhar com tensões de 3Vcc, 5Vcc e 127Vac da rede.

Foi visto anteriormente as condições de funcionamento do NodeMCU e está entre suas características funcionar com uma tensão de 3Vcc, pois nele existe um regulador que baixa a tensão de 5Vcc para 3Vcc, mas vamos precisar utilizar uma tensão 127 VAC para acionamento de uma carga, sendo necessário a implementação de um módulo relé (CLIQUE AQUI).

Raciocinando: O módulo NodeMCU é alimentado com 5Vcc da porta USB, mas internamente baixa para 3Vcc, então sai um sinal digital de +3V. O módulo relé trabalha com uma bobina de alimentação com 5Vcc, devemos chavear um sinal de +5V para o relé então.

Faremos uso do optoacoplador 4n25. Trata-se de um componente eletrônico conhecido como isolador óptico composto por um fototransistor sensível a luz, que quando acionado apresenta um ótimo tempo de resposta.

fonte: https://www.rapidonline.com

De uma maneira geral o 4n25 trabalha conforme a figura abaixo.

fonte: http://br-arduino.org

fonte : datasheet do componente

O papel principal desse componente é levar os +5V necessários para o acionamento da bobina do relé.

Para o circuito devemos ter em mão os seguintes componentes:

1 módulo NodeMCU

1 módulo relé 5Vcc

1 CI 4N25

2 botões tipo push-button

1 resistor de 150 ohm

3 resistores de 1k

1 fonte externa de 5Vcc

1 lâmpada (127/ 220V)

cabos tipo jumpers

O esquema elétrico

É possível observar que boa parte da ligação é proveniente da ultima postagem feita sobre o NodeMCU.

fonte: próprio autor

O código fonte

Vamos utilizar o mesmo código fonte que foi usado no acionamento do LED On/Off, por isso estou repetindo ele abaixo.
Copie e cole o código na IDE do Arduino e descarregue no NodeMCU.

 /** Código **/
// Elaborado por Tony Emerson Marim em 18/12/2016.
/** mecatronizando@gmail.com **/
/** Chaveamento **/
//Constantes
int rele = 16;
int botaoLig = 15;
int botaoDes = 13;

//Varável de estado dos botões
int estadobotaoLig = 0;
int estadobotaoDes = 0;

void setup() {
  // Define o pino 16 como saida
  pinMode(16, OUTPUT);
  //Define os pinos como entrada
  pinMode(15, INPUT);
  pinMode(13, INPUT);
}
 
void loop() {

  //Atribuindo resultado para o estado do botão
  estadobotaoLig = digitalRead(botaoLig);
  estadobotaoDes = digitalRead(botaoDes);
  
  //Lógica de funcionament0
  if (estadobotaoLig == HIGH)// Botão recebe 1
  {
    digitalWrite(16,HIGH);//Acende lampada
    }
    if (estadobotaoDes == HIGH)// Botão recebe 1
    {
  digitalWrite(16, LOW);    // Apaga lampada
 }
}

O funcionamento do circuito pode ser visto no vídeo abaixo.

Curtiu? Compartilhe pela nossa FanPage.
Assine o Canal no Youtube.
Caso seja necessário todo conteúdo pode ser baixado nesse LINK!

segunda-feira, 19 de dezembro de 2016

NodeMCU - Ameça real ao Arduino?

NodeMCU - Ameaça real ao Arduino?

fonte: próprio autor

Preferida entre a maioria dos hobbista ou makers de projetos de mecatrônica e eletrônica, o Arduino desde sua criação em 2005 destaca-se como uma ótima opção de ferramenta de baixo custo e fácil utilização contando com entradas e saídas digitais e analógicas, interface serial e USB e sem contar a infinidade de extensões com fins específicos (shields e módulos).

A facilidade de reprodução fez surgir no mercado uma infinidade de placas, aumentando as opções para os usuários e possibilitando a escolha de diversos tipos de microcontroladores à sua preferência.

Em 2014 a empresa Espressif lança a NodeMCU, um projeto derivado do ESP8266.
A NodeMCU em comparação com o Arduino é de tamanho bastante reduzido, mais veloz, mais potente, possui integrado conexão Wi-fi e o mais importante custa aproximadamente 50% mais barato (comparando placa por placa sem considerar o wi-fi).

fonte: http://thearduinoguy.org

Outra facilidade em que a placa NodeMCU têm destaque é a facilidade de integração com uma tendência que vem crescendo a cada dia: o conceito de projetos conectados na internet (IoT - internet of things), a internet das coisas.

Constituído por um módulo ESP 12-E, um conversor FTDI e um regulador de tensão que baixa de 5V para 3,3V consta com pinos padrões conectáveis em protoboards.

fonte: github.com

Sua programação é simples, utiliza somente um cabo para alimentação e transferência de dados, utiliza originalmente a linguagem de programação Lua (concebida em terras brasileiras por uma equipe da PUC-Rio), mas pode ser facilmente utilizada fazendo uploads em outras linguagens, em linguagem C por meio da SDK da Espressif e C++ por meio da IDE do Arduino.

Hardware

Possui um processador que pode atingir até 160 MHz (Tenscilica LX106), memória RAM de 20 KB e memória Flash de 4 MB, conexão Wi-fi 802.11 e g e limite de 300MBps de velocidade.

fonte: http://docs.thinger.io

Ponto Negativo

Um dos pontos negativos do módulo é contar com somente uma porta analógica (inviabilizando o uso de muitos sensores), além de única essa porta limita-se a um valor máximo de entrada de 1 volt necessitando de conversões para atingir o desejado. Pode-se considerar um outro ponto negativo a quantidade de portas digitais que é menor se comparada com o Arduin Uno.

Conclusão

É realmente impressionante a gama de oportunidades oferecidas por essa placa que consegue difundir o conceito IoT mesclando performance e baixo custo, Não é possível enxergar no horizonte um fim para essa evolução no ramo da eletrônica, o conceito de embarcados veio para ficar, então só nos resta desfrutar das possibilidades oferecidas.

Aguardaremos futuros lançamentos de empresas como Esprssif (que já anunciou a produção do ESP32) e outras para sistemas com componentes cada vez mais velozes e potentes, de tamanhos reduzidos que além do hardware o custo caiba nos nossos bolsos.

Continua...

Utilizando o NodeMCU

fonte: próprio autor

Programando o NodeMCU

Depois de apresentado o NodeMCU, é hora de começarmos a utilizar suas características a nosso favor.

Nesse post, vamos realizar algumas programações básicas para começarmos a trabalhar um pouco mais esse módulo.
Como o modulo permite, vamos programa-lo utilizando a IDE do Arduino.

Projeto 1: acionamento de um LED piscando

Para essa atividade vamos precisar de:

1 módulo NodeMCU

1 LED de qualquer cor
1 resistor 150 ohms

protoboard (matriz de contatos)

cabos jumpers

Esquema de ligação

fonte: próprio autor

O código fonte

Antes de escrever o código, é necessário algumas alterações na configuração da IDE do Arduino para que possa ser utilizada na programação do módulo.

1º Passo:

Entre na IDE;
Arquivo;
Preferências.

fonte: próprio autor

Digite em URLs adicionais de Gerenciadores de Placas:

http://arduino.esp8266.com/package_esp8266com_index.json

Dê OK!

2º Passo:

Clicar em :

Ferramentas;
Placas;
Gerenciadores de Placas.

fonte: próprio autor

Uma janela vai abrir, selecionar ao final da barra de rolagem: esp8266 by ESP8266 Community e instalar.

fonte: próprio autor

3º Passo

Selecionar a placa que deve ser utilizada no projeto: NodeMCU 1.0( ESP12E Module)

fonte próprio autor

Pronto! Agora é só carregar o código fonte como de costume usando a IDE do Arduino, copie e cole o código na montagem para piscar o LED conforme o tempo programado.

 /** Código 1 **/
// Elaborado por Tony Emerson Marim em 18/12/2016.
/** mecatronizando@gmail.com **/
/** Pisca LED**/

void setup() {
  // Define o pino 16 como saida
  pinMode(16, OUTPUT);
}
 
void loop() {
  digitalWrite(16, HIGH);   // Acende o Led
  delay(1000);              // Aguarda 1 segundo
  digitalWrite(16, LOW);    // Apaga o Led
  delay(1000);              // Aguarda 1 segundo
}

fonte próprio autor

Projeto 2: acionando LED com botão.

Seguindo o mesmo esquema de ligação, implementar agora um botão tipo push button que permite ao LED permanecer aceso enquanto estiver pressionado.

Realizando o esquema abaixo é possível realizar o projeto.

1 módulo NodeMCU

1 LED de qualquer cor
1 resistor 150 ohms
1 resistor 1k
1 botão tipo push button

protoboard (matriz de contatos)

cabos jumpers

fonte: próprio autor

O código fonte

 /** Código 2 **/
// Elaborado por Tony Emerson Marim em 18/12/2016.
/** mecatronizando@gmail.com **/
/** Liga LED**/
//Constantes
int led = 16;
int botao = 15;

//Varável de estado do botão
int estadobotao = 0;

void setup() {
  // Define o pino 16 como saida
  pinMode(16, OUTPUT);
  //Define o pino 15 como entrada
  pinMode(15, INPUT);
}
 
void loop() {

  //Atribuindo resultado para o estado do botão
  estadobotao = digitalRead(botao);

  //Lógica de funcionament0
  if (estadobotao == HIGH)// Botão recebe 1
  {
    digitalWrite(16,HIGH);//Acende led
    }
    else//Senão
    {
  digitalWrite(16, LOW);    // Apaga o Led
 }
}

Projeto 3: acionar LED com botões ON/OFF

E para finalizar, o esquema de uma montagem com dois botões onde pode ser observado o funcionamento de um LED sendo ligado por uma entrada e desligado por outra.

Nos materiais necessários para a execução deve ser adicionado mais um botão, mais um resistor no valor de 1k e fios jumpers.

1 módulo NodeMCU

1 LED de qualquer cor
1 resistor 150 ohms
2 resistor 1k
2 botões tipo push button

protoboard (matriz de contatos)

cabos jumpers

fonte: próprio autor

O código fonte

 /** Código 3 **/
// Elaborado por Tony Emerson Marim em 18/12/2016.
/** mecatronizando@gmail.com **/
/** Liga LED**/
//Constantes
int led = 16;
int botaoLig = 15;
int botaoDes = 13;

//Varável de estado dos botões
int estadobotaoLig = 0;
int estadobotaoDes = 0;

void setup() {
  // Define o pino 16 como saida
  pinMode(16, OUTPUT);
  //Define os pinos como entrada
  pinMode(15, INPUT);
  pinMode(13, INPUT);
}
 
void loop() {

  //Atribuindo resultado para o estado do botão
  estadobotaoLig = digitalRead(botaoLig);
  estadobotaoDes = digitalRead(botaoDes);
  
  //Lógica de funcionament0
  if (estadobotaoLig == HIGH)// Botão recebe 1
  {
    digitalWrite(16,HIGH);//Acende led
    }
    if (estadobotaoDes == HIGH)// Botão recebe 1
    {
  digitalWrite(16, LOW);    // Apaga o Led
 }
}

No vídeo é possível ver o comportamento dos códigos em funcionamento com acionamentos com LEDs, nos próximos post, vamos elaborar um pouco mais a programação e explorar as possíbilidades dessa plaquinha com chaveamentos de tensões e inseri-la na rede Wi-Fi.

Gostou? Curta e compartilhe pela nossa FanPage!
Assine o Canal!

Caso seja necessário todos os projetos podem ser baixados por esse LINK!

Bons Estudos!