<

Exibir mensagens

Esta seção lhe permite ver todas as mensagens deste membro. Note que você só pode ver as mensagens das áreas às quais você tem acesso.


Tópicos - Ivanov

Páginas: [1] 2 3 ... 5
1
Projetos / Programação em blocos – LDR (Parte 3/4)
« Online: Setembro 24, 2019, 10:06:40 am »
Programação em blocos – LDR (Parte 3/4)

Na continuidade da programação em blocos, hoje vamos aprender a montar um código com uma variável com o objetivo de receber dados acerca da iluminação do local onde nos encontramos.

Esquema de ligação:

Para o esquema deste post vamos precisar apenas de um sensor de luminosidade (LDR) e de uma resistência de 10k ohm:

Configuração da ferramenta:

Escolhemos a opção “Personal Project”:

Montagem do código:

Envio do código para a placa:

Depois de terminarmos a montagem do código, transferimos o código

Abrimos o código no programa “Arduino IDE”

E enviamos para a nossa placa arduino.

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


2
Projetos / Programação em blocos – Leds (Parte 2/4)
« Online: Setembro 24, 2019, 10:06:16 am »
Programação em blocos – Leds (Parte 2/4)

Hoje vamos dar seguimento à “série”, programação em blocos, mas com uma ferramenta diferente.

Para o trabalho de hoje iremos utilizar a ferramenta online para programação em blocos do site a “ArduinoBlocks”.

Esquema de ligação:

Para este projeto utilizaremos apenas um botão de pressão e um led vermelho tal como no esquema seguinte:

Configuração da ferramenta

Para utilizarmos esta ferramenta teremos que criar um login no site.

Após a criação do login e da confirmação da conta estamos prontos para iniciar o nosso projeto

Selecionamos a opção “Personal Project”:

Montagem do código:

 

Envio do código para a placa:

Depois de terminarmos a montagem do código, transferimos o código

Abrimos o código no programa “Arduino IDE”:

E enviamos para a nossa placa arduino.

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


3
Projetos / Programação em blocos – Led (Parte 1/4)
« Online: Setembro 24, 2019, 10:06:03 am »
Programação em blocos – Led (Parte 1/4)

No post de hoje vamos aprender como programar um arduino de forma mais interativa e apelativa do que a escrita de um simples código.

Esquema de ligações:

Para a realização deste trabalho vamos utilizar apenas um led vermelho e uma resistencia de 220 ohm que estarão conectados da seguinte forma:

Configuração do programa

Para a programação em blocos precisamos de instalar o programa “mblock” para que seja possível a conversão gráfica para escrita do próprio código Arduino.

Recomendo a instalação da versão 3, uma vez que a versão 5 ainda não se encontra otimizada para a comunicação com a placa Arduino UNO.

Montagem do código:

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


4
Projetos / Como fazer uma Casa Inteligente com Arduino – SmartHome (Parte 9/9)
« Online: Setembro 24, 2019, 10:05:54 am »
Como fazer uma Casa Inteligente com Arduino – SmartHome (Parte 9/9)

Projeto Final

/********Declaração de todas as librarias********/
  #include 
  #include 
  #include 
/*********Definição dos pinos dos componentes**********/

//sensor de gás
  #define MQ_analog A2
  #define MQ_dig 7

// enderço/protocolo do RTC
  #define DS1307_ADDRESS 0x68

//DHT-11 (sensor de humidade e temperatura)
  #define dht_dpin A1 //Pino DATA do Sensor ligado na porta Analogica A1

//LDR
  int ldr_Pin = A0; //LDR no pino analógico 0
  int ldr_Valor = 0; //Valor lido do LDR
  int leitura = 0;
  int value = 0;

//LEDS
  int led_1 = 3; //Led no pino 2
  int led_2 =5;  //Led no pino 5
  int led_3 = 6; //Led no pino 6
  int led_red = 9;
  int led_green = 10;
  int led_blue = 11;
  
  //Buzzer
  int buzzer = 8;
  
/*******Declaração das variáveis e constantes*******/
  int valor_analog;
  int valor_dig;
  const int chipSelect = 4;
  int a = 0;
  
/*******Inicialização de todos os sensores******/
//LCD
  LiquidCrystal_I2C lcd(0x3f,2,1,0,4,5,6,7,3, POSITIVE);
  
  byte zero = 0x00;

//DHT-11 (sensor de humidade e temperatura)
  dht DHT; 
  
