Контроллер доступа на Go + Raspberry Pi + Arduino Nano

#include <OneWire.h>
#include <EEPROM.h>

#define RELAY1 6  // пин подключения реле
boolean isClose; // флаг текущего состояния замка
boolean hl=false; // флаг текущего состояния режима блокировки
byte i; 
OneWire ds(7);  //пин подключения считывателя 
byte addr[8];  //буфер приема ключей

String inCommand = "";  // входящая команда от Raspberry Pi
char character; //буфер приема входящих команд

void setup() {
	Serial.begin(9600);
	pinMode(RELAY1, OUTPUT);
	stateRead(); 
}

void loop(){
	if (ds.search(addr)) {
		ds.reset_search();
		if ( OneWire::crc8( addr, 7) != addr[7]) {
		}
		else
		{
			if(!hl){
				for( i = 0; i < 8; i++) {
					Serial.print(addr[i],HEX);
				}
				Serial.println();
			}
		}
	}

	ds.reset();
	delay(500);
	
	while(Serial.available()) {
		character = Serial.read();
		inCommand.concat(character);
	}
	if (inCommand=="hlock1"){
		hl=true;  
		r_close();
		Serial.println("HardLock Enable");
	}
	if (inCommand=="hlock0"){
		hl=false; 
		Serial.println("HardLock Disable");
	}
	if (inCommand != "" && !hl) {
		if ((inCommand=="open") && (isClose) ){
			r_open();
		}
		if ((inCommand=="close") &&(!isClose)){
			r_close();
		}
	}
	inCommand="";
}

void r_open(){
	digitalWrite(RELAY1,LOW);
	isClose=false;
	stateSave(isClose);
	SoundTone(0);
	delay(100);
	Serial.println("Relay Open ");
}

void r_close(){
	digitalWrite(RELAY1,HIGH);
	isClose=true;
	stateSave(isClose);
	SoundTone(1);
	delay(100);
	Serial.println("Realy Close");
}


void stateSave(boolean st) // Запись в текущего состояния в EEPROM
{
	if (st)
	{
		int val=1;
		EEPROM.write(0,val);
	}
	else 
	{
		int val=0;
		EEPROM.write(0,val);
	}
}

void stateRead()
{
	int val;
	val= (EEPROM.read(0));
	if (val==1)
		r_close();
	else 
		r_open();
}

void SoundTone(boolean cmd){
	if(!cmd){
		for (int i=0;i<10;i++){
			tone(9, 815, 100);
			delay(250);
		}
	}
	else {
		for (int i=0;i<4;i++){
			tone(9, 395, 500);
			delay(350);
		}
	}
	noTone(9);
}  

package main

import (
	"bufio"

	"encoding/json"
	"io/ioutil"

	"fmt"
	"log"
	"net/http"
	"os"
	"regexp"
	"time"

	"github.com/boltdb/bolt"
	"github.com/tarm/serial"
)

const dbname = "access.db" //имя файла основной БД

var isOpen, isHLock bool = false, false
var serialPort *serial.Port

func main() {
	
	// Чтение конфигурации
	config, err := readConfig()

	if err != nil {
		fmt.Printf("Error read config file %s", err.Error())
		return
	}
	// Настройка логирования
	f, err := os.OpenFile(config.LogFilePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		log.Fatalf("error opening file: %v", err)
	}
	defer f.Close()
	log.SetOutput(f)

	// Настройка и запуск HTTP-сервиса
	http.HandleFunc("/"+config.NormalModeEndpoint, webNormalMode)
	http.HandleFunc("/"+config.HardLockModeEndpoint, webHLockMode)
	http.HandleFunc("/"+config.CloseEndpoint, webCloseRelay)
	http.HandleFunc("/"+config.OpenEndpoint, webOpenRelay)
	http.HandleFunc("/"+config.AddKeyEndpoint, addKey)
	http.HandleFunc("/"+config.ReadKeysEndpoint, readKeys)
	http.HandleFunc("/"+config.DeleteKeyEndpoint, deleteKey)

	go http.ListenAndServe(":"+config.HTTPPort, nil)

	log.Printf("Listening on port %s...", config.HTTPPort)

	// Проверка доступности БД
	db, err := bolt.Open(dbname, 0600, nil)
	if err != nil {
		log.Fatal(err)
	}
	db.Close()

	// Доступ к Serial порту
	c := &serial.Config{Name: config.SerialPort, Baud: 9600}
	s, err := serial.OpenPort(c)

	if err != nil {
		fmt.Printf("Error open serial port %s ", err.Error())
		log.Fatal(err)

	}
	serialPort = s
	
	// Создание канала и запус процесса, go-рутины
	ch := make(chan bool) // wait chanel until key is valid
	go getData(ch, s)

	for {
		time.Sleep(time.Second)
		tmp := <-ch
		if tmp {
			if isOpen {
				closeRelay()
			} else {
				openRelay()
			}
		}
	}

}

func getData(ch chan bool, s *serial.Port) {

	for {
		reader := bufio.NewReader(s)
		reply, err := reader.ReadBytes('n')
		if err != nil {
			log.Fatal(err)
		}
		k := string(reply)

		if chk := checkKey(k); chk {

			ch <- chk
			time.Sleep(2 * time.Second)
		}

	}

}
func invertBool() { //Смена флага состояния замка
	isOpen = !isOpen
}

func checkErr(err error) {
	if err != nil {
		panic(err)
	}
}

