API de sensor genérico – W3C

Cada vez mais, os dados dos sensores são usados ​​no desenvolvimento de aplicativos para permitir novos casos de uso, como geolocalização, contagem de etapas ou rastreamento de cabeças. Isso é especialmente verdadeiro em dispositivos móveis nos quais novos sensores são adicionados regularmente.

A exposição de dados de sensores à Web até agora tem sido lenta e ad-hoc. Poucos sensores já estão expostos à web. Quando eles são, muitas vezes é de maneiras que limitam seus possíveis casos de uso (por exemplo, expondo abstrações que são muito alto nível e que não funcionam bem o suficiente). As APIs também variam muito de um sensor para o outro, o que aumenta a carga cognitiva dos desenvolvedores de aplicativos da Web e diminui o desenvolvimento.

O objetivo da Generic Sensor API é promover consistência entre APIs de sensores, habilitar casos de uso avançados graças a APIs de baixo nível e aumentar o ritmo no qual novos sensores podem ser expostos à Web, simplificando a especificação e os processos de implementação.

Uma lista abrangente de sensores sólidos que são baseados na API do Sensor genérico, casos de uso aplicáveis ​​e exemplos de código pode ser encontrada nos documentos do [GENERIC-SENSOR-USECASES] e [MOTION-SENSORS] .

https://w3c.github.io/sensors/#high-level

SENSOR ULTRASÔNICO JSN-SR04T

O JSN-SR04T é um sensor de distância ultra-sônico à prova d’água, fácil de usar, com uma faixa de 25 a 450 cm. Se você está planejando construir um sistema de medição do nível de água ou se você precisa fazer outras medições de distância fora, então este é o sensor que você precisa!

Eu incluí um diagrama de fiação e códigos de exemplo para que você possa começar a experimentar seu sensor.

 

O que este artigo cobre

Informações sobre o sensor

O sensor vem com um cabo de 2,5 m de comprimento que se conecta a uma placa de fuga que controla o sensor e faz todo o processamento do sinal. Note que apenas o sensor e o cabo em si são à prova d’água, se você colocar água na placa de fuga, coisas ruins acontecerão.

Um sensor de distância ultra-sônico funciona enviando ondas de ultra-som. Essas ondas de ultra-som são refletidas de volta por um objeto e o sensor ultrassônico as detecta. Ao cronometrar quanto tempo passou entre enviar e receber as ondas sonoras, você pode calcular a distância entre o sensor e um objeto.

Distância (cm) = Velocidade do som (cm / µs) × Tempo (µs) / 2

Onde Tempo  é o tempo entre enviar e receber as ondas sonoras em microssegundos.

Então, quais são as diferenças entre este sensor e o HC-SR04? A principal diferença, além de ser à prova d’água, é que este sensor usa apenas um transdutor ultrassônico. Este transdutor serve tanto como transmissor quanto receptor das ondas de ultra-som.

Para mais informações sobre como os sensores ultrassônicos funcionam, você pode conferir o artigo no HC-SR04 abaixo. Neste artigo, o princípio de funcionamento é explicado com muito mais detalhes.

JSN-SR04T Especificações

Tensão operacional 5V
Corrente de operação 30mA
Corrente quiescente 5mA
Freqüência 40 kHz
Faixa de medição 25 a 450 cm
Resolução 2 mm
Ângulo de medição 45 a 75 graus
Dimensões do sensor Cabo de 23,5 x 20 mm, 2,5 m de comprimento
Dimensões do PCB 41 x 28,5 mm
Orifício de montagem 18 mm

Para mais informações, você pode conferir a folha de dados aqui.

Componentes

* Nota: os links acima são afiliados, o que significa – sem nenhum custo adicional para você – se você comprar algo usando eles, você está ajudando a apoiar o meu trabalho neste site. Meus humildes agradecimentos (eu realmente agradeço)! 

Ao comprar o sensor, você pode encontrar a versão atualizada,  JSN-SR04T-2.0 . Essa versão mais recente funciona exatamente da mesma forma, mas alguns usuários encontraram problemas ao usar os sensores em uma voltagem mais baixa. Esta versão mais recente está classificada para 3 a 5 V.

Usar um pulso de gatilho mais longo de pelo menos 20 µs em vez de 10 µs parece ajudar se você estiver tendo leituras defeituosas.

Fiação – Conectando o JSN-SR04T ao Arduino UNO

O diagrama de fiação / esquema abaixo mostra como conectar o sensor JSN-SR04T ao Arduino. A placa de desagregação da JSN-SR04T possui a mesma pinagem que a HC-SR04, portanto, pode ser usada como substituta imediata. O cabo do sensor em si pode ser conectado ao conector na parte de trás da placa de fuga.

