Archive for the ‘Módulos’ Category

Sensor de Vibração Alarme de Vibração

20 ABR
2016

Author: Leonardo Dalla Porta

Pra que serve um Sensor de Vibração?

Geralmente é muito difícil de se identificar um sensor de vibração, eles são pequenos, aplicados com bastante frequência em áreas industriais, para controle de vibração de motores elétricos ou de eixos, entre outros. Um sensor de Vibração obviamente detecta essas oscilações no seu ambiente e envia para o controlador efetuar alguma ação, seja de desativar um motor ou como é o nosso caso apenas gerar um BIP, para informar o usuário de tal fato.

Esta Experiência é muito simples, utilizando um Arduíno o sensor e um Buzzer, lemos a entrada analógica vindo do sensor e convertemos isso para bips, dependendo o nível de vibração, será  a quantidade e continuidade dos Bips.

 

 

 

Você vai precisar de:

  • Módulo Sensor de Vibração
  • Arduino Uno ou similar
  • Buzzer
  • Jumpers
  • Protoboard (Dependendo de seus jumpers)

 

 

 

Ligações:

A ligação do sensor é muito simples, o sensor possui 3 pinos, dos quais da esquerda para a direita são: GND, OUT, VCC. Destes o GND vai ligado ao GND do Arduino, o OUT, na entrada analógica A0 do Arduino, o VCC é ligado ao 5V simplesmente. O buzzer é conectado ao pino 11, lembrando novamente que o buzzer precisa ser com oscilador interno (Só alimenta-lo).

 

 

 

O Código:

O código assim como ja mencionado anteriormente apenas efetua a leitura da porta analógica A0 e Larga pulsos para o Buzzer na porta digital 11 do Arduino. Basta copiar e colar na sua IDE e compilar!

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//**************************************//
//**********Vibracao.INO****************//
//**********Nadiel Comércio*************//
//**Faça um bom uso desde que mantenha**//
//*seu autor e sua fonte!***************//
//*Atenciosamente: Leonardo Dalla Porta*//
//*************07/01/2016***************//
//**************************************//
int var;
 
void setup()
{
pinMode(11, OUTPUT);
}
 
void loop()
{
if(analogRead(A0)<400) { var++; if(var>1000)
  {
    var=0;
    digitalWrite(11, HIGH);
    delay(200);
  }
}
else
{
  digitalWrite(11, LOW);
}
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor PIR no arduino

01 ABR
2016

Author: Leonardo Dalla Porta

Neste tutorial você verá como conectar um Sensor PIR no arduino de forma muito simples, além disso você aprenderá a montar um alarme temporizado utilizando o arduino!

Você vai precisar de:

  • Sensor PIR
  • Arduino UNO
  • Jumpers
  • Protoboard
  • Led
  • Resistor

Ligaçoes:

A fiação é bastante simples, o sensor PIR tem impresso: o + e o – e o sinal. Caso haja duvidas segue a imagem para auxilia-lo:

Imagem de Setup

Código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/* 
 * //////////////////////////////////////////////////
 * //making sense of the Parallax PIR sensor's output
 * //////////////////////////////////////////////////
 *
 * Switches a LED according to the state of the sensors output pin.
 * Determines the beginning and end of continuous motion sequences.
 *
 * @author: Kristian Gohlke / krigoo (_) gmail (_) com / http://krx.at
 * @date:   3. September 2006 
 *
 * kr1 (cleft) 2006 
 * released under a creative commons "Attribution-NonCommercial-ShareAlike 2.0" license
 * http://creativecommons.org/licenses/by-nc-sa/2.0/de/
 *
 *
 * The Parallax PIR Sensor is an easy to use digital infrared motion sensor module. 
 * (http://www.parallax.com/detail.asp?product_id=555-28027)
 *
 * The sensor's output pin goes to HIGH if motion is present.
 * However, even if motion is present it goes to LOW from time to time, 
 * which might give the impression no motion is present. 
 * This program deals with this issue by ignoring LOW-phases shorter than a given time, 
 * assuming continuous motion is present during these phases.
 *  
 */
 
/////////////////////////////
//VARS
//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 30;        
 
//the time when the sensor outputs a low impulse
long unsigned int lowIn;         
 
//the amount of milliseconds the sensor has to be low 
//before we assume all motion has stopped
long unsigned int pause = 5000;  
 
boolean lockLow = true;
boolean takeLowTime;  
 
int pirPin = 7;    //the digital pin connected to the PIR sensor's output
int ledPin = 8;
 
 
/////////////////////////////
//SETUP
void setup(){
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);
 
  //give the sensor some time to calibrate
  Serial.print("calibrating sensor ");
    for(int i = 0; i < calibrationTime; i++){ Serial.print("."); delay(1000); } Serial.println(" done"); Serial.println("SENSOR ACTIVE"); delay(50); } //////////////////////////// //LOOP void loop(){ if(digitalRead(pirPin) == HIGH){ digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state if(lockLow){ //makes sure we wait for a transition to LOW before any further output is made: lockLow = false; Serial.println("---"); Serial.print("motion detected at "); Serial.print(millis()/1000); Serial.println(" sec"); delay(50); } takeLowTime = true; } if(digitalRead(pirPin) == LOW){ digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state if(takeLowTime){ lowIn = millis(); //save the time of the transition from high to LOW takeLowTime = false; //make sure this is only done at the start of a LOW phase } //if the sensor is low for more than the given pause, //we assume that no more motion is going to happen if(!lockLow && millis() - lowIn > pause){  
           //makes sure this block of code is only executed again after 
           //a new motion sequence has been detected
           lockLow = true;                        
           Serial.print("motion ended at ");      //output
           Serial.print((millis() - pause)/1000);
           Serial.println(" sec");
           delay(50);
           }
       }
  }

Você pode ver a partir do código, o sensor regula-se primeiro e depois relógios para o movimento. Quando se detecta o movimento, a luz azul acende-se. Você pode assistir no monitor serial para ver quanto tempo dura o movimento.

Imagem de Código

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor magnético A3144 – Sensor Hall

09 FEV
2016

Author: Leonardo Dalla Porta

 Sensor Magnético de efeito Hall

Mais conhecido como Sensor Hall, tem como principio transformar um campo magnético, em um sinal elétrico, assim podendo aplicar em diversos equipamentos de automação e desenvolvimento de sistemas.

 

Um Semicondutor?

Ele é um semicondutor, semelhante a um Transistor a imagem a seguir mostra de forma ilustrada como é o esquema interior do Sensor Hall A3144:

A3144_Hall-Effect-Sensor_Pin-Out_Symbol-Diagram

 

 

Você precisa apenas de:

  • Um Sensor Magnético A3144 (Sensor Hall)
  • Um Resistor de 10K (Para Pull UP)
  • Arduino Uno ou Equivalente
  • Protoboard
  • Jumpers

 

 

Ligações:

 

Na Imagem a seguir você pode ver a ligação do sensor junto ao resistor, onde o pino OUT é conectado ao A0 do arduino e simplesmente conectamos o arduino ao computador:

images

 

Código

Este Código está disponível também no site do Arduino (Arduino.cc), ele simplesmente mostra qual a polaridade do Imã o qual aproximado do sensor, para isso basta fazer Upload do código e abrir o monitor serial:

/*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 *    FILE: MM01
 *  AUTHOR: Rob van den Tillaart; modified Ralph Martin
 *    DATE: 2012 06 10 
 *     ORIGINAL URL: http://playground.arduino.cc/Code/HallEffect
 *
 * PURPOSE: use an A1301 or A1302 as magnetometer   
 *
 * Pin Layout LH Package
 * =====================
 *  1     VCC 5V
 *  2     signal    connected to Analog 0    
 *  3     GND
 *
 * Pin Layout UA Package
 * =====================
 *  1     VCC 5V
 *  2     GND
 *  3     signal    connected to Analog 0    
 *
 */
 
#define NOFIELD 505L    // Analog output with no applied field, calibrate this
 
// Uncomment one of the lines below according to device in use A1301 or A1302
// This is used to convert the analog voltage reading to milliGauss
#define TOMILLIGAUSS 1953L  // For A1301: 2.5mV = 1Gauss, and 1024 analog steps = 5V, so 1 step = 1953mG
// #define TOMILLIGAUSS 3756L  // For A1302: 1.3mV = 1Gauss, and 1024 analog steps = 5V, so 1 step = 3756mG
 
void setup() 
{
  Serial.begin(9600);
}
 
void DoMeasurement()
{
// measure magnetic field
  int raw = analogRead(0);   // Range : 0..1024
 
//  Uncomment this to get a raw reading for calibration of no-field point
//  Serial.print("Raw reading: ");
//  Serial.println(raw);
 
  long compensated = raw - NOFIELD;                 // adjust relative to no applied field 
  long gauss = compensated * TOMILLIGAUSS / 1000;   // adjust scale to Gauss
 
  Serial.print(gauss);
  Serial.print(" Gauss ");
 
  if (gauss > 0)     Serial.println("(South pole)");
  else if(gauss < 0) Serial.println("(North pole)");
  else               Serial.println();
}
 