//função millis
long previousMillis = 0;        // Variável de controlo do tempo
long serialinterval= 2000;    // Tempo em ms do intervalo a ser executado

  
 void setup() 
 {  
   Wire.begin();;
   Serial.begin(9600);
   lcd.begin(16, 2); // Define o LCD com 16 colunas e 2 linhas
 
  // A linha abaixo pode ser comentada/retirada depois de defenir a data e hora
  SelecionaDataeHora();

   pinMode(MQ_dig, INPUT);
   pinMode(led_1,OUTPUT); 
   pinMode(led_2,OUTPUT); 
   pinMode(led_3,OUTPUT); 
   pinMode(led_red,OUTPUT);
   pinMode(led_green,OUTPUT);
   pinMode(led_blue,OUTPUT);
   pinMode(buzzer,OUTPUT);
   
   digitalWrite(buzzer, LOW);
   digitalWrite(led_red, HIGH);
   digitalWrite(led_green, HIGH);
   digitalWrite(led_blue, HIGH);
}

  void loop ()
  {
    bluetooth ();
    
    sensorGAS();
   
    rtc();
    
  
    ldr();  
   
   
    dHt();
    
    lcd.setCursor(0,1);
       lcd.print("Hum:");
       lcd.print(DHT.humidity);
       lcd.print("%");
       lcd.print(" Temp:");
       lcd.print(DHT.temperature);
       delay(1000); 
   }


  void SelecionaDataeHora()   //Define a data e a hora do DS1307 
{
  byte segundos = 00; //Valores de 0 a 59
  byte minutos = 00; //Valores de 0 a 59
  byte horas = 15; //Valores de 0 a 23
  byte diadasemana = 5; //Valores de 0 a 6 ( 0=Domingo, 1 = Segunda, etc.) 
  byte diadomes = 15; //Valores de 1 a 31
  byte mes = 11; //Valores de 1 a 12
  byte ano = 18; //Valores de 0 a 99
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero); //Stop no CI para que o mesmo possa receber os dados

  /*As linhas abaixo escrevem no CI os valores de 
  data e hora que foram colocados nas variaveis acima*/
  Wire.write(ConverteParaBCD(segundos));
  Wire.write(ConverteParaBCD(minutos));
  Wire.write(ConverteParaBCD(horas));
  Wire.write(ConverteParaBCD(diadasemana));
  Wire.write(ConverteParaBCD(diadomes));
  Wire.write(ConverteParaBCD(mes));
  Wire.write(ConverteParaBCD(ano));
  Wire.write(zero);
  Wire.endTransmission(); 
}

byte ConverteParaBCD(byte val)
{ 
  //Converte o número de decimal para BCD
  return ( (val/10*16) + (val%10) );
}

byte ConverteparaDecimal(byte val)  
{ 
  //Converte de BCD para decimal
  return ( (val/16*10) + (val%16) );
} 

  
void sensorGAS ()
{ 
     boolean valor_dig = digitalRead(MQ_dig);
     
      if(valor_dig == 0)
      {
       Serial.println("GAS DETECTADO !!!");
        }
       else
       {
        Serial.print("GAS NÃO DETECTADO !!!");
        Serial.println();
       }
        
      valor_analog = analogRead(MQ_analog);
      
      if(valor_analog>=250 & valor_analog<=499)
      {
        digitalWrite(buzzer,HIGH);
        analogWrite(led_red,28); /*utilizamos o comando analogWrite para 
        tornar possível variar a intensidade de cada pino do led de forma a 
        permitir escolher a intensidade da cor a apresentar*/
        analogWrite(led_green,198);
        delay(1000);
        digitalWrite(led_red,HIGH);
        digitalWrite(led_green,HIGH);
        digitalWrite(buzzer,LOW);
        delay(100);
        
      }
        
      else
        {
        digitalWrite(buzzer,LOW);
        digitalWrite(led_red,HIGH);
          }
          
     if(valor_analog >=500)
      {
        digitalWrite(buzzer,HIGH);
        digitalWrite(led_red,LOW);
        delay(1000);
        digitalWrite(led_red,HIGH);
        digitalWrite(buzzer,LOW);
        delay(100);
        
      }
        
      else
        {
        digitalWrite(buzzer,LOW);
        digitalWrite(led_red,HIGH);
          }
          
       valor_analog = analogRead(MQ_analog);
       Serial.print("Qualidade do ar: ");
       Serial.print(valor_analog);
       Serial.println();
}