func boltStore(value Key) {
	db, err := bolt.Open(dbname, 0600, nil)
	if err != nil {
		log.Fatal(err)
	}

	defer db.Close()

	db.Update(func(tx *bolt.Tx) error {
		b, err := tx.CreateBucketIfNotExists([]byte("keys"))
		if err != nil {
			return err
		}
		return b.Put([]byte(value.Key), []byte(value.isEnable))
	})
}

func boltRead(key string) bool {
	var strKey string
	db, err := bolt.Open(dbname, 0600, nil)

	if err != nil {
		log.Fatal(err)
		return false
	}

	defer db.Close()

	db.View(func(tx *bolt.Tx) error {

		re := regexp.MustCompile(`rn`)
		key := re.ReplaceAllString(key, "")
		re = regexp.MustCompile(`n`)
		key = re.ReplaceAllString(key, "")
		re = regexp.MustCompile(`r`)
		key = re.ReplaceAllString(key, "")
		log.Printf("Readed key: %sn", key)

		b := tx.Bucket([]byte("keys"))
		v := b.Get([]byte(key))

		strKey = string(v)

		return nil
	})
	if strKey == "1" {
		log.Printf("Key %s validn", key)
		return true
	}
	return false

}

func addKey(w http.ResponseWriter, r *http.Request) {
	params := r.URL.Query()
	var key Key
	key.Key = params.Get("key")
	key.isEnable = params.Get("enable")
	boltStore(key)
	log.Printf("You add the key %s", key.Key)
	fmt.Fprintln(w, "You add the key", key.Key)

}
func readKeys(w http.ResponseWriter, r *http.Request) {
	keys := make(map[string]string)
	db, err := bolt.Open(dbname, 0600, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	db.View(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte("keys"))

		b.ForEach(func(k, v []byte) error {
			keys[string(k)] = string(v)
			fmt.Printf("map: %sn", keys[string(k)])
			return nil
		})
		return nil
	})
	data, _ := json.Marshal(keys)
	fmt.Fprintln(w, string(data))
}

func deleteKey(w http.ResponseWriter, r *http.Request) {
	params := r.URL.Query()
	deleteKey := params.Get("key")
	db, err := bolt.Open(dbname, 0600, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
	db.Update(func(tx *bolt.Tx) error {
		// Retrieve the users bucket.
		// This should be created when the DB is first opened.
		b := tx.Bucket([]byte("keys"))
		err := b.Delete([]byte(deleteKey))
		if err != nil {
			fmt.Printf("Key: "%s" delete failed: %sn", deleteKey, err.Error())
			return err
		}
		fmt.Fprintf(w, "Key: "%s" deleted succesfullyn", deleteKey)

		// Persist bytes to users bucket.
		return nil
	})

}

func webNormalMode(w http.ResponseWriter, r *http.Request) {
	isHLock = false
	_, err := serialPort.Write([]byte("hlock0"))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Fprintln(w, "Normal Mode")
}
func webHLockMode(w http.ResponseWriter, r *http.Request) {
	_, err := serialPort.Write([]byte("hlock1"))
	if err != nil {
		log.Fatal(err)
	}
	isHLock = true
	fmt.Fprintln(w, "HardLock Mode")
}
func webCloseRelay(w http.ResponseWriter, r *http.Request) {
	switchRelay()
	fmt.Fprintln(w, "switch relay")
}
func webOpenRelay(w http.ResponseWriter, r *http.Request) {
	openRelay()
	fmt.Fprintln(w, "open lock")
}

func closeRelay() {

	_, err := serialPort.Write([]byte("close"))
	if err != nil {
		log.Fatal(err)
	}
	invertBool()
	log.Println("Close")

}

func openRelay() {

	_, err := serialPort.Write([]byte("open"))
	if err != nil {
		log.Fatal(err)
	}
	invertBool()
	log.Println("Open")

}
func switchRelay() {
	if isOpen {
		closeRelay()
	} else {
		openRelay()
	}
}
func checkKey(key string) bool {
	if boltRead(key) {

		return true
	}
	return false
}

func readConfig() (*Config, error) {
	plan, _ := ioutil.ReadFile("config.json")
	config := Config{}
	err := json.Unmarshal([]byte(plan), &config)
	return &config, err
}

{
«serialPort»:"/dev/ttyUSB0",
«httpPort»:«80»,
«normalModeEndpoint»:«normal»,
«hardLockModeEndpoint»:«block»,
«closeEndpoint»:«close»,
«openEndpoint»:«open»,
«addKeyEndpoint»:«addkey»,
«deleteKeyEndpoint»:«deletekey»,
«readKeysEndpoint»:«readkeys»,
«logFilePath»:"/var/log/skud-go.log"
}

package main

//Key тип данных ключа доступа
type Key struct {
	Key      string
	isEnable string
}

//Config основные параметры контроллера
type Config struct {
	SerialPort           string `json:"serialPort"`
	HTTPPort             string `json:"httpPort"`
	NormalModeEndpoint   string `json:"normalModeEndpoint"`
	HardLockModeEndpoint string `json:"hardLockModeEndpoint"`
	CloseEndpoint        string `json:"closeEndpoint"`
	OpenEndpoint         string `json:"openEndpoint"`
	AddKeyEndpoint       string `json:"addKeyEndpoint"`
	DeleteKeyEndpoint    string `json:"deleteKeyEndpoint"`
	ReadKeysEndpoint     string `json:"readKeysEndpoint"`
	LogFilePath          string `json:"logFilePath"`
}