Archive for the ‘Microcontroladores’ Category

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.

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.

Matriz de Leds 8×8 RGB Anôdo comum

29 OUT
2015

Author: Leonardo Dalla Porta

Neste tutorial você verá como conectar e utilizar o display do tipo Matriz de Leds RGB 8×8 Ânodo comum no seu arduino, de forma quanto complexo, porém, vale a pena todo o trabalho, além que você aprenderá muitas coisas!

Começando pela matriz de leds, ela tem 32 pinos: 8 anodos, catodos de 8 para o vermelho, verde e 8 para 8 de azul. Então, utilizamos um arduino para controlar todos os parametros de cor e posição dos leds acesos e apagados!

Saiba que com o Shift Register você pode controlar todos os 32 pinos da matriz de leds usando apenas um par de fios do arduino. Registradores são baratos, neste caso foi usado o circuito integrado 74HC595, que por sua vez controla todos os leds da matriz, ou seja, 64 leds!

 

Esquema

O esquema de ligação da matriz de leds e todos os componentes deve ficar igual da imagem a seguir, lembrando que os 3 fios azul, verde e amarelo são conectados ao Arduino, neste tutorial mostraremos como utiliza-lo com o Circuito integrado “74HC595” mas pode ser usado também com o “TLC5940”, porém você precisa ter habilidades para poder montar isso:

 

 

 

Código

O código, como é muito extenso, está disponibilizado neste link! O código consta com vários deslocamentos de Bits, ou seja, para você poder mudar de cor, você precisa modificar alguns parâmetros disponibilizados no 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.

 

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.

Sensor de Fluxo de Agua

14 OUT
2015

Author: Leonardo Dalla Porta

 Um dia você deve ter pensado em criar um sistema de controle baseado na taxa de fluxo de água ou quantidade, não é? Por exemplo, enquanto jardinagem, para medir a quantidade de água usada para molhar suas plantas, para evitar o desperdício, etc. Se sim, então este projeto DIY muito fácil é para você. Aqui, instruções passo a passo são dadas sobre a forma de medir a taxa de fluxo e quantidade da água usando um sensor de caudal Arduino.

Você vai precisar de:

  1. Arduino / Arduino Clone ou fazer sua própria placa arduino costume com este tutorial.
  2. Medidor de fluxo de água.
  3. Fios de ligação.

 

Então, como isso funciona?

O medidor de fluxo de água funciona segundo o princípio de “efeito Hall”. De acordo com o qual, uma diferença de tensão é induzida numa direção transversal ao condutor de corrente eléctrica e o campo magnético perpendicular a ele. Aqui, de efeito Hall é utilizada no medidor de fluxo utilizando um rotor em forma de pequeno ventilador / propulsor que é colocado no percurso do líquido que se escoa.

O líquido, assim, empurra de encontro às alhetas do rotor, fazendo-o rodar. O eixo do rotor está ligado a um sensor de efeito Hall. É um arranjo de uma bobina de fluxo de corrente e um íman ligado ao veio do rotor. Assim, uma corrente / pulso é induzida como este rotor roda. Neste medidor de fluxo, por cada litro de líquido que passa através dele por minuto ele produz cerca de 4,5 pulses.This é devido ao campo magnético variável causado pelo íman ligado ao veio do rotor, como se vê na figura abaixo. Nós medimos o número de pulsos, usando um Arduino. E, em seguida, calcular a taxa de fluxo em L / h utilizando uma fórmula de conversão simples explicado a seguir:

Taxa de fluxo Arduino tutorial do sensor

Ligar o sensor de fluxo no Arduino

Aqui, as ligações necessárias para este sensor de fluxo em relação ao Arduino é muito simples. Existem apenas três fios que vêm do sensor de vazão. O 5V Vcc (fio vermelho), o Gnd (fio preto), e o sinal / pulso (geralmente amarelo) linha. Conecte o Vcc e GND do medidor de vazão para Vcc do arduino e GND. A linha de pulso do sensor de fluxo está ligado ao pino digital do arduino 2. pino digital do Arduino 2 serve como um pino de interrupção externa (interromper pino 0). Agora você ter ligado o seu medidor de fluxo para o Arduino.

Taxa de fluxo Arduino tutorial do sensor

Código

