float fix 4

src/udi/handlers/car/car.go

@@ -34,20 +34,20 @@ type CarHandler struct {
 */
 
 type CarValue struct {
-  Status            string  `unit:""   json:"status"`
-  Timestamp         string  `unit:""   json:"timestamp"`
-  VoltageL1         float32 `unit:"V"  json:"voltageL1"`
-  VoltageL2         float32 `unit:"V"  json:"voltageL2"`
-  VoltageL3         float32 `unit:"V"  json:"voltageL3"`
-  CurrentL1         float32 `unit:"A"  json:"currentL1"`
-  CurrentL2         float32 `unit:"A"  json:"currentL2"`
-  CurrentL3         float32 `unit:"A"  json:"currentL3"`
-  PowerL1           float32 `unit:"W"  json:"powerL1"`
-  PowerL2           float32 `unit:"W"  json:"powerL2"`
-  PowerL3           float32 `unit:"W"  json:"powerL3"`
-  TotalImportEnergy float32 `unit:"Wh" json:"totalImportEnergy"`
-  TotalExportEnergy float32 `unit:"Wh" json:"totalExportEnergy"`
-  Cnt               int     `unit:""   json:"cnt"`
+	Status            string  `unit:""   json:"status"`
+	Timestamp         string  `unit:""   json:"timestamp"`
+	VoltageL1         float32 `unit:"V"  json:"voltageL1"`
+	VoltageL2         float32 `unit:"V"  json:"voltageL2"`
+	VoltageL3         float32 `unit:"V"  json:"voltageL3"`
+	CurrentL1         float32 `unit:"A"  json:"currentL1"`
+	CurrentL2         float32 `unit:"A"  json:"currentL2"`
+	CurrentL3         float32 `unit:"A"  json:"currentL3"`
+	PowerL1           float32 `unit:"W"  json:"powerL1"`
+	PowerL2           float32 `unit:"W"  json:"powerL2"`
+	PowerL3           float32 `unit:"W"  json:"powerL3"`
+	TotalImportEnergy float32 `unit:"Wh" json:"totalImportEnergy"`
+	TotalExportEnergy float32 `unit:"Wh" json:"totalExportEnergy"`
+	Cnt               int     `unit:""   json:"cnt"`
 }
 
 func New(id string, config config.HandlerConfigT) handler.Handler {

src/udi/handlers/dt1t/dt1t.go

@@ -1,81 +1,75 @@
 package dt1t
 
 import (
-  "log"
-  "fmt"
-  "time"
-  "strconv"
-  "udi/handlers/handler"
-  "udi/database"
-  "udi/config"
+	"log"
+	"strconv"
+	"time"
+	"udi/config"
+	"udi/database"
+	"udi/handlers/handler"
 )
 
-
 type Dt1tHandler struct {
-  handler.CommonHandler
-  ready bool
-  label string
-  dbh *database.DatabaseHandle
-  application string
-  device string
-
+	handler.CommonHandler
+	ready       bool
+	label       string
+	dbh         *database.DatabaseHandle
+	application string
+	device      string
 }
 
 func New(id string, config config.HandlerConfigT) handler.Handler {
-  t := &Dt1tHandler {
-  }
+	t := &Dt1tHandler{}
 
-  if config.Attributes["Application"] == "" {
-    log.Println("Error: application not configured")
-    return t
-  }
-  t.application = config.Attributes["Application"]
-  if config.Attributes["Device"] == "" {
-    log.Println("Error: device not configured")
-    return t
-  }
-  t.device = config.Attributes["Device"]
-  t.Id = id
+	if config.Attributes["Application"] == "" {
+		log.Println("Error: application not configured")
+		return t
+	}
+	t.application = config.Attributes["Application"]
+	if config.Attributes["Device"] == "" {
+		log.Println("Error: device not configured")
+		return t
+	}
+	t.device = config.Attributes["Device"]
+	t.Id = id
 
-  t.dbh = database.NewDatabaseHandle()
-  log.Printf("Handler DT1T %d initialized", id)
-  t.ready = true
-  return t
+	t.dbh = database.NewDatabaseHandle()
+	log.Printf("Handler DT1T %d initialized", id)
+	t.ready = true
+	return t
 }
 
 func (self *Dt1tHandler) Handle(message handler.MessageT) {
-  if ! self.ready {
-    self.Lost("Handler is not marked as ready", nil, message)
-    return
-  }
-  // log.Printf("Handler DT1T %d processing %s -> %s", self.id, message.Topic, message.Payload)
+	if !self.ready {
+		self.Lost("Handler is not marked as ready", nil, message)
+		return
+	}
+	// log.Printf("Handler DT1T %d processing %s -> %s", self.id, message.Topic, message.Payload)
 
-  temperature, err := strconv.Atoi(message.Payload)
-  if err != nil {
-    self.Lost("Invalid raw value", err, message)
-    return
-  }
-  if temperature & 0x8000 != 0{
-    temperature = ((temperature - 1) ^ 0xffff) * -1
-  }
-  temperatureF := float32(temperature) / 10.0
+	temperature, err := strconv.Atoi(message.Payload)
+	if err != nil {
+		self.Lost("Invalid raw value", err, message)
+		return
+	}
+	if temperature&0x8000 != 0 {
+		temperature = ((temperature - 1) ^ 0xffff) * -1
+	}
+	temperatureF := float32(temperature) / 10.0
 
-  var measurement database.Measurement
-  measurement.Time = time.Now()
-  measurement.Application = self.application
-  measurement.Device = self.device
+	var measurement database.Measurement
+	measurement.Time = time.Now()
+	measurement.Application = self.application
+	measurement.Device = self.device
 
-  var variable database.VariableType
-  variable.Label = "Temperature"
-  variable.Variable = ""
-  variable.Unit = "°C"
-  variable.Value = fmt.Sprintf("%f", temperatureF)
-  measurement.Values = make(map[string]database.VariableType)
-  measurement.Values["Value"] = variable
+	var variable database.VariableType
+	variable.Label = "Temperature"
+	variable.Variable = ""
+	variable.Unit = "°C"
+	variable.Value = temperatureF
+	measurement.Values = make(map[string]database.VariableType)
+	measurement.Values["Value"] = variable
 
-  // log.Printf("Prepared measurement item: %s", measurement)
-  self.dbh.StoreMeasurement(&measurement)
-  self.S()
+	// log.Printf("Prepared measurement item: %s", measurement)
+	self.dbh.StoreMeasurement(&measurement)
+	self.S()
 }
-
-

src/udi/handlers/prepared/prepared.go

@@ -1,79 +1,74 @@
 package prepared
 
 import (
-  "time"
-  "log"
-  "encoding/json"
-  "udi/config"
-  "udi/handlers/handler"
-  "udi/database"
+	"encoding/json"
+	"log"
+	"time"
+	"udi/config"
+	"udi/database"
+	"udi/handlers/handler"
 )
 
-
 type PreparedHandler struct {
-  handler.CommonHandler
-  dbh *database.DatabaseHandle
+	handler.CommonHandler
+	dbh *database.DatabaseHandle
 }
 
 type endpoint_t struct {
-  Label string `json:"label"`
-  Variable string `json:"variable"`
-  Value string `json:"value"`
-  Unit string `json:"unit"`
-  Status string `json:"status"`
+	Label    string      `json:"label"`
+	Variable string      `json:"variable"`
+	Value    interface{} `json:"value"`
+	Unit     string      `json:"unit"`
+	Status   string      `json:"status"`
 }
 
 type observation_t struct {
-  Device string `json:"device"`
-  Label string `json:"label"`
-  Variables map[string]endpoint_t `json:"variables"`
+	Device    string                `json:"device"`
+	Label     string                `json:"label"`
+	Variables map[string]endpoint_t `json:"variables"`
 }
 
-
 func New(id string, config config.HandlerConfigT) handler.Handler {
-  t := &PreparedHandler {
-  }
-  t.Id = id
-  t.dbh = database.NewDatabaseHandle()
-  log.Printf("Handler Prepared %d initialized", id)
-  return t
+	t := &PreparedHandler{}
+	t.Id = id
+	t.dbh = database.NewDatabaseHandle()
+	log.Printf("Handler Prepared %d initialized", id)
+	return t
 }
 
 func (self *PreparedHandler) Handle(message handler.MessageT) {
-  log.Printf("Handler Prepared %d processing %s -> %s", self.Id, message.Topic, message.Payload)
+	log.Printf("Handler Prepared %d processing %s -> %s", self.Id, message.Topic, message.Payload)
 
-  var observation observation_t
-  err := json.Unmarshal([]byte(message.Payload), &observation)
-  if err != nil {
-    self.Lost("Unable to parse payload into Observation struct", err, message)
-    return
-  }
+	var observation observation_t
+	err := json.Unmarshal([]byte(message.Payload), &observation)
+	if err != nil {
+		self.Lost("Unable to parse payload into Observation struct", err, message)
+		return
+	}
 
-  var measurement database.Measurement
-  measurement.Time = time.Now()
+	var measurement database.Measurement
+	measurement.Time = time.Now()
 
-  measurement.Application = self.Id
-  measurement.Device = observation.Device
+	measurement.Application = self.Id
+	measurement.Device = observation.Device
 
-  measurement.Attributes = map[string]interface{} {
-    "Label": observation.Label,
-  }
+	measurement.Attributes = map[string]interface{}{
+		"Label": observation.Label,
+	}
 
-  measurement.Values = make(map[string]database.VariableType)
-  for k, v := range observation.Variables {
-    measurement.Values[k] = database.VariableType {
-      Label: v.Label,
-      Variable: v.Variable,
-      Unit: v.Unit,
-      Value: v.Value,
-      Status: v.Status,
-    }
-  }
+	measurement.Values = make(map[string]database.VariableType)
+	for k, v := range observation.Variables {
+		measurement.Values[k] = database.VariableType{
+			Label:    v.Label,
+			Variable: v.Variable,
+			Unit:     v.Unit,
+			Value:    v.Value,
+			Status:   v.Status,
+		}
+	}
 
-  log.Printf("Prepared measurement item: %s", measurement)
+	log.Printf("Prepared measurement item: %s", measurement)
 
-  self.dbh.StoreMeasurement(&measurement)
-  self.S()
+	self.dbh.StoreMeasurement(&measurement)
+	self.S()
 }
-
-