136 lines
2.6 KiB
Go
136 lines
2.6 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"golang.org/x/crypto/scrypt"
|
|
"time"
|
|
)
|
|
|
|
import (
|
|
"github.com/warthog618/gpiod"
|
|
)
|
|
|
|
type Wiegand struct {
|
|
aLine *gpiod.Line
|
|
bLine *gpiod.Line
|
|
bits [64]bool
|
|
bitNr int
|
|
bitTimeout time.Duration
|
|
bitTimeoutTimer *time.Timer
|
|
|
|
solenoidLine *gpiod.Line
|
|
}
|
|
|
|
func (w *Wiegand) OpenDoor() {
|
|
fmt.Println("Open")
|
|
w.solenoidLine.SetValue(1)
|
|
d, _ := time.ParseDuration("500ms")
|
|
time.Sleep(d)
|
|
w.solenoidLine.SetValue(0)
|
|
fmt.Println("Close")
|
|
}
|
|
|
|
func printCardId(card uint64) {
|
|
for i := 0; i < 7; i++ {
|
|
fmt.Printf("%02x", (card>>(8*i))&0xff)
|
|
}
|
|
fmt.Printf("\n")
|
|
}
|
|
|
|
func (w *Wiegand) cardRunner(validUids ValidUids) {
|
|
for {
|
|
// Wait for bit timeout
|
|
fmt.Printf("Waiting for bit timeout\n")
|
|
<-w.bitTimeoutTimer.C
|
|
fmt.Printf("\n")
|
|
|
|
if w.bitNr != 64 {
|
|
fmt.Printf("We got less than 64 bits: %d\n", w.bitNr)
|
|
}
|
|
|
|
var card uint64 = 0
|
|
for i := 63; i != 0; i-- {
|
|
if w.bits[i] == true {
|
|
card |= 1 << (63 - i)
|
|
}
|
|
}
|
|
|
|
printCardId(card)
|
|
|
|
b := make([]byte, 8)
|
|
binary.LittleEndian.PutUint64(b, card)
|
|
hashed, err := scrypt.Key(b, []byte("hashsah"), 16384, 8, 1, 64)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
hashedHex := hex.EncodeToString(hashed)
|
|
fmt.Println(hashedHex)
|
|
|
|
_, ok := validUids[hashedHex]
|
|
if ok {
|
|
fmt.Println("Opening door")
|
|
w.OpenDoor()
|
|
} else {
|
|
fmt.Println("Unknown card")
|
|
}
|
|
|
|
w.bitNr = 0
|
|
}
|
|
}
|
|
|
|
func (w *Wiegand) wiegandAEvent(evt gpiod.LineEvent) {
|
|
w.bitTimeoutTimer.Reset(w.bitTimeout)
|
|
w.bits[w.bitNr] = false
|
|
fmt.Printf("0")
|
|
w.bitNr += 1
|
|
}
|
|
|
|
func (w *Wiegand) wiegandBEvent(evt gpiod.LineEvent) {
|
|
w.bitTimeoutTimer.Reset(w.bitTimeout)
|
|
w.bits[w.bitNr] = true
|
|
fmt.Printf("1")
|
|
w.bitNr += 1
|
|
}
|
|
|
|
func WiegandSetup(a int, b int, bitTimeout time.Duration, solenoid int) *Wiegand {
|
|
|
|
var wiegand Wiegand
|
|
wiegand.bitTimeout = bitTimeout
|
|
|
|
wiegand.bitTimeoutTimer = time.NewTimer(wiegand.bitTimeout)
|
|
if !wiegand.bitTimeoutTimer.Stop() {
|
|
<-wiegand.bitTimeoutTimer.C
|
|
}
|
|
|
|
wa, err := gpiod.RequestLine("gpiochip0", a, gpiod.AsInput,
|
|
gpiod.WithFallingEdge, gpiod.WithEventHandler(wiegand.wiegandAEvent))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
wiegand.aLine = wa
|
|
|
|
wb, err := gpiod.RequestLine("gpiochip0", b, gpiod.AsInput,
|
|
gpiod.WithFallingEdge, gpiod.WithEventHandler(wiegand.wiegandBEvent))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
wiegand.bLine = wb
|
|
|
|
solenoidLine, err := gpiod.RequestLine("gpiochip0", solenoid, gpiod.AsOutput(0))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
wiegand.solenoidLine = solenoidLine
|
|
|
|
return &wiegand
|
|
}
|
|
|
|
func (w *Wiegand) WiegandClose() {
|
|
w.aLine.Close()
|
|
w.bLine.Close()
|
|
w.solenoidLine.Close()
|
|
}
|