flucky/PKGBUILD
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix: new implementation

Browse Source 
changes:
- Remove cli
  Some cli commands are not complete tested and are deprecated.

- Daemon
  - Old version has a very bad implementation of how to verify, if the
    device or the sensors are in the database insert. The current
    implementation can be improved but this one is betten then the old
    one.
  - Remove complete the cache store implementation. Use a normal array
    and query the length and capacity to determine how the array cache
    must be cleaned.

- Type
  Remove unused types and functions
This commit is contained in:
Markus Pesch
2020-05-03 14:04:08 +02:00
parent 84d052184e
commit fb8d4dd5eb
137 changed files with 658 additions and 14048 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
pkg/sensor/bme280.go
View File

@ -1,98 +1,91 @@
package sensor
import (
"log"
"time"
"fmt"
"sync"
"github.com/d2r2/go-bsbmp"
"github.com/d2r2/go-i2c"
"github.com/d2r2/go-logger"
uuid "github.com/satori/go.uuid"
"github.com/volker-raschek/flucky/pkg/internal/format"
"github.com/volker-raschek/flucky/pkg/types"
uuid "github.com/satori/go.uuid"
)
// BME280 is a sensor to measure humidity and temperature.
type BME280 struct {
*types.Sensor
}
// GetID returns the sensor id
func (s *BME280) GetID() string {
return s.ID
}
// GetTicker returns a new ticker, which tick every when the sensor should be read
func (s *BME280) GetTicker() *time.Ticker {
duration, err := time.ParseDuration(s.TickDuration)
if err != nil {
duration = time.Minute
}
return time.NewTicker(duration)
mutex *sync.Mutex
}
// Read measured values
func (s *BME280) Read() ([]*types.MeasuredValue, error) {
func (bme280 *BME280) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access
bme280.mutex.Lock()
defer bme280.mutex.Unlock()
// Create new connection to i2c-bus on 1 line with address 0x76.
// Use i2cdetect utility to find device address over the i2c-bus
i2c, err := i2c.NewI2C(*s.I2CAddress, *s.I2CBus)
i2c, err := i2c.NewI2C(*bme280.I2CAddress, *bme280.I2CBus)
if err != nil {
log.Fatal(err)
return nil, err
}
defer i2c.Close()
logger.ChangePackageLogLevel("i2c", logger.InfoLevel)
// Reduce loglevel
for _, pkg := range []string{"bsbmp", "i2c"} {
err = logger.ChangePackageLogLevel(pkg, logger.InfoLevel)
if err != nil {
return nil, fmt.Errorf("Failed to change package log level: %v", err)
}
}
sensor, err := bsbmp.NewBMP(bsbmp.BME280, i2c)
if err != nil {
log.Fatal(err)
return nil, err
}
logger.ChangePackageLogLevel("bsbmp", logger.InfoLevel)
temperatureValue, err := sensor.ReadTemperatureC(bsbmp.ACCURACY_STANDARD)
if err != nil {
log.Fatal(err)
return nil, err
}
pressureValue, err := sensor.ReadPressurePa(bsbmp.ACCURACY_STANDARD)
if err != nil {
log.Fatal(err)
return nil, err
}
// pressureValueRound := math.Round(float64(pressureValue)/10*0.25) * 10 / 0.25
_, humidityValue, err := sensor.ReadHumidityRH(bsbmp.ACCURACY_STANDARD)
if err != nil {
log.Fatal(err)
return nil, err
}
measuredValues := []*types.MeasuredValue{
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(humidityValue),
ValueType: types.MeasuredValueTypeHumidity,
ValueType: "humidity",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: bme280.ID,
},
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(pressureValue),
ValueType: types.MeasuredValueTypePressure,
ValueType: "pressure",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: bme280.ID,
},
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(temperatureValue),
ValueType: types.MeasuredValueTypeTemperature,
ValueType: "temperature",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: bme280.ID,
},
}

50
pkg/sensor/dht11.go
View File

