Sensores Ver

Sensores
Prefácio
Aqui está uma lista de sensores que consideramos úteis para vários projetos. Cada tutorial de um sensor fornece uma
explicação do que é, usos potenciais e código de amostra.
Sensor Infravermelho GP2Y0D810
Introdução
Sensores infravermelhos são uma forma de sensores de distância. Eles tendem a ser mais suscetíveis a imprecisões. Isso
ocorre porque eles enviam luz infravermelha e esperam que a luz informe a distância. Certas cores, especialmente pretas,
absorvem parte da luz infravermelha e podem retornar uma leitura falsa.
Isso foi testado em uma variedade de objetos que seriam considerados pretos. Uma leitura foi obtida de quase todos os
objetos testados, embora a distância retornada tenha variado. Havia um objeto preto que o sensor não detectou. A moral
desta história não se baseia apenas em sensores infravermelhos para detecção de distância. Redundância é fundamental
quando se trabalha com robôs.
Para o sensor GP2Y0D810, o Pololu faz uma placa de fuga que possui três pinos: VIN, GND e OUT.
Esquemático
O importante é notar que o pino OUT vai para um pino analógico.
Codificação
Este sensor foi usado em um robô que não queria se aproximar muito dos objetos, então quando o valor analógico atingiu
um determinado número, o robô estava a 10cm de um objeto no lado que o sensor estava. Sabendo o valor, o robô seria
capaz de responder de acordo.
Abaixo está o código explicando como o sensor funciona. O valor que é dado foi encontrado segurando os objetos sobre o
sensor e abaixando-os até que o LED embutido acendesse. O valor foi encontrado para ser consistente.
int irPin = A0;
int sensorValue = 0;
void setup () {
Serial.begin (9600);
}
void loop () {
sensorValue = analogRead (irPin);
// verifica o valor de 85 ou menos para o teste de distância
if (sensorValue <= 85) {
Serial.println ("Too close");
atraso (1000);
Este é apenas um uso muito simples do sensor infravermelho, mas um eficaz, dependendo do propósito.
Sensor Infravermelho GP2Y0A02YK em Distância Real
Introdução
Esta é uma versão de longo alcance do Sensor Infravermelho GP2Y0D810 . São cerca
de 15 $ e funcionam razoavelmente bem para distâncias entre 0,5 e 1,5 metro. É importante notar que a distância até a
curva de tensão não é linear. Então, se você quiser a distância real, medida em mm, você precisará encontrar uma curva de
melhor ajuste com base em alguns dados experimentais.
Como a versão midrange, a fiação é fácil. Vermelho vai para + 5V, Preto vai para GND e branco vai para um pino analógico
(no meu caso A0). Você pode até conectar vários deles, desde que use um pino branco para analógico.
Novamente, o IR não é o mesmo em todas as superfícies. Depende da sua refletividade. Por exemplo, superfícies pretas
tendem a parecer muito distantes, pois não refletem muita luz. Então, quando você reunir seus dados para fazer uma curva
de melhor ajuste, você deve usar uma superfície similar àquela que você planeja detectar.
Colete alguns dados
Eu usei a tensão de entrada de 5V conectada ao pino de leitura analógico do Arduino. Eu coloquei uma fita métrica e gravei
a saída de analogRead () a cada distância. Aqui estão os resultados:
Ajustar os dados
Acho que uma regressão polinomial se ajustaria melhor à curva. Eu usei um polinômio cúbico. Aqui estão os coeficientes
que encontrei com base nas minhas amostras:
-0,00003983993846 v 3 + 0,0456899769 v 2 - 17,48535575 v + 2571,052715
Converter para código
Depois de ter uma curva de bom ajuste, o código é bastante simples:
// alguns globals usados para calcular a média das amostras
int numSamples = 0;
irSum longo = 0;
// converte a tensão para milímetros
int convertIRvoltsToMM (float v) {
devolução -0,00003983993846 * v * v * v + 0,0456899769 * v * v - 17,48535575 * v + 2571,052715;
void setup () {}
void loop () {
irSum + = analogRead (A0);
numSamples ++;
if (numSamples> = 10) {
int distance = convertIRvoltsToMM (float (irSum) / float (numSamples));
Serial.println (distância);
irSum = numSamples = 0;
Conclusão
Pode ser uma boa ideia coletar amostras com uma frequência relativamente rápida e compará-las para produzir resultados
mais precisos. Mesmo depois de fazer isso, o meu ainda flutua em alguns centímetros, mesmo em sua faixa de
acuracidade. Há uma chance de que isso possa ser limpo com um melhor circuito eletrônico.
Você também pode ligar dois desses, coletar amostras de ambos e fazer a média dos dois. Eles não parecem interferir
demais uns com os outros.
A variabilidade de detecção com cores de superfície de reflexão também é uma desvantagem bastante significativa. É uma
desvantagem o suficiente que, se você estiver realmente querendo medir qualquer coisa à distância real, você
provavelmente não deveria usá-los. Eles provavelmente funcionam melhor como detectores "limiares", onde são
acionados quando atingem uma determinada voltagem.
Anexos:
long-ir-enchanced.jpg
Ping))) Sensor Ultrassônico
Introdução
Parallax's Ping))) sensor é um sensor ultrassônico que é usado para medições de distância.
Os sensores ultrassônicos funcionam enviando uma onda sonora e esperando até que essa onda retorne ao sensor. Isso
significa que a precisão do sensor pode realmente mudar com a velocidade do som. No entanto, isso geralmente não é um
problema.
A vantagem do sensor Ping sobre sensores ultrassônicos semelhantes é que ele possui apenas três pinos: + 5V, GND,
Trigger. Isso significa que um pino a menos é usado no Arduino, o que pode ser crucial para um projeto.
Codificando o Ping
Codificar o Ping é muito simples, pois existe um código de exemplo do Arduino incluído no IDE em: Arquivo >> Exemplos >>
06.Sensores >> Ping.
Isso dá o código básico para obter o Ping operando. Para integrar isso no código, pode não ser necessário ler o sensor toda
vez, então colocar um timer nele pode ser vantajoso:
long previousMillis = millis ();

int PingPin = 7;
void setup () {
}
void loop () {
intervalo int = 1000;
longa duração;
if (millis () - previousMillis> interval) {

// O ping é acionado
pinMode (pingPin, OUTPUT);
digitalWrite (pingPin, LOW);
atrasoMicrosegundos (2);
digitalWrite (pingPin, ALTO);
digitalWrite (pingPin, LOW);

pinMode (pingPin, INPUT);
duration = pulseIn (pingPin, ALTO);
previousMillis = millis ();

}
}
Esta é uma maneira simples de acionar o sensor somente quando o intervalo de tempo tiver passado.
Sensor de Distância Ultrassônico HC-SR04
Introdução
O sensor de distância HC-SR04 é um sensor ultrassônico usado para medições de distância.
Os sensores ultrassônicos funcionam enviando uma onda sonora e esperando até que essa onda retorne ao sensor. Isso
significa que a precisão do sensor pode realmente mudar com a velocidade do som. No entanto, isso geralmente não é um
problema.
Esta é uma alternativa mais barata ao sensor Ping. Em vez de três pinos, ele tem quatro: + 5V, GND, Trigger e Echo. Isso
significa que um pino a menos está disponível no Arduino, mas, dependendo do projeto, isso pode não importar.
Esquemático
O sensor está conectado da seguinte forma:
Codificação
A codificação do HC-SR04 é simples, pois o código pré-existente para o Ping pode ser desenvolvido rapidamente para
funcionar com ele. Por exemplo:
// Adaptado do código de David A. Mellis para o sensor Ping
const int trigPin = 7;
const int echoPin = 8;
void setup () {
// inicializa a comunicação serial:
pinMode (trigPin, OUTPUT);
pinMode (echoPin, INPUT);
loop void ()
longa duração, polegadas, cm;
digitalWrite (trigPin, LOW);
digitalWrite (trigPin, HIGH);
digitalWrite (trigPin, LOW);
duração = pulseIn (echoPin, HIGH);
// converte o tempo em uma distância
inches = microsecondsToInches (duração);
cm = microsecondsToCentimeters (duração);
Serial.print (polegadas);
Serial.print ("in");
Serial.print (cm);
Serial.print ("cm");
Serial.println ();
atraso (100);
microsecondsToInches longos (microssegundos longos)
// De acordo com a folha de dados da Parallax para o PING))), existem
// 73.746 microssegundos por polegada (ou seja, o som viaja a 1130 pés por
// segundo). Isso dá a distância percorrida pelo ping, saída
// e retornar, então dividimos por 2 para obter a distância do obstáculo.
// Veja: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
retorno microssegundos / 74/2;
microsecondsToCentimeters longos (microssegundos longos)
// A velocidade do som é de 340 m / s ou 29 microssegundos por centímetro.
// O ping viaja para fora e para trás, para encontrar a distância do
// Objeto nós tomamos metade da distância percorrida.
retorno microssegundos / 29/2;
Este código simplesmente leva em conta que o pino no Ping são dois pinos separados no sensor HC-SR04.
Sensor PIR (HC-SR501)
Introdução
Os sensores de infravermelho passivo (PIR) são usados para detectar movimento com base no calor infravermelho na área
circundante. Isso os torna uma escolha popular ao criar um sistema para detectar possíveis intrusos ou pessoas em
geral. Esses sensores podem demorar de 10 a 60 segundos para se aquecer, então tente evitar o movimento durante esse
tempo.
Peças
 Arduino
 Sensor PIR
 Fios
Esquemático
Abaixo está o esquema para usar um sensor PIR. É bastante simples.
Código
A Adafruit tem um ótimo tutorial de como esses sensores são usados e vários projetos para eles.
Abaixo está o código para trabalhar com um sensor PIR. Deve-se notar que o sensor PIR não responde imediatamente
quando o movimento é interrompido. Isso tem a ver com os dois potenciadores no sensor.
int pirPin = 8;
int val;
void setup () {
void loop () {
val = digitalRead (pirPin); // leia o estado do PIR
if (val == LOW) {
Serial.println ("sem movimento"); // se o valor lido for baixo, não houve movimento
outro {
Serial.println ("Motion!"); // se o valor lido for alto, houve movimento
atraso (1000);
}
Câmera JPEG Linksprite
Introdução
Câmeras podem ser usadas em inúmeras aplicações: survellience, hobbies, robótica, etc. Elas são muito úteis para ver o
que está acontecendo quando um robô está se movendo sozinho ou até mesmo para se divertir.
Eu tenho uma câmera UART para brincar e que pretendo ficar em um robô. No entanto, obter o código funcionando na
câmera era mais difícil do que eu esperava inicialmente e não parecia haver bons tutoriais disponíveis.
Eu modifiquei o código fornecido pela Linksprite para a câmera deles, de modo que ela tirasse fotos continuamente, em
vez de pegar uma e parar. Afinal, se esta câmera for usada em um robô, ela poderá tirar mais de uma foto.
Adafruit e Sparkfun fornecem código de exemplo, mas eles precisam ter um cartão SD, que eu não tinha no momento. Isso
imprimirá as imagens diretamente na porta serial e as imagens poderão ser traduzidas com o código Python.
Peças
 Câmara JPEG TTL da Linksprite
 Arduino
 2 resistências de 10K
 Fios
Esquemático
Abaixo está o esquema de como ligar a câmera ( Adafruit tinha um tutorial explicando isso):
Código
Há duas etapas para obter uma foto da câmera. O primeiro é conseguir obter o HEX correto para imprimir no monitor serial
do Arduino. O segundo é ser capaz de transformar todo o HEX em uma imagem JPEG.
Arduino: tire fotos
O código a seguir foi criado alterando o código fornecido pelo Linksprite para permitir que a câmera capturasse imagens
continuamente. O código original pegou uma imagem e parou.
#include <SoftwareSerial.h>
Byte Bybyte;
// Configure os pinos 2 e 3 como porta serial
SoftwareSerial cameraSerial = SoftwareSerial (2, 3);
int a = 0x0000, // Read Endereço inicial

j = 0,
k = 0,
contagem = 0;
uint8_t MH, ML;
EndFlag booleano = 0;
void setup () {
cameraSerial.begin (38400);
SendResetCmd ();
atraso (3000);
void loop () {
SendTakePhotoCmd ();
Serial.println ("Iniciar foto");
atraso (100);
while (cameraSerial.available ()> 0) {
incomingbyte = cameraSerial.read ();
byte b [32];
while (! EndFlag) {
j = 0;
k = 0;
contagem = 0;
SendReadDataCmd ();
atraso (75); // tente subir
incomingbyte = cameraSerial.read ();
k ++;
if ((k> 5) && (j <32) && (! EndFlag)) {
b [j] = entrada de bytes;
if ((b [j-1] == 0xFF) && (b [j] == 0xD9))
EndFlag = 1;
j ++;
contar ++;
para (j = 0; j <count; j ++) {
if (b [j] <0x10)
Serial.print ("0");
Serial.print (b [j], HEX);
Serial.println ();
atraso (3000);
StopTakePhotoCmd (); // pare esta foto para que outra possa ser tomada
EndFlag = 0; // reset flag para permitir que outra imagem seja lida
Serial.println ("Fim da foto");
Serial.println ();
// Send Reset command
void SendResetCmd () {
cameraSerial.write ((byte) 0x56);

// Envia o comando take picture
void SendTakePhotoCmd () {
a = 0x0000; // reset para que outra foto possa ser tirada
void FrameSize () {
// Ler dados
void SendReadDataCmd () {
MH = a / 0x100;
ML = a% 0x100;
cameraSerial.write ((byte) 0x0c);

cameraSerial.write ((byte) 0x0a);
cameraSerial.write ((byte) MH);
cameraSerial.write ((byte) ML);
a + = 0x20;
void StopTakePhotoCmd () {
Arduino: Alterar tamanho da imagem
Aqui está o código que eu uso quando eu quero alterar o tamanho das imagens que estão sendo tomadas.
/ ***********************
ChangeCameraSize
Jennifer Case
28/02/2013
*********************** /
SoftwareSerial mySerial = SoftwareSerial (2, 3);

void setup ()
mySerial.begin (38400);
int sizeChange = 0;
void loop () {
SendResetCmd ();
atraso (3000);
if (sizeChange == 0) {
ChangeSizeSmall ();
Serial.println ("Tamanho Alterado");
sizeChange ++;
mySerial.write ((byte) 0x56);
void ChangeSizeSmall () {

void ChangeSizeMedium ()
void ChangeSizeBig ()
Eu apenas altero a função que quero chamar para alterar o tamanho.
Python
O código a seguir pega um arquivo de texto chamado "outputData.txt" e o transforma em uma imagem JPEG chamada
"binaryData.jpg". O código Python deve estar na mesma pasta em que as imagens estão ou não poderá encontrá-lo.
O seguinte código é para o Python 2.7:
importar binascii
f = open ("outputData5.txt", "r")
nf = open ("binaryData5.jpg", "wb")
#Ler o arquivo inteiro em dados
enquanto 1:
c = f.readline ()
d = c.strip ()
se não c:
pausa
nf.write (binascii.a2b_hex (d))
# Feche o arquivo
f.close ()
nf.close ()
O seguinte código é para o Python 3:
importar binascii
f = open ("outputData14.txt", "r")
nf = open ("binaryData14.jpg", "wb")
enquanto 1:
c = f.readline ()
d = c.strip ()
se não c:
pausa
nf.write (binascii.a2b_hex (bytes (d, "ascii")))

# Feche o arquivo
f.close ()
nf.close ()
Solução de problemas
Existem muitos erros que podem ocorrer quando se lida com a câmera. Eu listei os que parecem ser problemas comuns e
que eu encontrei.
Bandas ou artefatos
Descobri que as faixas ou artefatos ocorreram quando tentei tirar imagens maiores. Há um atraso logo após a linha
SendReadDataCmd () que pode ser aumentada para reduzir a formação de faixas, mas nunca consegui capturar imagens
grandes sem perder a última parte da imagem.
Python JPEG não funcionou
Se o JPEG feito a partir do arquivo de texto não foi aberto ou foi corrompido, provavelmente é devido ao fato de o arquivo
de texto não ter a imagem completa. Isto pode ser devido à falta da primeira linha da imagem enviada através da serial.
Isso foi corrigido adicionando-se um pequeno atraso depois que o comando para tirar a foto foi enviado.
Edições
19/12/2013:
Edições foram feitas no código para que mais de uma imagem seja lida. - Obrigado jadnexus por apontar
Além disso, se você quiser salvar essas fotos em um cartão SD, dê uma olhada no seguinte tutorial: http://robotic-
controls.com/learn/projects/simple-security-system ou http: // robotic-controls. com / learnt / sensors / linksprite-jpeg-
camera / salvando-imagens-sd-card-0
Anexos:
ChangeCameraSize.ino
camera_TakeMultiplePics2.ino
Salvando Imagens em um Cartão SD
Introdução
Antes de tentar este código, certifique-se de que sua câmera funcionou porque você não poderá ver o que está
acontecendo com a câmera enquanto estiver salvando no cartão SD. Se você está tendo problemas com isso, confira o
Software de Avaliação fornecido pelo L inksprite .
Você também deve dar uma olhada neste tutorial e garantir que você possa, de fato, obter uma imagem convertida antes
de tentar salvar várias imagens.
Peças
 Câmara TTL da Linksprite
 Placa de abertura do cartão SD
 Cartão SD
 2 resistências de 10k
 3 outros resistores (não tenho certeza se o tamanho é importante, mas o meu era todo acima de 1k)
 Fios
 Arduino
Esquemático
Código
Arduino
Este código configura o cartão SD e tira fotos, incrementando o nome que o arquivo é salvo a cada vez.
/ ***************************
Salvar imagens no cartão SD
por Jennifer Case
14/04/2014
Peças:
Placa de fuga do cartão SD
-TTL Camera
Pin 2,3 - Câmera
Pino 10 - CS / D3
Pino 11 - CMD
Pino 12 - D0
Pino 13 - CLK
**************************** /
#include <SdFat.h>
//Cartão SD
SdFat sd;
SdFile myFile;
int picCnt = 0;
//Câmera
Byte Bybyte;
SoftwareSerial cameraSerial = SoftwareSerial (2, 3); // Configure os pinos 2 e 3 como porta serial
int a = 0x0000, j = 0, k = 0, contagem = 0; // Leia o endereço inicial
uint8_t MH, ML;
EndFlag booleano = 0;
// Declara os pinos
const int chipSelect = 10;
void setup () {
Serial.begin (19200); // iniciar serial
cameraSerial.begin (38400); // iniciar serial com câmera
// Inicialize o SdFat ou imprima uma mensagem de erro detalhada e pare
// Use meia velocidade como a biblioteca nativa.
// mude para SPI_FULL_SPEED para mais desempenho.
if (! sd.begin (chipSelect, SPI_HALF_SPEED)) sd.initErrorHalt ();
SendResetCmd (); // permite que a câmera tire fotos
atraso (3000); // atraso necessário para a reinicialização da câmera
void loop () {
// cria título para imagens
char photoTitle [25] = {};
sprintf (photoTitle, "pic% d.txt", picCnt);
// certifique-se de que o arquivo possa ser criado, caso contrário, o erro de impressão
if (! myFile.open (photoTitle, O_RDWR | O_CREAT | O_AT_END)) {
sd.errorHalt ("abertura do photoTitle.txt para gravação falhada");
SendTakePhotoCmd (); //tirar fotos
atraso (200); // demora para garantir que não haja queda nos dados
incomingbyte = cameraSerial.read (); // limpar serial sem necessidade da câmera
byte b [32];
while (! EndFlag) {
j = 0;
k = 0;
contagem = 0;
SendReadDataCmd (); // comando para tirar foto da câmera
atraso (75); // atraso necessário para que os dados não sejam perdidos
incomingbyte = cameraSerial.read (); // ler serial da câmera
k ++;
if ((k> 5) && (j <32) && (! EndFlag)) {
b [j] = entrada de bytes;
if ((b [j-1] == 0xFF) && (b [j] == 0xD9))
EndFlag = 1; // quando o fim da imagem aparece, pare de ler os dados
j ++;
contar ++;
}
}
para (j = 0; j <count; j ++) {// armazena a imagem no arquivo
if (b [j] <0x10)
myFile.print ("0");
myFile.print (b [j], HEX);
myFile.println ();
StopTakePhotoCmd (); // pare esta foto para que outra possa ser tirada
EndFlag = 0; // reset flag para permitir que outra imagem seja lida
myFile.close (); // fecha o arquivo
picCnt ++; // incrementa valor para a próxima imagem
// Envia o comando take picture
void SendTakePhotoCmd () {

a = 0x0000; // reset para que outra foto possa ser tirada
void FrameSize () {
// Ler dados
void SendReadDataCmd () {
MH = a / 0x100;
ML = a% 0x100;
cameraSerial.write ((byte) 0x0c);
cameraSerial.write ((byte) MH);
cameraSerial.write ((byte) ML);
a + = 0x20;
}
void StopTakePhotoCmd () {
Python
O código Python do tutorial da câmera foi renovado para permitir que várias fotos sejam processadas por vez. Isso é
configurado para funcionar com o nome dado no código acima. O usuário ainda pode ter que ajustar o intervalo,
dependendo do número de fotos.
#! / usr / bin / python
# abrir arquivo
importar binascii
contagem = 0
para contagem no intervalo (0,4):
f = open ("PIC% d.txt"% (contagem), "r")
nf = open ("IMAGEM% d.jpg"% (contagem), "wb")
enquanto 1:
c = f.readline ()
d = c.strip ()
#print (c)
#print (d)
se não c:
pausa
nf.write (binascii.a2b_hex (bytes (d, "ascii")))

# Feche o arquivo
f.close ()
nf.close ()
Anexos:
SavingImagesOnSDCard.ino
Adafruit Ultimate GPS Breakout
Introdução
A placa Breakout GPS Adafruit Ultimate é uma excelente maneira de começar com GPS e Arduino. Adafruit faz um
excelente trabalho fornecendo tutoriais e código para o usuário. Eu sugeriria verificar seus tutoriais e código fornecidos
antes de procurar em outro lugar.
Quando eu estava trabalhando com o GPS, fiz algumas alterações no código que o Adafruit forneceu com base em como o
Arduino manipula os floats (ou não os manipula). As alterações que eu fiz não são particularmente necessárias dependendo
do que está sendo usado, mas aumentam a precisão do módulo no nível de código. No entanto, sugiro que você se
familiarize com o funcionamento da unidade antes de tentar alterar o código.
Esquemático
Abaixo está um esquema para conectar o módulo GPS ao Arduino.
Existem vários pinos na placa de fuga que não são utilizados neste esquema. Esses outros pinos não são necessários para
comunicação com o módulo GPS, mas podem ser úteis em outros aspectos.
Como ler latitude e longitude de saída
A Adafruit forneceu vários códigos diferentes para uma variedade de aplicações. Especificamente, vou repassar o código de
análise que eles fornecem e como ler os dados para latitude e longitude. Abaixo está a parte do código que lida com os
dados de latitude e longitude.
// Testar código para módulos GPS Adafruit usando o driver MTK3329 / MTK3339
//
// Este código mostra como ouvir o módulo GPS em uma interrupção
// que permite ao programa ter mais 'liberdade' - apenas analisar

// quando uma nova sentença NMEA está disponível! Então acesse os dados quando
// desejado.
//
// Testado e funciona muito bem com o módulo GPS Adafruit Ultimate
// usando o chipset MTK33x9
// ------> http://www.adafruit.com/products/746
// Escolha uma hoje na loja de eletrônicos Adafruit
// e ajudar a suportar hardware e software de código aberto! -ada
Serial.print ("Localização:");
Serial.print (GPS.latitude, 4); Serial.print (GPS.lat);
Serial.print (",");
Serial.print (GPS.longitude, 4); Serial.println (GPS.lon);
Esse código usa as bibliotecas que o Adafruit disponibilizou onde analisam os dados para o usuário. Aqui, você pode ver
que o GPS.latitude chamará o float segurando a latitude para o usuário (sendo o GPS uma instância da classe Adafruit_GPS
e o GPS.latitude sendo uma propriedade da classe). Enquanto o GPS.lat vai te 'N' ou 'S', dependendo do hemisfério.
Traduzindo dados de GPS
Aqui precisamos analisar a saída real mais de perto. A amostra de saída com a qual estaremos trabalhando é uma leitura de
latitude de 1234.5678 e uma leitura de longitude de 12345.6789.
Se a leitura da latitude = 1234,5678, a latitude real é lida como 12 ° 34,5678 '.
Se a leitura da longitude for 12345.6789, a longitude real será lida como 123º 45.6789 '.
Isso significa que os flutuadores podem exigir algum processamento, dependendo de quais dados são
necessários. Pessoalmente, eu prefiro transformar todos os dados em minutos de graus.
Assim, 12 ° 34,5678 '= 12 * 60 + 34,5678 = 754,5678' e 123 ° 45,6789 '= 123 * 60 + 45,6789 = 7425,6789'.
Isto pode então ser convertido em metros sabendo que 1 '≈ 1852 metros (saindo do fato que cada grau é
aproximadamente 111km ).
Com esse conhecimento, podemos fazer duas leituras de latitude e duas de longitude e determinar a diferença é de metros
entre as duas coordenadas. Eu mostro como fazer isso em um tutorial sobre como fazer um mapa (pendente).
Problema com flutuadores
Se você procurar na biblioteca fornecida pela Adafruit , verá que os dados são analisados da seguinte forma (isso é apenas
uma pequena parte do código inteiro):
/ ***********************************
Esta é nossa biblioteca de GPS
A Adafruit investe tempo e recursos fornecendo este código fonte aberto,
por favor, suporte Adafruit e hardware de código aberto através da compra
produtos da Adafruit!
Escrito por Limor Fried / Ladyada para as Indústrias Adafruit.
Licença BSD, verifique license.txt para mais informações
Todo o texto acima deve ser incluído em qualquer redistribuição
**************************************** /
// analise a latitude
p = strchr (p, ',') + 1;
latitude = atof (p);
p = strchr (p, ',') + 1;
if (p [0] == 'N') lat = 'N';
else if (p [0] == 'S') lat = 'S';
else if (p [0] == ',') lat = 0;
mais retorno falso;
// analisa a longitude
p = strchr (p, ',') + 1;
longitude = atof (p);
p = strchr (p, ',') + 1;
if (p [0] == 'W') lon = 'W';
else if (p [0] == 'E') lon = 'E';
else if (p [0] == ',') lon = 0;
mais retorno falso;
Todos os dados começam como uma string e são analisados de acordo com o que os dados realmente são. Aqui, você pode
ver que a string contendo a latitude e longitude é transformada em floats com o comando atof (p).
O que eu descobri é que o Arduino não foi feito para lidar bem com os floats (e os dobros não são diferentes dos floats do
Arduino). Flutuadores de Arduino são realmente precisos até sete dígitos, enquanto os flutuadores de GPS têm até oito ou
nove dígitos. Então, o que o Arduino faz é dar sete dígitos precisos e depois adivinhar os outros dois. Abaixo está uma
imagem de um experimento em que a string do GPS é impressa, seguida pela atof (p) float que o código original está
produzindo.
Olhando para esses dados, você pode ver que a diferença entre o valor da string verdadeira e a estimativa da flutuação é
tão grande quanto 0,0005, o que pode não parecer muito, mas isso pode ser traduzido para aproximadamente 0,926
metros (usando a matemática de cima), poderia ter um efeito sobre a precisão do GPS. Embora, admito, isso possa não ser
uma diferença suficientemente grande para a matéria e a aproximação dos medidores aos graus provavelmente não será
precisa o suficiente para justificar a diferença de 0,926m. Minha sugestão seria pular o resto do tutorial se isso não
importa. No entanto, se isso importa, há uma solução alternativa para obter os valores da string.
Alterando a Biblioteca
Para corrigir o problema, introduzo novas variáveis para manter a latitude e a longitude no arquivo de cabeçalho. Esta
variável é uma matriz de caracteres. Abaixo está a linha adicionada ao arquivo de cabeçalho:
char latit [10], longit [11]; // adicionado para obter strings para latitude e longitude
O código que foi exibido antes é então alterado para se parecer com o seguinte:
/ ***********************************
Esta é nossa biblioteca de GPS
A Adafruit investe tempo e recursos fornecendo este código fonte aberto,
por favor, suporte Adafruit e hardware de código aberto através da compra
produtos da Adafruit!
Escrito por Limor Fried / Ladyada para as Indústrias Adafruit.
Licença BSD, verifique license.txt para mais informações

Todo o texto acima deve ser incluído em qualquer
alteração de redistribuição por Jennifer Case
**************************************** /
// analise a latitude
p = strchr (p, ',') + 1;
para (int i = 0; i <9; i ++) {
latit [i] = p [i];
latit [9] = '\ 0';
latitude = atof (p);
p = strchr (p, ',') + 1;
if (p [0] == 'N') lat = 'N';
else if (p [0] == 'S') lat = 'S';
else if (p [0] == ',') lat = 0;
mais retorno falso;
// analisa a longitude
p = strchr (p, ',') + 1;
para (int i = 0; i <10; i ++) {
longit [i] = p [i];
longit [10] = '\ 0';
longitude = atof (p);
As novas variáveis, latit e longit, podem então ser chamadas de forma semelhante ao exemplo de código de análise
chamado latitude e longitude anteriormente. A única diferença é que latit e longit são tratados como strings ao invés de
floats.
Como essas coordenadas são agora cadeias de caracteres, isso pode complicar o processamento delas, portanto, criei uma
classe Coordinate para manipular as strings e distribuí-las de maneira mais controlada.
Biblioteca de coordenadas
A biblioteca de coordenadas foi desenvolvida para trabalhar com as cadeias de caracteres que serão analisadas com essas
modificações na biblioteca Adafruit. Anexei a biblioteca a este tutorial.
Há usos nesta biblioteca que não serão necessários para uso (como alguns construtores). Alguns deles foram feitos para
funcionar com a construção de um mapa.
O construtor principal que será de interesse é o seguinte:

// constrói latitude e longitude a partir da string GPS
// degreeLen é determinado por se você está construindo
// uma latitude ou uma longitude. Use um grau de 2 quando
// construindo uma latitude e um grau de 3 quando
// construindo uma longitude.
Coordenar :: Coordenar (char * gpsString, int degreeLen) {
int i = 0;
grau de char [4];
minuto de char [3];
char minflt [7];
// Processo string
int j;
para (j = 0; j <degreeLen; j ++) {
grau [j] = gpsString [i];
i ++;
grau [j] = '\ 0';
para (j = 0; j <2; j ++) {
minuto [j] = gpsString [i];
i ++;
minuto [j] = '\ 0';
minflt [0] = '0';
para (j = 1; j <6; j ++) {
minflt [j] = gpsString [i];
i ++;
minflt [j] = '\ 0';
// calcular para e depois
frente = 60 * atol (grau) + atol (minuto);

aft = atof (minflt); // atof é aceitável devido a dígitos reduzidos
Este método usa dois argumentos, uma string e um inteiro. A string é latit ou longit do código anterior. O inteiro permite
que a classe saiba se deve processar a cadeia como uma latitude ou longitude. Como dito anteriormente, as longitudes têm
um dígito extra na parte do grau. Assim, enquanto a porção de grau de uma latitude tem dois dígitos de comprimento
(degreeLen = 2), a porção de grau de uma longitude tem três dígitos de comprimento (degreeLen = 3).
Isso converte tudo em minutos para o usuário e o gerencia em duas seções antes e depois. A parte dianteira é a totalidade
dos minutos, enquanto a parte posterior é a parte decimal dos minutos.
Para fins de comunicação, existe também um método que permite imprimir uma coordenada através da serial do Arduino:
// converta coordenada para uma string e imprima através de serial
void Coordinate :: print () {
CARACTERÍSTICA [10], ESTRADA [7], tempAft [6];
dtostrf (ré, 7,4, strAft);
int i = 0;
para (i = 0; i <6; i ++) {
tempAft [i] = strAft [i + 2];
tempAft [i] = '\ 0';
sprintf (strFore, "% 02d", fore);
Serial.print (strFore); // esta serial pode ser alterada se estiver usando um serial mega ou soft
Serial.print (tempAft); // esta serial pode ser alterada se estiver usando um serial mega ou soft
Existem mais métodos que podem ser usados ou adicionados à biblioteca para atender às necessidades individuais.
Anexos:
Coordinate.cpp
Coordinate.h
ArduIMU
Introdução
Uma IMU é algo usado para detectar principalmente orientação, mas é um termo geral para uma unidade de medida
inercial. Escusado será dizer que eles podem fornecer algumas informações vitais para robôs móveis. Em particular, os
robôs voadores precisam deles, pois não há como adivinhar a orientação usando os encoders de roda.
Uma vantagem em ter uma unidade all-in-one em vez de usar apenas cada um dos seus sensores é que a placa pode fazer a
verificação cruzada e mesclar os dados para você. Por exemplo, um giroscópio lhe dá mudanças na orientação em cada
eixo, mas um acelerômetro e um magnetômetro enviam direções em 3D - ambos em direções diferentes também. Mais
ainda, a aceleração nem sempre aponta para baixo.
Espera-se que esses sensores sejam capazes de fornecer informações de velocidade ou até de posição. Infelizmente, os
sensores não são precisos o suficiente para serem capazes de integrar numericamente e evitar erros de desvio. Pode ser
possível usar as informações para refinar algo que seja capaz de fornecer informações de posição - como um GPS. Em
parte, é por isso que muitas dessas placas incluem uma porta GPS. A outra é que eles são usados principalmente em drones
voadores, que geralmente querem um GPS de qualquer maneira e não é muito caro adicionar o conector.
Vantagens
Embora talvez não seja a IMU de maior desempenho, escolhi esse sensor porque achei razoavelmente barato por US $ 50
na DIY Robotics. Agora estou me perguntando se isso foi um erro, já que agora é mais caro. Por US $ 80, ainda é um sensor
ok. Eu também aprecio o fato de que ele pode ser reprogramado com um cabo FTDI e o Arduino IDE. Isso permite que você
altere as configurações e adicione seus próprios recursos. Outros sensores da IMU também farão isso. Um muito
semelhante é o IMU 130 $ Razor disponível no SparkFun .
Comunicação
Conexão
Simplesmente conecte o RX a TX e TX a RX em cada extremidade do ArduIMU e o que quer que você esteja lendo.
Para apenas ler a saída em um controlador baseado em Linux, simplesmente execute o comando no bash:
gato sudo / dev / ttyAMA0
Não use I2C
Não se preocupe em tentar se comunicar com ele via i2c. Claro, o i2c é legal e compacto, mas a bússola na placa está
realmente usando esses pinos e o i2c. Como resultado, o ArduIMU está no modo mestre e você não pode ser o mestre. Eu
perdi muito tempo tentando descobrir como lê-lo. Não se deixe enganar pelo fato de poder ver um dispositivo no endereço
1E, que é a bússola. Além disso, o i2c é um pouco lento demais para ser usado, então, mesmo que isso não fosse um
problema, ainda seria uma má ideia.
Formato
De acordo com a página do Google Code, o formato de saída é assim:

VER: 1,8,1, RLL: 1,12, PCH: -0,07, YAW: 34,03, IMUH: 253, LAT: 499247361, LON: -1193955623, ALT: 3525, COG: 0, SOG: 0,
CORRECÇÃO: 1 , SAT: 9, TOW: 21230400 ***
Isso provavelmente não é o que parece com o seu. Para ver de onde isso vem, encontre o código fonte aqui para a sua
versão, então olhe para Output.pde. Na minha versão 1.9.1, o formato adiciona slots para pinos analógicos. Meu ArduIMU
v3 produz algo no formato de:
Temp: 63503 Precios: 0 2 27 Giroscópios: 0 0 0 Mag: 397 0 -482
Em primeiro lugar, esses espaços são, na verdade, caracteres de tabulação. Também não tenho idéia do que temp está
fazendo, mas parece inútil aqui, já que está mudando aleatoriamente. "Giroscópios" é a mudança de orientação detectada
pelo giroscópio. Então, ele dirá 1 ou -1 normalmente em cada - talvez um pouco mais se estiver girando rápido. As saídas
accels e mag são vetores apontando na direção e magnitude do pull em x, yez. A saída padrão não possui nenhum ângulo
de euler, quaternião ou matrizes de cosseno de direção, o que é decepcionante.
Com toda a probabilidade, o ArduIMU provavelmente está enviando mais informações do que você realmente deseja. Pode
valer a pena reprogramar para fornecer apenas as informações necessárias. A maioria das escolhas comuns pode ser feita
editando o Arduimu.ino.
Depois de alguns ajustes, o meu agora se parece com isso:
RLL: -7,76, PCH: 3,77, YAW: 145,72, IMUH: 253, ACCX: -0,33, ACCY: -0,67, ACCZ: 9,58,
Imprime os ângulos euler, saúde IMU e vetor de aceleração. Eu também removi qualquer coisa para fazer com um GPS. É
rápido o suficiente para que o Arduino IDE não consiga acompanhar a saída serial. Ele maximiza meu processador e fica um
pouco atrasado. Espero que este não seja o atraso do sensor, mas apenas a exibição extremamente rápida.
Se você estiver interessado, leia como programar o ArduIMU abaixo e, em seguida, pegue minhas modificações no código
ArduIMU na parte inferior desta página.
Reprogramando
Ligando o FTDI
Conexão FTDI
ArduIMU v3 OSEPP FTDI
Preto GND
GND CTS
5V VCC
RX TXD
TX RXD
??? DTR
É provável que você queira que os ângulos de Euler, a matriz de quatérnio ou de rotação sejam impressos, pois isso é muito
mais fácil de usar rapidamente. Você precisará de um cabo FTDI. Eu escolhi o OSEPP porque ele tem um jumper para
escolher entre 3.3V e 5V, o que parece ser um recurso incrível. Eu peguei por cerca de 15 $ na Amazon.
Eu consegui apenas soldar um conector fêmea no meu OSTEP FTDI e conectar o Arduimu diretamente usando o grupo de
pinos horizontais na parte inferior. Também certifique-se de mudar para o modo 3.3V. Pelo que li, parece que não importa,
realmente, qual é a tensão em algumas das linhas. O SparkFun discute em uma das páginas do produto . Estou apostando
que há alguma verdade nisso, pois há um pino de 5V.
Além disso, dependendo do cabo FTDI que você tem, existe a possibilidade de que você precise pressionar o botão de reset
sozinho. O recurso de redefinição automática é aparentemente um pouco novo e também depende se ele está conectado
corretamente.
Também é recomendado que você alimente o ArduIMU com algo diferente do cabo FTDI durante a programação. Portanto,
certifique-se de conectar uma fonte de energia adicional aos pinos Vin ou 3.3V.
Makefile
De lá, você só precisa configurar o makefile. Execute make configure para configurar o make e execute make upload para
compilar e fazer o upload. Meu Makefile ficou assim, mas nunca consegui fazê-lo funcionar:
BOARD = atmega328
ARDUINO_DIR = / usr / share / arduino
TARGET = Arduimu
ARDUINO_PORT = / dev / ttyUSB0
ARDUINO_DIR = / usr / share / arduino
AVR_TOOLS_PATH = / usr / bin
incluem ../AP_Common/Arduino.mk
Eu também achei que você pode precisar adicionar # definir ARDUINO 103 para o código, a fim de corrigir alguns erros de
compilação. Este foi provavelmente um sinal de alguns problemas maiores embora.
IDE do Arduino
Na verdade, é mais fácil usar apenas o IDE do Arduino.
Copie a pasta Library do zip do código baixado para a pasta Library do seu caderno de esboços.
Abra o arquivo Arduimu.ino no Arduino IDE.
Simplesmente selecione a porta Serial correta - no meu sistema Ubuntu Linux era / dev / ttyUSB0. Em seguida, selecione
uma placa compatível - o Arduino Nano w ATmega328. O programador é apenas o padrão AVRISP mkII devido à interface
serial selecionada. No Windows, o processo de configuração do cabo FTDI pode ser mais detalhado. O ArduIMU google
code page tem mais algumas informações sobre ele. Você pode ser melhor apenas olhando para o seu cabo FTDI específico
primeiro.
Com o cabo FTDI no meu sistema, você pode realmente apenas abrir o monitor serial e definir a taxa de transmissão para
38400. Eu não sabia disso no início e estava conectando-o a um pi de framboesa para ver a saída. Isso é muito mais fácil.
Corrigindo Erros
Se você receber este erro:
AP_Common / AP_Common.h: na função 'int strcasecmp_P (const char *, const prog_char_t *)':
AP_Common / AP_Common.h: 108: 38: erro: ISO C ++ proíbe declaração de 'nome do tipo' sem tipo [-fmissmissive]
AP_Common / AP_Common.h: 108: 38: erro: ISO C ++ proíbe declaração de 'nome do tipo' sem nenhum tipo [-
fmissmissivo]
AP_Common / AP_Common.h: 108: 32: erro: expressão-primária esperada antes de 'const'
AP_Common / AP_Common.h: 108: 32: erro: esperado ')' antes de 'const'
Apenas adicione esta linha ao topo do Arduimu.pde. Em algum lugar acima das instruções #include:
typedef char PROGMEM prog_char;
Eu também fui ao redor e removi FastSerial e apenas deixei com o serial regular. Eu estou supondo que havia uma boa
razão para fazer o seu próprio, mas foi extremamente chato que eles tinham que usar o mesmo nome de variável que o
objeto Serial regular. Eu não consegui compilar devido a isso.
Configurando Saída
Há um monte de instruções #define no arquivo Arduimu.ino. Aqueles podem ser alterados para modificar muitos dos
recursos importantes. Eu tive que mudar quase todas as configurações para conseguir o que eu queria. Este é o resultado:
// Enable Air Start usa o sinalizador Remove Before Fly - conexão ao pino 6 no ArduPilot
#define ENABLE_AIR_START 0 // 1 se estiver usando sinalização airstart / groundstart, 0 se não
#define GROUNDSTART_PIN 8 // Número do pino usado para sinal de partida no solo (recomende 10 em v1 e 8 no
hardware v2)
/ * Filtro de velocidade mínima para correção de

desvios de guinada * / #define SPEEDFILT 0 //> 1 use o filtro de velocidade mínima para cancelamento de desvio de
guinada (m / s), 0 = não use filtro de velocidade
/ * Para depuração propurses * /

#define PRINT_DEBUG 0 // Imprime mensagens de depuração
// OUTPUTMODE = 1 imprime os dados corrigidos, 0 imprime dados não corrigidos dos giroscópios (com desvio), 2 imprime
somente dados do acelerômetro
#define OUTPUTMODE 1
#define PRINT_DCM 0 // Irá imprimir toda a direção da matriz coseno

#define PRINT_ANALOGS 0 // Irá imprimir os dados brutos analógicos
#define PRINT_EULER 1 // Irá imprimir os ângulos de Euler Roll, Pitch e Yaw
#define PRINT_GPS 0 // Irá imprimir GPS data
#define PRINT_MAGNETOMETER 0 // Irá imprimir dados do magnetômetro (se o magnetômetro estiver ativado)
// *** NOTA! Para usar o ArduIMU com o ArduPilot você deve selecionar mensagens de saída binária (mude para 1 aqui)
#define PRINT_BINARY 0 // Irá imprimir mensagens binárias e suprimir mensagens ASCII (acima)
// *** NOTA! O relatório de desempenho é suportado apenas para o Ublox. Definido como 0 para outros
#define PERFORMANCE_REPORTING 0 // Incluir relatórios de desempenho na saída binária ~ 1/2 min
Além disso, acho estranho que eles tivessem a opção de imprimir o magnetômetro, mas não o acelerômetro. Parece que a
aceleração seria muito mais importante para um controlador, já que as informações do magnetômetro, presumo, já estão
embutidas na saída de orientação.
Modificando a saída
Para adicionar as informações de aceleração, acabei de modificar o Output.ino (linha 61 a 68)
#define ACCELCONVERSION 0.0023147712

Serial.print ("ACCX:");
Serial.print (Accel_Vector [0] * ACCCONCONVERSÃO);
Serial.print (", ACCY:");
Serial.print (Accel_Vector [1] * ACCELCONVERSION);
Serial.print (", ACCZ:");
Serial.print (Accel_Vector [2] * ACCCONCONVERSÃO);
Serial.print (",");
A constante ACCELCONVERSION foi escolhida por expermentation para converter a saída para m / s 2 usando o seguinte
método:
1. Imprima os valores do Accel_Vector
2. Deixe o ArduIMU em um apartamento nível superfície
3. Pegue algumas amostras da aceleração no eixo z (Accel_Vector [2])
4. ACCELCONVERSION = 9,81 / SampleAverage
Repita o processo, se necessário, até que a saída seja corretamente calibrada para a constante gravitacional conhecida.
Talvez seja melhor prática, em vez disso, fazer a conversão no dispositivo de recebimento, uma vez que os valores seriam
mais compactos e enviados com precisão em série. Por outro lado, torna o ArduIMU mais acessível se as unidades forem
conhecidas. Para converter os dados de aceleração no dispositivo de leitura, o procedimento é o mesmo.
Analisando a entrada serial
Enquanto você pode ler este sensor com um Arduino, ele já é um Arduino. Além disso, o simples fato de você estar usando
isso provavelmente significa que você quer analisar um sistema 3D. Você provavelmente vai precisar de mais poder de
fogo. Algo como um Raspberry Pi ou um BeagleBone. Um processador Raspberry Pi é pelo menos 1000 vezes mais rápido
que um Arduino, e um BeagleBone Black é pelo menos duas vezes mais rápido que um Raspberry Pi e tem mais pinos.
Com esses dispositivos mais rápidos, você pode usar uma linguagem de programação de nível superior, como Python ou
Node.js. Ambos irão rodar o Python, então é uma boa escolha para velocidade e portabilidade.
Anexos:
ArduIMU-1.9.8-gpsless.zip
Controle de video game
Introdução
Os joysticks se tornaram uma ferramenta comum entre vários dispositivos, como controladores de jogos. Eles podem ser
uma adição interessante aos projetos também. Joysticks são componentes simplesmente simples que usam dois
potenciadores para dar as leituras de dois eixos. Eles também podem incluir um botão para ver se o usuário clicou no
joystick.
Esquemático
Abaixo está um esquema mostrando como o joystick se conecta a um Arduino.

Como dito anteriormente, um joystick comum usa dois potenciômetros giratórios e um botão. Os potenciadores são
analógicos, enquanto o botão é digital.
Código
O código a seguir mostra como ler os vários componentes do joystick.
int verPin = A0;
int horPin = A1;
int selPin = 2;
void setup () {
pinMode (selPin, INPUT);
digitalWrite (selPin, ALTO);
void loop () {
int verPos = analogRead (verPin);
int horPos = analogRead (horPin);
booleano selBtn = digitalRead (selPin);
Obter as informações do componente é muito simples, mas muitos projetos divertidos podem ser feitos com joysticks.

Sensores Ver

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sensores Ver

Enviado por

Direitos autorais:

Formatos disponíveis

Sensores

Sensor Infravermelho GP2Y0D810

O importante é notar que o pino OUT vai para um pino analógico.

int irPin = A0;

sensorValue = analogRead (irPin);

// verifica o valor de 85 ou menos para o teste de distância

if (sensorValue <= 85) {

Serial.println ("Too close");

Sensor Infravermelho GP2Y0A02YK em Distância Real

Colete alguns dados

-0,00003983993846 v 3 + 0,0456899769 v 2 - 17,48535575 v + 2571,052715

Converter para código

Depois de ter uma curva de bom ajuste, o código é bastante simples:

// alguns globals usados para calcular a média das amostras

// converte a tensão para milímetros

int convertIRvoltsToMM (float v) {

devolução -0,00003983993846 * v * v * v + 0,0456899769 * v * v - 17,48535575 * v + 2571,052715;

irSum + = analogRead (A0);

int distance = convertIRvoltsToMM (float (irSum) / float (numSamples));

Ping))) Sensor Ultrassônico

long previousMillis = millis ();

if (millis () - previousMillis> interval) {

pinMode (pingPin, OUTPUT);

digitalWrite (pingPin, LOW);

digitalWrite (pingPin, ALTO);

digitalWrite (pingPin, LOW);

duration = pulseIn (pingPin, ALTO);

previousMillis = millis ();

Sensor de Distância Ultrassônico HC-SR04

O sensor de distância HC-SR04 é um sensor ultrassônico usado para medições de distância.

O sensor está conectado da seguinte forma:

// Adaptado do código de David A. Mellis para o sensor Ping

const int trigPin = 7;

const int echoPin = 8;

// inicializa a comunicação serial:

pinMode (trigPin, OUTPUT);

pinMode (echoPin, INPUT);

longa duração, polegadas, cm;

digitalWrite (trigPin, LOW);

digitalWrite (trigPin, HIGH);

digitalWrite (trigPin, LOW);

duração = pulseIn (echoPin, HIGH);

// converte o tempo em uma distância

inches = microsecondsToInches (duração);

microsecondsToInches longos (microssegundos longos)

// De acordo com a folha de dados da Parallax para o PING))), existem

// segundo). Isso dá a distância percorrida pelo ping, saída

// e retornar, então dividimos por 2 para obter a distância do obstáculo.

retorno microssegundos / 74/2;

microsecondsToCentimeters longos (microssegundos longos)

// A velocidade do som é de 340 m / s ou 29 microssegundos por centímetro.

// O ping viaja para fora e para trás, para encontrar a distância do

// Objeto nós tomamos metade da distância percorrida.

retorno microssegundos / 29/2;

Sensor PIR (HC-SR501)

Abaixo está o esquema para usar um sensor PIR. É bastante simples.

val = digitalRead (pirPin); // leia o estado do PIR

Serial.println ("Motion!"); // se o valor lido for alto, houve movimento

Câmera JPEG Linksprite

 Câmara JPEG TTL da Linksprite

Arduino: tire fotos

// Configure os pinos 2 e 3 como porta serial

SoftwareSerial cameraSerial = SoftwareSerial (2, 3);