add hx711 driver

Author: gen2thomas

examples/hx711/main.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/hx711"
+)
+
+const (
+	clockOutPin     = machine.D3
+	dataInPin       = machine.D2
+	gainAndChannel  = hx711.A128           // only the first channel A is used
+	tickSleep       = 1 * time.Microsecond // set it to zero for slow MCU's
+	calibrationWait = 10 * time.Second
+	cycleTime       = 1 * time.Second
+)
+
+// please adjust to your load used for calibration
+const (
+	setLoad = 100 // used unit will equal the measured unit
+	unit    = "gram"
+)
+
+func main() {
+	time.Sleep(5 * time.Second) // wait for monitor connection
+
+	cfg := hx711.DefaultConfig
+	cfg.TickSleep = tickSleep
+
+	clockOutPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	dataInPin.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+
+	clockOutPinSet := func(v bool) error { clockOutPin.Set(v); return nil }
+	dataInPinGet := func() (bool, error) { return dataInPin.Get(), nil }
+
+	sensor := hx711.New(clockOutPinSet, dataInPinGet, gainAndChannel)
+	if err := sensor.Configure(&cfg); err != nil {
+		println("Configure failed")
+		panic(err)
+	}
+
+	println("Please remove the mass completely for zeroing within", calibrationWait.String())
+	time.Sleep(calibrationWait)
+	println("Zero starts")
+	if err := sensor.Zero(false); err != nil {
+		println("Zeroing failed")
+		panic(err)
+	}
+
+	println("Please apply the load (", setLoad, unit+" ) for calibration within", calibrationWait.String())
+	time.Sleep(calibrationWait)
+	println("Calibration starts")
+	if err := sensor.Calibrate(setLoad, false); err != nil {
+		println("Calibration failed")
+		panic(err)
+	}
+
+	offs, factor := sensor.OffsetAndCalibrationFactor(false)
+	println("Calibration done completely, offset:", offs, "factor:", factor)
+
+	println("Measurement starts")
+	for {
+		if err := sensor.Update(0); err != nil {
+			println("Sensor update failed", err.Error())
+		}
+
+		v1, _ := sensor.Values()
+
+		println("Mass:", v1, unit)
+
+		time.Sleep(cycleTime)
+	}
+}

fraction.go

@@ -0,0 +1,93 @@
+package drivers
+
+import (
+	"errors"
+	"math"
+	"math/big"
+)
+
+// Float32Fractions calculates the biggest possible denominator "den" for a given floating point number "f" and
+// returns this denominator together with the resulting nominator "nom", so "f" can be reconstructed by "f = num / den".
+// All values are in the range MaxInt32: 2147483647, MinInt32: -2147483648. If the given "f" exceeds this range, it is
+// not possible anymore to represent "f" with "f = num / 1" and an error will be returned with the nearest values.
+// As an exception we define that "den" is always positive, so negative numbers "f" leads always to negative "num".
+//
+// Used formulas:
+// For "abs(f)=af < 1" applies the biggest denominator: "den = math.MaxInt32" and "num = af * den". For "af > 0" this
+// can be written more generalized when split integer part "ip" from fractional part "fp" with "af = ip + fp":
+// "den = math.MaxInt32/(ip + 1)"; "num = af * den"
+// very good accuracy can be reached, similar to calculating with "math/big.Rat", but 2-15 times faster:
+// max. epsilon = 1.9073486328125e-06 in test for "17459216/697177" on arm64, but better for this example on MCU,
+// nrf52840 12.207µs-14.496µs (independent of used base)
+//
+// Sign:
+// "abs(MaxInt32) > abs (MinInt32)", the sign can be applied to "den" or "nom", but we already defined "den" as positive
+//
+// Considered other options: see function in test file
+func Float32Fractions(f float32) (int32, int32, error) {
+	const baseMax = math.MaxInt32
+	//const baseMax = 1000000000 // 10 digits
+	//const baseMax = 2000000000 // 10.5 digits
+	ip, den, err := float32FractionsPreCheck(f)
+	if den == 1 || err != nil {
+		return ip, den, err
+	}
+
+	if f < 0 {
+		ip = -ip
+	}
+
+	// see also "math.Modf()"
+	den = baseMax / (ip + 1)
+	if den == 0 {
+		den = 1
+	}
+
+	return int32(float32(den) * f), den, nil
+}
+
+// Float32FractionsBigRat uses the big/math go library for splitting the given value in fractions. This function seems
+// to produce more accurate results, but is 5-8 times slower than Float32Fractions (depending on value).
+// nrf52840: 74.768µs-106.049µs
+func Float32FractionsBigRat(f float32) (int32, int32, error) {
+	if ip, den, err := float32FractionsPreCheck(f); den == 1 || err != nil {
+		return ip, den, err
+	}
+
+	r := new(big.Rat).SetFloat64(float64(f))
+	d := r.Denom().Int64() //Denom returns the denominator of x; it is always > 0.
+	if d > math.MaxInt32 {
+		d = math.MaxInt32
+	}
+
+	n := f * float32(d)
+	if n > math.MaxInt32 {
+		println("n ex+", n)
+		return math.MaxInt32, int32(float32(math.MaxInt32) / f), nil
+	} else if n < math.MinInt32 {
+		println("n ex-", n)
+		return math.MinInt32, int32(float32(math.MinInt32) / f), nil
+	}
+
+	return int32(n), int32(d), nil
+}
+
+func float32FractionsPreCheck(f float32) (int32, int32, error) {
+	if f > math.MaxInt32 {
+		return math.MaxInt32, 1, errors.New("input value exceeds +int32 range")
+	}
+
+	if f < math.MinInt32 {
+		return math.MinInt32, 1, errors.New("input value exceeds -int32 range")
+	}
+
+	ip := int32(f)
+	den := int32(0)
+
+	if float32(ip) == f {
+		// float is an integer
+		den = 1
+	}
+
+	return ip, den, nil
+}