122 lines
2.7 KiB
Go
122 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/warthog618/gpio"
|
|
"math"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
const Timeout = math.MaxInt32
|
|
const TimeoutErrInitial string = "timed out waiting for sensor's initial %s reading"
|
|
|
|
var oneSecondInCycles = (func() int {
|
|
result := cyclesInAMillisecond()
|
|
for i := 0; i < 100; i++ {
|
|
result += cyclesInAMillisecond()
|
|
}
|
|
return result / 100
|
|
})()
|
|
|
|
func cyclesInAMillisecond() int {
|
|
count := 0
|
|
start := time.Now().UnixNano()
|
|
for {
|
|
count++
|
|
if time.Now().UnixNano() - start >= 1000000 {
|
|
break
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func main() {
|
|
err := gpio.Open()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer gpio.Close()
|
|
|
|
pin := gpio.NewPin(gpio.GPIO4)
|
|
dhtData, err := readDataFromDHT(pin)
|
|
if err != nil {
|
|
fmt.Println(fmt.Sprintf("Bad read! Reason: %s!", err.Error()))
|
|
} else {
|
|
fmt.Println(
|
|
strconv.FormatInt(int64(dhtData[0]), 2),
|
|
strconv.FormatInt(int64(dhtData[1]), 2),
|
|
strconv.FormatInt(int64(dhtData[2]), 2),
|
|
strconv.FormatInt(int64(dhtData[3]), 2),
|
|
strconv.FormatInt(int64(dhtData[4]), 2))
|
|
fmt.Println(convertToRhAndTemp(dhtData))
|
|
}
|
|
}
|
|
|
|
func sendStartSignal(pin *gpio.Pin) {
|
|
pin.PullUp()
|
|
time.Sleep(time.Millisecond)
|
|
pin.Output()
|
|
pin.Low()
|
|
time.Sleep(1100 * time.Microsecond)
|
|
pin.High()
|
|
time.Sleep(20 * time.Microsecond)
|
|
pin.Input()
|
|
}
|
|
|
|
func readDataFromDHT(pin *gpio.Pin) ([5]byte, error) {
|
|
cycles := [80]int{}
|
|
sendStartSignal(pin)
|
|
if cyclesForReading(pin, gpio.Low) == Timeout {
|
|
return [5]byte{}, errors.New(fmt.Sprintf(TimeoutErrInitial, "low"))
|
|
}
|
|
if cyclesForReading(pin, gpio.High) == Timeout {
|
|
return [5]byte{}, errors.New(fmt.Sprintf(TimeoutErrInitial, "high"))
|
|
}
|
|
for i := 0; i < 80; i += 2 {
|
|
cycles[i] = cyclesForReading(pin, gpio.Low)
|
|
cycles[i + 1] = cyclesForReading(pin, gpio.High)
|
|
}
|
|
receivedInput, err := storeCycleCountsAsBinarySequence(&cycles)
|
|
if err != nil {
|
|
return [5]byte{}, err
|
|
}
|
|
return receivedInput, nil
|
|
}
|
|
|
|
func cyclesForReading(pin *gpio.Pin, level gpio.Level) int {
|
|
count := 0
|
|
for pin.Read() == level {
|
|
count++
|
|
if count >= oneSecondInCycles {
|
|
return Timeout
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func storeCycleCountsAsBinarySequence(cycles *[80]int) ([5]byte, error) {
|
|
data := [5]byte{}
|
|
for i := 0; i < 40; i++ {
|
|
lowCycles := cycles[2 * i]
|
|
highCycles := cycles[2 * i + 1]
|
|
fmt.Println(lowCycles, highCycles)
|
|
if (lowCycles == Timeout) || (highCycles == Timeout) {
|
|
//return [5]byte{}, errors.New("timed out waiting for sensor pulse")
|
|
}
|
|
data[i / 8] <<= 1
|
|
if highCycles > lowCycles {
|
|
data[i / 8] |= 1
|
|
}
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
func convertToRhAndTemp(data [5]byte) (float32, float32) {
|
|
rh := float32(int(data[0]) << 8) + float32(data[1])
|
|
temp := float32(int(data[2]) << 8) + float32(data[3])
|
|
return rh/10, temp/10
|
|
}
|
|
|