void rtc ()
{
   Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int segundos = ConverteparaDecimal(Wire.read());
  int minutos = ConverteparaDecimal(Wire.read());
  int horas = ConverteparaDecimal(Wire.read() & 0b111111);
  int diadasemana = ConverteparaDecimal(Wire.read()); 
  int diadomes = ConverteparaDecimal(Wire.read());
  int mes = ConverteparaDecimal(Wire.read());
  int ano = ConverteparaDecimal(Wire.read());

  // Mostra os dados no display
  lcd.setCursor(0,0);
  lcd.print("Horas:");
  // Acrescenta o 0 (zero) se a hora for menor do que 10
  if (horas <10)
    lcd.print("0");
  lcd.print(horas);
  lcd.print(":");
  // Acrescenta o 0 (zero) se minutos for menor do que 10
  if (minutos < 10)
     lcd.print("0");
  lcd.print(minutos);
  lcd.print(":");
  if (segundos<10)
  {
    lcd.print("0");
  }
  lcd.print(segundos);
  }
  
void ldr()
{
if(a ==0)
  { 
 
 ///ler o valor do LDR
leitura = analogRead(ldr_Pin);
  value = analogRead(ldr_Pin);
  value = constrain(value,190,760);
  value = map(value,190,760,0,255);

  Serial.print("luminosidade: ");
  Serial.print(value);
  analogWrite(led_1, value);
  analogWrite(led_3, value);
 }
}

 void dHt()
 {
   DHT.read11(dht_dpin); //Lê as informações do sensor
      Serial.println();
      Serial.print("Hum:");
      Serial.print(DHT.humidity);
      Serial.print("%");
      Serial.print(" Temp:");
      Serial.print(DHT.temperature); 
      Serial.println(" º ");
      Serial.println ("");
  
      
  }

 void bluetooth()
 {


  if(Serial.available())
    {
       /*utilizamos a função millis para tornar possível a apresentação 
       dos dados dos diversos sensores no smartphone em intervalos de 
       tempo maiores*/
       unsigned long currentMillis = millis();    //Tempo atual em ms

      if (currentMillis - previousMillis > serialinterval) { 
      previousMillis = currentMillis;    // Salva o tempo atual

     Serial.print("Luminosidade: ");
     Serial.println(ldr_Valor);
     Serial.print("Humidade: ");
     Serial.println(DHT.humidity);
     Serial.print("Temperatura: ");
     Serial.println(DHT.temperature);
      }

     char caracter = Serial.read();
          switch (caracter) 
          {
            case "1": 
                    digitalWrite(led_1, HIGH);
                    delay(1000);
            break;
            
             case "2": 
                    digitalWrite(led_2, HIGH);
                    delay(1000);
            break; 
            
             case "3": 
                    digitalWrite(led_3, HIGH);
                    delay(1000);
            break;
            
             case "4": 
                    digitalWrite(led_1, LOW);
                    delay(1000);
            break;
            
            case "5": 
                    digitalWrite(led_2, LOW);
                    delay(1000);
            break;
            
             case "6": 
                    digitalWrite(led_3, LOW);
                    delay(1000);
            break;
            
             case "a": 
                      a = 1;
                      digitalWrite(led_1, HIGH);
                      digitalWrite(led_2, HIGH);
                      digitalWrite(led_3, HIGH);
                      
            break;
            
             case "s": digitalWrite(led_1, LOW);
                      digitalWrite(led_2, LOW);
                      digitalWrite(led_3, LOW) ;   
                      a = 0;
            break;
          }
    }
 }

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


5
Como fazer uma Casa Inteligente com Arduino – Display I2C (Parte 7/9)

Display I2C

É com a instalação de um display, em cada divisão do projeto que tornamos possível o fácil acesso às horas e às condições mais importantes da nossa casa.

Iremos utilizar um Display 16×2 (16 colunas; 2 linhas) com o protocolo I2C para facilitara comunicação entre o arduino e o componente.

O protocolo I2C utiliza apenas duas linhas de comunicação( SDA e SCL), sendo que, devido à existência de apenas uma linha de dados não é possível o envio e a receção de dados em simultâneo.

Neste protocolo, todos os dispositivos ficam anexados. Devido à falta de quaisquer linhas de seleção para a escolha do slave com que o master pretende comunicar è necessário utilizar um endereço por software que varia de dispositivo para dispositivo.