Carregar o seguinte código ao seu Arduino: Código do Sensor. Aqui, o código usa uma interrupção externa no pino digital da arduino 2. Esta é usada para ler os impulsos provenientes do medidor de vazão. Quando arduino detecta o pulso, ele imediatamente aciona a função pulseCounter (). Esta função, em seguida, conta o número total de impulsos.

Neste sensor de Fluxo para Arduino, para cada litro de líquido que passa através dele por minuto ele produz cerca de 4,5 pulsos. Assim, dividindo-se o total de contagem de pulso obtido por 4,5 irá dar-lhe a quantidade total de líquido que passa por ele em litros / minuto. Além disso dividindo-o em 60 vai lhe dar a vazão em litros / hr. E, portanto, o valor total ou a quantidade de água / líquido que passou através dele. O sensor tem uma precisão de 3%.

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.

 

Primeiros passos com o arduino Lilypad

13 OUT
2015

Author: Leonardo Dalla Porta

Este é um rápido tutorial para você começar costurar um circuito apenas para LEDs simples usando o Conselho Simples Arduino Lilypad. Você não vai aprender a criar o seu próprio programa Arduino, mas você vai ligar 9 LEDs para o conselho (um para cada pino exceto + e -), e você vai fazer upload de código fornecido para mudar a forma como as luzes se mover e piscar .

Você vai precisar de:

  • Fio condutor
  • LEDs LilyPad
  • LilyPad Arduino Board Simples
  • LilyPad FTDI
  • Cabo USB Mini
  • Bateria (Mesma de celular)
  • Tecido, vestuário, ou projeto
  • Arduino

Recomendado, mas não é necessário:

  • Bordados Hoop

 

Dê uma olhada em seu LilyPad que tem 11 conectores nele que podem ser costurados para qualquer número de dispositivos interessantes. Neste tutorial, nós apenas estamos indo para lidar com luzes, mas lembre-se que a placa Arduino é uma ferramenta muito versátil. Ele pode ser usado para direcionar a atividade de sensores, motores, campainhas, vibração motors- qualquer coisa que você pode comprar em uma placa de LilyPad, e muitas coisas que você não pode. Estamos usando 9 placas de luz LED, porque você tem nove blocos na placa além de + e – almofadas.

Vá em frente e passe a agulha com o fio condutora, e costurar de cima para baixo ao tecido onde você quer que pelo buraco na almofada rotulado ‘5’.

Costure longe deste ponto para onde você quer que seu primeiro LED para ir, em seguida, costurar para baixo o bloco positivo do LED

Amarrar e cortar o fio, reiniciar na próxima almofada que você gostaria de costurar para baixo. Acho que é mais fácil de passar para o outro lado do tabuleiro, de modo que ele está firmemente conectado em ambos os lados. Costure deste para onde você gostaria que o LED correspondente, e mais uma vez costurar para baixo o lado positivo do LED.

Repita esse processo para cada pad exceto os marcados + e -. Eu tenho o meu costurado em um padrão radial – você pode desviar-se este padrão, mas lembre-se para não cruzar qualquer dos fios. Desde fio condutor é não isolada, se as linhas de costura cruz, dois LEDs receberá o atual significou para apenas um.

Você tem duas almofadas de esquerda agora.

Costurar em direção a – pad, chamado ‘ground’ e costurar a partir dele para o “-” no LED mais próximo. Você não tem que amarrar e cortar essa linha de costura – continuá-lo para o próximo LED, e no próximo, a toda a volta para o LED de última, certificando-se de nunca cruzar um traço “+” com este – trace “” .

Quando você chegar ao último LED, vá em frente e dê um nó no fio e cortá-la. Deve agora ter todos os 9 LEDs ligados para almofadas individuais na placa Arduino sobre os seus lados positivos, e todos eles ligados de uma linha contíguos uns aos outros e para a almofada de terra.

Aqui está o que o circuito parece que da parte traseira – você pode ver que nenhum dos traços positivos estão em contacto uns com os outros, e todos os negativos são.

Você é feito agora com a porção de costura – o circuito está completo. Ligue a placa FTDI para os cabeçalhos na placa Arduino Lilypad e final mini-USB do seu cabo à placa FTDI assim:

E o fim do cabo USB em seu computador

Em seguida, você vai fazer o upload do programa. Se você não tiver instalado o Arduino no seu computador, no entanto, você precisará fazê-lo agora. Quando você abre Arduino, você vai ter uma tela como esta:

Verifique que você selecionou a placa correta

