sexta-feira, 14 de junho de 2013

Controlando Um Carrinho Através de Comandos Infra vermelho de um Controle Remoto Incrementado de sensores de distancia, Luminosidade, Temperatura e Umidade.





Esse Carrinho, é controlado Via Infra Vermelho por um controle Remoto de um som automotivo com auxílio de uma Ponte H e alguns Sensores para dar enfase ao Projeto.

A princípio a idéia era somente pilotar esse carrinho via Porta Serial, mas no decorrer do percurso, tamanha foi a facilidade que resolvemos implementar alguns sensores.


Agora além de ser comandado via Infra Vermelho por um controle Remoto de som Automotivo, o mesmo possui Sensor de Ultrassom, que detecta obstáculos a frente e aciona sinal sonoro para obstáculos a menos de 20cm, e para motor em obstáculos abaixo de 10cm.
Possui ainda um LED que se acende quando esta sobre baixa luminosidade, detectada por um LDR.  
O Sensor DHT11, transmite Temperatura e Humidade do ar no local onde o Carrinho está percorrendo. 
Tais Indormações Podem Ser Observadas através do Serial Monitor da IDE do Arduíno.





Itens Utilizados:

1 Arduíno Uno
1 Ponte H de Potência L298N para Controlar até 2 (dois) Motores DC
1 Carro de brinquedo com dois motores DC.
1 Buzzer
1 Led
1 Sensor de Ultrasom HC-SR04
1 Sensor Receptor Infra Vermelho IR
1 Sensor de Umidade e Temperatura DHT11
1 Resistor LDR
1 Protoboard


Ligações Ponte H.



Saída MotorA Da ponte H Ligada No Motor 1 - Move para Frente e Para Traz.
Saída MotorB Da Ponte H Ligada No Motor 2 - Move para Esquerda e Direita.



ENA liga na Pino Digital 3 Arduino.
IN1 liga na Pino Digital 2 Arduíno.
IN2 liga na Pino Digital 4 Arduíno.
IN3 liga na Pino Digital 5 Arduíno.
IN4 liga na Pino Digital 7 Arduíno.
ENB liga na Pino Digital 6 Arduíno.


Ligações Sensor HC-SR04



VCC - Alimentação 5V Arduíno.
Trig - liga na Pino Digital 12 Arduino.
Echo - liga na Pino Digital 13 Arduino.
GND - Ground Arduíno.


Ligações Sensor DHT11





VCC - Alimentação 5V
OUT - Liga na Pino Analógica A1 do Arduino.
GND - Ground Arduíno


Ligações Sensor Receptor Infra Vermelho IR 






OUT - Pino 8 Digital Arduíno
VCC - Alimentação 5V Arduíno
GND -Ground Arduino
Ligação LDR
Pino Analógico A1 Arduíno ( Ver Modelo Ligação )

Demais Ligações

Buzzer - Pino Digital 9 Arduíno
Led - Pino Digital 10 Arduíno




Código Programa

#include <IRremote.h> //Inclui Biblioteca
#include <dht.h> //Inclui Biblioteca
#define dht_dpin A1 //Pino DATA do Sensor ligado na porta Analogica A1
#define echoPin 13 //Pino 13 recebe o pulso do echo
#define trigPin 12 //Pino 12 envia o pulso para gerar o echo

//--------------------------Variáveis----------------------------

long distanciag = 0;
int luminosidade =0;
int temper = 0;
int humid=0;
int pinoIN=8;
IRrecv sinal(pinoIN);
decode_results resultado;
dht DHT; //Inicializa o sensor
long int codigo=-8;

//--------------------------Setanado Pinos entrada e Saida----------------

void setup()