@ -2,49 +2,35 @@ package sensor
import (
"fmt"
"time"
"sync"
"github.com/volker-raschek/flucky/pkg/internal/format"
"github.com/volker-raschek/flucky/pkg/types"
"github.com/go-flucky/go-dht"
uuid "github.com/satori/go.uuid"
"github.com/volker-raschek/flucky/pkg/internal/format"
"github.com/volker-raschek/flucky/pkg/types"
)
// DHT11 is a sensor to measure humidity and temperature.
type DHT11 struct {
*types.Sensor
}
// GetID returns the sensor id
func (s *DHT11) GetID() string {
return s.ID
}
// GetTicker returns a new ticker, which tick every when the sensor should be read
func (s *DHT11) GetTicker() *time.Ticker {
duration, err := time.ParseDuration(s.TickDuration)
if err != nil {
duration = time.Minute
}
return time.NewTicker(duration)
mutex *sync.Mutex
}
// Read measured values
func (s *DHT11) Read() ([]*types.MeasuredValue, error) {
func (dht11 *DHT11) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access
dht11.mutex.Lock()
defer dht11.mutex.Unlock()
err := dht.HostInit()
if err != nil {
return nil, fmt.Errorf("HostInit error: %v", err)
return nil, fmt.Errorf("Failed to initialize periph: %v", err)
}
gpio, err := types.GPIOToString(*s.GPIONumber)
dht, err := dht.NewDHT(dht11.GPIONumber, dht.Celsius, "")
if err != nil {
return nil, err
}
dht, err := dht.NewDHT(gpio, dht.Celsius, "")
if err != nil {
return nil, fmt.Errorf("NewDHT error: %v", err)
return nil, fmt.Errorf("Failed to initialize new DHT11 sensor: %v", err)
}
humidityValue, temperatureValue, err := dht.Read()
@ -53,21 +39,21 @@ func (s *DHT11) Read() ([]*types.MeasuredValue, error) {
}
measuredValues := []*types.MeasuredValue{
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(humidityValue),
ValueType: types.MeasuredValueTypeHumidity,
ValueType: "humidity",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: dht11.ID,
},
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(temperatureValue),
ValueType: types.MeasuredValueTypeTemperature,
ValueType: "temperature",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: dht11.ID,
},
}

50
pkg/sensor/dht22.go
View File

@ -2,49 +2,35 @@ package sensor
import (
"fmt"
"time"
"sync"
"github.com/volker-raschek/flucky/pkg/internal/format"
"github.com/volker-raschek/flucky/pkg/types"
"github.com/go-flucky/go-dht"
uuid "github.com/satori/go.uuid"
"github.com/volker-raschek/flucky/pkg/internal/format"
"github.com/volker-raschek/flucky/pkg/types"
)
// DHT22 is a sensor to measure humidity and temperature.
type DHT22 struct {
*types.Sensor
}
// GetID returns the sensor id
func (s *DHT22) GetID() string {
return s.ID
}
// GetTicker returns a new ticker, which tick every when the sensor should be read
func (s *DHT22) GetTicker() *time.Ticker {
duration, err := time.ParseDuration(s.TickDuration)
if err != nil {
duration = time.Minute
}
return time.NewTicker(duration)
mutex *sync.Mutex
}
// Read measured values
func (s *DHT22) Read() ([]*types.MeasuredValue, error) {
func (dht22 *DHT22) Read() ([]*types.MeasuredValue, error) {
// Lock multiple access
dht22.mutex.Lock()
defer dht22.mutex.Unlock()
err := dht.HostInit()
if err != nil {
return nil, fmt.Errorf("HostInit error: %v", err)
return nil, fmt.Errorf("Failed to initialize periph: %v", err)
}
gpio, err := types.GPIOToString(*s.GPIONumber)
dht, err := dht.NewDHT(dht22.GPIONumber, dht.Celsius, "")
if err != nil {
return nil, err
}
dht, err := dht.NewDHT(gpio, dht.Celsius, "")
if err != nil {
return nil, fmt.Errorf("NewDHT error: %v", err)
return nil, fmt.Errorf("Failed to initialize new DHT22 sensor: %v", err)
}
humidityValue, temperatureValue, err := dht.Read()
@ -53,21 +39,21 @@ func (s *DHT22) Read() ([]*types.MeasuredValue, error) {
}
measuredValues := []*types.MeasuredValue{
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(humidityValue),
ValueType: types.MeasuredValueTypeHumidity,
ValueType: "humidity",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: dht22.ID,
},
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(temperatureValue),
ValueType: types.MeasuredValueTypeTemperature,
ValueType: "temperature",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: dht22.ID,
},
}