Agora é hora de fazer o upload do código que irá executar suas luzes!

Este é o código que você vai usar:

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
#define LED1 5
#define LED2 6
#define LED3 9
#define LED4 10
#define LED5 11
#define LED6 16
#define LED7 17
#define LED8 18
#define LED9 19
 
#define interval 11000
#define dead_time 1000
 
unsigned long PWM_counter = 0;
 
int offset = 0;
int step_size = 200;
unsigned long on_time = 0;
unsigned long cycle_start = 0;
char dir = 1;
 
int offset2 = 0;
int step_size2 = 200;
unsigned long on_time2 = 0;
unsigned long cycle_start2 = 0;
char dir2 = 1;
 
byte LED_tracker1 = 1;
byte LED_tracker2 = 1;
 
void setup() {
  Serial.begin(57600);
  pinMode(LED1, OUTPUT);      
  pinMode(LED2, OUTPUT); 
  pinMode(LED3, OUTPUT); 
  pinMode(LED4, OUTPUT); 
  pinMode(LED5, OUTPUT); 
  pinMode(LED6, OUTPUT); 
  pinMode(LED7, OUTPUT); 
  pinMode(LED8, OUTPUT); 
  pinMode(LED9, OUTPUT); 
  offset = random(2500,7500);
  offset2 = random(2500,7500);
}
 
void loop()
{
  PWM_counter = micros();
 
  if( (PWM_counter + offset - cycle_start) >= interval) {  // completed cycle, start over
    on_time += step_size*dir;
    cycle_start = PWM_counter;
    if (on_time >= (interval - dead_time) ) {
      dir *= -1;
      on_time = interval - dead_time;
    }
    else if (on_time <= 0) { on_time = 0; dir *= -1; LED_tracker1 = LED_tracker2; while (LED_tracker1 == LED_tracker2) LED_tracker1 = random(1,10); offset2 = random(0,4000); } } else if( (PWM_counter + offset - cycle_start) >= (dead_time + on_time) ) {  // time to switch LED off
    //digitalWrite(LED1, LOW);
    LED_off(LED_tracker1);
  }
  else if( (PWM_counter + offset - cycle_start) >= dead_time) {  // time to switch LED on
    //digitalWrite(LED1, HIGH);
    LED_on(LED_tracker1);
  }  
 
  if( (PWM_counter + offset2 - cycle_start2) >= interval) {  // completed cycle, start over
    on_time2 += step_size2*dir2;
    cycle_start2 = PWM_counter;
    if (on_time2 >= (interval - dead_time) ) {
      dir2 *= -1;
      on_time2 = interval - dead_time;
    }
    else if (on_time2 <= 0) { on_time2 = 0; dir2 *= -1; LED_tracker2 = LED_tracker1; while (LED_tracker2 == LED_tracker1) LED_tracker2 = random(1,10); offset2 = random(0,4000); } } else if( (PWM_counter + offset2 - cycle_start2) >= (dead_time + on_time2) ) {  // time to switch LED off
    //digitalWrite(LED1, LOW);
    LED_off(LED_tracker2);
  }
  else if( (PWM_counter + offset2 - cycle_start2) >= dead_time) {  // time to switch LED on
    //digitalWrite(LED1, HIGH);
    LED_on(LED_tracker2);
  }
}
 
void LED_on(byte LED)
{
  if (LED == 1) digitalWrite(LED1, HIGH);
  if (LED == 2) digitalWrite(LED2, HIGH);
  if (LED == 3) digitalWrite(LED3, HIGH);
  if (LED == 4) digitalWrite(LED4, HIGH);
  if (LED == 5) digitalWrite(LED5, HIGH);
  if (LED == 6) digitalWrite(LED6, HIGH);
  if (LED == 7) digitalWrite(LED7, HIGH);
  if (LED == 8) digitalWrite(LED8, HIGH);
  if (LED == 9) digitalWrite(LED9, HIGH);
}
 
void LED_off(byte LED)
{
  if (LED == 1) digitalWrite(LED1, LOW);
  if (LED == 2) digitalWrite(LED2, LOW);
  if (LED == 3) digitalWrite(LED3, LOW);
  if (LED == 4) digitalWrite(LED4, LOW);
  if (LED == 5) digitalWrite(LED5, LOW);
  if (LED == 6) digitalWrite(LED6, LOW);
  if (LED == 7) digitalWrite(LED7, LOW);
  if (LED == 8) digitalWrite(LED8, LOW);
  if (LED == 9) digitalWrite(LED9, LOW);
}