Para saber o endereço I2C que cada componente está a utilizar vamos utilizar um scanner de endereços.

/******Declaração das libraras responsáveis pelo controlo de cada componente do projeto******/
#include 
#include 

//Endereço do display
//em alguns casos o endereço pode variar consoante o fornecedor do display
LiquidCrystal_I2C lcd(0x3f,2,1,0,4,5,6,7,3, POSITIVE); 
 
void setup()
    {
      lcd.begin (16,2); // Define o LCD com 16 colunas e 2 linhas
    }
 
void loop()
    {
      lcd.setBacklight(HIGH); //Comando responsável pela iluminação de fundo do display
      lcd.setCursor(0,0);
      lcd.print("ElectroFun.pt"); /* Dentro dos parenteses escrevemos 
      a mensagem que queremos a presentar na 1ª linha */
      lcd.setCursor(0,1);
      lcd.print("LCD e modulo I2C"); /* Dentro dos parenteses escrevemos 
      a mensagem que queremos a presentar na 2ª linha */
      delay(1000); 
      lcd.setBacklight(LOW); /* Comando responsável pela iluminação de fundo 
      do display */
      delay(1000);
    }

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


6
Projetos / Como fazer uma Casa Inteligente com Arduino – HC-05 (Parte 6/9)
« Online: Setembro 24, 2019, 10:03:24 am »
Como fazer uma Casa Inteligente com Arduino – HC-05 (Parte 6/9)

HC-05

Através de um módulo HC-05 (módulo Bluetooth), torna-mos a nossa “Smart-House” ainda mais inteligente, habilitando o controlo da iluminação, e a verificação das condições do projeto com a simples abertura de uma aplicação no nosso telemóvel ou tablet

/******Declaração das variáveis e definição dos pinos de cada componente presentes no projeto******/

int led_1 = 13; //led do arduino

int caracter;

void setup() 
 {
   Serial.begin(9600);
   pinMode(led_1, OUTPUT);
   digitalWrite(led_1, LOW);
 }

void loop() 
{
  
   if(Serial.available())
       {
       
          char caracter = Serial.read();
          Serial.print("Recebi os dados:");
          Serial.println(caracter);
          switch (caracter) 
           {
            
              case "l": //se enviar a tecla "l" o led liga
                       digitalWrite(led_1, HIGH);
              break;
              
              case "d": //se enviar a tecla "d" o led desliga
                       digitalWrite(led_1, LOW);
              break;
            }
       }
}

Para executarmos este programa vamos precisar de instalar no nosso smartphone a app “Arduino Bluetooth Controler”.

Se o módulo ainda se encontrar com as definições de fábrica, a chave  de emparelhamento entre o smartphone e o módulo HC-05 será "1234".


Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


7
Projetos / Como fazer uma Casa Inteligente com Arduino – LDR (Parte 2/9)
« Online: Setembro 24, 2019, 10:02:55 am »
Como fazer uma Casa Inteligente com Arduino – LDR (Parte 2/9)

LDR

Utilizaremos uma foto resistência (LDR) para criarmos um ambiente interativo de controlo de iluminação com base na luminosidade do exterior.

 

/******Declaração das variáveis e definição dos pinos de cada componente presentes no projeto******/
int led_1 = 3; //Led no pino 3
int led_2 = 4; //Led no pino 4
int led_3 = 5; //Led no pino 5
int ldr_Pin = A0; //LDR no pino analógico 5
int ldr_Valor = 0; //Valor lido do LDR
int leitura = 0;
int value = 0;

void setup() 
{
  pinMode(led_1,OUTPUT); //define a porta 3 como saída
  pinMode(led_2,OUTPUT); //define a porta 4 como saída
  pinMode(led_3,OUTPUT); //define a porta 5 como saída
  Serial.begin(9600); //Inicia a comunicação serial
}

 void loop ()
{
  leitura = analogRead(ldr_Pin);
    value = analogRead(ldr_Pin);
    value = constrain(value,290,760);
    value = map(value,290,760,0,255);

    Serial.print("luminosidade: ");
    Serial.print(value);
    analogWrite(led_1, value);
    analogWrite(led_2, value);
    analogWrite(led_3, value);
}

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


8
Projetos / ESP8266: Part 2 – Controlo de leds e análise de sensores via WIFI
« Online: Setembro 24, 2019, 10:02:22 am »
ESP8266: Part 2 – Controlo de leds e análise de sensores via WIFI