void loop() 
{
    delay(1000);
    DoMeasurement();
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Gravador e reprodutor de voz ISD1820

02 FEV
2016

Author: Leonardo Dalla Porta

Módulo de Gravação de Voz ISD1820 tem como base o microcontrolador ISD1820, que um dispositivo de gravação de múltiplas mensagens e também de reprodução. Ele tem capacidade de reprodução para 8 a 20 segundos. A amostra é 3.2K e o total de 20s para o gravador. Este uso do módulo é muito fácil que você pode direcionar o controle por botão de pressão a bordo ou por microcontrolador, assim como o Arduino. 

Características do ISD1820

  • Interface com micro Switch’s
  • Modo power-down automático
  • On-chip controlador dos alto falantes de 8Ω
  • Alimentação 3V
  • Pode ser controlada tanto manualmente ou por MCU
  • Taxa de amostragem e a duração podem ser substituídos com um único resistor
  • Grava até 20 segundos de áudio
  • Dimensões: 37 x 54 mm

Se você quiser alterar a duração da gravação, uma resistência externa é necessária para selecionar a freqüência de amostragem e duração da gravação, que pode variar de 8 – 20 segundo (frequência de amostragem 4-12kHz). O Módulo de Gravação de Voz de nosso fornecer conexão padrão 100k resistor através de P2 por curto cap. Assim, a duração da gravação padrão é 10s.

  1. PLAYE – Reprodução. Quando uma transição Alto curso é detectado continua até que um marcador de fim de Mensagem (MOE) é encontrado ou o fim do espaço de memória é atingido.
  2. REC – A entrada REC é um registro ativo de alta signal. Os registros de dispositivo sempre que REC é alta. Este pino deve permanecer elevada durante o período de gravação. REC tem precedência sobre qualquer de reprodução (PLAYL ou PLAYE) sinal.
  3. Saídas de alto-falante – O SP + e SP- pinos fornecem acionamento direto para altifalantes com impedâncias tão baixo quanto 8Ω.
  4. MIC – entrada de microfone, a entrada de microfone transfere os seus sinais para o pré-amplificador on-chip.
  5. REPLAY – loop de tocar o disco.
  6. FT – Feed Through: Este modo permite o uso dos drivers de alto-falante para sinais externos.
  7. ISD1820 – chip IC
  8. Levar Fora IO – VCC LED NC FT GND / VCC REC PLAYÉ PLAYL GND
  9. P2 – padrão curto conexão ROSC para 100kΩ resistência, que é significa tempo de gravação é de 10s
  10. PLAYL – Reprodução, Nível-ativado, quando esta entrada trânsitos nível pin para baixo para cima, um ciclo de reprodução é iniciada.

 

Gravando:

  1. Pressione o botão REC, em seguida, o RECLED (D1) irá acender e manter o impulso até o final registro.
  2. Solte o botão REC
  3. Selecione o modo de reprodução:    PLAYE, só precisa apertar uma vez, e irá reproduzir todos os tipos de registro ou desligar;  PLAYL, você precisa sempre pressionar este botão até que você quer parar de registro de reprodução ou final; REPEAT, mude 5 para o lado direito, e o registro será reproduzido tempo um tempo até que o interruptor de luz ou desligar
  4. FT modo, quando você alternar 6 para o lado direito, isso significa que todos vocês falar com MIC vai dirigir a reprodução do Speaker.

Testes

Veremos como criar um alarme utilizando um sensor PIR e o Módulo de gravação de voz, utilizando um arduino, com pouquíssimos Jumpers podemos colocar isso em prática!

 

 

 

 O Código:

O código é muito simples, os pinos você pode ver no cabeçalho do código, após isso faça upload, e divirta-se!

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*********************************************************************
**  Device: ISD1820                                                 **
**  File:   EF_Alert.c                                              **
**                    **
**  Created by ElecFreaks Robi.W /14 Nov 2011                       **
**                                                                  **
**  Description:                                                    **
**  This file is alert demo code base on PIR sensor and ISD1820     **
**  Voice record module, just a sample code for your reference.     **
**                                                                  **
**  Copyright (C) 2011 ElecFreaks Corp.                           **
**  http://www.elecfreaks.com                                       **
*********************************************************************/
 
#define SOUT   12
#define REC    8
#define PLAYE  9
#define PLAYL  10
 
void setup(){
  pinMode(SOUT, INPUT);
  Serial.begin(9600);
}
 
void loop(){
  int ret = digitalRead(SOUT);
  if(ret == 1)
  {
    Serial.println("--------------> PIR");
    digitalWrite(PLAYE, 1);
    delay(5000);
    digitalWrite(PLAYE, 0);
  }
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Easy Driver no Arduino Motor de Passo

01 FEV
2016

Author: Leonardo Dalla Porta

Se você está afim de montar uma impressora 3D ou uma Fresa CNC ou ainda, controlar simplesmente um motor de Passo utilizando arduino, o Easy Driver está sendo a melhor opção do mercado, pois tem seu custo bem baixo, e uma utilidade infinta. A placa conta com um Circuito integrado fabricado pela Allegro MicroSystems, conta com material de ótima qualidade e muito pratico de utilizar.

Precisaremos de:

  • Easy Driver
  • Protoboard
  • Arduino
  • Motor de passo (4 Fios)
  • Jumpers
  • Fonte 12V 2A (Depende da tensão do motor)

 

Aos testes:

Nesse tutorial mostraremos como conectar este maravilhoso módulo Easy Driver no arduino, apenas utilizando 2 fios, um para o lado direito, outra para o lado esquerdo, onde para ele girar precisa-se pulsar no pino para a direção esperada, no esquema a seguir mostramos as ligações do arduino ao Easy Driver, lembramos que deve ser utilizado uma fonte de corrente maior que 2a, pois o motor consome bastante energia, nunca plugue diretamente a placa arduino, ela poderá ser danificada devido a corrente de operação do motor.

Squemtatics

 

O Código

Neste código giramos o motor 3600 passos para a direita, e para meio segundo e volta a girar 3600 passos para a esquerda, note que o código é muito simples, e a velocidade depende do 1 ms predefinido, caso queira mais devagar basta aumentar o tempo entre pulsos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
int Distance = 0;  // Record the number of steps we've taken
 
void setup() {                
  pinMode(8, OUTPUT);     
  pinMode(9, OUTPUT);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
}
 
void loop() {
  digitalWrite(9, HIGH);
  delayMicroseconds(100);          
  digitalWrite(9, LOW); 
  delayMicroseconds(100);
  Distance = Distance + 1;   // record this step
 
  // Check to see if we are at the end of our move
  if (Distance == 3600)
  {
    // We are! Reverse direction (invert DIR signal)
    if (digitalRead(8) == LOW)
    {
      digitalWrite(8, HIGH);
    }
    else
    {
      digitalWrite(8, LOW);
    }
    // Reset our distance back to zero since we're
    // starting a new move
    Distance = 0;
    // Now pause for half a second
    delay(500);
  }
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Módulo Wireless NRF24l01+

30 OUT
2015

Author: Leonardo Dalla Porta

Para quem trabalha com domótica já deve ter utilizado os módulos Xbee para comunicação com outros módulos espalhados pela casa. Mas podemos perceber que ele é pouco conhecido devido seu alto custo, dependendo da aplicação, seu custo fica inviável, mas como sempre temos uma alternativa secundaria. O Módulo Wireless NRF24L01+ é um grande substitudo ao Xbee, seu fabricante, no caso a “Nordic” chip utilizou ótimos materiais com um custo muito mais reduzido para a criação do chip, vejamos agora um pouco mais sobre este módulo.

 

Pequeno, mas ENORME!

 

Com seu tamanho reduzido podemos estar aplicando em diversas áreas, seu fabricante, a NORDIC tem como meta desenvolver sistemas wireless econômicos. Muitos Makers já criaram inúmeros tipos de projetos utilizando estes módulos,

 

 

Ligando os NRF24l01+ no seu Arduino

Para você conectar este módulo ao seu Arduino, basta seguir a tabela a seguir:

nRF24L01 + Pro Micro nRF24L01 + Pro Micro
VCC 3.3v GND GND
CSN 10 CE 9
MOSI 16 SCK 15
IRQ Não conectado MISO 14

Exemplo de Transmissão e Recepção

O exemplo de código todo mundo aponta para a sua primeira conexão (o esboço ping-par) não é exatamente projetado para facilitar a leitura, mas faz um trabalho digno de obter uma conexão testado com algum feedback. Várias pessoas têm expandido o teste par de ping para deixá-lo rapidamente se transformar em um modo de transmissão e outro em modo de recepção, e há todos os tipos de exemplos de desenhos alternativos.

Neste link você encontra o exemplo de transmissão simples / receber exemplo esboço. Basicamente, que transmite um pacote de 32 byte de dados com um valor único, em seguida, o receptor envia de volta.

 

Dicas

Quando começar com o nRF24L01+, tente não ficar sobrecarregado com a enorme quantidade de posts nos fórums e blogs devido as versões das bibliotecas. Antes de ligar qualquer coisa, certifique-se que você tem uma boa fonte de 3.3v. Use um direito capacitor 10uF antes do NRF24L01+. Evite jumpers. Caso precise, instale as seguintes bibliotecas para perfeito funcionamento de seu código: bibliotecas SPI e rf24.

 

Solução de problemas avançado

Problema: córregos receptor ‘pacote recebido “mensagens erroneamente

Isso normalmente aconteceu quando as linhas MOSI / MISO foram trocadas. Verifique se você tê-lo prendido acima corretamente.

Problema: cada extremidade mostra o endereço 0x00000000

Normalmente, quando isso acontece, foi porque a fonte de energia estava sendo mal conectadas ou os jumpers estavam perdendo sua conexão. Como você se move coisas ao redor, certifique-se seus fios estão bem apertados na placa de ensaio também.

Problema: rádios que perdem seus endereços

Soldar as linhas de comunicação realmente ajuda.

Também pode-se utilizar a seguinte linha:

void loop () 
{
  radio.printDetails ();
  delay(1000);
}

Sua saída deve ser algo parecido com isto:

STATUS = 0x0e RX_DR = 0 = 0 MAX_RT TX_DS = 0 = 7 TX_FULL RX_P_NO = 0
RX_ADDR_P0-1 = 0xc2c2c2c2c2 0xe7e7e7e7e7
RX_ADDR_P2-5 = 0xC3 0xC4 0xC6 0xc5
TX_ADDR = 0xc2c2c2c2c2
RX_PW_P0-6 = 0x20 0x20 0x00 0x00 0x00 0x00
EN_AA = 0x00
EN_RXADDR = 0x03
RF_CH = 0x4C
RF_SETUP = 0x07
CONFIG = 0x0f
DYNPD / 0x00 0x00 feature =
Data Rate = 1Mbps
Modelo = nRF24L01 +
CRC Comprimento = 16 bits
PA de potência = PA_HIGH

Depois de conseguir um exemplo de trabalho uma vez, tudo muda. Você vai começar a mover-se em torno de seus pinos CE / CSN, você vai experimentar com diferentes tipos de Arduinos, e você vai descobrir rapidamente que você precisa para projetar seu próprio protocolo para que você possa se mover em torno de diferentes tipos de dados a partir de diferentes unidades.

 

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de chama infravermelho no Arduino

15 OUT
2015

Author: Leonardo Dalla Porta

 

Neste tutorial você vai ver como funciona, e como utilizar o sensor de chama utilizando um Arduino, dessa forma você poderá detectar chamas e acionar alarmes de incêndio entre outros.

Materiais necessários:

  • Sensor de Chama (modelo com uma saída analógica)
  • Jumpers
  • Um Arduino
  • Isqueiro ou outra fonte de chama para o teste.

Conhecendo o seu sensor de chama:

Imagem de Conhecer o seu sensor de chama:

Uso:
Estes tipos de sensores são usados ​​para a detecção de curto alcance fogo e pode ser usado para monitorar projetos ou como uma precaução de segurança para cortar dispositivos on / off.

Alcance:

Aproximadamente uns 3 metros

Como funciona:

O sensor de chama é muito sensível ao comprimento de onda IR a 760 nm ~ 1100 nm de luz.

Saída analógica (A0): sinal de tensão de saída em tempo real sobre a resistência térmica.

A saída digital (D0): Quando a temperatura atinge um determinado limiar, a saída elevada e baixo sinal de limiar ajustável através do potenciómetro.

Pinos:

VCC …… entrada positiva de tensão: 3.3v 5v para analógico para digital.

Saída analógica A0 ……….

D0 ……… saída Digital

GND terra …..

Dimensões:

1,18 em x 0,59 em x 0,20 na (3,0 cm x 1,5 cm x 0,5 cm)

Peso:

0,28 oz (8 g)

Teste e solução de problemas:

Imagem de Teste e solução de problemas:

Teste:
Para testar o sensor de chama e garantir que ele está funcionando corretamente ligar o VCC de uma fonte de alimentação 5v e GND. Mover uma fonte de chama com um pé da frente do sensor IR e o LED deve acender.

Solução de problemas:

Se o LED não se acender, verifique o seguinte:

  • É a fonte de alimentação 5v?
  • É a terra ligado?
  • É a chama com um em pé e na linha de visão?

Se nenhuma das opções anteriores faz com que a luz LED D0-up, o sensor pode estar com defeito.

Fiação para o Arduino:

Para conectar o sensor de chama para o Arduino basta conectar o seguinte, como mostrado:

Sensor de chama …………… Arduino

VCC …………………………. 5v

GND GND ………………………….

A0 ……………………………. Analog em 0

Código

Os seguintes mapas de código e lê os valores analógicos dadas pelo sensor de chama (0-1024). O sensor da chama terá a seguinte reação com este código:

  • Se segurando uma chama dentro de 1,5 metros na frente do sensor; “caso 0” será ativada e “** ** Fim Fogo” será enviado para o monitor serial.
  • Se segurando uma chama entre 1,5 pés e 3 metros em frente do sensor; “Caso 1” será ativada e “** ** Fogo Distante” será enviado para o monitor serial.
  • Se for detectada nenhuma chama em frente do sensor; “case 2” será ativada e “No Fire” será enviado para o monitor serial.

* Para visualizar a saída, apontar um monitor serial como Putty em seu Arduino.

* Este código é actualizar constantemente a fim de proporcionar um feedback do sensor de chama em tempo real.

Código: Download aqui

Pan Tilt com arduino

15 OUT
2015

Author: Leonardo Dalla Porta

Neste tutorial você vai ver como funciona o Pan Tilt, e como controla-lo com o Arduino de forma simples e pratica. Este Pan Tilt utiliza somente dois servomotores, um para o eixo X, e outro para o eixo Y, estaremos controlando isso com um Joystick, que também pode ser encontrado em nossa loja!

Você vai precisar de:

  • 1 Kit Pan Tilt
  • 1 Arduino
  • 1 Joystick
  • Jumpers
  • Protoboard

Ligações

Os servo motores são conectados aos pinos 9, e 10 respectivamente x, e Y, o Joystick vai ligado conforme a figura a seguir:

2

 

Código

Abaixo está o código para o Arduino, após ter feito o Upload, basta se divertir brincando com seu novo Pan Tilt, após ter funcionado, você pode estar incrementando este projeto com diversos outros itens, até mesmo controlando por wifi, pois a criatividade é sua, e o desafio foi lançado!

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include 
 
Servo myservo0;  // create servo object to control a servo
Servo myservo1;
 
int potpin0 = 0;  // analog pin used to connect the potentiometer
int potpin1 = 1;
int val;    // variable to read the value from the analog pin
 
void setup()
{
  myservo0.attach(9);   // attaches servo to pin 9
  myservo1.attach(10);  // attaches the servo on pin 10 to the servo object
}
 
void loop()
{
  val = analogRead(potpin0);            // reads the value of the potentiometer (value between 0 and 1023)
  val = map(val, 0, 1023, 0, 179);     // scale it to use it with the servo (value between 0 and 180)
  myservo0.write(val);                  // sets the servo position according to the scaled value
  delay(25);                           // waits for the servo to get there
  val = analogRead(potpin1);            // bananas are high in potassium
  val = map(val, 0, 1023, 0, 179);     //
  myservo1.write(val);                  //
  delay(25);                           //
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Acelerômetro Gy-521 no arduino

14 OUT
2015

Author: Leonardo Dalla Porta

Eu vou mostrar para você hoje como podemos usar o acelerômetro GY-521 com o Arduino mega 2560 para obter as leituras do sensor.

 

Você vai precisar de:

  • Arduino
  • Acelerômetro GY-521
  • Jumpers
  • Protoboard

 

 

O sensor acelerômetro GY-521 contém um acelerômetro MEMS e um giroscópio MEMS em um único chip. Ele é muito preciso, pois ele contém 16-bits analógico para hardware conversão digital para cada canal. Pelo que capta a x, y, e z de canal ao mesmo tempo.

– Chip: MPU-6050
– Fonte de alimentação: 3.5V (Mas como há um regulador de tensão na placa, você pode usar 5V diretamente)
– Modo de comunicação: protocolo de comunicação padrão IIC, I2C.
– Chip conversor embutido 16bit AD, os dados 16bit saída
– giroscópios variam: +/- 250 500 1000 2000 graus / seg
– gama de Aceleração: +/- 2g, 4g +/-, +/- 8 g, +/- 16g

 

Conexões

  • GY-521 Arduino mega
  • VCC 3,3V ou 5V
  • GND GND
  • SCL Pin0 21 (SCL) Pino Arduino Uno: A5
  • SDA Pin0 20 (SDA) Pino Arduino Uno: A4
  • INT Pin 2 (Interrupção 0)5

Agora para o programa. Como temos uma grande quantidade de recursos sobre o uso do Arduino, vamos tentar o código a partir deles.

Primeiro vamos tentar descobrir se nosso dispositivo está conectado com o Arduino. Para isso, pode utilizar o código Scanner I2C por “Krodal” para descobrir os dispositivos conectados I2C para Arduino.

Compilar o código e enviá-lo para Arduino. Abra o monitor serial e fazer upload para o Arduino.

Download

Ele vai encontrar o seu GY-521 no endereço 0x68 ou 0x69. Se ele não encontrar o IMU nesse local, pode haver um problema com sua fiação. Por favor, verifique novamente.

Agora, podemos utilizar o seguinte código de Krodal para obter os resultados brutos do sensor. O esboço de Krodal podem ser encontradas aqui. Por favor, vá até o final da página e você vai ser capaz de encontrar o código. Também eu estarei postando aqui.

Download

A saída deve ser semelhante a essa:

8

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Sensor de temperatura e umidade DHT11 no arduino

13 OUT
2015

Author: Leonardo Dalla Porta

O DHT11 é um ótimo sensor pois é calibrado em laboratório, sua medição é precisa e estável e a sua saída de sinal é digital. O mais importante de tudo, é relativamente barato para o desempenho dado. Ele é um sensor pequeno e não necessita de muitos componentes para funcionar perfeitamente.

 

Pinos

 

 Pino Nome Descrição
 1  VDD  Fonte de alimentação 3-5,5 V DC
 2  DADOS  Saída de dados seriais
 3  NC  Não conectado
 4  GND  Chão

Ligações

Conecte o sensor ao seu Arduino assim como descrevemos abaixo:

 DHT11  Arduino
 Pin 1  Vcc
 Pin 2  Analog0
 Pin 4  Gnd


Instalar a biblioteca DHT11:

Baixe este arquivo e descompacte no diretório de bibliotecas da pasta Arduino IDE. Após isso, navegue até os exemplos e procure pelos exemplos do DHT11. Feito isso, basta clicar em Upload.

    

                                                                  

  Saída no monitor Serial

No monitor serial teremos algo como:

Módulo Relés duplo para Arduino

13 OUT
2015

Author: Leonardo Dalla Porta

O módulo de relés para Arduino permite uma ampla gama de microcontrolador Arduino, como, AVR, PIC, ARM com saídas digitais para controlar cargas maiores e dispositivos como AC ou DC Motores, eletroímãs, solenoides e lâmpadas incandescentes. Este módulo foi projetado para ser integrado com 2 relés. Este módulo é isolado por optoacopladores

Características

  • Número de Relés: 2
  • Sinal de controle: nível TTL
  • Carga nominal: 7A / 240V 10A / 125VAC 10A / 28VDC
  • Contato tempo de ação: 10ms / 5ms

Pinos

Relé 2 pin.jpg

  • Pin comum COM-
  • NC- Normalmente fechado, caso em que NC está conectado com COM quando INT1 foi definido como baixo e desconectado quando INT1 é elevada;
  • NO- Normalmente Aberta, neste caso, não é desconectada com COM1 quando INT1 foi definido como baixo e conectado quando INT1 é alta.

O terminal 2 é semelhante ao terminal 1, excepto que a porta de controlo é INT2

  • INT 1- Relé porta 1 controle
  • INT 2- Relé porta 2 controle

Ligações

Relaywring.jpg

O Código

1
2
3
4
5
6
7
8
9
10
11
12
int Relay = 12; 
void setup() 
{ 
 pinMode(Relay, OUTPUT);     //Set Pin12 as output 
} 
void loop() 
{ 
         digitalWrite(Relay, HIGH);   //Turn off relay 
         delay(2000); 
         digitalWrite(Relay, LOW);    //Turn on relay 
         delay(2000); 
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Sensor de Umidade do solo

12 OUT
2015

Author: Leonardo Dalla Porta

Neste tutorial vamos mostrar-lhe como conectar a um Arduino Nano e um sensor de umidade. A informação será exibida com 5 LEDs, conforme for a umidade da terra no sensor, mais leds serão acendidos, caso contrario, eles apagarão.

 

Você vai precisar de:

  • 1 – Protoboard
  • 5 – LEDs
  • 5 – Resistores 1k 
  • Sensor de umidade do solo
  • Arduino
  • Jumpers

Conexões

A0 – Vai conectado ao sensor de umidade do solo
D2: D6 – LEDS 1,2,3,4,5

LED1 – Verde
LED2 – Verde
LED3 – Verde
LED4 – Amarelo
LED5 – Vermelho

Após todos os fios conectados, vamos ao nosso código, ele é muito simples, apenas comparamos valores de condições com o valor lido do sensor e acendemos leds, você pode incrementar este código com diversas outras tarefas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
int LED1 = 2;
LED2 int = 3;
LED3 int = 4;
int LED4 = 5;
int LED5 = 6;
 
int mostureSensor = 0;
 
void setup () {
// Serial Comece para que possamos ver os dados do sensor mosture na nossa janela de entrada serial.
Serial.begin (9600);
// Definindo os pinos conduzidos às saídas
pinMode (LED1, OUTPUT);
pinMode (LED2, OUTPUT);
pinMode (LED3, OUTPUT);
pinMode (LED4, OUTPUT);
pinMode (LED5, OUTPUT);
}
 
// A rotina de loop é executado uma e outra vez para sempre:
void loop () {
// Ler a entrada no pino analógico 0:
int SensorValue = analogRead (mostureSensor);
// Imprimir o valor que você lê:
 
Serial.println (SensorValue);
 
if (SensorValue> = 820)
{
digitalWrite (LED1, HIGH);
digitalWrite (LED2, HIGH);
digitalWrite (LED3, HIGH);
digitalWrite (LED4, HIGH);
digitalWrite (LED5, LOW);
}
else if (SensorValue> = 615 && SensorValue <820) { digitalWrite (LED1, HIGH); digitalWrite (LED2, HIGH); digitalWrite (LED3, HIGH); digitalWrite (LED4, LOW); digitalWrite (LED5, LOW); } else if (SensorValue> = 410 && SensorValue <615) { digitalWrite (LED1, HIGH); digitalWrite (LED2, HIGH); digitalWrite (LED3, LOW); digitalWrite (LED4, LOW); digitalWrite (LED5, LOW); } else if (SensorValue> = 250 && SensorValue <410) { digitalWrite (LED1, HIGH); digitalWrite (LED2, LOW); digitalWrite (LED3, LOW); digitalWrite (LED4, LOW); digitalWrite (LED5, LOW); } else if (SensorValue> = 0 && SensorValue <250)
{
digitalWrite (LED1, LOW);
digitalWrite (LED2, LOW);
digitalWrite (LED3, LOW);
digitalWrite (LED4, LOW);
digitalWrite (LED5, LOW);
}
atraso (1000); // Atraso de 1 segundo entre lê
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

 

 

Sensor Magnetômetro, Bússola Hmc5883l

10 OUT
2015

Author: Leonardo Dalla Porta

O sensor Magnetômetro HMC5883l é um dispositivo de alta sensibilidade e baixa eixo transversal é projetado para medir tanto a direção e a magnitude dos campos magnéticos da Terra, a partir de mili-gauss a 8 Gauss.

Como é que um magnetômetro? Como funciona?

Um magnetômetro eletrônico como o  HMC5883L  baseia-se na anisotrópica no fenômeno da Magnetorresistência.
Basicamente, a um campo magnético interage com o caminho da corrente que flui através de um material ferroso, de acordo com a Lei de  Lorentz, consequentemente, a resistência do material parece mudar para o observador. Você pode imaginar como se o bar de material ferroso (por exemplo InSb) cresce mais tempo, aumentando a sua resistência elétrica. Portanto, medindo a alteração na resistência pode-se estimar o campo magnética! A equação que governa o fenômeno é na imagem abaixo. Para uma investigação mais aprofundada da questão, especialmente na eletrônica um magnetômetro baseia-se:

Em uma bússola, o campo magnético se mede é a sua terra. É tangente à superfície do planeta e flui de norte a sul. O  HMC5883L  tem três eixos diferentes para calcular as posições, como você pode não saber a inclinação do dispositivo quando você precisar os dados! De qualquer forma para este exemplo, vamos supor que o sensor é plana sobre uma mesa, por isso não precisa se ​​preocupar com a sua inclinação. Portanto, vamos usar apenas eixos X e Y dados.

Vamos assumir Hz = 0

Após entender esta parte, neste link você pode fazer download da biblioteca para o sensor, as ligações são muito simples, pois este sensor é I2C, o que facilita muito na hora de por em pratica, além de ser possível utilizar mais dispositivos ligados juntos, em apenas duas portas de comunicação.

E aqui o Código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
/*
HMC5883L_Example.ino - Example sketch for integration with an HMC5883L triple axis magnetometer.
 Copyright (C) 2013 BluLemonLabs (bluelemonlabs.blogspot.com)
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the version 3 GNU General Public License as
 published by the Free Software Foundation.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 */
 
// Reference the I2C Library
#include <Wire.h>
// Reference the HMC5883L Compass Library
#include <HMC5883L.h>
 
// Store our compass as an object.
HMC5883L compass;
 
// Record any errors that may occur in the compass.
int error = 0;
 
// Out setup routine, here we will configure the microcontroller and compass.
void setup()
{
  // Initialize the serial port.
  Serial.begin(9600);
 
  Serial.println("Starting the I2C interface.");
  Wire.begin(); // Start the I2C interface.
 
  Serial.println("Constructing new HMC5883L");
  compass = HMC5883L(); // Construct a new HMC5883 compass.
  //The implementation of the class is provided in the library
 
  // Now we have an istance of the class!
  //Let's initializate it...
 
  Serial.println("Setting scale to +/- 1.3 Ga");
  error = compass.SetScale(1.3); // Set the scale of the compass to 1.3Ga
  if(error != 0){ // If there is an error, print it out. 
    Serial.println(compass.GetErrorText(error));
    error =0;
  }
 
  Serial.println("Setting measurement mode to continous.");
  error = compass.SetMeasurementMode(Measurement_Continuous); // Set the measurement mode to Continuous
  if(error != 0) {// If there is an error, print it out.
    Serial.println(compass.GetErrorText(error)); //Todo: Error handling for this method in .h and .cpp
    error=0;
  }
}
 
// Our main program loop. 
void loop()
{
  // Retrieve the raw values from the magnetometer (not scaled).
  MagnetometerRaw raw = compass.ReadRawAxis();
  // Retrieve the scaled values from the magnetometer (scaled to the configured scale).
  MagnetometerScaled scaled = compass.ReadScaledAxis();
 
  // Values are accessed like so:
  int MilliGauss_OnThe_XAxis = scaled.XAxis;// (or YAxis, or ZAxis)
 
  // Calculate heading when the magnetometer is level, then correct for signs of axis.
  // Atan2() automatically check the correct formula taking care of the quadrant you are in
  float heading = atan2(scaled.YAxis, scaled.XAxis);
 
  // Once you have your heading, you must then add your 'Declination Angle',
  // which is the 'Error' of the magnetic field in your location. Mine is 0.0404 
  // Find yours here: http://www.magnetic-declination.com/
 
  // If you cannot find your Declination, comment out these two lines, your compass will be slightly off.
  float declinationAngle = 0.0404;
  heading += declinationAngle;
 
  // Correct for when signs are reversed.
  if(heading < 0)
    heading += 2*PI;
 
  // Check for wrap due to addition of declination.
  if(heading > 2*PI)
    heading -= 2*PI;
 
  // Convert radians to degrees for readability.
  float headingDegrees = heading * 180/M_PI; 
 
  // Output the data via the serial port.
  Output(raw, scaled, heading, headingDegrees);
 
  // By default the HMC5883L reads the data 15 time per second (15Hz)
  // However since we have a long serial out (104ms at 9600) we will let
  // it run at its natural speed.
  // delay(66);
}
 
// Output the data down the serial port.
void Output(MagnetometerRaw raw, MagnetometerScaled scaled, float heading, float headingDegrees)
{
  Serial.print("Raw:\t");
  Serial.print(raw.XAxis);
  Serial.print("   ");   
  Serial.print(raw.YAxis);
  Serial.print("   ");   
  Serial.print(raw.ZAxis);
  Serial.print("   \tScaled:\t");
 
  Serial.print(scaled.XAxis);
  Serial.print("   ");   
  Serial.print(scaled.YAxis);
  Serial.print("   ");   
  Serial.print(scaled.ZAxis);
 
  Serial.print("   \tHeading:\t");
  Serial.print(heading);
  Serial.print(" Radians   \t");
  Serial.print(headingDegrees);
  Serial.println(" Degrees   \t");
}
Na imagem abaixo você pode ver como o título medido com um iPhone 4 é bastante próximo ao que temos lido do Arduino. Existem muitos margem de melhoria.  Além disso, esta protoboard tem um plano de terra de alumínio na sua parte inferior, o que, obviamente, pode tornar mais difícil para a estrutura para detectar o campo magnético e / ou pode derivar-lo e criar um deslocamento.

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Módulo RF 433 MHz com Arduino

09 OUT
2015

Author: Leonardo Dalla Porta

Módulo RF 433 MHz com Arduino

Se você está procurando uma maneira de se comunicar entre Arduinos, mas não tem muito dinheiro à sua disposição, então não procure mais. Estes módulos de RF não são apenas acessíveis, mas fácil de usar.Eles são muito mais fáceis de configurar do que um XBee, mais você pode usá-los sem a necessidade de um protetor especial. Antes de você sair correndo e comprar uma tonelada destes módulos, certifique-se que você não está quebrando todas as leis de transmissão de rádio no seu país. Faça sua pesquisa, e comprá-los somente se você está autorizado a usá-los em sua área. Há algumas bibliotecas que podem ser usados ​​para ajudar você e seu projeto particular:

RF Blink

Em primeiro lugar, precisamos testar se os módulos de RF estão funcionando. Então, vamos projetar uma transmissão muito simples para testar a sua funcionalidade. Nós vamos usar o led do Arduino de para mostrar quando o transmissor está transmitindo, e quando o outro Arduino está recebendo. Haverá um pequeno atraso entre os dois Arduinos. Você pode soldar uma antena para estes módulos, no entanto, nós não fizemos isso, eu só manteve os módulos fechar juntos (1-2 cm de intervalo). Enquanto estiver usando 5V para VCC no receptor, gostaria de obter um monte de interferência, porém com 3V, eu quase não tivemos qualquer ruído. Se você achar que você está obtendo resultados imprevisíveis, eu sugiro que você mudar para 3V no receptor e mover os módulos de transmissor e receptor ao lado uns dos outros.

Você vai precisar de:

    • 2 x placas Arduino UNO ou compatíveis
    • Placa de ensaio
    • Fios
    • Módulo de RF (433 Mhz) – Transmissor e receptor par ou a versão de 315 MHz

O transmissor e o receptor no Fritzing:

O Transmissor

Dados para a transmissão dos dados entre eles:

E este é o esboço Arduino para realizar a transmissão de dados.

Transmissor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/ *  
 RF Blink - Transmitir esboço  
     Escrito por ScottC 17 junho de 2014 
     Arduino IDE versão 1.0.5 
     Website: http://arduinobasics.blogspot.com 
     Transmissor: FS1000A / XY-FST 
     Descrição:. Um esboço simples usado para testar a transmissão RF           
 - -------------------------------------------------- --------- * /

 #define rfTransmitPin 4   // Transmissor RF pin = digitais pino 4 
 #define ledPin 13         // Onboard LED = pino digital 13

 vazio de configuração ()
   {pinMode (rfTransmitPin, OUTPUT);     
    pinMode (ledPin, OUTPUT);    
 }

 vazio de loop ()
   {para (int i = 4000; i> 5; i = i- (i / 3))
     {digitalWrite (rfTransmitPin, ALTA);      // transmitir um sinal ALTA digitalWrite (ledPin, ALTA);             // Ligue o LED em atraso (2000);                            // Aguarde um segundo
     
     
     
     digitalWrite (rfTransmitPin, LOW);       // transmitir um sinal LOW digitalWrite (ledPin, LOW);             // Ligue o LED off atraso (i);                             // atraso variável
     
     
   }
 }

O receptor

Se tudo correr como planejado, a bordo LED nesta Arduino deve acender (e sair), ao mesmo tempo que o onboard LED no Arduino transmissão. Há uma chance de que o receptor pode pegar sinais dispersos de outros aparelhos de transmissão usando essa freqüência específica. Assim, você pode precisar de brincar com o valor limite para eliminar o “ruído”. Mas não torná-lo muito grande, ou você vai eliminar o sinal nesta experiência. Você também vai notar um pequeno atraso entre os dois Arduinos.

Receptor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/ *  
  RF Blink - Receptor esboço  
     Escrito por ScottC 17 junho de 2014 
     Arduino IDE versão 1.0.5 
     Website: http://arduinobasics.blogspot.com 
     Receiver: XY-MK-5V 
     Descrição: Um esboço simples usado para testar a transmissão RF / receptor.           
 -------------------------------------------------- ----------- * /

 #define rfReceivePin A0   // RF Receiver pin = Analog pin 0 
 #define ledPin 13         // Onboard LED = pino digital 13

 unsigned  int dados = 0;    // variável usada para armazenar os dados recebidos 
 const  unsigned  int upperThreshold = 70;   // valor limite superior 
 const  unsigned  int lowerThreshold = 50;   // menor valor limiar

 vazio de configuração ()
   {pinMode (ledPin, OUTPUT);
    Serial. começar (9600);
 }

 vazio de loop () {
   data = analogRead (rfReceivePin);     // ouvir de dados sobre Analog pin 0
   
    se (dados> upperThreshold)
     {digitalWrite (ledPin, LOW);    // Se um sinal LOW é recebido, por sua vez levou OFF Serial. println (dados);
     
   }
   
   se (dados <lowerThreshold)
     {digitalWrite (ledPin, ALTA);    // Se um sinal de alta é recebida, vire LED ON Serial. println (de dados);
     
   }
 }

Quando um sinal alto é transmitida para o outro Arduino. Ele irá produzir uma analogRead = 0.
Quando um sinal LOW é transmitido, que irá produzir um analogRead = 400.
Isso pode variar, dependendo do seu módulo e tensão utilizada.
Os sinais recebidos podem ser vistos usando o Monitor serial, e pode ser copiado em uma planilha para criar uma tabela como esta:

Você vai notar que o sinal HIGH (H) é constante, enquanto que o sinal LOW (L) está ficando menor a cada ciclo. Não estou certo por que o sinal ALTA produz uma leitura analógica de “0”. Eu teria pensado que teria sido o contrário. Mas você pode ver a partir dos resultados que um sinal de alta produz um 0 resultado e um sinal de baixa produz um valor de 400 (aproximadamente).

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Ponte H L298 2 Canais no arduino

09 OUT
2015

Author: Leonardo Dalla Porta

Veja neste tutorial como utilizar a Ponte H L298 Módulo duplo  no arduino com grande facilidade, de forma muito simples, pois este módulo foi desenvolvido para facilitar a vida dos Makers de plantão, para poder controlar motores seja escovado, ou motor de passo

 

Materiais necessários:

  • Ponte H L298 Módulo duplo
  • Jumpers
  • Um Arduino
  • Uma fonte de alimentação DC, 7-35v
  • Um motor que é a voltagem correta para sua fonte de alimentação usada.

O módulo e seus conectores:

Imagem de Conhecer o seu módulo L298N duplo H-Bridge Motor Controlador:

Uso:

H-Ponte do são normalmente utilizados no controle de motores velocidade e direção, mas pode ser usado para outros projetos, tais como dirigir o brilho de certos projetos de iluminação, como grandes matrizes LED.

Como funciona:

Uma H-Ponte é um circuito que pode conduzir uma corrente em qualquer polaridade e ser controlada por * Pulse Width Modulation (PWM).

* Largura de Pulso de Modulação é um meio de controlar a duração de um pulso eletrônico. Nos motores tente imaginar o pincel como uma roda de água e elétrons como uma das gotículas de fluxo de água. A tensão seria a água que flui através da roda a uma velocidade constante, tanto mais quanto maior for o fluxo de água de tensão. Os motores são classificados em certas tensões e pode ser danificado se a voltagem é aplicada a fortemente ou se cair rapidamente para reduzir a velocidade do motor para baixo. Assim PWM. Tome a analogia roda de água e pensar na água bater em pulsos, mas a um fluxo constante. Quanto mais tempo os impulsos, o mais rápido a roda vai sua vez, o menor dos impulsos, mais lenta é a roda de água vai virar. Motors vai durar muito mais tempo e ser mais fiável se controlada através de PWM.

Pinos:

  • Out 1: Saida motor 1
  • Out 2: Saida motor 1
  • Out 3: Saída Motor 2
  • Out 4: Saída Motor 2
  • GND: Terra
  • 5v: entrada 5v (desnecessário se sua fonte de alimentação é 7V-35V, se a fonte de alimentação está 7V-35V, então ele pode atuar como um 5v out)
  • EnA: Ativa sinal PWM para motor A
  • In1: Ativar Motor A
  • In2: Ativar Motor A
  • In3: Ativar Motor B
  • In4: Ativar Motor B
  • ENB: permite que o sinal PWM para Motor B

Especificações:

  • Duplo ponte H Unidade Chip: L298N
  • Tensão lógica: tensão 5V Drive: 5V-35V
  • Lógico atual: corrente 0-36mA Drive: 2A (MAX única ponte)
  • Potência máxima: 25W
  • Dimensões: 43 x 43 x 26 milímetros
  • Peso: 26 g

* Built-in fonte de alimentação 5v, quando a tensão de condução é 7V-35V

Conexões

Imagem de Fiação para um Arduino:

Duas coisas a mencionar;

  • Certifique-se de ter todos os seus motivos amarrados; Arduino, fonte de alimentação, eo controlador do motor.
  • Os pinos PWM são desnecessárias, se você não quer controlar os recursos PWM.

 

Considerações

O código do arduino é muito simples. Uma vez que não é uma biblioteca para o L298N duplo H-Bridge Motor Controlador você só tem que declarar que o controlador é ligado aonde.

O “int dir (número) Pin (letra)” ‘pinos pode ser conectado a qualquer pino digital disponível que você tem disponível, desde que você declare o pino correto em seu esboço. Isso faz com que o L298N duplo H-Bridge Motor Controlador muito versátil, se seu projeto está usando um monte de Arduino pinos.

O int “speedPin (letra)” pins precisa estar conectado a um pino PWM no Arduino, se você deseja ativar o controle de velocidade através de PWM.

Aqui mostramos quais são os pinos PWM disponíveis no Arduino Mega e Uno:

  • No Mega – PWM: 2 a 13 e 44 a 46. Fornecer saída PWM de 8 bits com a função analogWrite ().
  • UNO – PWM: 3, 5, 6, 9, 10, e 11. Fornecer saída PWM de 8 bits com a função analogWrite ().

 

Código Exemplo

Este exemplo de código que escrevi para permitir que um programa monitor serial como Putty para controlar a L298N duplo H-Bridge Motor controlador através de um teclado com teclas pressionadas. O arquivo contendo o código está disponível para download aqui.

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Display TFT colorido 2,4 polegadas

09 OUT
2015

Author: Leonardo Dalla Porta


Se você estiver procurando por uma interface gráfica barato para sua Arduino, você está no lugar correto! Nosso Display TFT colorido de 2,4 polegadas tem uma tela de quatro fios de toque resistivo, ainda um slot de micro cartão SD é um conveniente. Para ajudá-lo a ir nós fornecemos alguns códigos de exemplo, que pode ser baixado aqui, neste tutorial

 

Especificações

  • Tamanho da tela: 2,4 polegadas
  • Resolução: 240 x 320
  • Cor LCD: 65k
  • Motorista LCD: ST7781
  • Interface: 8080 bits de dados 8 bits de controle com 4
  • Touchscreen: 4 Fios touchscreen resistiva

Conexões Arduino

Com este shield você nao precisa se preocupar com esta tabela a seguir, porém se for fazer uma “engenharia reversa” aqui está a ligação dos pinos:

Arduino Pin LCD Protetor Pin Uso
3.3V 3.3V Power
5V 5V Power
GND GND Power
A0 LCD_RD Controle LCD
A1 LCD_WR TOUCH_YP Controle LCD / Dados Toque
A2 LCD_RS TOUCH_XM Controle LCD / Dados Toque
A3 LCD_CS Controle LCD
A4 LCD_RST Redefinir LCD
D2 LCD_D2 Dados LCD
D3 LCD_D3 Dados LCD
D4 LCD_D4 Dados LCD
D5 LCD_D5 Dados LCD
D6 LCD_D6 / TOQUE XP Dados LCD / Dados Toque
D7 LCD_D7 / TOQUE YM Dados LCD / Dados Toque
D8 LCD_D0 Dados LCD
D9 LCD_D1 Dados LCD
D10 SD_CS SD Select
D11 SD_DI Dados SD
D12 SD_DO Dados SD
D13 SD_SCK Relógio SD

Tome cuidado para alinhar os pinos corretamente, e assegurar a parte inferior do shield não faz contato com a porta USB Arduino.

Softwares

Examinando os exemplos devem dar uma boa ideia de como usá-los, no entanto, estão sempre dispostos a responder a perguntas relevantes. A biblioteca original foi escrito para funcionar com uma variedade de diferentes controladores e shields. Enquanto isso é conveniente para o uso de placas de forma intercambiável, decidimos tira-lo de volta para apenas o que era necessário para este shield e o controlador de ST7781, ao invés de ampliá-lo para incluir mais um escudo. Isso deve fazer o menor consumo de memória, e o código um pouco mais rápido. Para utilizar o código de demonstração, baixar a biblioteca aqui, e extrair. Copie a pasta “SWTFT-Shield” a partir do arquivo extraído para a pasta Bibliotecas arduino. Você também vai precisar instalar o:

 

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Módulo Sensor de Chuva no Arduino

25 SET
2015

Author: Leonardo Dalla Porta

Neste tutorial mostraremos como conectar um Módulo Sensor de Chuva ao Arduino de forma muito simples e intuitiva, a partir disso você pode estar desenvolvendo coisas inacreditáveis! A criatividade é sua, e vamos ao tutorial!

 

Materiais necessários:

  • Sensor de chuva (modelo com uma saída analógica)
  • Jumpers
  • Um Arduino
  • Água

 

Conexões

 

  • Saída analógica A0 ……….
  • D0 ……… saída Digital
  • GND terra …..
  • VCC …… tensão positiva (entrada: 3.3v 5v para analógico para digital.)

 

Sensor-Sonda

  • + ………. Sensor placa de conexão A
  • – ……….. Conexão bordo Sensor B
Imagem de Conhecer o seu sensor de chuva:

Funcionamento

Os sensores de chuva são usados ​​na detecção de água além do que um sensor de umidade pode detectar. O sensor de chuva detecta água que completa os circuitos impressos em ligações de seus quadros de sensores. A placa do sensor age como um resistor variável que vai mudar a partir de 100k ohms quando molhado para 2M ohms quando seca. Em suma, quanto mais molhado bordo do mais atual que será conduzida.

 

 

Código

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/* Flame Sensor analog example.
Code by Reichenstein7 (thejamerson.com)
 
For use with a Rain Sensor with an analog out!
 
To test view the output, point a serial monitor such as Putty at your Arduino. 
 
  - If the Sensor Board is completely soaked; "case 0" will be activated and " Flood " will be sent to the serial monitor.
  - If the Sensor Board has water droplets on it; "case 1" will be activated and " Rain Warning " will be sent to the serial monitor.
  - If the Sensor Board is dry; "case 2" will be activated and " Not Raining " will be sent to the serial monitor. 
 
*/
 
// lowest and highest sensor readings:
const int sensorMin = 0;     // sensor minimum
const int sensorMax = 1024;  // sensor maximum
 
void setup() {
  // initialize serial communication @ 9600 baud:
  Serial.begin(9600);  
}
void loop() {
  // read the sensor on analog A0:
	int sensorReading = analogRead(A0);
  // map the sensor range (four options):
  // ex: 'long int map(long int, long int, long int, long int, long int)'
	int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
 
  // range value:
  switch (range) {
 case 0:    // Sensor getting wet
    Serial.println("Flood");
    break;
 case 1:    // Sensor getting wet
    Serial.println("Rain Warning");
    break;
 case 2:    // Sensor dry - To shut this up delete the " Serial.println("Not Raining"); " below.
    Serial.println("Not Raining");
    break;
  }
  delay(1);  // delay between reads
}

 

 

 

A saída

Imagem de Arduino Esboço Exemplo:

Os seguintes mapas de código e lê os valores analógicos dadas pelo sensor de chuva (0-1024). O sensor de chuva terá a seguinte reação com este código:

  • Se o Sensor está completamente encharcado; “caso 0” será ativada e “Flood” será enviado para o monitor serial.
  • Se o Sensor tem gotas de água nela; “Caso 1” será ativada e “Rain Warning” será enviado para o monitor serial.
  • Se a placa do sensor está seco; “caso 2” será ativada e “não está chovendo” será enviado para o monitor serial.

* A saída em “caso 2”, “não está chovendo” é apenas para esta demonstração.Quando eu usei este código na produção omiti a saída para este caso e só tinha o alerta para “Aviso Rain” e “Flood”.

* Para visualizar a saída, apontar um monitor serial como Putty em seu Arduino.

Teste:

Para testar o sensor de chuva e garantir que ele está funcionando corretamente ligar o VCC a uma fonte de alimentação 5v e GND. Experimente colocar algumas gotas de água na placa de detecção do sensor de chuva e o LED deve acender.

 

Solução de problemas:

Se o LED não se acender, verifique o seguinte:

  • É o módulo ligado corretamente?
  • Às vezes, a salinidade é um problema com estas unidades, este funcionou bem com filtrada, garrafas de água, mas em alguns casos você pode ter que adicionar um pouco de sal para aumentar a condução águas.
  • Isso pode ser um pouco mais complicado, mas por algum motivo, dois modelos diferentes por dois fabricantes diferentes tiveram defeitos de suas habilidades de solda. Certifique-se de todo o pouco de SMD e conectores foram soldadas de forma adequada. IE – são realmente soldadas juntas de solda?
  • Se nenhuma das opções anteriores faz com que a luz LED ligue, o sensor pode estar com defeito.

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Luximetro com um GY-30 e um Arduino

25 SET
2015

Author: Leonardo Dalla Porta

Luximetro com um GY-30 e um Arduino

Neste circuito simples, nós usamos um pequeno sensor GY-30 e um Arduino para medir a iluminância em lux. Além da aplicação para medir a iluminação de objetos na fotografia, você pode – com uma extensão deste circuito, também facilmente fazer uma iluminação adaptada de quartos ou jardins. Também é possível realizar um controle automático de brilho para monitores, entre muitas outras aplicações.

Conexões

Nós conectamos o nosso Arduino – neste caso, um Arduino – com o (GY-30)  da seguinte forma:

Arduino
(Nano,  Uno, Mini Pro)
Arduino
(Mega,  mega 2560)
GY-30
5V oder 3.3V (VCC) 5V oder 3.3V (VCC) VCC
GND GND GND
A4 (SDA) D20 (SDA) SDA
A5 (SCL) D21 (SCL) SCL

 modulo-gy-30-medidor-de-iluminncia-bh1750fvi-p-arduino-923901-MLB20423186982_092015-O

O código

Como uma biblioteca adicional não é necessária, precisamos apenas fazer o upload do seguinte esboço para o nosso Arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include &lt;Wire.h&gt;
 
int BH1750_address = 0x23; // i2c Addresse
byte buff[2];
 
void setup(){
 
  Wire.begin();
  BH1750_Init(BH1750_address);
 
  delay(200);
  Serial.begin(9600);
  Serial.println("Starte Beleuchtungsstaerkemessung - blog.simtronyx.de");
}
 
void loop(){
 
  float valf=0;
 
  if(BH1750_Read(BH1750_address)==2){
 
    valf=((buff[0]&lt;&lt;8)|buff[1])/1.2;
 
    if(valf&lt;0)Serial.print("&gt; 65535");
    else Serial.print((int)valf,DEC); 
 
    Serial.println(" lx"); 
  }
  delay(1000);
}
 
void BH1750_Init(int address){
 
  Wire.beginTransmission(address);
  Wire.write(0x10); // 1 [lux] aufloesung
  Wire.endTransmission();
}
 
byte BH1750_Read(int address){
 
  byte i=0;
  Wire.beginTransmission(address);
  Wire.requestFrom(address, 2);
  while(Wire.available()){
    buff[i] = Wire.read(); 
    i++;
  }
  Wire.endTransmission();  
  return i;
}

Download do Código Fonte

e depois iniciar o monitor serial, o resultado deve ser semelhante a este:

Medição de iluminância com um BH1750FVI e um Arduino Uno - monitor-blog.simtronyx.de de série

Agora devemos ter uma saída semelhante como mostrado acima. Neste caso, o sensor foi deslocado no tempo ensolarado entre sombra (temporariamente coberto com a mão a uma curta distância) e luz solar direta. Pode ser visto que, em luz solar direta do intervalo de valores do sensor de for excedido muito rapidamente.

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Módulo Ethernet ENC28j60 no arduino

25 SET
2015

Author: Leonardo Dalla Porta

Já pensou em desenvolver um projeto, seja na área de automação por exemplo, onde você precisa um script para se comunicar com a internet, para poder usar em qualquer dispositivo seja em algum celular, ou até no PC, isso só é possível com o Shield Ethernet. Nesse tutorial estaremos mostrando como utilizar esse Módulo Ethernet ENC28j60, através de um Arduino e uma pagina de “hello world” na web, muito simples!

 

Você vai precisar de:

  • Arduino
  • Módulo Ethernet ENC28j60
  • Jumpers
  • Protoboard

 

Conexões:

Agora é hora de ligar o módulo. Você pode usar um conector para colocar no módulo Ethernet ou solde diretamente sobre os pinos. Você vai precisar de apenas seis jumpers. Liga se da seguinte forma:

Liga-se da seguinte forma (ENC > Arduino):

– ENC SO -> pino Arduino 12

– ENC SI -> pino Arduino 11

– ENC SCK -> Arduino pino 13

– ENC CS -> Arduino pino 8

– ENC VCC -> Arduino 3V3 pin

– ENC GND -> Arduino Gnd

 

ENC28J60

Se tudo estiver certo ao ligar o Arduino o módulo deverá acender alguns leds.

 

Código

O último passo é fazer upload de código Arduino para se conectar à Internet. Para o módulo ENC28J60, existem duas bibliotecas Arduino disponíveis: Ethershield (desenvolvimento parado) e EtherCard (o mais novo).Coloque um esboço e vamos ver o Arduino como um servidor web, Nesse caso, ao você conectar seu Módulo ENC28J60 na sua rede, e ao conectar na rede no seu navegador basta digitar o IP disponível no código como: “static byte myip[] = { 192,168,1,203 };”, antes de testar, veja se isso está disponível na sua rede:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// This is a demo of the RBBB running as webserver with the Ether Card
// 2010-05-28 &lt;jc@wippler.nl&gt; http://opensource.org/licenses/mit-license.php
 
#include &lt;EtherCard.h&gt;
 
// ethernet interface mac address, must be unique on the LAN
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
static byte myip[] = { 192,168,1,203 };
 
byte Ethernet::buffer[500];
BufferFiller bfill;
 
void setup () {
 if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)
 Serial.println( "Failed to access Ethernet controller");
 ether.staticSetup(myip);
}
 
static word homePage() {
 long t = millis() / 1000;
 word h = t / 3600;
 byte m = (t / 60) % 60;
 byte s = t % 60;
 bfill = ether.tcpOffset();
 bfill.emit_p(PSTR(
 "HTTP/1.0 200 OK\r\n"
 "Content-Type: text/html\r\n"
 "Pragma: no-cache\r\n"
 "\r\n"
 "&lt;meta http-equiv='refresh' content='1'/&gt;"
 "&lt;title&gt;RBBB server&lt;/title&gt;"
 "&lt;h1&gt;$D$D:$D$D:$D$D&lt;/h1&gt;"),
 h/10, h%10, m/10, m%10, s/10, s%10);
 return bfill.position();
}
 
void loop () {
 word len = ether.packetReceive();
 word pos = ether.packetLoop(len);
 
 if (pos) // check if valid tcp data is received
 ether.httpServerReply(homePage()); // send web page data
}

Com um pouco de hacking, você pode facilmente adicionar o código para exibir os valores analógicos lido os pinos analógicos, por exemplo.

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de Fumaça Mq-2 no arduino

25 SET
2015

Author: Leonardo Dalla Porta

A série de sensores de gases MQ usa um pequeno aquecedor dentro com um sensor eletro-química. Eles são sensíveis a uma gama dos gases e são utilizados em ambientes fechados, à temperatura ambiente. A saída é um sinal analógico e pode ser lido com uma entrada analógica do Arduino.

O módulo de MQ-2 sensor de gás é útil para a detecção de vazamento de gás em casa e na indústria. Pode detectar GPL, i-butano, propano, metano, o álcool, o hidrogênio e o fumo.

Alguns módulos têm uma resistência variável incorporado para ajustar a sensibilidade do sensor.

Nota: O sensor fica muito quente depois de um tempo, não toque nele!

Você vai precisar de:

  • Uno Arduino
  • Placa de ensaio
  • Módulo sensor MQ-2 Gas

 

O Circuito

As conexões são bastante fáceis:

sensor-de-gas-fumaca-mq-2-para-arduino-pic-19890-MLB20178648459_102014-O

 

  • Vcc ao Arduino pino 5V
  • GNG ao Arduino pino GND
  • Saída para pin Arduino analógica A0

O Código

/* Testing MQ-2 GAS sensor with serial monitor
Suitable for detecting of LPG, i-butane, propane, methane ,alcohol, Hydrogen or smoke
Dev: Michalis Vasilakis // Date: 11/6/2015 // www.ardumotive.com */

const int gasPin = A0; //GAS sensor output pin to Arduino analog A0 pin

void setup()
{
Serial.begin(9600); //Initialize serial port – 9600 bps
}

void loop()
{
Serial.println(analogRead(gasPin));
delay(1000); // Print value every 1 sec.
}

 

 

Teste:

Após feito isso, e já feito upload do código basta abrir o monitor serial, e utilizar um isqueiro para testar, ou até mesmo um fósforo, e é só criar!

Dica: Você pode usar este tutorial para ler os valores de todos os sensores de gás MQ (MQ-2, MQ-3, MQ-4, MQ-5, 6-MQ, MQ-7, etc)

 

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor Infravermelho Ajustável

24 SET
2015

Author: Leonardo Dalla Porta

Sensor Infravermelho Ajustável

O Sensor Infravermelho Ajustável é um conjunto de transmissor e receptor em um dos sensores fotoelétricos. A distância de detecção pode ser ajustado de acordo com a demanda. O ajustável Interruptor Sensor Infravermelho é pequeno, fácil de usar, barato, fácil de montar e pode ser amplamente utilizado em um robô para evitar obstáculos, mídia interativa, linha de montagem industrial, e muitas outras ocasiões. A saída de sinal de comutação é diferente, de acordo com os obstáculos. Ele continua a ser elevada quando há obstáculos e continua a ser baixa, quando há obstáculos. Há também um LED vermelho na sua parte de trás para indicar o estado do sensor.

Especificação

  • Fonte de alimentação: 5V
  • Corrente de trabalho: <100mA
  • Alcance de detecção ajustável: 3 centímetros – 80 centímetros
  • Pino e descrição:
    • Vermelho – 5V
    • Verde ou Preto – GND
    • Amarelo – Saída digital
  • Saída digital:
    • “0” – barreira encontrada (~ 0V)
    • “1” – nenhuma barreira (~ 4V)
  • Dimensão: 45x18mm

Diagrama de conexão

Caso necessário pode-se utilizar um resistor de 10k entre o pino amarelo e um GND, ou 5V dependendo do caso:

SEN0019 Sensor interruptor Diagrama de Conexão greenGND.png

Código

O código para este sensor é muito simples, e pode ser visto logo abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const int InfraredSensorPin = 4; // Ligue o pino sinal ao pino digital 4
const int LedDisp = 13;
void setup()
{
  Serial.begin(57600);
  Serial.println("Start!"); 
  pinMode(InfraredSensorPin, entradas);
  pinMode(LedDisp, OUTPUT);
  digitalWrite(LedDisp, LOW);
}
void loop()
{
  if(digitalRead(InfraredSensorPin) == LOW)  digitalWrite(LedDisp,HIGH);
  else  digitalWrite(LedDisp,LOW);
  Serial.print("Infrared Switch Status:");
  Serial.println(digitalRead(InfraredSensorPin),BIN);
  delay(50);
}

Resultado

Ao cobrir a frente do sensor com a mão, o LED (Pin13) a bordo acende-se, segure-o em direção a uma área aberta, o LED será desligado. Abra o monitor serial do Arduino, lá você também pode obter o status do sensor infravermelho.

Sen0019 result.png

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Módulo Joystick – Arduino

22 SET
2015

Author: Leonardo Dalla Porta

Conheça o módulo Joystick analógico, um módulo muito pratico, seu modelo é semelhante do console “PlayStation 3”. O módulo é muito fácil de usar com um Arduino e custa muito pouco. Ele utiliza uma resistência variável para cada eixo, portanto somente duas portas analógicas do Arduino!

Visão geral

O módulo tem 5 pinos: SCR, GND, X, Y, SW. Note-se que os rótulos em seu pode ser ligeiramente diferente. Este módulo é analógico e deve fornecer leituras mais precisas do que simples Joysticks direcionais ou os modelos de botões ou interruptores mecânicos.  Além disso, você pode pressionar o Joystick para baixo para ativar uma chave, dessa forma você pode criar menus e navegar neles!

Utilizaremos pinos analógicos do Arduino para ler os dados a partir dos pinos X e Y , e um pino de digital para ler o botão. O pino de chave é ligado ao GND, quando o Joystick é pressionado recebemos leituras no pino Key, ele precisa ser ligado a Vcc através de um resistor de pull-up, ou utilizar os disponíveis nas saídas analógicas do Arduino.

Ligações

As ligações do Joystick são muito simples, não precisa nenhum componente a mais, na figura a seguir mostramos todas as ligações:

2

 

Código de exemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
int xPin = A1;
int yPin = A0;
int buttonPin = 2;
 
int xPosition = 0;
int yPosition = 0;
int buttonState = 0;
 
void setup() {
  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
 
  pinMode(xPin, INPUT);
  pinMode(yPin, INPUT);
 
  //activate pull-up resistor on the push-button pin
  pinMode(buttonPin, INPUT_PULLUP); 
 
  // For versions prior to Arduino 1.0.1
  // pinMode(buttonPin, INPUT);
  // digitalWrite(buttonPin, HIGH);
 
}
 
void loop() {
  xPosition = analogRead(xPin);
  yPosition = analogRead(yPin);
  buttonState = digitalRead(buttonPin);
 
  Serial.print("X: ");
  Serial.print(xPosition);
  Serial.print(" | Y: ");
  Serial.print(yPosition);
  Serial.print(" | Button: ");
  Serial.println(buttonState);
 
  delay(100); // add some delay between reads
}

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Adaptador USB para TTL – Serial

19 SET
2015

Author: Leonardo Dalla Porta

Neste tutorial iremos mostrar como utilizar o Adaptador USB para TTL – Serial, que é um ótimo dispositivo para desenvolvedores IoT, ele é muito pratico, facilita a comunicação entre arduino x computador, ou qualquer MCU, seu uso é muito simples, basta instalar um drive e está pronto para uso!

Instalando Drivers

Você pode fazer download dos drivers deste dispositivo aqui, dentro desta pasta você pode encontrar os seguintes arquivos:

20

Você deverá executar o “PL2303_Profilic_DriverInstaler_V1.8.0.exe” após instalado, conecte seu dispositivo:

No windows o reconhecimento deve ser semelhante a este:
Imagem de Conexão do adaptador
Para descobrir em qual porta seu adaptador está, basta abrir o gerenciador de dispositivos disponível no painel de controle do windows

Testando o adaptador

Se jampearmos os pinos TXD e RXD, poderemos enviar e receber por ele mesmo, assim como descrevemos aqui:

ide.jpg
Abra sua IDE do arduino, vá até em Tools>Serial Porta>COM5 (Substitua COM5 por sua porta respectiva), terminando isso, abra o monitor serial, e envie qualquer mensagem na própia IDE

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de Batimentos Cardiacos no arduino

19 SET
2015

Author: Leonardo Dalla Porta

Sensor de Batimentos Cardiacos no arduino

O sensor de batimentos cardíacos é um dispositivo médico conhecido usado para monitoramento da freqüência cardíaca não invasiva. Sensor de Pulsações Amped responde a alterações relativas na intensidade da luz. Se a quantidade de luz incidente sobre o sensor mantém-se constante, o valor do sinal permanecerá no (ou perto) 512 (ponto médio da gama ADC). Mais luz e o sinal sobe.Menos luz, o oposto. A luz do LED verde que é refletida de volta para as mudanças sensor durante cada pulso.

figura 1

Nosso objetivo é encontrar momentos sucessivos de batimento cardíaco instantâneo e medir o tempo entre, chamado the Beat Inter Interval (IBI). Ao seguir a forma eo padrão da onda PPG previsível, somos capazes de fazer exatamente isso.

 

Alguns pesquisadores dizem que é do coração quando o sinal chega a 25% da amplitude, alguns dizem que quando é 50% da amplitude, e alguns dizem que é o ponto em que a inclinação é mais acentuada durante o evento ascensão para cima. Esta versão 1.1 do código do sensor de pulso é projetado para medir o IBI cronometrando entre momentos quando o sinal atravessa 50% da amplitude da onda durante esse aumento para cima rápido. O BPM é derivado cada batida de uma média dos tempos anteriores 10 IBI.  Aqui está como o fazemos!

Em primeiro lugar, é importante ter uma taxa de amostragem regular com resolução suficiente para obter medições fiáveis ​​de que o intervalo entre cada batimento. Para fazer isso, montamos Timer2, um temporizador de hardware 8 bit no ATmega328 (ONU), de modo que ele gera uma interrupção a cada dois milissegundos.Isso nos dá uma taxa de amostragem de 500Hz, e batimento a batimento resolução de temporização de 2mS (Nota 2). Isso irá desativar a saída PWM no pino 3 e 11. Além disso, ele irá desativar o comando tom (). Esse código funciona com Arduino UNO ou Arduino PRO ou Arduino Pro Mini 5V ou qualquer Arduino execução com um ATmega328 e relógio 16MHz.

 

Ligações

As ligações deste sensor são muito simples, basta conectar o fio preto ao GND, o fio vermelho aos 5V, e o fio roxo ao pino A0 do arduino:

PulseSensorAmpedFinger-web_2

 

 

 

Pra cair dentro do assunto:

NOME DA VARIÁVEL

TAXA DE ATUALIZAÇÃO

O QUE É ISSO

Sinal 2mS Sinal do sensor de pulso cru
IBI cada batida tempo entre batimentos cardíacos em MS
BPM cada batida batimentos por minuto
QS definir verdadeiro cada batida deve ser afastada pelo usuário
Pulso definir verdadeiro cada batida foi afastada pelo ISR
Lá você tem o código básico batida constatação. Tendo todas as variáveis ​​vitais atualizados automaticamente torna mais fácil fazer fazer coisas divertidas na função loop (). Nosso exemplo que trabalha com processamento para criar um batimento cardíaco e visualizar é um exemplo básico.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int pulsePin = 0;          
int blinkPin = 13;         
int fadePin = 5;           
int fadeRate = 0;  
volatile int BPM;                  
volatile int Signal;                
volatile int IBI = 600;             
volatile boolean Pulse = false; 
volatile boolean QS = false;  
volatile int rate[10];                  
volatile unsigned long sampleCounter = 0;   
volatile unsigned long lastBeatTime = 0;      
volatile int P =512;                
volatile int T = 512;               
volatile int thresh = 512;       
volatile int amp = 100;          
volatile boolean firstBeat = true;       
volatile boolean secondBeat = false; 
 
void setup(){
  pinMode(13,OUTPUT);  
  pinMode(10,OUTPUT);  
  Serial.begin(115200);  
  interruptSetup();      
//  analogReference(EXTERNAL);  
}

 

PulsePin é o número pino analógico que Pulso Sensor fio roxo está conectado. Você pode mudá-lo se você precisar. blinkPin piscará com o pulso. A variável fadeRate é usado para fornecer um efeito de desvanecimento opcional com cada batida em fadePin LED (deve ser um pino de PWM, mas não 3 ou 11). Ele parece mais agradável do que um piscar no pino 13. As outras variáveis ​​devem ser familiares para você agora.Eles são declarados volátil, porque eles se acostumar no ISR e as outras partes do código. Na instalação, instruções de pinos são declarados ea rotina interruptSetup é executado. A última linha na configuração só é usado quando você tem uma tensão diferente de ligar o sensor de pulsações do que você está usando para alimentar o Arduino. Principalmente, deve ser comentada.

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Teclado 4×4 e 3×4 no arduino Keypad

19 SET
2015

Author: Leonardo Dalla Porta

Neste projeto, vamos falar sobre como integrar um teclado com uma placa Arduino para que o arduino pode ler as teclas sendo pressionadas por um usuário.

Os teclados são usados ​​em todos os tipos de dispositivos, incluindo telefones celulares, aparelhos de fax, microondas, fornos, fechaduras, etc. Eles estão praticamente em todos os lugares. Toneladas de dispositivos eletrônicos usá-los para a entrada do usuário.

Assim, sabendo como ligar um teclado para um microcontrolador, tal como um Arduino é muito valioso para a construção de muitos tipos diferentes de produtos comerciais.

No final, quando tudo está conectado corretamente e programado, quando uma tecla é pressionada, ela aparecer no Monitor de série em seu computador. Sempre que você pressionar uma tecla, ele aparece no Monitor de série. Mais tarde, em outro projeto, que vai ligar o circuito de teclado, de modo que serão exibidas em um LCD. Mas, por enquanto, para fins de simplicidade, nós começamos a simplesmente mostrar a tecla pressionada no computador.

Para este projeto, o tipo de teclado, vamos utilizar é um teclado matriz. Este é um teclado que se segue um esquema de codificação que permite que ele tem muito menos pinos de saída que existem teclas. Por exemplo, o teclado matriz estamos usando tem 16 teclas (0-9, AD, *, #), mas apenas 8 pinos de saída.Com um teclado linear, não teria de ser 17 pinos de saída (uma para cada tecla e um pino de terra), a fim de funcionar. O esquema de codificação de matriz permite a menos pinos de saída e, portanto, muito menos conexões que têm que fez para o teclado para trabalhar. Desta forma, eles são mais eficientes do que os teclados lineares, sendo que eles têm menos cablagem.

Você vai precisar de:

  • Arduino
  • 4×4 Matrix Teclado
  • Conectores em barra para o terminal do teclado

 

Ligações

Com o teclado virado para cima para que as chaves são para cima e virada para si, da esquerda para a direita, o 1º ao 4º pino são os pinos de linha e os últimos 4 pinos são os pinos de coluna. Ao conectar os pinos para a placa Arduino, que conectá-los aos pinos de saída digital, D9-D2. Nós conectamos o primeiro pino do teclado para D9, o segundo pino para D8, o terceiro pino para D7, o quarto pino para D6, o quinto pino para D5, o sexto pino para D4, sétimo pino de D3, eo oitavo PIN para D2.

Estas são as conexões em uma tabela:

Pino do teclado Pino do Arduino
1 D9
2 D8
3 D7
4 D6
5 D5
6 D4
7 D3
8 D2

Este é um visual de como o circuito é ligado, quando se.

Teclado com circuito arduino

Aqui você pode ver visualmente todas as conexões que foram escritas acima.

Agora que temos a configuração física, tudo o que precisamos agora é o código.

 

Código

Antes de executar isso, você tem que importar a biblioteca do teclado e, em seguida, uma vez que você importá-lo, então você pode entrar em seu programa. Uma vez que é entrado em seu programa, você deverá ver a linha #include<Keypad.h>. Se você não vê isso, o que significa que a biblioteca teclado não foi colocado com sucesso em seu código e não vai funcionar.

Você pode baixar a biblioteca do teclado aqui: Teclado. Ao fazer o download, mude o nome para a pasta para algo diferente de teclado. Se a pasta e o arquivo que você está importando ter o mesmo nome, que não vai funcionar.

//Para utilizar teclados 3×4 apenas modifique as linhas:

//const byte numRows= 4; //number of rows on the keypad

//const byte numCols= 4; //number of columns on the keypad

//O Código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//*4x4 Matrix Keypad connected to Arduino
This code prints the key pressed on the keypad to the serial port*/
 
#include &lt;Keypad.h&gt;
 
const byte numRows= 4; //number of rows on the keypad
const byte numCols= 4; //number of columns on the keypad
 
//keymap defines the key pressed according to the row and columns just as appears on the keypad
char keymap[numRows][numCols]= 
{
{'1', '2', '3', 'A'}, 
{'4', '5', '6', 'B'}, 
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
 
//Code that shows the the keypad connections to the arduino terminals
byte rowPins[numRows] = {9,8,7,6}; //Rows 0 to 3
byte colPins[numCols]= {5,4,3,2}; //Columns 0 to 3
 
//initializes an instance of the Keypad class
Keypad myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);
 
void setup()
{
Serial.begin(9600);
}
 
//If key is pressed, this key is stored in 'keypressed' variable
//If key is not equal to 'NO_KEY', then this key is printed out
//if count=17, then count is reset back to 0 (this means no key is pressed during the whole keypad scan process
void loop()
{
char keypressed = myKeypad.getKey();
if (keypressed != NO_KEY)
{
Serial.print(keypressed);
}
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 
Free WordPress Theme
WordPress Themes