Recorte e cole esse código, em sua totalidade, para a janela esboço do Arduino, em seguida, clique no botão de upload.

E vejam o quadro preto na parte inferior.

Se você tem uma mensagem de erro vermelho, verifique a porta de comunicação. Você pode fazer isso abrindo-se este menu e desligar o cabo que liga o computador à placa FTDI da porta USB do computador. Olhe para a porta COM desaparece, em seguida, conecte o cabo USB de volta para o computador e selecione essa porta.

Exceto erros, você deve agora ter todos os nove luzes de participantes de forma rápida, desaparecendo efeito brilho. Vá em frente e retire a placa FTDI da placa Arduino, conecte a bateria e ligar o switch para verificá-la. Eu usei esse circuito para criar este vestido cocktail brilhando, mas você pode aplicar este circuito a qualquer coisa que você gostaria – sinta-se livre para usar a sua criatividade!

 

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 toque Humano

12 OUT
2015

Author: Leonardo Dalla Porta

Este dispositivo usa o seu corpo como parte do circuito. Quando você toca o teclado de sensor, a capacitância do circuito é alterado e é detectado. Essa mudança detectada em resultados de capacitância nos estados de saída em mudança.

 

Conecte o sensor de toque

Este é um real simples configurar. Você vai saber que você tem o poder corretamente aplicada quando o LED verde está aceso.

Arduino Tutorial de sensor de toque capacitivoO Código

O código abaixo fornece uma saída para o seu monitor serial indicando se o sensor está pressionado, ou não.


 

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
// Henry's Bench
// Capacitive Touch Sensor Tutorial
 
// When Sig Output is high, touch sensor is being pressed
#define ctsPin 2 // Pin for capactitive touch sensor
 
int ledPin = 13; // pin for the LED
 
void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);  
  pinMode(ctsPin, INPUT);
}
 
void loop() {
  int ctsValue = digitalRead(ctsPin);
  if (ctsValue == HIGH){
    digitalWrite(ledPin, HIGH);
    Serial.println("TOUCHED");
  }
  else{
    digitalWrite(ledPin,LOW);
    Serial.println("not touched");
  } 
  delay(500);
 
}

Teste

Uma vez que você enviou o esboço, abra o monitor serial. Toque no sensor de almofada enquanto olha para o monitor. Você deverá ver uma saída que é algo como a imagem abaixo.

Arduino Tutorial de sensor de toque capacitivo de saída

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.

Sensor Digital de Temperatura DS18B20

08 OUT
2015

Author: Leonardo Dalla Porta

Esta é uma nova versão do nosso 1-Wire tutorial sensor de temperatura digital, agora com mais sensores de temperatura! Veja como utilizar este maravilhoso sensor de forma muito simples utilizando um arduino. Lembrando que este sensor digital de temperatura pode ser utilizado com inúmeros outros sensores “OneWire”, este tipo de comunicação permite

Este tutorial irá mostrar-lhe como conectar o sensor de temperatura DS18B20 no seu arduino!

 

Código de software utilizado neste tutorial pode ser baixado aqui:

 

Exemplo Sensor de temperatura DS18B20

Biblioteca OneWire

Biblioteca DallasTemperatura

 

 

Hardware utilizado neste tutorial:

 

– DS18B20 Digital Sensor de temperatura

– 4.7k ohm (ou assim) resistor pullup

– Protoboard

– Alguns jumpers

– Placa Arduino (Uno, o Mega, Duemilanove, etc.)

 

Instruções:

 

Use a sua protoboard para fazer as conexões. Todos os sensores de temperatura pode ser DS18B20 ligado ao mesmo pino IO:

conexão DS18B20 arduino

 

* Você só precisa de um resistor 4.7k pullup para todos os dispositivos 1-fio ligado ao Arduino pino 3

** Veja a DS18B20 folha de dados para o diagrama de pinos, e tenha muito cuidado.

 

 

 

Você deve ver algo como:

 

sensor de temperatura DS18B20 arduino

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.

Servo Motor no arduino

24 SET
2015

Author: Leonardo Dalla Porta

Servo Motor

Neste tutorial estaremos mostrando lhe como girar servos de forma muito simples, utilizando apenas um arduino eu um servo Motor.

 