No post anterior aprendemos como controlar a iluminação e o toque de um buzzer ativo através da app “Blynk”. Hoje vamos aprender como adicionar sensores ao projeto anterior e ler os dados obtidos de diferentes formas.

Código de programação:

/**************Definição das librarias responsaveis pela comunicação com o esp e com o arduino**************/
#define BLYNK_PRINT Serial

#include "ESP8266_Lib.h"

#include "BlynkSimpleShieldEsp8266.h"
#include "SoftwareSerial.h"
SoftwareSerial EspSerial(8,9); // RX, TX

// Adquire o TOKEN na aplicação
char auth[] = "8*******************************"; //Inserir o AUTH TOKEN entre das aspas presentes no programa

/************** Credenciais WIFI ***************/

// Defenição da password e do nome da rede

char ssid[] = "REDE WIFI";

char pass[] = "PASSWORD WIFI";

// Definir a baud dp esp8266 para 9600 para permitir a comunicação com a aplicação

#define ESP8266_BAUD 9600

ESP8266 wifi(&EspSerial);

void setup()

{
Serial.begin(9600);

delay(10);

EspSerial.begin(ESP8266_BAUD);

delay(10);

Blynk.begin(auth, wifi, ssid, pass);

}

void loop()

{

Blynk.run();

} 

Como adicionar sensores ao projeto:

Selecionamos o widget “Gauge” e o resultado deverá ser o seguinte:

De seguida vamos configurar o widget para ler os dados obtidos pelo LDR da seguinte forma:

Resultado Final:

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.


9
Projetos / ESP8266 – Controlo de leds e análise de sensores via WIFI
« Online: Setembro 24, 2019, 10:02:08 am »
ESP8266 – Controlo de leds e análise de sensores via WIFI

Hoje vamos mostrar como controlar leds, módulos e diversos sensores utilizando apenas o nosso ESP8266, uma aplicação para smartphone e a nossa comunicação WIFI.

Esquema de ligação:

Para comunicarmos com o nosso módulo WIFI ESP8266 vamos utilizar uma fonte de alimentação 3.3V/5V, um arduino nano, um led , uma resistência 220 ohm e seguiremos o seguinte esquema

Aplicação “BLYNK”:

O Blynk é uma plataforma que integra um aplicativo (iOS e Android) com o hardware, que pode ser ESP8266, Arduino, Raspberry Pi, Intel Edison, entre outras plataformas de desenvolvimento.

O aplicativo permite a integração direta com o dispositivo pela Internet, ou seja, torna-se possível controlar uma saída digital do ESP pela Internet em poucos minutos e sem complicações.

1.Inicio do aplicativo:

Para utilizarmos esta aplicação vamos ter que criar uma conta onde iremos guardar todos os projetos criados.

2.Configuração do aplicativo:

No ponto 1 vamos definir o nome do nosso projeto

No ponto 2 será possível escolhermos qual o dispositivo que mais se adapta ao nosso projeto, neste caso, vamos escolher o Arduino Nano.

No ponto 3 definimos o tipo de comunicação que vamos utilizar

No ponto 4 podemos escolher o tema que mais nos agrada variando entre o branco e o preto

Por fim, depois de todos os pontos estarem preenchidos de acordo com o nosso projeto, selecionamos o botão “Create”. Irá aparecer um aviso indicando que o TOKEN do nosso projeto foi enviado via email para completar o nosso codigo.

Código de programação:

Após a criação do novo projeto na app “Blynk”, vamos programar o nosso arduino para tornar possível a comunicação WIFI entre a aplicação e o módulo

/**************Definição das librarias responsaveis pela comunicação com o  esp e com o arduino**************/
#define BLYNK_PRINT Serial

#include 

#include 
#include 
SoftwareSerial EspSerial(8,9); // RX, TX

// Adquire o TOKEN na aplicação
char auth[] = "INSERIR AUTH TOKEN"; //Inserir o AUTH TOKEN entre das aspas presentes no programa


/************** Credenciais WIFI ***************/

// Defenição da password e do nome da rede 

char ssid[] = "REDE WIFI";

char pass[] = "PASSWORD WIFI";



// Definir a baud dp esp8266 para 9600 para permitir a comunicação com a aplicação

#define ESP8266_BAUD 9600



ESP8266 wifi(&EspSerial);



void setup()

{
  Serial.begin(9600); 

  delay(10);

  EspSerial.begin(ESP8266_BAUD);

  delay(10);
  
  Blynk.begin(auth, wifi, ssid, pass);

}