JSN-SR04T com diagrama de fiação do Arduino

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o gatilho e o pino de eco, mas é claro que você pode mudar isso para qualquer pino digital desejado.

Conexões JSN-SR04T

JSN-SR04T Arduino
5V 5V
Trig Pino 2
Eco Pino 3
GND GND

Exemplo de código para o JSN-SR04T com Arduino

Agora que você conectou o sensor, é hora de conectar o Arduino ao computador e fazer o upload de algum código. O sensor pode ser usado sem uma biblioteca do Arduino. Mais tarde, mostrarei um exemplo com a biblioteca NewPing, que torna o código muito mais curto.

Você pode fazer o upload do seguinte código de exemplo para o seu Arduino usando o  Arduino IDE . Em seguida, vou explicar como o código funciona. (Este código também funciona para o JSN-SR04T-2.0).

/* JSN-SR04T Ultrasonic Distance Sensor with Arduino Example Code. More info: https://www.makerguides.com */

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 3

//Define variables
long duration;
int distance;

void setup()
{
//Define inputs and outputs
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

//Begin Serial communication
Serial.begin(9600); // Starts the serial communication at a baudrate of 9600
}

void loop()
{
//Clear the trigPin by setting it LOW
digitalWrite(trigPin, LOW);
delayMicroseconds(5);

//Trigger the sensor by setting the trigPin high for 10 microseconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

//Read the echoPin. pulseIn() returns the duration (length of the pulse) in microseconds.
duration = pulseIn(echoPin, HIGH);
// Calculate the distance
distance= duration*0.034/2;

//Print the distance on the Serial Monitor (Ctrl+Shift+M)
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(100);
}

Se houver a necessidade de leitura de mais sensores, isso pode ser feito facilmente com a biblioteca NewPing. Basta criar duas ou mais instâncias da classe NewPing e adicionar um gatilho e um eco adicionais:

#define trigPin 2 
#define echoPin 3 
#define trigPin2 4 
#define echoPin2 5

Sonar NewPing (trigPin, echoPin, MAX_DISTANCE); 
Sonar 2 de NewPing (trigPin2, echoPin2, MAX_DISTANCE);

Agora, se você quiser ler o primeiro sensor, você pode usar o sonar.ping_cm () e o segundo sensor sonar2.ping_cm ().

 

DOWNLOAD DA BIBLIOTECA NEW PING

 

FONTE: https://www.makerguides.com/jsn-sr04t-arduino-tutorial/

 

Módulo Ultrassônico JSN-SR04T WAVGAT À Prova D’ Água

Características:

O tamanho pequeno, fácil de usar
Baixa tensão, baixo consumo de energia
Alta precisão
Forte anti-jamming
Integrado com sonda de fio fechado à prova d’ água, adequado para molhado, duras ocasiões de medição

Especificação:

Tensão de funcionamento: DC 5 V
Estática atual de trabalho: 5mA
Corrente de trabalho: 30mA
Freqüência de emissão acústica: 40 KHz
Fiação: + 5 V (positiva); Trig (controle); Echo (receber); GND (cátodo)

Conexão com arduino:
5 V: 5 V Suply
Trig: D12
Echo: D13
GND: GND

Aplicação:

Distância Horizontal messurement
Desvio de obstáculos, controle automático
Controle de tráfego
Segurança, controle industrial

 

 

Sensor de temperatura DS18B20

O sensor DS18B20 utiliza o protocolo de comunicação 1-Wire. Este protocolo permite a conexão de inúmeros dispositivos numa mesma rede, utilizando apenas 1 fio para a troca de dados.

O sensor DS18B20 fornece temperaturas entre -55°C e 125°C com uma precisão de ±0.5°C no intervalo de -10°C to +85°C. Vide datasheet. Ele é identificado na rede 1-Wire a partir de um código único de 64 bits.

Na figura acima são observados os seus pinos no encapsulamento TO92. Nota-se que o pino GND corresponde ao terra, VDD a 5V e no pino DQ é fornecida a informação de temperatura.
 Um microcontrolador pode ler informações deste sensor utilizando um único fio e resistor de pull-up, sendo normalmente utilizado um resistor de 4k7 ohms.

No circuito abaixo observa-se a conexão do sensor com uma placa arduino, sendo que foi escolhida a porta digital 2 do arduino para a leitura do sensor.

ds18b20_schem
Com este circuito, é possível monitorar as temperaturas amostradas pelo sensor utilizando o código  abaixo. As bibliotecas OneWire e DallasTemperature podem ser obtidas aqui. Basta descompactar as bibliotecas no diretório “libraries” do ambiente arduino.
#include "OneWire.h"
#include "DallasTemperature.h"