Você vai precisar de:

  • Arduino ou Genuino Board
  • Servo Motor
  • fios de gancho-se

 

O circuito

Servo motores têm três fios: poder, terrestres, e de sinal. O fio de alimentação é tipicamente vermelho, e deve ser conectado ao pino de 5V no Arduino ou Genuino. O fio terra é normalmente preto ou marrom e deve ser conectado a um pino terra no tabuleiro. O pino de sinal é tipicamente amarelo, laranja ou branco e deve ser conectado ao pino 9 no tabuleiro.

 

Esquemático

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
/* Sweep
 by BARRAGAN &lt;http://barraganstudio.com&gt;
 This example code is in the public domain.
 
 modified 8 Nov 2013
 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Sweep
*/
 
#include 
 
Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards
 
int pos = 0;    // variable to store the servo position
 
void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}
 
void loop() {
  for (pos = 0; pos &lt;= 180; pos += 1) { // goes from 0 degrees to 180 degrees // in steps of 1 degree myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position } for (pos = 180; pos &gt;= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}

 

 

 

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.

 

Shield Motor L293D no arduino

23 SET
2015

Author: Leonardo Dalla Porta

Shield Motor L293D

O shield contém dois L293D e um registrador 74HC595. O registo de deslocamento expande 3 pinos do Arduino para 8 pinos para controlar a direção para os drivers de motor. A saída para servo motores do shield está diretamente ligado ao saídas PWM do Arduino.

Para aumentar a corrente máxima, o L293D permite ser empilhado. Ao empilhar/soldar um ou dois ou três L293D extras na placa aumenta a corrente por canal. Pois o L293D permite a operação paralela.

O Shield de motor é capaz de conduzir 2 servo motores, e tem 8 saídas de meia ponte para 2 motores de passo ou 4 saídas do motor Cheio-Ponte H ou 8 condutores meia-ponte, ou uma combinação.

Os servomotores usam o + 5V da placa Arduino. O regulador de tensão na placa Arduino pode ficar quente. Para evitar isso, você deve conectar uma fonte com maior corrente diretamente no seu shield!

 

Começando

Fornecer a energia seja através da placa Arduino ou o cabeçalho do poder do Escudo Motor.Só se a placa Arduino e do Escudo usar uma fonte de alimentação independente, o jumper deve ser removido.

Carregue o Código abaixo (o código não é para motores de passo) e conecte leds, lampadas, motores, enfim, o que quiser, operando dentro das especificaçoes.

 

 O Código

O Código abaixo é um esboço simples de usar o shield em motor sem a biblioteca da Adafruit. Este código não suporta motores de passo, mas cada saída também pode ser usada para conduzir solenoides ou relês. O código esta disponível logo abaixo:

 

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
// Simple Motor Shield sketch
// -----------------------------------
//
// By arduino.cc user "Krodal".
// June 2012
// Open Source / Public Domain
//
// Using Arduino 1.0.1
//
// A simple sketch for the motor shield,
// without using the Adafruit library.
//
// The outputs can be used for DC-motors 
// (either full H-bridge or just On and Off), lights, 
// relays, solenoids, etc.
// But stepper motors can not be used !
// Servo motors can be used with the default Servo library.
//
// A maximum of 4 DC motors can be used with full-bridge,
// or a maximum of 8 normal outputs, or a combination.
// Two servo motors can always be used, they use the +5V 
// of the Arduino board, so the voltage regulator could 
// get hot.
//
// Tested with an Ebay clone with the Arduino Uno.
//
// Parts of the code are from an old Adafruit Motor Shield
// library, which was public domain at that time.
// This code is also public domain
//
// This simplified program is using the normal 
// Arduino library functions as much as possible.
//
// The motors will make a whistling sound, 
// due to the analogWrite() PWM frequency.
// The Adafruit library is specifically designed to avoid
// this, so use the Adafruit library for a better result.
//
//
//
// Connector usage
// ---------------
// The order is different than what you would expect.
// If the Arduino (Uno) board is held with the USB
// connector to the left, the positive (A) side is 
// at the top (north), and the negative (B) side is 
// the bottom (south) for both headers.
//
//   Connector X1:
//     M1 on outside = MOTOR1_A   (+) north
//     M1 on inside  = MOTOR1_B   (-)
//     middle        = GND
//     M2 on inside  = MOTOR2_A   (+)
//     M2 on outside = MOTOR2_B   (-) south
//
//   Connector X2:
//     M3 on outside = MOTOR3_B   (-) south
//     M3 on inside  = MOTOR3_A   (+)
//     middle        = GND
//     M4 on inside  = MOTOR4_B   (-)
//     M4 on outside = MOTOR4_A   (+) north
//
//
//         -------------------------------
//         | -+s                         |
//         | -+s                         |
//    M1 A |                             | M4 A
//    M1 B |                             | M4 B
//    GND  |                             | GND
//    M2 A |                             | M3 A
//    M2 B |                             | M3 B
//         |                       ..... |
//         -------------------------------
//                + - 
//
//
//
// Pin usage with the Motorshield
// ---------------------------------------
// Analog pins: not used at all
//     A0 ... A5 are still available
//     They all can also be used as digital pins.
//     Also I2C (A4=SDA and A5=SCL) can be used.
//     These pins have a breadboard area on the shield.
// Digital pins: used: 3,4,5,6,7,8,9,10,11,12
//     Pin 9 and 10 are only used for the servo motors.
//     Already in use: 0 (RX) and 1 (TX).
//     Unused: 2,13
//     Pin 2 has an soldering hole on the board, 
//           easy to connect a wire.
//     Pin 13 is also connected to the system led.
// I2C is possible, but SPI is not possible since 
// those pins are used.
//
 
 
#include 
 
 
// Arduino pins for the shift register
#define MOTORLATCH 12
#define MOTORCLK 4
#define MOTORENABLE 7
#define MOTORDATA 8
 
// 8-bit bus after the 74HC595 shift register 
// (not Arduino pins)
// These are used to set the direction of the bridge driver.
#define MOTOR1_A 2
#define MOTOR1_B 3
#define MOTOR2_A 1
#define MOTOR2_B 4
#define MOTOR3_A 5
#define MOTOR3_B 7
#define MOTOR4_A 0
#define MOTOR4_B 6
 
// Arduino pins for the PWM signals.
#define MOTOR1_PWM 11
#define MOTOR2_PWM 3
#define MOTOR3_PWM 6
#define MOTOR4_PWM 5
#define SERVO1_PWM 10
#define SERVO2_PWM 9
 
// Codes for the motor function.
#define FORWARD 1
#define BACKWARD 2
#define BRAKE 3
#define RELEASE 4
 
 
// Declare classes for Servo connectors of the MotorShield.
Servo servo_1;
Servo servo_2;
 
 
void setup()
{
  Serial.begin(9600);
  Serial.println("Simple Motor Shield sketch");
 
  // Use the default "Servo" library of Arduino.
  // Attach the pin number to the servo library.
  // This might also set the servo in the middle position.
  servo_1.attach(SERVO1_PWM);
  servo_2.attach(SERVO2_PWM);
}
 
 
void loop()
{
  // Suppose there are two servo motors connected.
  // Let them move 180 degrees.
  servo_1.write(0);  
  delay(1000);
  servo_1.write(180);
  delay(2000);
 
  servo_2.write(0);
  delay(1000);
  servo_2.write(180);
  delay(2000);
 
 
  // Suppose there is a relay, or light or solenoid
  // connected to M3_A and GND.
  // Note that the 'speed' (the PWM, the intensity) 
  // is for both M3_A and M3_B.
  // The output is a push-pull output (half bridge), 
  // so it can also be used to drive something low.
  // The 'speed' (the PWM, the intensity) can be set 
  // to zero, that would make the output disabled 
  // and floating.
  motor_output(MOTOR3_A, HIGH, 255);
  delay(2000);
  motor_output(MOTOR3_A, LOW, 255);
 
 
  // Suppose a DC motor is connected to M1_A(+) and M1_B(-)
  // Let it run full speed forward and half speed backward.
  // If 'BRAKE' or 'RELEASE' is used, the 'speed' parameter
  // is ignored.
  motor(1, FORWARD, 255);
  delay(2000);
  // Be friendly to the motor: stop it before reverse.
  motor(1, RELEASE, 0);
  delay(500);
  motor(1, BACKWARD, 128);
  delay(2000);
  motor(1, RELEASE, 0);
}
 
 
// Initializing
// ------------
// There is no initialization function.
//
// The shiftWrite() has an automatic initializing.
// The PWM outputs are floating during startup, 
// that's okay for the Motor Shield, it stays off.
// Using analogWrite() without pinMode() is valid.
//
 
 
// ---------------------------------
// motor
//
// Select the motor (1-4), the command, 
// and the speed (0-255).
// The commands are: FORWARD, BACKWARD, BRAKE, RELEASE.
//
void motor(int nMotor, int command, int speed)
{
  int motorA, motorB;
 
  if (nMotor &gt;= 1 &amp;&amp; nMotor &lt;= 4) { switch (nMotor) { case 1: motorA = MOTOR1_A; motorB = MOTOR1_B; break; case 2: motorA = MOTOR2_A; motorB = MOTOR2_B; break; case 3: motorA = MOTOR3_A; motorB = MOTOR3_B; break; case 4: motorA = MOTOR4_A; motorB = MOTOR4_B; break; default: break; } switch (command) { case FORWARD: motor_output (motorA, HIGH, speed); motor_output (motorB, LOW, -1); // -1: no PWM set break; case BACKWARD: motor_output (motorA, LOW, speed); motor_output (motorB, HIGH, -1); // -1: no PWM set break; case BRAKE: // The AdaFruit library didn't implement a brake. // The L293D motor driver ic doesn't have a good // brake anyway. // It uses transistors inside, and not mosfets. // Some use a software break, by using a short // reverse voltage. // This brake will try to brake, by enabling // the output and by pulling both outputs to ground. // But it isn't a good break. motor_output (motorA, LOW, 255); // 255: fully on. motor_output (motorB, LOW, -1); // -1: no PWM set break; case RELEASE: motor_output (motorA, LOW, 0); // 0: output floating. motor_output (motorB, LOW, -1); // -1: no PWM set break; default: break; } } } // --------------------------------- // motor_output // // The function motor_ouput uses the motor driver to // drive normal outputs like lights, relays, solenoids, // DC motors (but not in reverse). // // It is also used as an internal helper function // for the motor() function. // // The high_low variable should be set 'HIGH' // to drive lights, etc. // It can be set 'LOW', to switch it off, // but also a 'speed' of 0 will switch it off. // // The 'speed' sets the PWM for 0...255, and is for // both pins of the motor output. // For example, if motor 3 side 'A' is used to for a // dimmed light at 50% (speed is 128), also the // motor 3 side 'B' output will be dimmed for 50%. // Set to 0 for completelty off (high impedance). // Set to 255 for fully on. // Special settings for the PWM speed: // Set to -1 for not setting the PWM at all. // void motor_output (int output, int high_low, int speed) { int motorPWM; switch (output) { case MOTOR1_A: case MOTOR1_B: motorPWM = MOTOR1_PWM; break; case MOTOR2_A: case MOTOR2_B: motorPWM = MOTOR2_PWM; break; case MOTOR3_A: case MOTOR3_B: motorPWM = MOTOR3_PWM; break; case MOTOR4_A: case MOTOR4_B: motorPWM = MOTOR4_PWM; break; default: // Use speed as error flag, -3333 = invalid output. speed = -3333; break; } if (speed != -3333) { // Set the direction with the shift register // on the MotorShield, even if the speed = -1. // In that case the direction will be set, but // not the PWM. shiftWrite(output, high_low); // set PWM only if it is valid if (speed &gt;= 0 &amp;&amp; speed &lt;= 255)    
    {
      analogWrite(motorPWM, speed);
    }
  }
}
 
 
// ---------------------------------
// shiftWrite
//
// The parameters are just like digitalWrite().
//
// The output is the pin 0...7 (the pin behind 
// the shift register).
// The second parameter is HIGH or LOW.
//
// There is no initialization function.
// Initialization is automatically done at the first
// time it is used.
//
void shiftWrite(int output, int high_low)
{
  static int latch_copy;
  static int shift_register_initialized = false;
 
  // Do the initialization on the fly, 
  // at the first time it is used.
  if (!shift_register_initialized)
  {
    // Set pins for shift register to output
    pinMode(MOTORLATCH, OUTPUT);
    pinMode(MOTORENABLE, OUTPUT);
    pinMode(MOTORDATA, OUTPUT);
    pinMode(MOTORCLK, OUTPUT);
 
    // Set pins for shift register to default value (low);
    digitalWrite(MOTORDATA, LOW);
    digitalWrite(MOTORLATCH, LOW);
    digitalWrite(MOTORCLK, LOW);
    // Enable the shift register, set Enable pin Low.
    digitalWrite(MOTORENABLE, LOW);
 
    // start with all outputs (of the shift register) low
    latch_copy = 0;
 
    shift_register_initialized = true;
  }
 
  // The defines HIGH and LOW are 1 and 0.
  // So this is valid.
  bitWrite(latch_copy, output, high_low);
 
  // Use the default Arduino 'shiftOut()' function to
  // shift the bits with the MOTORCLK as clock pulse.
  // The 74HC595 shiftregister wants the MSB first.
  // After that, generate a latch pulse with MOTORLATCH.
  shiftOut(MOTORDATA, MOTORCLK, MSBFIRST, latch_copy);
  delayMicroseconds(5);    // For safety, not really needed.
  digitalWrite(MOTORLATCH, HIGH);
  delayMicroseconds(5);    // For safety, not really needed.
  digitalWrite(MOTORLATCH, 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.

 

 

Programar atmega328 com um arduino

22 SET
2015

Author: Leonardo Dalla Porta

Este tutorial explica como migrar de uma placa Arduino a um microcontrolador autônomo em uma protoboard.

A menos que você optar por usar a configuração mínima descrita no final deste tutorial, você vai precisar de quatro componentes (além do Arduino, ATmega328, e placa de ensaio):

Você vai precisar de:

  • Um 16 MHz cristal,
  • Uma resistência de 10 k, e
  • dois 18 a 22 picofarad capacitores (cerâmica).

 

 

Uma vez que seu ATmega328 ja tenha o bootloader sobre ele, você pode fazer upload de programas a ele usando o (chip FTDI) USB para serial conversor em uma placa Arduino. Para isso, você remove o microcontrolador da placa Arduino assim o chip FTDI pode falar com o microcontrolador na placa de ensaio em seu lugar. O diagrama à direita mostra como conectar as linhas RX e TX da placa Arduino para o ATmega na placa de ensaio. Para programar o microcontrolador, selecione “Arduino Duemilanove ou nano w / ATmega328″ a partir do menu Ferramentas> Board (ou“ATmega328 em uma placa de ensaio (8 MHz relógio interno)” se você estiver usando a configuração mínima descrita abaixo).

Em seguida, fazer o upload como de costume:

Upload de esboços para um ATmega em uma protoboard. Lembre-se de remover o microcontrolador da placa Arduino!

Eliminando o cristal externo

Se você não tem o cristal e os capacitores 18-22 picofarad utilizados nos exemplos acima, você pode configurar ao ATmega328 usar seu interno oscilador 8 MHz como uma fonte de clock em vez disso.

Você precisará instalar o suporte para uma configuração de hardware adicional:

  1. Faça o download deste arquivo de configuração de hardware: breadboard-1-6-x.zip, Breadboard1-5-x.zip ouBreadboard1-0-x.zip dependendo de qual IDE você usa.
  2. Crie uma sub-pasta de “hardware” na sua pasta sketchbook Arduino (cuja localização você pode encontrar no diálogo de preferências Arduino). Se você tiver instalado anteriormente o suporte para configuração de hardware adicional, você já pode ter uma pasta “hardware” em seu caderno.
  3. Mova a pasta placa de ensaio a partir do arquivo zip para a pasta “hardware” de seu caderno Arduino.
  4. Reinicie o software Arduino.
  5. Você deverá ver “ATmega328 em uma placa de ensaio (8 MHz relógio interno)” no menu Ferramentas> Board.

Uma vez feito isso, você pode gravar os programas bootloader e fazer o upload para o seu ATmega328 como descrito acima. Certifique-se de selecionar “ATmega328 em uma placa de ensaio (8 MHz relógio interno)” quando gravar o bootloader. (Se você selecionar o item errado e configurar o microcontrolador para usar um relógio externo, não vai funcionar a menos que você conectar um.)

Atenção

Este procedimento funciona em software 1.0.x Arduino.

Usando uma placa Arduino para queimar o bootloader para um ATmega em uma placa de ensaio (w / o um clock externo).

 

Upload de esboços para um ATmega em uma placa de ensaio.

Observações

Uma vez que você programou as ATmega na placa de ensaio, você pode eliminar o Arduino. Para fazer isso, você precisará fornecer uma fonte de energia alternativa para o microcontrolador. Veja o Arduino autônomo em uma protoboard tutorial para mais detalhes.

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.

 
Free WordPress Themes
WordPress Themes