void loop()

{

  Blynk.run();

}

3.Configuração do ambiente de trabalho do projeto:

Para preencher o nosso espaço de controlo, a aplicação conta com uma pilha com 2000 pontos de energia (plano gratuito), e é possível gastar a energia da pilha à medida que adicionamos widgets.

A aplicação tem 7 tipos de widgets diferentes, sendo que para este post apenas iremos utilizar 2 deles: Widgets de Controlo e Widgets de Leitura, respetivamente.

  1. Para começar vamos arrastar um “button” e um “slider” responsáveis pelo controlo do led para a área de trabalho do aplicativo e vamos configura-los.

2. Agora voltamos a selecionar mais um “Button” e um “slider”, desta vez responsáveis pelo buzzer, colocamo los na area de trabalho e configuramo-los da mesma forma que os controladores do led

Num post futuro iremos mostrar como adicionar e fazer a leitura de um sensor apresentando os resultados obtidos sob a forma de gráfico.

Resultado Final:

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.


10
Projetos / Como fazer uma Casa Inteligente com Arduino – RTC (Parte 1/9)
« Online: Setembro 24, 2019, 10:01:13 am »
Como fazer uma Casa Inteligente com Arduino – RTC (Parte 1/9)

Smart-House

Todos nós, nos dias correntes, ficamos intrigados e com vontade de ter uma casa inteligente e perceber como esta funciona. No post de hoje vamos mostrar o funcionamento destas casas e ainda como montar o nosso próprio projeto.

RTC

Neste projeto vamos utilizar um modulo RTC para que nos seja possível, verificar as horas de forma digital e ainda definir alarmes.

Para isso seguiremos o esquema e o código apresentados a seguir.

#include 
#define DS1307_ADDRESS 0x68
byte zero = 0x00;

void setup()
  {
  Wire.begin();;
  Serial.begin(9600);
   
  
  // A linha abaixo pode ser retirada depois de defenir a data e hora
  SelecionaDataeHora();
 
  }
 
void loop()
  {
    Mostrarelogio();
    delay(1000);
 
  }
 
  void SelecionaDataeHora() //define a data e a hora do DS1307
{
  byte segundos = 40; // Valores de 0 a 59
  byte minutos = 40; // Valores de 0 a 59
  byte horas = 13; // Valores de 0 a 23
  byte diadasemana = 2; // Valores de 0 a 6 (0=Domingo, 1 = Segunda, 2 = Terça, ...)
  byte diadomes = 07; // Valores de 1 a 31
  byte mes = 11; // Valores de 1 a 12
  byte ano = 18; // Valores de 0 a 99
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
 
  /* As linhas abaixo escrevem no CI os valores de
  data e hora que foram colocados nas variaveis acima*/
  Wire.write(ConverteParaBCD(segundos));
  Wire.write(ConverteParaBCD(minutos));
  Wire.write(ConverteParaBCD(horas));
  Wire.write(ConverteParaBCD(diadasemana));
  Wire.write(ConverteParaBCD(diadomes));
  Wire.write(ConverteParaBCD(mes));
  Wire.write(ConverteParaBCD(ano));
  Wire.write(zero); //Inicio no CI
  Wire.endTransmission();
}
 
byte ConverteParaBCD(byte val)
{
  // Converte o número de decimal para BCD
  return ( (val / 10 * 16) + (val % 10) );
}
 
byte ConverteparaDecimal(byte val)
{
  // Converte de BCD para decimal
  return ( (val / 16 * 10) + (val % 16) );
}
 
void Mostrarelogio()
{
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int segundos = ConverteparaDecimal(Wire.read());
  int minutos = ConverteparaDecimal(Wire.read());
  int horas = ConverteparaDecimal(Wire.read() & 0b111111);
  int diadasemana = ConverteparaDecimal(Wire.read());
  int diadomes = ConverteparaDecimal(Wire.read());
  int mes = ConverteparaDecimal(Wire.read());
  int ano = ConverteparaDecimal(Wire.read());
 
  Serial.print (horas);
  Serial.print (":");
  Serial.print (minutos);
  Serial.print(":");
  Serial.println (segundos);
 
  if (minutos < 01)
  {
    Serial.println("acerto de hora");
  }
}

Lista de Material:

Todos os produtos foram adquiridos na loja de eletrónica e robótica ElectroFun: www.electrofun.pt.