45
pkg/sensor/ds18b20.go
View File

@ -3,45 +3,42 @@ package sensor
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"sync"
uuid "github.com/satori/go.uuid"
"github.com/volker-raschek/flucky/pkg/internal/format"
"github.com/volker-raschek/flucky/pkg/types"
uuid "github.com/satori/go.uuid"
)
// DS18B20 is a sensor to measure humidity and temperature.
type DS18B20 struct {
*types.Sensor
}
// GetID returns the sensor id
func (s *DS18B20) GetID() string {
return s.ID
}
// GetTicker returns a new ticker, which tick every when the sensor should be read
func (s *DS18B20) GetTicker() *time.Ticker {
duration, err := time.ParseDuration(s.TickDuration)
if err != nil {
duration = time.Minute
}
return time.NewTicker(duration)
mutex *sync.Mutex
}
// Read measured values
func (s *DS18B20) Read() ([]*types.MeasuredValue, error) {
func (ds18b20 *DS18B20) Read() ([]*types.MeasuredValue, error) {
if s.WireID == nil {
return nil, fmt.Errorf("WireID is not specified for sensor %v", s.Name)
// Lock multiple access
ds18b20.mutex.Lock()
defer ds18b20.mutex.Unlock()
if ds18b20.WireID == nil {
return nil, fmt.Errorf("WireID is not specified")
}
data, err := ioutil.ReadFile(filepath.Join("/sys/bus/w1/devices", *s.WireID, "/w1_slave"))
socketPath := filepath.Join("/sys/bus/w1/devices", *ds18b20.WireID, "/w1_slave")
if _, err := os.Stat(socketPath); os.IsNotExist(err) {
return nil, fmt.Errorf("Socket path not found: %v", socketPath)
}
data, err := ioutil.ReadFile(socketPath)
if err != nil {
return nil, fmt.Errorf("Can not read data from sensor %v", s.Name)
return nil, fmt.Errorf("Can not read data from sensor %v", ds18b20.Name)
}
raw := string(data)
@ -59,13 +56,13 @@ func (s *DS18B20) Read() ([]*types.MeasuredValue, error) {
temperatureValue := c / 1000
measuredValues := []*types.MeasuredValue{
&types.MeasuredValue{
{
ID: uuid.NewV4().String(),
Value: float64(temperatureValue),
ValueType: types.MeasuredValueTypeTemperature,
ValueType: "temperature",
FromDate: format.FormatedTime(),
TillDate: format.FormatedTime(),
SensorID: s.ID,
SensorID: ds18b20.ID,
},
}

68
pkg/sensor/sensor.go
View File

@ -1,46 +1,40 @@
package sensor
import (
"errors"
"sync"
"github.com/volker-raschek/flucky/pkg/types"
)
func Read(sensors []Sensor, measuredValueType types.MeasuredValueType) ([]*types.MeasuredValue, error) {
var (
ErrSensorModelNotMatched = errors.New("Sensor model not matched")
)
type result struct {
measuredValues []*types.MeasuredValue
err error
// New returns a new sensor
func New(sensor *types.Sensor) (Sensor, error) {
switch sensor.Model {
case "BME280":
return &BME280{
Sensor: sensor,
mutex: new(sync.Mutex),
}, nil
case "DHT11":
return &DHT11{
Sensor: sensor,
mutex: new(sync.Mutex),
}, nil
case "DHT22":
return &DHT22{
Sensor: sensor,
mutex: new(sync.Mutex),
}, nil
case "DS18B20":
return &DS18B20{
Sensor: sensor,
mutex: new(sync.Mutex),
}, nil
default:
return nil, ErrSensorModelNotMatched
}
resultChannel := make(chan *result, len(sensors))
// producers
// read measured values
for _, s := range sensors {
go func(s Sensor) {
measuredValues, err := s.Read()
resultChannel <- &result{
measuredValues: measuredValues,
err: err,
}
}(s)
}
// consumer
measuredValues := make([]*types.MeasuredValue, 0)
counter := len(sensors)
for {
if counter == 0 {
break
}
select {
case result := <-resultChannel:
counter--
if result.err != nil {
return nil, result.err
}
measuredValues = append(measuredValues, result.measuredValues...)
}
}
return types.SelectMeasuredValues(measuredValueType, measuredValues), nil
}