#define ONE_WIRE_BUS 2       // sensor conectado na porta digital 2


OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

void setup() {
Serial.begin(9600);
sensors.begin();
}

void loop() {
sensors.requestTemperatures();

Serial.print(“Temperatura no sensor 1 : “); // pode haver mais
Serial.println(sensors.getTempCByIndex(0)); // do que um sensor
}

Para verificar as temperaturas amostradas, basta pressionar a tecla “Serial Monitor” no ambiente de programação arduino e visualizar uma tela similar à figura abaixo:

ds18b20Janela

Placa inteligente que transforma qualquer superfície em um sensor

 

Em tempos onde a tecnologia está tomando conta das nossas vidas, não saber nada sobre o assunto passa a ser analfabetismo. Ensinando as pessoas a criar e transformar qualquer superfície em um sensor de um jeito fácil, a placa inteligente Touch Board veio para revolucionar o mercado.

Através do financiamento coletivo no Kickstarter, em 2013, o time de desenvolvedores realizou alguns experimentos utilizando sensores de toque e de proximidade até chegar ao resultado final, ativando sons e outros itens com o uso da criatividade, aplicada a uma plataforma, Arduino, que seria especialmente para prototipagem eletrônica, composta de hardware e software, no esquema open source, ou seja, com código aberto e acessível.

Ao combinar a placa com uma tinta condutora, que pode ser aplicada a diversos tipos de materiais, não há necessidade de fios, o que torna o processo mais apresentável e simples de ser usado.  O produto está à venda em versão pré-programada, com um guia de ajuda gravado em áudio. Dá uma olhada no vídeo de experimentação:

touchboardtouchboard5toucboard8touchboard3touchboard6toucboard2touchboard11touchboard7toucboard2 touchboard4touchboard8 touchboard9 touchboard10

touch2

Arduino: Leitura do sensor DS18S20 e DS18B20

1

Demonstração de leitura do sensor DS18S20 e DS18B20 utilizando o arduino. Esses sensor utiliza a comunicação 1-Wire, que possui vantagens em releção ao I2C, pois permite a integração de vários sensores utilizando apenas um fio.
Eu utilizei a biblioteca OneWire, que pode ser baixada aqui.
Funções principais da biblioteca OneWire:
OneWire ds( pin ); – Cria o objeto onewire e define o pino a ser utilizado.
ds.search( addr );  – recupera o endereço de todos no barramento.
ds.reset(); – reset no barramento.
ds.select( addr ); – seleciona o sensor.
ds.write( byte ); – envia um byte ao sensor.
ds.read() – lê um byte do sensor.

DOWNLOAD:
Arquivo de simulação do Proteus: DS18x20_Arduino.DSN;

CóDIGO-FONTE:
2
#include <LiquidCrystal.h>
#include <OneWire.h>

OneWire ds(2); // pino 2
LiquidCrystal lcd(13,12,11,10,9,8);

void setup(void) {
lcd.begin(16,2);
lcd.print(“DS18S20: “);
lcd.setCursor(0,1);
lcd.print(“DS18B20: “);
}

void loop(void) {
byte i = 0;
byte data[9];
byte addr[8];
int temp;
boolean type;

//recupera o endereço dos sensores e armazena em “addr”
if(!ds.search(addr)){
return;
}

switch(addr[0]){
case 0x10: type = 1; break;//DS18S20
case 0x22: type = 0; break;//DS1822
case 0x28: type = 0; break;//DS18B20
default: break;
}

ds.reset();//sinal de reset
ds.select(addr);//envia o endereço do sensor
ds.write(0x44);//inicializa conversao de temperatura
delay(750);//espera 750ms para calcular a temperatura

ds.reset();//sinal de reset
ds.select(addr);//envia o endereço do sensor atual
ds.write(0xBE);//inicia a leitura do scratchpad ( 9 bytes )

//Leitura
for ( i = 0; i < 9; i++) {
data[i] = ds.read();
}

if(!type){//DS18B20 ou DS1822

lcd.setCursor(9,1);

if((data[1]>>7)==1){//verifica se a temperatura é negativa
data[1] = ~data[1];
data[0] = (~data[0]) + 1;
lcd.print(“-“);
}
else{
lcd.print(“+”);
}
temp = (data[1]<<4) | (data[0]>>4);
lcd.print(temp);
lcd.print(“.”);
temp = (data[0] & 0x0F) * 625;//casas decimais
if(temp>625){
lcd.print(temp);
}
else{
lcd.print(“0”);
lcd.print(temp);
}
}
else{//DS18S20

lcd.setCursor(9,0);

if((data[1]>>7)==1){//verifica se a temperatura é negativa
data[0] = ~data[0];
lcd.print(“-“);
}
else{
lcd.print(“+”);
}
temp = data[0]>>1;
lcd.print(temp);
lcd.print(“.”);
lcd.print((data[0] & 0x01)*5);//casa decimal

}
lcd.print(” “);
lcd.write(223);//imprime o caracter (°)
lcd.print(“C “);
}

