restructure db and logging process, and also config

config.toml

@@ -10,7 +10,7 @@ type = "sqlite3"
 path = "test.db"
 
 [Channel_1]
-type = 'K'
+type = 'k'
 unit = 'C'
 gain = 106.8
 offset = 2.4

config/config.go

@@ -3,6 +3,7 @@ package config
 import (
 	"errors"
 	"fmt"
+	"strings"
 	"th7/data/config"
 	"th7/data/temperature"
 	"th7/data/thermocouple"
@@ -36,6 +37,7 @@ var (
 )
 
 func getThermocoupleType(t string) (thermocouple.Type, error) {
+	t = strings.ToUpper(t)
 	if val, ok := thermocoupleTypes[t]; ok {
 		return val, nil
 	} else {
@@ -44,6 +46,7 @@ func getThermocoupleType(t string) (thermocouple.Type, error) {
 }
 
 func getTemperatureUnit(u string) (temperature.Unit, error) {
+	u = strings.ToUpper(u)
 	if val, ok := temperatureUnits[u]; ok {
 		return val, nil
 	} else {
@@ -70,31 +73,33 @@ func Load() (config.Config, error) {
 	v.SetDefault("TH7.LED", true)
 	v.SetDefault("TH7.logfreq", 60)
 	v.SetDefault("TH7.debug", false)
+	v.SetDefault("TH7.nolog", false)
 
 	cfg.Board.Port = v.GetInt("TH7.port")
 	cfg.Board.Cache = v.GetBool("TH7.cache")
 	cfg.Board.Led = v.GetBool("TH7.LED")
 	cfg.Board.Logfreq = v.GetInt("TH7.logfreq")
 	cfg.Board.Debug = v.GetBool("TH7.debug")
+	cfg.Board.NoLogging = v.GetBool("TH7.nolog")
 
 	cfg.Channels = make([]config.Channel, 0)
-	var c config.Channel
 
 	// set defaults for channels
 	for i := 1; i < 8; i++ {
 		var head = fmt.Sprintf("Channel_%d", i)
+		v.SetDefault(head+".type", "NOTSET")
 		v.SetDefault(head+".gain", 106.8)
 		v.SetDefault(head+".offset", 0.0)
 		v.SetDefault(head+".unit", "UV")
 	}
 
 	for i := 1; i < 8; i++ {
+		var c config.Channel
+		var unit temperature.Unit
+		var tc thermocouple.Type
 		var head = fmt.Sprintf("Channel_%d", i)
 
-		tc := v.GetString(head + ".type")
+		if v.GetString(head+".type") == "NOTSET" {
-		// thermocouple type is non-optional, so if it doesnt exist
-		// then the entry does not exist.
-		if tc == "" {
 			continue
 		}
 
@@ -102,17 +107,22 @@ func Load() (config.Config, error) {
 		c.Gain = v.GetFloat64(head + ".gain")
 		c.Offset = v.GetFloat64(head + ".offset")
 
-		tctype, err := getThermocoupleType(tc)
+		tc, err := getThermocoupleType(v.GetString(head + ".type"))
 		if err != nil {
+			fmt.Printf("%s.type=%s\n", head, v.GetString(head+".type"))
 			return cfg, err
 		}
-		c.Thermo = tctype
+		c.Thermo = tc
 
-		unit, err := getTemperatureUnit(v.GetString(head + ".unit"))
+		if tc == thermocouple.None {
+			unit = temperature.None
+		} else {
+			unit, err = getTemperatureUnit(v.GetString(head + ".unit"))
 			if err != nil {
-			fmt.Printf("%s.unit=%c\n", head, v.GetInt(head+".unit"))
+				fmt.Printf("%s.unit=%s\n", head, v.GetString(head+".unit"))
 				return cfg, err
 			}
+		}
 		c.Unit = unit
 
 		cfg.Channels = append(cfg.Channels, c)

data/config/data.go

@@ -19,6 +19,7 @@ type TH7 struct {
 	Led       bool `json:"LED"`
 	Logfreq   int  `json:"logfreq"`
 	Debug     bool `json:"debug"`
+	NoLogging bool `json:"nologging"`
 }
 
 type Config struct {

db/adapter.go

@@ -3,21 +3,41 @@ package db
 import (
 	"errors"
 	"fmt"
+	"th7/data/config"
 	"th7/ports"
+	"time"
 )
 
-func NewAdapter(db map[string]interface{}) (ports.DBPort, error) {
+func NewAdapter(corePort ports.CorePort, cfg config.Config) (ports.DBPort, error) {
 
-	// if no "type" is given, use dummy
+	var duration time.Duration
-	if _, ok := db["type"]; !ok {
+	var no_logging bool
-		return NewDummyAdapter()
+	var adapter ports.DBPort
+	var err error
+
+	no_logging = cfg.Board.NoLogging
+	duration = time.Duration(cfg.Board.Logfreq) * time.Second
+
+	if _, ok := cfg.DB["type"]; !ok || no_logging {
+		adapter, _ = NewDummyAdapter() // it doesn't fail
+		go startLoggingProcess(adapter, corePort, duration)
+		return adapter, nil
 	}
 
-	db_type := fmt.Sprint(db["type"])
+	db := fmt.Sprint(cfg.DB["type"])
-	switch db_type {
+
+	switch db {
 	case "sqlite3":
-		return NewSQLite3Adapter(db)
+		adapter, err = NewSQLite3Adapter(cfg.DB)
+
+	default:
+		return &DummyAdapter{}, errors.New("unknown db type")
 	}
 
-	return &DummyAdapter{}, errors.New("unknown db type")
+	if err != nil {
+		return &DummyAdapter{}, err
+	}
+
+	go startLoggingProcess(adapter, corePort, duration)
+	return adapter, nil
 }

db/dummy.go

@@ -16,6 +16,11 @@ func (d *DummyAdapter) Close() {
 	fmt.Println("Closing DB ...")
 }
 
-func (d *DummyAdapter) Save([]core.Channel) {
+func (d *DummyAdapter) Save(channels []core.Channel) error {
-	fmt.Println("Saving data to DB ...")
+	fmt.Println("=======================================")
+	for _, val := range channels {
+		fmt.Printf("Saved: id=%d, unit=%d, value=%g\n", val.Id, val.Unit, val.Value)
+	}
+	fmt.Println("=======================================")
+	return nil
 }

db/logger/logger.go

@@ -1,44 +0,0 @@
-package logger
-
-import (
-	"fmt"
-	"th7/ports"
-	"time"
-)
-
-type Logger struct {
-	core   ports.CorePort
-	db     ports.DBPort
-	period int
-	run    bool
-}
-
-func doLogging(log *Logger) {
-
-	duration := time.Duration(log.period) * time.Second
-
-	for log.run {
-
-		time.Sleep(duration)
-
-		ch, err := log.core.GetChannels()
-		if err != nil {
-			fmt.Printf("error getting data for logger: %v\n", err)
-		}
-		log.db.Save(ch)
-	}
-}
-
-func NewLogger(core ports.CorePort, db ports.DBPort, period int) *Logger {
-	var logger Logger
-	logger.db = db
-	logger.core = core
-	logger.period = period
-	logger.run = true
-	go doLogging(&logger)
-	return &logger
-}
-
-func (l *Logger) Stop() {
-	l.run = false
-}

db/logging.go

@@ -0,0 +1,28 @@
+package db
+
+import (
+	"fmt"
+	"th7/ports"
+	"time"
+)
+
+func startLoggingProcess(db ports.DBPort, core ports.CorePort, dur time.Duration) {
+
+	// wait 10 seconds to not log start up values that can be noisy
+	time.Sleep(10 * time.Second)
+
+	for true {
+
+		val, err := core.GetChannels()
+		if err != nil {
+			fmt.Printf("Error encountered while getting values: %v\n", err)
+		}
+
+		err = db.Save(val)
+		if err != nil {
+			fmt.Printf("Error encountered while saving values: %v\n", err)
+		}
+
+		time.Sleep(dur)
+	}
+}

db/sqlite3.go

@@ -51,11 +51,13 @@ func NewSQLite3Adapter(dbInfo map[string]interface{}) (*SQLite3Adapter, error) {
 
 func (ad *SQLite3Adapter) Close() {
 	ad.db.Close()
+	return
 }
 
-func (ad *SQLite3Adapter) Save([]core.Channel) {
+func (ad *SQLite3Adapter) Save([]core.Channel) error {
 	ad.mu.Lock()
 	defer ad.mu.Unlock()
 
 	fmt.Println("TODO save data...")
+	return nil
 }

main.go

@@ -9,7 +9,6 @@ import (
 	"th7/config"
 	"th7/core"
 	"th7/db"
-	"th7/db/logger"
 	"th7/pcb"
 	"th7/ports"
 	"th7/web"
@@ -43,19 +42,16 @@ func main() {
 	}
 	defer pcbPort.Deinit()
 
-	dbPort, err = db.NewAdapter(config.DB)
-	if err != nil {
-		log.Fatalf("Fatal error: %v\n", err)
-	}
-	defer dbPort.Close()
-
 	corePort, err = core.NewAdapter(pcbPort, config)
 	if err != nil {
 		log.Fatalf("Error starting TH7 Adapter: %v\n", err)
 	}
 
-	logger := logger.NewLogger(corePort, dbPort, config.Board.Logfreq)
+	dbPort, err = db.NewAdapter(corePort, config)
-	defer logger.Stop()
+	if err != nil {
+		log.Fatalf("Fatal error: %v\n", err)
+	}
+	defer dbPort.Close()
 
 	webPort = web.NewGinAdapter(corePort)
 	go webPort.Run()

ports/db.go

@@ -4,5 +4,5 @@ import "th7/data/core"
 
 type DBPort interface {
 	Close()
-	Save([]core.Channel)
+	Save([]core.Channel) error
 }