112 lines
2.3 KiB
Go
112 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"errors"
|
|
"github.com/warthog618/gpio"
|
|
"math"
|
|
"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()
|
|
}
|
|
fmt.Println(result / 100)
|
|
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()
|
|
|
|
pinNumber := gpio.GPIO4
|
|
pin := gpio.NewPin(pinNumber)
|
|
result, err := readDataFromDHT(pin)
|
|
if err != nil {
|
|
fmt.Println(fmt.Sprintf("Bad read! Reason: %s", err.Error()))
|
|
} else {
|
|
fmt.Println(result)
|
|
}
|
|
}
|
|
|
|
func readDataFromDHT(pin *gpio.Pin) ([5]byte, error) {
|
|
receivedInput := [5]byte{0, 0, 0, 0, 0}
|
|
// Setup
|
|
pin.PullUp()
|
|
time.Sleep(time.Second)
|
|
|
|
// Send start signal
|
|
pin.Low()
|
|
pin.Output()
|
|
time.Sleep(1100 * time.Microsecond)
|
|
pin.Input()
|
|
time.Sleep(40 * time.Microsecond)
|
|
|
|
// Get Data
|
|
if cyclesForReading(pin, gpio.Low) == Timeout {
|
|
return receivedInput, errors.New(fmt.Sprintf(TimeoutErrInitial, "low"))
|
|
}
|
|
if cyclesForReading(pin, gpio.High) == Timeout {
|
|
return receivedInput, errors.New(fmt.Sprintf(TimeoutErrInitial, "high"))
|
|
}
|
|
|
|
// Store cycle number for each low and high pulse
|
|
cycles := [80]int{}
|
|
for i := 0; i < 80; i += 2 {
|
|
cycles[i] = cyclesForReading(pin, gpio.Low)
|
|
cycles[i + 1] = cyclesForReading(pin, gpio.High)
|
|
}
|
|
|
|
err := storeCycleCountsAsBinarySequence(&receivedInput, &cycles)
|
|
if err != nil {
|
|
return receivedInput, err
|
|
}
|
|
|
|
return receivedInput, nil
|
|
}
|
|
|
|
func storeCycleCountsAsBinarySequence(store *[5]byte, cycles *[80]int) error {
|
|
for i := 0; i < 40; i++ {
|
|
lowCycles := cycles[2 * i]
|
|
highCycles := cycles[2 * i + 1]
|
|
if (lowCycles == Timeout) || (highCycles == Timeout) {
|
|
return errors.New("Timed out waiting for sensor pulse!")
|
|
}
|
|
store[i / 8] <<= 1
|
|
if highCycles > lowCycles {
|
|
store[i / 8] |= 1
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func cyclesForReading(pin *gpio.Pin, level gpio.Level) int {
|
|
count := 0
|
|
for pin.Read() == level {
|
|
count++
|
|
if count >= oneSecondInCycles {
|
|
return Timeout
|
|
}
|
|
}
|
|
return count
|
|
} |