3
UTILIZANDO APENAS UM SENSOR

Caso utilize apenas um sensor no barramento, não há necessidade de fazer a procurar do endereço ROM do dispositivo, pois o mesmo nem será usado.

Ao invés disso envie o comando SKIP ROM(0xCC).
Veja o código como ficou, utilizando apenas o DS18B20:
2
#include <LiquidCrystal.h>
#include <OneWire.h>

OneWire ds(2); // pino 2
LiquidCrystal lcd(13,12,11,10,9,8);

void setup(void) {
lcd.begin(16,2);
lcd.print(“DS18S20: “);
}

void loop(void) {
byte data[9];
int temp;

ds.reset();//sinal de reset
ds.write(0xCC);//skip rom
ds.write(0x44);//inicia conversão de temperatura
delay(750);//espera 750ms para calcular a temperatura
ds.reset();//sinal de reset
ds.write(0xCC);//skip rom
ds.write(0xBE);//inicia a leitura do scratchpad ( 9 bytes )

//Leitura
for (byte i = 0; i < 9; i++) {
data[i] = ds.read();
}
lcd.setCursor(9,0);

if((data[1]>>7)==1){//verifica se a temperatura é negativa
data[1] = ~data[1];
data[0] = (~data[0]) + 1;
lcd.print(“-“);
}
else{
lcd.print(“+”);
}
temp = (data[1]<<4) | (data[0]>>4);
lcd.print(temp);
lcd.print(“.”);
temp = (data[0] & 0x0F) * 625;
if(temp>625){
lcd.print(temp);
}
else{
lcd.print(“0″);
lcd.print(temp);
}
lcd.print(” “);
lcd.write(223);//imprime o caracter (°)
lcd.print(“C “);
}

3

RECUPERANDO O ENDEREÇO ROM
Caso você queira saber o endereço ROM do sensor, é preciso enviar o comando READ ROM(0x33). Veja que so poderá ter apenas um sensor no barramento, para que não ocorra uma colisão de dados.

Você verá no monitor serial algo do tipo: 10 30 C5 B8 0 0 0 C3;
o código em azul: indica a familia do sensor (0x10 – DS18S20, 0x28 – DS18B20, 0x22 – DS1822)
o código em verde: é o número serial (possui 6 bytes, do menos significativo ao mais significativo)
o código em vermelho: é o CRC(verificador de redundância cíclica), usado para a verificar se os dados enviados ao arduino não possuem erros.

Veja o código:
2
#include <OneWire.h>

OneWire ds(2); // pino 2

void setup(void) {
Serial.begin(9600);
}

void loop(void) {
byte i = 0;
byte data[8];
int temp;

ds.reset();//sinal de reset
ds.write(0x33);//read rom

//Leitura
for ( i = 0; i < 8; i++) {
data[i] = ds.read();
Serial.print(data[i], HEX);
Serial.print(” “);
}

Serial.println();

delay(100);
}

3
EXEMPLO COM DS18S20 E POSSUINDO SEU ENDEREÇO ROM
2
#include <OneWire.h>

OneWire ds(2); // pino 2

void setup(void) {
Serial.begin(9600);
}

void loop(void) {
byte data;
byte signal;
int temp;
byte addr[8]={0x10,0x30,0xC5,0xC8,0,0,0,0xC3};//endereço rom do ds18s20

ds.reset();//sinal de reset
ds.select(addr);//envia o endereço rom
ds.write(0x44);//inicia a conversão da temperatura
delay(750);
ds.reset();//sinal de reset
ds.select(addr);//envia o endereço rom
ds.write(0xBE);//leitura da temperatura
data = ds.read();//byte 0 – temperatura
signal = ds.read();//byte 1 – sinal de negativo/positivo
if(signal){//se a temp. for negativa
data = (~data);
Serial.print(“-“);
}
Serial.print(data>>1);
Serial.print(“.”);
Serial.print((data & 0x01)*5);
Serial.println();

delay(100);
}

3
Ligação do Sensor DS18S20 e DS18B20:
DS18B20 - 2 sensores