Add more geiger

geiger.go

@@ -2,6 +2,7 @@ package geiger // import "lukechampine.com/geiger"
 
 import (
 	"math"
+	"math/rand"
 	"runtime"
 	"time"
 
@@ -10,17 +11,22 @@ import (
 )
 
 const sr = beep.SampleRate(44100)
-const memSampleRate = 100 * time.Millisecond
+const memSampleRate = 500 * time.Millisecond
+const baseline = 160
 
 func Count() {
-	var freq, t float64
-	step := sr.D(1).Seconds()
-	speaker.Init(sr, sr.N(memSampleRate))
+	var p int
+	speaker.Init(sr, sr.N(memSampleRate)/5)
+	rng := rand.New(rand.NewSource(0x1337))
+	sign := 1.0
 	speaker.Play(beep.StreamerFunc(func(samples [][2]float64) (int, bool) {
 		for i := range samples {
-			t += step
-			a := math.Sin(2 * math.Pi * freq * t)
-			samples[i] = [2]float64{a, a}
+			if rng.Intn(int(sr)) < p {
+				samples[i] = [2]float64{sign, sign}
+				sign *= -1
+			} else {
+				samples[i] = [2]float64{0, 0}
+			}
 		}
 		return len(samples), true
 	}))
@@ -32,8 +38,13 @@ func Count() {
 		runtime.ReadMemStats(&ms)
 		diff := ms.Mallocs - prevAllocs
 		prevAllocs = ms.Mallocs
+		// Allocs per second
+		rate := float64(diff)/memSampleRate.Seconds() - baseline
+		// If it becomes too high it becomes inaudible.
+		// Limit at 3.6 Roentgen.
+		rate = math.Min(rate, float64(sr)/3.6)
 		speaker.Lock()
-		freq = float64(diff) / memSampleRate.Seconds()
+		p = int(rate)
 		speaker.Unlock()
 	}
 }

geiger_test.go

@@ -0,0 +1,65 @@
+package geiger
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"testing"
+	"time"
+)
+
+// TestCount requires human ears.
+func TestCount(t *testing.T) {
+	go Count()
+	tests := []struct {
+		name string
+		hz   int
+		per  int
+	}{
+		{
+			name: "baseline",
+			hz:   1,
+			per:  0,
+		},
+		{
+			name: "5hz",
+			hz:   5,
+			per:  1,
+		}, {
+			name: "50hz",
+			hz:   50,
+			per:  1,
+		}, {
+			name: "500hz",
+			hz:   50,
+			per:  10,
+		}, {
+			name: "5000hz",
+			hz:   50,
+			per:  100,
+		}, {
+			name: "50000hz",
+			hz:   50,
+			per:  1000,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			done := time.After(5 * time.Second)
+			every := time.NewTicker(time.Second / time.Duration(tt.hz))
+			for {
+				select {
+				case <-done:
+					return
+				case <-every.C:
+					for i := 0; i < tt.per; i++ {
+						// alloc tmp
+						tmp := bytes.Buffer{}
+						io.Copy(ioutil.Discard, &tmp)
+					}
+				}
+			}
+		})
+	}
+}