Outros produtos que possam ser úteis:


11
Projetos / Como controlar fitas de LED com Arduino por SMS GSM [Vídeo]
« Online: Setembro 24, 2019, 09:36:30 am »
Como controlar fitas de LED com Arduino por SMS GSM [Vídeo]

Hoje vamos mostrar como controlar fitas de LED com SMS, por isso se és um dos amantes das fitas de LED, este projeto é para ti.

Controlar fitas de LED com SMS é prático, divertido e também a podemos controlar em qualquer parte do mundo ao contrário de métodos como bluetooth ou rádio frequências.

O controlo com SMS é também uma forma económica, já que quase todas as pessoas atualmente têm tarifários com SMS gratuitas.

Caso perfiras ver como fazer este projeto em formato de vídeo, nós temos um vídeo perfeito para ti no nosso canal de youtube:

Neste projeto queremos controlar a fita de LED sem ter que lhe fazer qualquer alteração, para a podermos utilizar em outros projetos se quisermos.

Para fazermos isto nós utilizaremos um led infravermelho, para simular o funcionamento do comando, mas para isso temos primeiro que ler os sinais enviados pelo comando, utilizaremos um arduino, um sensor infravermelhos e a biblioteca IRremote.

#Montagem do Sensor Infravermelhos

Passamos a explicar passo a passo a montagem do sensor infravermelho:

  • Ligamos o VCC e GND do sensor aos 5V e GND do arduino, respetivamente;
  • Ligamos o pino Sinal do sensor infravermelho ao pino digital 11 do arduino;

Esquema utilizado para o sensor infravermelhos no projeto

#Código para o sensor infravermelhos

O código que utilizaremos para ler os sinais enviados pelo comando será um dos exemplos da biblioteca IRremote, o IRrecvDump para ser especifico.

Esta imagem mostra qual o exemplo da biblioteca utilizado

Depois de carregar o código exemplo abrimos o Serial Monitor e clicamos num dos botões do comando, do texto que é escrito no Serial monitor, anotamos o tipo de comando, o código hexadecimal e o numero de bits do sinal.

Texto que aparece no serial monitor durante os testes

Repetimos este processo para todos os botões que queremos simular, depois de todos os valores anotados passamos á montagem do led infravermelho e do módulo SIM800.

Controlar fitas de LED com SMS

Agora que temos os sinais dos botões que queremos utilizar, podemos passar á montagem principal para controlar fitas de LED com SMS, para isso precisamos de ter um cartão SIM, ao qual temos que tirar o código PIN para funcionar corretamente com o código, depois de retidado o PIN ligamo-lo ao módulo SIM800.

#Montagem do projeto

Mais uma vez explicaremos a montagem passo a passo para facilitar a compreensão:

  • Começamos por ligar os 5V e GND do módulo SIM800 á fonte de alimentação para breadboard;
  • Depois ligamos os pinos TXD do módulo ao pino digital 8 do arduino e o pino RXD ao pino digital 9;
  • Para o led infravermelhos ligamos ao pino PWM 3 do arduino através de uma resistência, neste caso de 100Ω;

Nós utilizamos uma fonte de alimentação para breadboard, porque o módulo SIM800 em certos momentos necessita de mais corrente do que o arduino consegue providenciar de forma segura.

Este é o esquema de montagem do projeto para controlar fita de LED

Antes de passarmos ao código devemos pôr um cartão SIM no módulo SIM800, mas antes disso devemos pô-lo num telemovel e retirar-lhe o código PIN.

#Código utilizado

Apresentamos agora o código que utilizamos, para este código a biblioteca IRremote também é necessária.

#include  //Incluimos a livraria IRremote
#include  //Incluimos a livraria SoftwareSerial
SoftwareSerial SIM800L(8, 9); //Declaramos os pinos RX(8) e TX(9) que vamos usar
 
String Comando; //Declaramos uma variavel de tipo String para armazenar o texto do SMS recebido

IRsend irsend;
 
void setup(){
Serial.begin(9600); //Iniciamos a comunicação serie
SIM800L.begin(9600); //Iniciamos una instância da livraria SoftwareSerial
SIM800L.println("AT+CMGF=1"); //Configuramos o módulo para trabalhar com os SMS em modo texto
delay(1000); //Pausa de 1 segundo
SIM800L.println("AT+CNMI=1,2,0,0,0"); //Configuramos o módulo para que nos mostre os SMS recebidos por comunicação serie
pinMode(LED, OUTPUT); //Definimos o pino onde esta ligado o LED como saida
}
 
