float fix 2

deployment/instances/udi-influx/default/config.json

@@ -105,6 +105,7 @@
           "devicePart": "3",
           "valueFrom": "payload",
           "valuePart": "1",
+          "valueType": "float",
           "unitFrom": "payload",
           "unitPart": "3"
         }
@@ -183,26 +184,40 @@
       "config": {
         "databaseConnStr": "",
         "attributes": {
-          "application": "Temperature Shellies",
+          "application": "Shellies Sensor Temperature",
-          "deviceSelector": "T:1",
+          "deviceSelector": "T:2",
           "valueSelector": "J:$.tC",
           "unitSelector": "C:°C"
         }
       }
     },
     {
-      "topics": [ "shellies/sensor+/status/humidity:0" ],
+      "topics": [ "shellies/sensor/+/status/humidity:0" ],
       "handler": "SVEJ",
       "id": "SVEJ5",
       "config": {
         "databaseConnStr": "",
         "attributes": {
-          "application": "Humidity Shellies",
+          "application": "Shellies Sensor Humidity",
-          "deviceSelector": "T:1",
+          "deviceSelector": "T:2",
           "valueSelector": "J:$.rh",
           "unitSelector": "C:%"
         }
       }
+    },
+    {
+      "topics": [ "shellies/sensor/+/status/devicepower:0" ],
+      "handler": "SVEJ",
+      "id": "SVEJ6",
+      "config": {
+        "databaseConnStr": "",
+        "attributes": {
+          "application": "Shellies Sensor Power",
+          "deviceSelector": "T:2",
+          "valueSelector": "J:$.battery.percent",
+          "unitSelector": "C:%"
+        }
+      }
     }
   ],
   "archiver": {

src/udi/handlers/dt1t/dt1t.go

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

src/udi/handlers/svej/svej.go

@@ -1,29 +1,30 @@
 package svej
 
 import (
-  "log"
+	"encoding/json"
-  "time"
+	"fmt"
-  "strconv"
+	"log"
-  "strings"
+	"strconv"
-  "fmt"
+	"strings"
-  "github.com/oliveagle/jsonpath"
+	"time"
-  "encoding/json"
+	"udi/config"
-  "udi/config"
+	"udi/database"
-  "udi/handlers/handler"
+	"udi/handlers/handler"
-  "udi/database"
+
+	"github.com/oliveagle/jsonpath"
 )
 
 type SingleValueExtractorJsonpathHandler struct {
-  handler.CommonHandler
+	handler.CommonHandler
-  ready bool
+	ready          bool
-  application string
+	application    string
-  deviceSelector string
+	deviceSelector string
-  valueSelector string
+	valueSelector  string
-  unitSelector string
+	unitSelector   string
-  deviceJsonpath *jsonpath.Compiled
+	deviceJsonpath *jsonpath.Compiled
-  valueJsonpath *jsonpath.Compiled
+	valueJsonpath  *jsonpath.Compiled
-  unitJsonpath *jsonpath.Compiled
+	unitJsonpath   *jsonpath.Compiled
-  dbh *database.DatabaseHandle
+	dbh            *database.DatabaseHandle
 }
 
 /*
@@ -33,134 +34,131 @@ T:TopicPartIndex
 C:ConstantValue
 */
 
-
 func New(id string, config config.HandlerConfigT) handler.Handler {
-  t := &SingleValueExtractorJsonpathHandler {
+	t := &SingleValueExtractorJsonpathHandler{
-    ready: false,
+		ready: false,
-  }
+	}
 
-  if config.Attributes["application"] == "" {
+	if config.Attributes["application"] == "" {
-    log.Println("Error: application not configured")
+		log.Println("Error: application not configured")
-    return t
+		return t
-  }
+	}
-  t.application = config.Attributes["application"]
+	t.application = config.Attributes["application"]
-  
-  t.deviceSelector = config.Attributes["deviceSelector"]
-  if t.deviceSelector[:2] == "J:" {
-    jp, err := jsonpath.Compile(t.deviceSelector[2:])
-    if err != nil {
-      log.Printf("Unable to compile deviceJsonpath: %s, %s", t.deviceSelector[2:], err)
-      return t
-    }
-    t.deviceJsonpath = jp
-  }
-  t.valueSelector = config.Attributes["valueSelector"]
-  if t.valueSelector[:2] == "J:" {
-    jp, err := jsonpath.Compile(t.valueSelector[2:])
-    if err != nil {
-      log.Printf("Unable to compile valueJsonpath: %s, %s", t.valueSelector[2:], err)
-      return t
-    }
-    t.valueJsonpath = jp
-  }
-  t.unitSelector = config.Attributes["unitSelector"]
-  if t.unitSelector[:2] == "J:" {
-    jp, err := jsonpath.Compile(t.unitSelector[2:])
-    if err != nil {
-      log.Printf("Unable to compile unitJsonpath: %s, %s", t.unitSelector[2:], err)
-      return t
-    }
-    t.unitJsonpath = jp
-  }
 
-  t.Id = id
+	t.deviceSelector = config.Attributes["deviceSelector"]
-  t.ready = true
+	if t.deviceSelector[:2] == "J:" {
-  t.dbh = database.NewDatabaseHandle()
+		jp, err := jsonpath.Compile(t.deviceSelector[2:])
-  log.Printf("Handler SVEJ %d initialized", id)
+		if err != nil {
-  return t
+			log.Printf("Unable to compile deviceJsonpath: %s, %s", t.deviceSelector[2:], err)
+			return t
+		}
+		t.deviceJsonpath = jp
+	}
+	t.valueSelector = config.Attributes["valueSelector"]
+	if t.valueSelector[:2] == "J:" {
+		jp, err := jsonpath.Compile(t.valueSelector[2:])
+		if err != nil {
+			log.Printf("Unable to compile valueJsonpath: %s, %s", t.valueSelector[2:], err)
+			return t
+		}
+		t.valueJsonpath = jp
+	}
+	t.unitSelector = config.Attributes["unitSelector"]
+	if t.unitSelector[:2] == "J:" {
+		jp, err := jsonpath.Compile(t.unitSelector[2:])
+		if err != nil {
+			log.Printf("Unable to compile unitJsonpath: %s, %s", t.unitSelector[2:], err)
+			return t
+		}
+		t.unitJsonpath = jp
+	}
+
+	t.Id = id
+	t.ready = true
+	t.dbh = database.NewDatabaseHandle()
+	log.Printf("Handler SVEJ %s initialized", id)
+	return t
 }
 
-func (self *SingleValueExtractorJsonpathHandler) ExtractionHelper(subTopics []string, jPayload interface{}, selector string, jp *jsonpath.Compiled) (string, error) {
+func (self *SingleValueExtractorJsonpathHandler) ExtractionHelper(subTopics []string, jPayload interface{}, selector string, jp *jsonpath.Compiled) (interface{}, error) {
-  var res string
+	var res interface{}
-  switch selector[:2] {
+	switch selector[:2] {
-  case "J:":
+	case "J:":
-    // extract using jsonpath from payload
+		// extract using jsonpath from payload
-    r, e := jp.Lookup(jPayload)
+		r, e := jp.Lookup(jPayload)
-    if e != nil {
+		if e != nil {
-      return "", fmt.Errorf("jp.Lookup failed with %s", e)
+			return "", fmt.Errorf("jp.Lookup failed with %s", e)
-    }
+		}
-    res = fmt.Sprint(r)
+		res = r
-  case "T:":
+	case "T:":
-    // T: extract from topic
+		// T: extract from topic
-    i, e := strconv.Atoi(selector[2:])
+		i, e := strconv.Atoi(selector[2:])
-    if e != nil {
+		if e != nil {
-      return "", fmt.Errorf("Atoi failed with %s", e)
+			return "", fmt.Errorf("Atoi failed with %s", e)
-    }
+		}
-    if i >= len(subTopics) {
+		if i >= len(subTopics) {
-      return "", fmt.Errorf("not enough subtopics")
+			return "", fmt.Errorf("not enough subtopics")
-    }
+		}
-    res = subTopics[i]
+		res = subTopics[i]
-  case "C:":
+	case "C:":
-    // use constant value
+		// use constant value
-    res = selector[2:]
+		res = selector[2:]
-  default:
+	default:
-    return "", fmt.Errorf("Invalid selector: %s", selector[:2])
+		return "", fmt.Errorf("Invalid selector: %s", selector[:2])
-  }
+	}
-  return res, nil
+	return res, nil
 }
 
-
 func (self *SingleValueExtractorJsonpathHandler) Handle(message handler.MessageT) {
-  if ! self.ready {
+	if !self.ready {
-    self.Lost("Handler is not marked as ready", nil, message)
+		self.Lost("Handler is not marked as ready", nil, message)
-    return
+		return
-  }
+	}
-  log.Printf("Handler SingleValueExtractorJsonpath %d processing %s -> %s", self.Id, message.Topic, message.Payload)
+	log.Printf("Handler SingleValueExtractorJsonpath %d processing %s -> %s", self.Id, message.Topic, message.Payload)
 
-  var measurement database.Measurement
+	var measurement database.Measurement
-  measurement.Time = time.Now()
+	measurement.Time = time.Now()
-  measurement.Application = self.application
+	measurement.Application = self.application
-  
-  subTopics := strings.Split(message.Topic, "/")
-  log.Printf("Subtopics: %s", strings.Join(subTopics, ", "))
-  var jPayload interface{}
-  err := json.Unmarshal([]byte(message.Payload), &jPayload)
-  if err != nil {
-    self.Lost("Unable to unmarshal payload", err, message)
-    return
-  }
 
-  device, err1 := self.ExtractionHelper(subTopics, jPayload, self.deviceSelector, self.deviceJsonpath)
+	subTopics := strings.Split(message.Topic, "/")
-  if err1 != nil {
+	log.Printf("Subtopics: %s", strings.Join(subTopics, ", "))
-    self.Lost("Device extraction failed", err1, message)
+	var jPayload interface{}
-    return
+	err := json.Unmarshal([]byte(message.Payload), &jPayload)
-  }
+	if err != nil {
-  log.Printf("device: %s", device) 
+		self.Lost("Unable to unmarshal payload", err, message)
+		return
+	}
 
-  value, err2 := self.ExtractionHelper(subTopics, jPayload, self.valueSelector, self.valueJsonpath)
+	device, err1 := self.ExtractionHelper(subTopics, jPayload, self.deviceSelector, self.deviceJsonpath)
-  if err2 != nil {
+	if err1 != nil {
-    self.Lost("Value extraction failed", err2, message)
+		self.Lost("Device extraction failed", err1, message)
-    return
+		return
-  }
+	}
+	log.Printf("device: %s", device)
 
-  unit, err3 := self.ExtractionHelper(subTopics, jPayload, self.unitSelector, self.unitJsonpath)
+	value, err2 := self.ExtractionHelper(subTopics, jPayload, self.valueSelector, self.valueJsonpath)
-  if err3 != nil {
+	if err2 != nil {
-    self.Lost("Unit extraction failed", err3, message)
+		self.Lost("Value extraction failed", err2, message)
-    return
+		return
-  }
+	}
 
-  measurement.Device = device
+	unit, err3 := self.ExtractionHelper(subTopics, jPayload, self.unitSelector, self.unitJsonpath)
+	if err3 != nil {
+		self.Lost("Unit extraction failed", err3, message)
+		return
+	}
 
-  var variable database.VariableType
+	measurement.Device = device.(string)
-  variable.Label = ""
-  variable.Variable = ""
-  variable.Unit = unit
-  variable.Value = value
-  measurement.Values = make(map[string]database.VariableType)
-  measurement.Values["Value"] = variable
 
-  log.Printf("Prepared measurement item: %s", measurement)
+	var variable database.VariableType
-  self.dbh.StoreMeasurement(&measurement)
+	variable.Label = ""
-  self.S()
+	variable.Variable = ""
+	variable.Unit = unit.(string)
+	variable.Value = value
+	measurement.Values = make(map[string]database.VariableType)
+	measurement.Values["Value"] = variable
+
+	log.Printf("Prepared measurement item: %s", measurement)
+	self.dbh.StoreMeasurement(&measurement)
+	self.S()
 }
-

src/udi/handlers/sver/sver.go

@@ -1,23 +1,22 @@
 package sver
 
 import (
-  "time"
+	"log"
-  "strconv"
+	"regexp"
-  "strings"
+	"strconv"
-  "regexp"
+	"strings"
-  "log"
+	"time"
-  "udi/config"
+	"udi/config"
-  "udi/handlers/handler"
+	"udi/database"
-  "udi/database"
+	"udi/handlers/handler"
 )
 
-
 type SingleValueExtractorRegexHandler struct {
-  handler.CommonHandler
+	handler.CommonHandler
-  ready bool
+	ready        bool
-  config localConfig
+	config       localConfig
-  payloadRegex *regexp.Regexp
+	payloadRegex *regexp.Regexp
-  dbh *database.DatabaseHandle
+	dbh          *database.DatabaseHandle
 }
 
 const TOPIC_SEL = "topic"
@@ -26,175 +25,191 @@ const PAYLOAD_FULL_SEL = "payload-full"
 const CONSTANT_SEL = "constant"
 
 type localConfig struct {
-  application string
+	application string
-  deviceFrom string
+	deviceFrom  string
-  devicePart int
+	devicePart  int
-  device string
+	device      string
-  valueFrom string
+	valueFrom   string
-  valuePart int
+	valuePart   int
-  unitFrom string
+	valueType   string
-  unitPart int
+	unitFrom    string
-  unit string
+	unitPart    int
+	unit        string
 }
 
-
 func New(id string, config config.HandlerConfigT) handler.Handler {
-  t := &SingleValueExtractorRegexHandler {
+	t := &SingleValueExtractorRegexHandler{
-    ready: false,
+		ready: false,
-  }
+	}
 
-  var localConfig localConfig
+	var localConfig localConfig
-  if config.Attributes["application"] == "" {
+	if config.Attributes["application"] == "" {
-    log.Println("Error: application not configured")
+		log.Println("Error: application not configured")
-    return t
+		return t
-  }
+	}
-  localConfig.application = config.Attributes["application"]
+	localConfig.application = config.Attributes["application"]
-  
-  payloadRegex := config.Attributes["payloadRegex"]
-  if payloadRegex != "" {
-    t.payloadRegex = regexp.MustCompile(payloadRegex)
-  } else {
-    t.payloadRegex = nil
-  }
 
-  if config.Attributes["deviceFrom"] != TOPIC_SEL && config.Attributes["deviceFrom"] != PAYLOAD_SEL && config.Attributes["deviceFrom"] != CONSTANT_SEL {
+	payloadRegex := config.Attributes["payloadRegex"]
-    log.Printf("Error: invalid value %s for deviceFrom", config.Attributes["deviceFrom"])
+	if payloadRegex != "" {
-    return t
+		t.payloadRegex = regexp.MustCompile(payloadRegex)
-  }
+	} else {
-  localConfig.deviceFrom = config.Attributes["deviceFrom"]
+		t.payloadRegex = nil
+	}
 
-  devicePart, err1 := strconv.Atoi(config.Attributes["devicePart"])
+	if config.Attributes["deviceFrom"] != TOPIC_SEL && config.Attributes["deviceFrom"] != PAYLOAD_SEL && config.Attributes["deviceFrom"] != CONSTANT_SEL {
-  if err1 != nil {
+		log.Printf("Error: invalid value %s for deviceFrom", config.Attributes["deviceFrom"])
-    log.Printf("Error: unable to convert devicePart to number: %s", err1)
+		return t
-    return t
+	}
-  }
+	localConfig.deviceFrom = config.Attributes["deviceFrom"]
-  localConfig.devicePart = devicePart
 
-  // empty device is valid
+	devicePart, err1 := strconv.Atoi(config.Attributes["devicePart"])
-  localConfig.device = config.Attributes["device"]
+	if err1 != nil {
+		log.Printf("Error: unable to convert devicePart to number: %s", err1)
+		return t
+	}
+	localConfig.devicePart = devicePart
 
-  if config.Attributes["valueFrom"] != PAYLOAD_SEL && config.Attributes["valueFrom"] != PAYLOAD_FULL_SEL {
+	// empty device is valid
-    log.Printf("Error: invalid value %s for valueFrom", config.Attributes["valueFrom"])
+	localConfig.device = config.Attributes["device"]
-    return t
-  }
-  localConfig.valueFrom = config.Attributes["valueFrom"]
 
-  if config.Attributes["valueFrom"] == PAYLOAD_SEL {
+	if config.Attributes["valueFrom"] != PAYLOAD_SEL && config.Attributes["valueFrom"] != PAYLOAD_FULL_SEL {
-    valuePart, err2 := strconv.Atoi(config.Attributes["valuePart"])
+		log.Printf("Error: invalid value %s for valueFrom", config.Attributes["valueFrom"])
-    if err2 != nil {
+		return t
-      log.Printf("Error: unable to convert valuePart to number: %s", err2)
+	}
-      return t
+	localConfig.valueFrom = config.Attributes["valueFrom"]
-    }
-    localConfig.valuePart = valuePart
-  }
 
-  if config.Attributes["unitFrom"] != PAYLOAD_SEL && config.Attributes["unitFrom"] != CONSTANT_SEL {
+	if config.Attributes["valueFrom"] == PAYLOAD_SEL {
-    log.Printf("Error: invalid value %s for unitFrom", config.Attributes["unitFrom"])
+		valuePart, err2 := strconv.Atoi(config.Attributes["valuePart"])
-    return t
+		if err2 != nil {
-  }
+			log.Printf("Error: unable to convert valuePart to number: %s", err2)
-  localConfig.unitFrom = config.Attributes["unitFrom"]
+			return t
+		}
+		localConfig.valuePart = valuePart
+	}
 
-  if config.Attributes["unitFrom"] == PAYLOAD_SEL {
+	if config.Attributes["valueType"] != "float" && config.Attributes["valueType"] != "string" {
-    unitPart, err3 := strconv.Atoi(config.Attributes["unitPart"])
+		log.Printf("Error: invalid value %s for valueType", config.Attributes["valueType"])
-    if err3 != nil {
+		return t
-      log.Printf("Error: unable to convert unitPart to number: %s", err3)
+	}
-      return t
+	localConfig.valueType = config.Attributes["valueType"]
-    }
-    localConfig.unitPart = unitPart
-  }
 
-  // empty unit is valid
+	if config.Attributes["unitFrom"] != PAYLOAD_SEL && config.Attributes["unitFrom"] != CONSTANT_SEL {
-  localConfig.unit = config.Attributes["unit"]
+		log.Printf("Error: invalid value %s for unitFrom", config.Attributes["unitFrom"])
+		return t
+	}
+	localConfig.unitFrom = config.Attributes["unitFrom"]
 
-  t.config = localConfig
+	if config.Attributes["unitFrom"] == PAYLOAD_SEL {
+		unitPart, err3 := strconv.Atoi(config.Attributes["unitPart"])
+		if err3 != nil {
+			log.Printf("Error: unable to convert unitPart to number: %s", err3)
+			return t
+		}
+		localConfig.unitPart = unitPart
+	}
 
-  t.Id = id
+	// empty unit is valid
-  t.ready = true
+	localConfig.unit = config.Attributes["unit"]
-  t.dbh = database.NewDatabaseHandle()
+
-  log.Printf("Handler SVER %d initialized", id)
+	t.config = localConfig
-  return t
+
+	t.Id = id
+	t.ready = true
+	t.dbh = database.NewDatabaseHandle()
+	log.Printf("Handler SVER %d initialized", id)
+	return t
 }
 
 func (self *SingleValueExtractorRegexHandler) Handle(message handler.MessageT) {
-  if ! self.ready {
+	if !self.ready {
-    self.Lost("Handler is not marked as ready", nil, message)
+		self.Lost("Handler is not marked as ready", nil, message)
-    return
+		return
-  }
+	}
-  //log.Printf("Handler SingleValueExtractor %d processing %s -> %s", self.id, message.Topic, message.Payload)
+	//log.Printf("Handler SingleValueExtractor %d processing %s -> %s", self.id, message.Topic, message.Payload)
 
-  var measurement database.Measurement
+	var measurement database.Measurement
-  measurement.Time = time.Now()
+	measurement.Time = time.Now()
-  measurement.Application = self.config.application
+	measurement.Application = self.config.application
-  
-  subTopics := strings.Split(message.Topic, "/")
-  //log.Printf("Subtopics: %s", strings.Join(subTopics, ", "))
 
-  var payloadMatches []string
+	subTopics := strings.Split(message.Topic, "/")
-  if self.payloadRegex != nil {
+	//log.Printf("Subtopics: %s", strings.Join(subTopics, ", "))
-    payloadMatches = self.payloadRegex.FindStringSubmatch(message.Payload)
-    //log.Printf("Matches: %s", strings.Join(payloadMatches, ", "))
-  }
 
-  switch self.config.deviceFrom {
+	var payloadMatches []string
-  case TOPIC_SEL:
+	if self.payloadRegex != nil {
-    if self.config.devicePart >= len(subTopics) {
+		payloadMatches = self.payloadRegex.FindStringSubmatch(message.Payload)
-      self.Lost("devicePart out of range", nil, message)
+		//log.Printf("Matches: %s", strings.Join(payloadMatches, ", "))
-      return
+	}
-    }
-    measurement.Device = subTopics[self.config.devicePart]
-  case PAYLOAD_SEL:
-    if self.payloadRegex == nil {
-      self.Lost("no payloadRegex defined, devicePart can't be used", nil, message)
-      return
-    }
-    if self.config.devicePart >= len(payloadMatches) {
-      self.Lost("devicePart out of range", nil, message)
-      return
-    }
-    measurement.Device = payloadMatches[self.config.devicePart]
-  case CONSTANT_SEL:
-    measurement.Device = self.config.device
-  }
 
-  measurement.Values = make(map[string]database.VariableType)
+	switch self.config.deviceFrom {
-  var variable database.VariableType
+	case TOPIC_SEL:
-  variable.Label = ""
+		if self.config.devicePart >= len(subTopics) {
-  variable.Variable = ""
+			self.Lost("devicePart out of range", nil, message)
+			return
+		}
+		measurement.Device = subTopics[self.config.devicePart]
+	case PAYLOAD_SEL:
+		if self.payloadRegex == nil {
+			self.Lost("no payloadRegex defined, devicePart can't be used", nil, message)
+			return
+		}
+		if self.config.devicePart >= len(payloadMatches) {
+			self.Lost("devicePart out of range", nil, message)
+			return
+		}
+		measurement.Device = payloadMatches[self.config.devicePart]
+	case CONSTANT_SEL:
+		measurement.Device = self.config.device
+	}
 
-  switch self.config.valueFrom {
+	measurement.Values = make(map[string]database.VariableType)
-  case PAYLOAD_SEL:
+	var variable database.VariableType
-    if self.payloadRegex == nil {
+	variable.Label = ""
-      self.Lost("no payloadRegex defined, valuePart can't be used", nil, message)
+	variable.Variable = ""
-      return
-    }
-    if self.config.valuePart >= len(payloadMatches) {
-      self.Lost("valuePart out of range", nil, message)
-      return
-    }
-    variable.Value = payloadMatches[self.config.valuePart]
-  case PAYLOAD_FULL_SEL:
-    variable.Value = message.Payload
-  }
 
-  switch self.config.unitFrom {
+	var value string
-  case PAYLOAD_SEL:
+	switch self.config.valueFrom {
-    if self.payloadRegex == nil {
+	case PAYLOAD_SEL:
-      self.Lost("no payloadRegex defined, unitPart can't be used", nil, message)
+		if self.payloadRegex == nil {
-      return
+			self.Lost("no payloadRegex defined, valuePart can't be used", nil, message)
-    }
+			return
-    if self.config.unitPart >= len(payloadMatches) {
+		}
-      self.Lost("unitPart out of range", nil, message)
+		if self.config.valuePart >= len(payloadMatches) {
-      return
+			self.Lost("valuePart out of range", nil, message)
-    }
+			return
-    variable.Unit = payloadMatches[self.config.unitPart]
+		}
-  case CONSTANT_SEL:
+		value = payloadMatches[self.config.valuePart]
-    variable.Unit = self.config.unit
+	case PAYLOAD_FULL_SEL:
-  }
+		value = message.Payload
+	}
+	if self.config.valueType == "float" {
+		fValue, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			self.Lost("Unable to convert value to float", err, message)
+			return
+		}
+		variable.Value = fValue
+	} else {
+		variable.Value = value
+	}
 
-  measurement.Values["Value"] = variable
+	switch self.config.unitFrom {
+	case PAYLOAD_SEL:
+		if self.payloadRegex == nil {
+			self.Lost("no payloadRegex defined, unitPart can't be used", nil, message)
+			return
+		}
+		if self.config.unitPart >= len(payloadMatches) {
+			self.Lost("unitPart out of range", nil, message)
+			return
+		}
+		variable.Unit = payloadMatches[self.config.unitPart]
+	case CONSTANT_SEL:
+		variable.Unit = self.config.unit
+	}
 
-  //log.Printf("Prepared measurement item: %s", measurement)
+	measurement.Values["Value"] = variable
-  self.dbh.StoreMeasurement(&measurement)
+
-  self.S()
+	//log.Printf("Prepared measurement item: %s", measurement)
+	self.dbh.StoreMeasurement(&measurement)
+	self.S()
 }
-