{
Serial.begin(9600); // programa a porta serial para comunicação em 9600 bps
pinMode(echoPin, INPUT);
pinMode(trigPin, OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
sinal.enableIRIn();
}


//------------------------------------------------------
//------------------------------------------------------


void loop()

{
DHT.read11(dht_dpin);
temper=DHT.temperature;
humid=DHT.humidity ;
luminosidade= Luminosidade();
distanciag= Distancia();
if (sinal.decode(&resultado)) //----------Recebe codigo do Controle
{
codigo=resultado.value;
Serial.print("Código Recebido: ");
Serial.println(codigo);
sinal.resume();
}
distanciag= Distancia();
if ((codigo==16718055)&&(distanciag >10)) // Condição Para seguir em frente
{
Frente();
}
if ((distanciag<10)||(codigo==16726215)) // Condiçãode parada
{
Parar();
}
if (codigo==16730805) // Condição para dar ré
{
Traz();
}
if (codigo==16716015) // Condição para ir a esquerda
{
Esquerda();
}
if (codigo==16734885) // Condição para ir a Direita
{
Direita();
}
if (codigo==16724175) // Condição para Receber Dados dos Sensores e lança´los a tela
{
DHT.read11(dht_dpin);
temper=DHT.temperature;
humid=DHT.humidity ;
luminosidade= Luminosidade();
distanciag= Distancia();
Tela();
codigo=-8;
}
if (luminosidade<400)
{
digitalWrite(10,HIGH);
}
if (luminosidade>=400)
{
digitalWrite(10,LOW);
}
if (distanciag<10)
{
digitalWrite(9,HIGH);
}
if (distanciag>10)
{
digitalWrite(9,LOW);
}
delay (5);
}

      ///-------------------------Funções

void Tela()

{
Serial.println("DISTANCIA - TEMPERATURA - HUMIDADE - LUMINOSIDADE");
Serial.print(" ");
Serial.print(distanciag);
Serial.print("CM ");
Serial.print(temper);
Serial.print("ºC ");
Serial.print(humid);
Serial.print("% ");
Serial.print(luminosidade/10);
Serial.println("% ");
}

//-----------------------------------------------------
//----------------------------------------------------

int Direita()

{
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
digitalWrite(5,LOW);
}

//-----------------------------------------------------
//----------------------------------------------------

int Esquerda()

{
digitalWrite(6,HIGH);
digitalWrite(5,HIGH);
digitalWrite(7,LOW);
}

//-----------------------------------------------------
//----------------------------------------------------

int Frente()

{
digitalWrite(3,HIGH);
digitalWrite(2,HIGH);
digitalWrite(4,LOW);
}

//------------------------------------------------------
//------------------------------------------------------


int Traz()

{
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(2,LOW);
}

//------------------------------------------------------
//------------------------------------------------------


int Parar()

{
digitalWrite(3,LOW);
digitalWrite(2,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
}


//------------------------------------------------------
//------------------------------------------------------

int Luminosidade()

{
int i = analogRead(0);
return (i);
}
//------------------------------------------------------
//------------------------------------------------------

long Distancia()

{
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duration = pulseIn(echoPin,HIGH);
long distancia = duration /29 / 2 ;
return(distancia); 
}
//------------------------------------------------------
//------------------------------------------------------

quarta-feira, 5 de junho de 2013

LDR E ARDUÍNO


LDR (do inglês Light Dependent Resistor), em português Resistor Dependente de Luz, é um resistor cuja resistência varia conforme a intensidade da luz  que incide sobre ele. Tipicamente, à medida que a intensidade da luz aumenta, a sua resistência diminui.

Numa utilização normal, o LDR é montado num circuito onde a resistência é convertida para tensão. A forma mais simples de o fazer é através de um circuito divisor de tensão.





O LDR é muito utilizado em circuitos eletrônicos onde seja necessário um sensor de luz devido ao seu baixo custo e facilidade de utilização.
É possível fazer um teste bem legal com o Arduíno seguindo o esquema montado na figura acima, onde através do Monitor Serial da IDE do Arduíno você acompanha o comportamento do LDR de acordo com a variação de luminosidade.


FIO Vermelho Liga em 5V.
FIO Preto Liga em GND
FIO AMARELO Liga na entrada analógica 0.
Resistor 220 ohms

CÓDIGO


int senseur = 0;
void setup ()
{
    Serial.begin (9600);
}
void loop ()
{
int val = analogRead (senseur);
Serial.println (Val);
delay (100);
}

Agora é só acompanhar os valores no Serial Monitor se alterarem de acordo com a intensidade da luz sobre o LDR.




quarta-feira, 1 de maio de 2013

Primeiro Contato Com Arduíno

Em nosso primeiro contato com Arduíno, realizamos uma prática simples, retirada guia de exemplos do MINIBLOQ.
Manipulamos dados do exemplo e transferimos para o Arduíno, tudo muito simples para familiarizarmos com o Arduíno e com Minibloq.
Uma espécie de "olá mundo" da programação.
O Arduíno Possuí um LED interligado a saída digital 13, e através do Minibloq, é montado um conjunto de instruções que ao ser transferida para o Arduíno, faz com que esse LED Alterne aceso em um determinado limite de tempo definido.
Esse exemplo está incluído na biblioteca do Minibloq.

Vídeo Do programa em Execução


Código Criado no Minibloq


Arduíno Uno



É uma plataforma de prototipagem eletrônica de hardware livre, projetada com um microcontrolador Atmel AVR de placa única, com suporte de entrada/saída embutido, uma linguagem de programação padrão.


O objetivo do projeto é criar ferramentas que são acessíveis, com baixo custo, flexíveis e fáceis de se usar por artistas e amadores. Principalmente para aqueles que não teriam alcance aos controladores mais sofisticados e de ferramentas mais complicadas.


Pode ser usado para o desenvolvimento de objetos interativos independentes, ou ainda para ser conectado a um computador. Uma típica placa Arduino é composta por um controlador, algumas linhas de E/S digital e analógica, além de uma interface serial ou USB, para interligar-se a um computador, que é usado para programá-la e interagi-la em tempo real.


Ela em si não possui qualquer recurso de rede, porém é comum combinar um ou mais Arduínos deste modo, usando extensões apropriadas chamadas de shields.


A interface do hospedeiro é simples, podendo ser escrita em várias linguagens.


O projeto iniciou-se na cidade de Ivrea, Itália, em 2005, com o intuito de interagir em projetos escolares de forma a ter um orçamento menor que outros sistemas de prototipagem disponíveis naquela época. Seu sucesso foi sinalizado com o recebimento de uma menção honrosa na categoria Comunidades Digitais em 2006, pela Prix Ars Electronica, além da marca de mais de 50.000 placas vendidas até outubro de 2008.


Atualmente, seu hardware é feito através de um microcontrolador Atmel AVR, sendo que este não é um requisito formal e pode ser estendido se tanto ele quanto a ferramenta alternativa suportarem a linguagem Arduíno e forem aceitas por seu projeto. Considerando esta característica, muitos projetos paralelos se inspiram em cópias modificadas com placas de expansões, e acabam recebendo seus próprios nomes.


ÓTIMA FERRAMENTA PARA SE INTRODUZIR PROGRAMAÇÃO

Minibloq é um ambiente de programação gráfica para Arduino ™ , Multiplo , dispositivos de computação físicos e robôs. 
Um dos seus objetivos, é introduzir de uma forma fácil e divertida  a programação física e plataformas de robótica para escolas primárias, crianças e iniciantes da área de informática. 
Ele possui um ambiente colorido e divertido, onde seus comandos podem ser facilmente interpretados por figuras que introduzem instintivamente sua funcionalidade.

Veja você mesmo como é fácil.






Você consegue mais informações sobre o MINIBLOQ juntamente com downloads, tutoriais e exemplos AQUI NESSE LINK.