void loop(){
if (SIM800L.available()){ //Se há dados disponiveis
  Comando = SIM800L.readString(); //Armazenamo-los na variavel Comandos
  Serial.println("NOVO SMS ENTRADA: " + Comando); //Obtemo-los por comunicação série
}
 
//Código para ligar
if(Comando.indexOf("On")>=0){ //Se a variável Comando contem a palavra ON
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7C03F, 32); //Enviamos o código hexadecimal do botão "ON" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Desligar if(Comando.indexOf("Off")>=0){ //Se a variavel Comando contem a palavra OFF
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF740BF, 32);//Enviamos o código hexadecimal do botão "OFF" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Vermelho if(Comando.indexOf("Vermelho")>=0){ //Se a variavel Comando contem a palavra Vermelho
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF720DF, 32); //Enviamos o código hexadecimal do botão "Vermelho" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para verde if(Comando.indexOf("Verde")>=0){ //Se a variavel Comando contem a palavra Verde
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7A05F, 32); //Enviamos o código hexadecimal do botão "Verde" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Azul if(Comando.indexOf("Azul")>=0){ //Se a variavel Comando contem a palavra Azul  
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7609F, 32);//Enviamos o código hexadecimal do botão "Azul" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Branco if(Comando.indexOf("Branco")>=0){ //Se a variavel Comando contem a palavra Branco
for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7E01F, 32); //Enviamos o código hexadecimal do botão "Branco" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Flash if(Comando.indexOf("Flash")>=0){ //Se a variavel Comando contem a palavra Flash
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7D02F, 32); //Enviamos o código hexadecimal do botão "Flash" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Strobe if(Comando.indexOf("Strobe")>=0){ //Se a variavel Comando contem a palavra Strobe
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7F00F, 32); //Enviamos o código hexadecimal do botão Strobe delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Fade if(Comando.indexOf("Fade")>=0){ //Se a variavel Comando contem a palavra Fade
  for (int i = 0; i < 3; i++) { irsend.sendNEC(0xF7C837, 32); //Enviamos o código hexadecimal do botão "FADE" delay(40); } Comando = ""; //Esvaziamos a variavel } //Código para Smooth if(Comando.indexOf("Smooth")>=0){ //Se a variavel Comando contem a palavra Smooth
  for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0xF7E817, 32); //Enviamos o código hexadecimal do botão "Smooth"
    delay(40);
  }
Comando = ""; //Esvaziamos a variavel
}

}

#Material utilizado


12
Projetos / Como saber endereços dos dispositivos ligados ao Barramento I2C?
« Online: Setembro 24, 2019, 09:35:50 am »
Como saber endereços dos dispositivos ligados ao Barramento I2C?

Este tutorial explica de forma simples como encontrar dispositivos anexados ao barramento i2c com o Arduino. Verifica ainda qual o endereço de cada dispositivo i2c ligado ao Arduino.

Ligações

Basta fazer as seguintes quatro conexões entre o dispositivo Arduino e I2C.

1. Analógico 4 -> SDA

2. Analógico 5 -> SCL

3. VCC -> VCC

4. GND -> GND

Scanner i2c

Copie o seguinte codigo para o Arduino IDE e envie para o Arduino. Se seguida abra o Serial Monitor e encontrará o endereço dos dispositivos i2c anexados.

#include 

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

// Leonardo: wait for serial port to connect
while (!Serial)
{
}

Serial.println ();
Serial.println ("I2C scanner. Scanning ...");
byte count = 0;

Wire.begin();
for (byte i = 1; i < 120; i++)
{
Wire.beginTransmission (i);
if (Wire.endTransmission () == 0)
{
Serial.print ("Found address: ");
Serial.print (i, DEC);
Serial.print (" (0x");
Serial.print (i, HEX);
Serial.println (")");
count++;
delay (1); // maybe unneeded?
} // end of good response
} // end of for loop
Serial.println ("Done.");
Serial.print ("Found ");
Serial.print (count, DEC);
Serial.println (" device(s).");
} // end of setup

void loop() {}


13
Projetos / Como ligar um LDR ao Arduino? [Video]
« 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)


14
Projetos / Projetos do INETE com Arduino
« 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:



 





15
Projetos / Qual a diferença entre Buzzer Ativo vs Buzzer Passivo
« 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.


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