DHT22传感器+；pi4j+；JAVA
我在以下带有先决条件的链接中尝试了该代码： Java 1.8.0_65 pi4j 1.1 树莓皮3 B型 DHT22温度传感器 在这里，当我尝试执行链接中可用的以下两个代码时，我面临的问题是代码中的DHT22传感器+；pi4j+；JAVA,java,pi4j,Java,Pi4j,我在以下带有先决条件的链接中尝试了该代码： Java 1.8.0_65 pi4j 1.1 树莓皮3 B型 DHT22温度传感器 在这里，当我尝试执行链接中可用的以下两个代码时，我面临的问题是代码中的LibPins public DHT11(int pin) { final GpioController gpio = GpioFactory.getInstance(); dht11Pin = gpio.provisionDigitalMultipurposePin(LibPins.getPin
LibPinspublic DHT11(int pin) {
final GpioController gpio = GpioFactory.getInstance();
dht11Pin = gpio.provisionDigitalMultipurposePin(LibPins.getPin(pin),
PinMode.DIGITAL_INPUT, PinPullResistance.PULL_UP);
}
sudo apt get install wiringpiimport com.pi4j.wiringpi.Gpio;
import com.pi4j.wiringpi.GpioUtil;
public class DHT22 implements Runnable {
private static final int maxTimings = 85;
private final int[] dht22_dat = {0, 0, 0, 0, 0};
private float temperature = 9999;
private float humidity = 9999;
boolean shuttingDown = false;
public DHT22() {
// setup wiringPi
if (Gpio.wiringPiSetup() == -1) {
System.out.println(" ==>> GPIO SETUP FAILED");
return;
}
GpioUtil.export(3, GpioUtil.DIRECTION_OUT);
}
private int pollDHT22() {
int lastState = Gpio.HIGH;
int j = 0;
dht22_dat[0] = dht22_dat[1] = dht22_dat[2] = dht22_dat[3] = dht22_dat[4] = 0;
int pinNumber = 16;
Gpio.pinMode(pinNumber, Gpio.OUTPUT);
Gpio.digitalWrite(pinNumber, Gpio.LOW);
Gpio.delay(18);
Gpio.digitalWrite(pinNumber, Gpio.HIGH);
Gpio.pinMode(pinNumber, Gpio.INPUT);
for (int i = 0; i < maxTimings; i++) {
int counter = 0;
while (Gpio.digitalRead(pinNumber) == lastState) {
counter++;
Gpio.delayMicroseconds(1);
if (counter == 255) {
break;
}
}
lastState = Gpio.digitalRead(pinNumber);
if (counter == 255) {
break;
}
/* ignore first 3 transitions */
if (i >= 4 && i % 2 == 0) {
/* shove each bit into the storage bytes */
dht22_dat[j / 8] <<= 1;
if (counter > 16) {
dht22_dat[j / 8] |= 1;
}
j++;
}
}
return j;
}
private void refreshData() {
int pollDataCheck = pollDHT22();
if (pollDataCheck >= 40 && checkParity()) {
final float newHumidity = (float) ((dht22_dat[0] << 8) + dht22_dat[1]) / 10;
final float newTemperature = (float) (((dht22_dat[2] & 0x7F) << 8) + dht22_dat[3]) / 10;
if (humidity == 9999 || ((newHumidity < humidity + 40) && (newHumidity > humidity - 40))) {
humidity = newHumidity;
if (humidity > 100) {
humidity = dht22_dat[0]; // for DHT22
}
}
if (temperature == 9999 || ((newTemperature < temperature + 40) && (newTemperature > temperature - 40))) {
temperature = (float) (((dht22_dat[2] & 0x7F) << 8) + dht22_dat[3]) / 10;
if (temperature > 125) {
temperature = dht22_dat[2]; // for DHT22
}
if ((dht22_dat[2] & 0x80) != 0) {
temperature = -temperature;
}
}
}
}
float getHumidity() {
if (humidity == 9999) {
return 0;
}
return humidity;
}
@SuppressWarnings("unused")
float getTemperature() {
if (temperature == 9999) {
return 0;
}
return temperature;
}
float getTemperatureInF() {
if (temperature == 9999) {
return 32;
}
return temperature * 1.8f + 32;
}
private boolean checkParity() {
return dht22_dat[4] == (dht22_dat[0] + dht22_dat[1] + dht22_dat[2] + dht22_dat[3] & 0xFF);
}
@Override
public void run() {
while (!shuttingDown) {
refreshData();
}
}
}
import com.pi4j.wiringpi.Gpio；
导入com.pi4j.wiringpi.GpioUtil；
公共类DHT22实现可运行{
专用静态最终整数最大定时=85；
私有final int[]dht22_dat={0,0,0,0}；
专用浮子温度=9999；
私人浮子湿度=9999；
布尔关闭=假；
公共DHT22（）{
//安装接线
如果（Gpio.wiringPiSetup（）=-1）{
System.out.println（“==>>GPIO设置失败”）；
返回；
}
GpioUtil.export（3，GpioUtil.DIRECTION_OUT）；
}
私有整数pollDHT22（）{
int lastState=Gpio.HIGH；
int j=0；
dht22_-dat[0]=dht22_-dat[1]=dht22_-dat[2]=dht22_-dat[3]=dht22_-dat[4]=0；
int-pinNumber=16；
Gpio.pinMode（pinNumber，Gpio.OUTPUT）；
Gpio.digitalWrite（pinNumber，Gpio.LOW）；
Gpio.延迟（18）；
Gpio.digitalWrite（pinNumber，Gpio.HIGH）；
Gpio.pinMode（pinNumber，Gpio.INPUT）；
对于（int i=0；i=4&&i%2==0）{
/*将每个位放入存储字节*/
dht22_-dat[j/8]=40&&checkParity（）{
最终浮子新湿度=（浮子）（（dht22_dat[0]100）{
湿度=dht22_dat[0]；//对于dht22
}
}
如果（温度==9999 | |（（新温度<温度+40）和&（新温度>温度-40）））{
温度=（浮动）（（dht22_dat[2]和0x7F）125）{
温度=dht22_dat[2]；//对于dht22
}
如果（（dht22_dat[2]&0x80）！=0）{
温度=-温度；
}
}
}
}
浮动湿度（）{
如果（湿度==9999）{
返回0；
}
返回湿度；
}
@抑制警告（“未使用”）
浮子温度（）{
如果（温度==9999）{
返回0；
}
返回温度；
}
浮点getTemperatureInF（）{
如果（温度==9999）{
返回32；
}
返回温度*1.8f+32；
}
私有布尔校验（）{
返回dht22_-dat[4]=（dht22_-dat[0]+dht22_-dat[1]+dht22_-dat[2]+dht22_-dat[3]&0xFF）；
}
@凌驾
公开募捐{
当（！关机）{
刷新数据（）；
}
}
}
import java.io.Closeable；
导入java.io.IOException；
导入java.nio.ByteBuffer；
导入java.nio.ByteOrder；
导入java.util.Objects；
导入java.util.concurrent.Callable；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
导入java.util.concurrent.TimeUnit；
导入java.util.concurrent.TimeoutException；
导入com.pi4j.io.gpio.Pin；
导入com.pi4j.io.gpio.RaspiPin；
导入com.pi4j.wiringpi.Gpio；
/**
*使用Pi4J在Java中实现DHT22/AM2302读取。
*
*有关计时的详细信息，请参见（AM2302.pdf）规格表。
*
*@作者Doug Culnane
*/
公共类DHT22{
/**
*分离零和一信号的时间（以纳秒为单位）。
*/
专用静态最终整数最长_0=50000；
/**
*PI4J引脚编号。
*/
私有整数；
/**
*来自传感器的40位数据
*/
专用字节[]数据=null；
/**
*上次成功读取的湿度值。
*/
私人双湿度=零；
/**
*上次成功读取的温度值。
*/
专用双温=零；
/**
*上次读取尝试
*/
private Long lastRead=null；
/**
*带用于信号的引脚的构造函数。有关详细信息，请参阅PI4J和WiringPI
*引脚编号系统。。。。。
*
*@param-pin
*/
公共DHT22（Pin）{
pinNumber=pin.getAddress（）；
}
/**
*与传感器通信以获取新的读取数据。
*
*@如果无法成功读取数据，则引发异常。
*/
私有void getData（）引发异常{
ExecutorService executor=Executors.newSingleThreadExecutor（）；
ReadSensorFuture readSensor=新的ReadSensorFuture（）；
未来=执行者提交（读取传感器）；
//重置数据
数据=新字节[5]；
试一试{
data=future.get（3，TimeUnit.SECONDS）；
readSensor.c
import java.io.Closeable;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.wiringpi.Gpio;
/**
* Implements the DHT22 / AM2302 reading in Java using Pi4J.
*
* See (AM2302.pdf) specksheet for details of timings.
*
* @author Doug Culnane
*/
public class DHT22 {
/**
* Time in nanoseconds to separate ZERO and ONE signals.
*/
private static final int LONGEST_ZERO = 50000;
/**
* PI4J Pin number.
*/
private int pinNumber;
/**
* 40 bit Data from sensor
*/
private byte[] data = null;
/**
* Value of last successful humidity reading.
*/
private Double humidity = null;
/**
* Value of last successful temperature reading.
*/
private Double temperature = null;
/**
* Last read attempt
*/
private Long lastRead = null;
/**
* Constructor with pin used for signal. See PI4J and WiringPI for
* pin numbering systems.....
*
* @param pin
*/
public DHT22(Pin pin) {
pinNumber = pin.getAddress();
}
/**
* Communicate with sensor to get new reading data.
*
* @throws Exception if failed to successfully read data.
*/
private void getData() throws Exception {
ExecutorService executor = Executors.newSingleThreadExecutor();
ReadSensorFuture readSensor = new ReadSensorFuture();
Future<byte[]> future = executor.submit(readSensor);
// Reset data
data = new byte[5];
try {
data = future.get(3, TimeUnit.SECONDS);
readSensor.close();
} catch (TimeoutException e) {
readSensor.close();
future.cancel(true);
executor.shutdown();
throw e;
}
readSensor.close();
executor.shutdown();
}
/**
* Make a new sensor reading.
*
* @throws Exception
*/
public boolean read() throws Exception {
checkLastReadDelay();
lastRead = System.currentTimeMillis();
getData();
checkParity();
humidity = getReadingValueFromBytes(data[0], data[1]);
temperature = getReadingValueFromBytes(data[2], data[3]);
lastRead = System.currentTimeMillis();
return true;
}
private void checkLastReadDelay() throws Exception {
if (Objects.nonNull(lastRead)) {
if (lastRead > System.currentTimeMillis() - 2000) {
throw new Exception("Last read was under 2 seconds ago. Please wait longer between reads!");
}
}
}
private double getReadingValueFromBytes(final byte hi, final byte low) {
ByteBuffer bb = ByteBuffer.allocate(2);
bb.order(ByteOrder.BIG_ENDIAN);
bb.put(hi);
bb.put(low);
short shortVal = bb.getShort(0);
return new Double(shortVal) / 10;
}
private void checkParity() throws ParityChheckException {
if (!(data[4] == (data[0] + data[1] + data[2] + data[3] & 0xFF))) {
throw new ParityChheckException();
}
}
public Double getHumidity() {
return humidity;
}
public Double getTemperature() {
return temperature;
}
/**
* Run from command line to loop and make readings.
* @throws IOException
*/
public static void main(String[] args) throws IOException {
System.out.println("Starting DHT22");
if (Gpio.wiringPiSetup() == -1) {
System.out.println("GPIO wiringPiSetup Failed!");
return;
}
DHT22 dht22 = new DHT22(RaspiPin.GPIO_05);
int LOOP_SIZE = 10;
int countSuccess = 0;
for (int i=0; i < LOOP_SIZE; i++) {
try {
Thread.sleep(3000);
System.out.println();
dht22.read();
System.out.println("Humidity=" + dht22.getHumidity() +
"%, Temperature=" + dht22.getTemperature() + "*C");
countSuccess++;
} catch (TimeoutException e) {
System.out.println("ERROR: " + e);
} catch (Exception e) {
System.out.println("ERROR: " + e);
}
}
System.out.println("Read success rate: "+ countSuccess + " / " + LOOP_SIZE);
System.out.println("Ending DHT22");
}
/**
* Callable Future for reading sensor. Allows timeout if it gets stuck.
*/
private class ReadSensorFuture implements Callable<byte[]>, Closeable {
private boolean keepRunning = true;
public ReadSensorFuture() {
Gpio.pinMode(pinNumber, Gpio.OUTPUT);
Gpio.digitalWrite(pinNumber, Gpio.HIGH);
}
@Override
public byte[] call() throws Exception {
// do expensive (slow) stuff before we start.
byte[] data = new byte[5];
long startTime = System.nanoTime();
sendStartSignal();
waitForResponseSignal();
for (int i = 0; i < 40; i++) {
while (keepRunning && Gpio.digitalRead(pinNumber) == Gpio.LOW) {
}
startTime = System.nanoTime();
while (keepRunning && Gpio.digitalRead(pinNumber) == Gpio.HIGH) {
}
long timeHight = System.nanoTime() - startTime;
data[i / 8] <<= 1;
if ( timeHight > LONGEST_ZERO) {
data[i / 8] |= 1;
}
}
return data;
}
private void sendStartSignal() {
// Send start signal.
Gpio.pinMode(pinNumber, Gpio.OUTPUT);
Gpio.digitalWrite(pinNumber, Gpio.LOW);
Gpio.delay(1);
Gpio.digitalWrite(pinNumber, Gpio.HIGH);
}
/**
* AM2302 will pull low 80us as response signal, then
* AM2302 pulls up 80us for preparation to send data.
*/
private void waitForResponseSignal() {
Gpio.pinMode(pinNumber, Gpio.INPUT);
while (keepRunning && Gpio.digitalRead(pinNumber) == Gpio.HIGH) {
}
while (keepRunning && Gpio.digitalRead(pinNumber) == Gpio.LOW) {
}
while (keepRunning && Gpio.digitalRead(pinNumber) == Gpio.HIGH) {
}
}
@Override
public void close() throws IOException {
keepRunning = false;
// Set pin high for end of transmission.
Gpio.pinMode(pinNumber, Gpio.OUTPUT);
Gpio.digitalWrite(pinNumber, Gpio.HIGH);
}
}
private class ParityChheckException extends Exception {
private static final long serialVersionUID = 1L;
}
}