The missing half of the prior reorganization. Also, make tests work a…

…gain.

Not entirely happy about creating a fake LPD8806, but we can deal with that later.

effects/effects.go

@@ -2,15 +2,15 @@ package effects
 
 import (
  "fmt"
+ pixarray "github.com/Jon-Bright/ledctl/pixarray"
  "log"
  "math"
- "pixarray"
  "time"
 )
 
 type Effect interface {
- Start(pa *pixarray.PixArray, now time.Time)
- NextStep(pa *pixarray.PixArray, now time.Time) time.Duration
+ Start(pa pixarray.PixArray, now time.Time)
+ NextStep(pa pixarray.PixArray, now time.Time) time.Duration
  Name() string
 }
 
@@ -110,7 +110,7 @@ func NewFade(fadeTime time.Duration, dest pixarray.Pixel) *Fade {
  return &f
 }
 
-func (f *Fade) Start(pa *pixarray.PixArray, now time.Time) {
+func (f *Fade) Start(pa pixarray.PixArray, now time.Time) {
  log.Printf("Starting Fade, dest %v", f.dest)
  var lastp pixarray.Pixel
  f.allSame = true
@@ -149,7 +149,7 @@ func (f *Fade) Start(pa *pixarray.PixArray, now time.Time) {
  f.start = now
 }
 
-func (f *Fade) NextStep(pa *pixarray.PixArray, now time.Time) time.Duration {
+func (f *Fade) NextStep(pa pixarray.PixArray, now time.Time) time.Duration {
  td := now.Sub(f.start)
  pct := float64(td.Nanoseconds()) / float64(f.fadeTime.Nanoseconds())
  if pct >= 1.0 {
@@ -264,7 +264,7 @@ func NewRainbow(cycleTime time.Duration) *Rainbow {
  return &r
 }
 
-func (r *Rainbow) Start(pa *pixarray.PixArray, now time.Time) {
+func (r *Rainbow) Start(pa pixarray.PixArray, now time.Time) {
  log.Printf("Starting Rainbow")
  r.start = now
 }
@@ -286,7 +286,7 @@ func fToPix(f float64, o float64) int {
  return 0
 }
 
-func (r *Rainbow) NextStep(pa *pixarray.PixArray, now time.Time) time.Duration {
+func (r *Rainbow) NextStep(pa pixarray.PixArray, now time.Time) time.Duration {
  pos := float64(now.Sub(r.start).Nanoseconds()) / float64(r.cycleTime.Nanoseconds())
  pos -= math.Floor(pos)
  offs := round(float64(pa.NumPixels()) * pos)
@@ -323,7 +323,7 @@ func NewCycle(cycleTime time.Duration) *Cycle {
  return &c
 }
 
-func (c *Cycle) Start(pa *pixarray.PixArray, now time.Time) {
+func (c *Cycle) Start(pa pixarray.PixArray, now time.Time) {
  log.Printf("Starting Cycle")
  c.start = now
  p := pa.GetPixel(0)
@@ -386,7 +386,7 @@ func (c *Cycle) Start(pa *pixarray.PixArray, now time.Time) {
  }
 }
 
-func (c *Cycle) NextStep(pa *pixarray.PixArray, now time.Time) time.Duration {
+func (c *Cycle) NextStep(pa pixarray.PixArray, now time.Time) time.Duration {
  if c.fade != nil {
  t := c.fade.NextStep(pa, now)
  if t != 0 {
@@ -446,12 +446,12 @@ func NewZip(zipTime time.Duration, dest pixarray.Pixel) *Zip {
  return &z
 }
 
-func (z *Zip) Start(pa *pixarray.PixArray, now time.Time) {
+func (z *Zip) Start(pa pixarray.PixArray, now time.Time) {
  log.Printf("Starting Zip")
  z.start = now
 }
 
-func (z *Zip) NextStep(pa *pixarray.PixArray, now time.Time) time.Duration {
+func (z *Zip) NextStep(pa pixarray.PixArray, now time.Time) time.Duration {
  p := int((float64(now.Sub(z.start).Nanoseconds()) / float64(z.zipTime.Nanoseconds())) * float64(pa.NumPixels()))
  for i := z.lastSet + 1; i < pa.NumPixels() && i <= p; i++ {
  pa.SetOne(i, z.dest)
@@ -479,13 +479,13 @@ func NewKnightRider(pulseTime time.Duration, pulseLen int) *KnightRider {
  return &kr
 }
 
-func (kr *KnightRider) Start(pa *pixarray.PixArray, now time.Time) {
+func (kr *KnightRider) Start(pa pixarray.PixArray, now time.Time) {
  log.Printf("Starting KnightRider")
  kr.start = now
  pa.SetAll(pixarray.Pixel{0, 0, 0})
 }
 
-func (kr *KnightRider) NextStep(pa *pixarray.PixArray, now time.Time) time.Duration {
+func (kr *KnightRider) NextStep(pa pixarray.PixArray, now time.Time) time.Duration {
  pulse := now.Sub(kr.start).Nanoseconds() / kr.pulseTime.Nanoseconds()
  pulseProgress := float64(now.Sub(kr.start).Nanoseconds()-(pulse*kr.pulseTime.Nanoseconds())) / float64(kr.pulseTime.Nanoseconds())
  pulseHead := int(float64(pa.NumPixels()+kr.pulseLen) * pulseProgress)

effects/effects_test.go

@@ -1,8 +1,8 @@
 package effects
 
 import (
+ pixarray "github.com/Jon-Bright/ledctl/pixarray"
  "math"
- "pixarray"
  "testing"
  "time"
 )
@@ -27,7 +27,7 @@ func d(s string, tb testing.TB) time.Duration {
 }
 
 func TestAllSameFade(t *testing.T) {
- pa, err := pixarray.NewPixArray(&FakeLEDDev{}, 100, 0, pixarray.GRB)
+ pa, err := pixarray.NewLPD8806(&FakeLEDDev{}, 100, 0, pixarray.GRB)
  if err != nil {
  t.Fatalf("Failed NewPixArray: %v", err)
  }
@@ -98,7 +98,7 @@ func TestAllSameFade(t *testing.T) {
 }
 
 func BenchmarkFadeStep(b *testing.B) {
- pa, err := pixarray.NewPixArray(&FakeLEDDev{}, 100, 0, pixarray.GRB)
+ pa, err := pixarray.NewLPD8806(&FakeLEDDev{}, 100, 0, pixarray.GRB)
  if err != nil {
  b.Fatalf("Failed NewPixArray: %v", err)
  }

pixarray/basearray.go

@@ -8,7 +8,7 @@ type baseArray struct {
  b int
 }
 
-func newBaseArray(numPixels int, pixels []byte, order int) (*baseArray) {
+func newBaseArray(numPixels int, pixels []byte, order int) *baseArray {
  offsets := offsets[order]
  ba := baseArray{numPixels, pixels, offsets[0], offsets[1], offsets[2]}
  return &ba
@@ -57,7 +57,7 @@ func (ba *baseArray) SetAlternate(num int, div int, p1 Pixel, p2 Pixel) {
  }
 }
 
-func (pa *baseArray) SetPerChanAlternate(num Pixel, div int, p1 Pixel, p2 Pixel) {
+func (ba *baseArray) SetPerChanAlternate(num Pixel, div int, p1 Pixel, p2 Pixel) {
  totSet := Pixel{}
  shouldSet := Pixel{}
  for i := 0; i < ba.numPixels; i++ {
@@ -91,15 +91,15 @@ func (pa *baseArray) SetPerChanAlternate(num Pixel, div int, p1 Pixel, p2 Pixel)
  }
 }
 
-func (pa *baseArray) SetAll(p Pixel) {
+func (ba *baseArray) SetAll(p Pixel) {
  for i := 0; i < ba.numPixels; i++ {
  ba.pixels[i*3+ba.g] = byte(0x80 | p.G)
  ba.pixels[i*3+ba.r] = byte(0x80 | p.R)
  ba.pixels[i*3+ba.b] = byte(0x80 | p.B)
  }
 }
 
-func (pa *baseArray) SetOne(i int, p Pixel) {
+func (ba *baseArray) SetOne(i int, p Pixel) {
  ba.pixels[i*3+ba.g] = byte(0x80 | p.G)
  ba.pixels[i*3+ba.r] = byte(0x80 | p.R)
  ba.pixels[i*3+ba.b] = byte(0x80 | p.B)

pixarray/pixarray_test.go → pixarray/basearray_test.go

@@ -4,22 +4,9 @@ import (
  "testing"
 )
 
-type FakeLEDDev struct {
-}
-
-func (f *FakeLEDDev) Fd() uintptr {
- return 0
-}
-
-func (f *FakeLEDDev) Write(b []byte) (n int, err error) {
- return len(b), nil
-}
-
 func TestSetOneThenGetOneByOne(t *testing.T) {
- pa, err := NewPixArray(&FakeLEDDev{}, 100, 0, GRB)
- if err != nil {
- t.Fatalf("Failed NewPixArray: %v", err)
- }
+ pixels := make([]byte, 100*3)
+ pa := newBaseArray(100, pixels, GRB)
  ps := Pixel{10, 25, 45}
  pb := Pixel{0, 0, 0}
  pa.SetOne(20, ps)
@@ -34,10 +21,8 @@ func TestSetOneThenGetOneByOne(t *testing.T) {
 }
 
 func TestSetOneThenGetAll(t *testing.T) {
- pa, err := NewPixArray(&FakeLEDDev{}, 100, 0, GRB)
- if err != nil {
- t.Fatalf("Failed NewPixArray: %v", err)
- }
+ pixels := make([]byte, 100*3)
+ pa := newBaseArray(100, pixels, GRB)
  ps := Pixel{10, 25, 45}
  pb := Pixel{0, 0, 0}
  pa.SetOne(20, ps)
@@ -55,10 +40,8 @@ func TestSetOneThenGetAll(t *testing.T) {
 }
 
 func TestSetAlternate(t *testing.T) {
- pa, err := NewPixArray(&FakeLEDDev{}, 100, 0, GRB)
- if err != nil {
- t.Fatalf("Failed NewPixArray: %v", err)
- }
+ pixels := make([]byte, 100*3)
+ pa := newBaseArray(100, pixels, GRB)
  p1 := Pixel{10, 25, 45}
  p2 := Pixel{9, 7, 5}
 
@@ -126,10 +109,8 @@ func TestSetAlternate(t *testing.T) {
 }
 
 func TestSetPerChanAlternate(t *testing.T) {
- pa, err := NewPixArray(&FakeLEDDev{}, 100, 0, GRB)
- if err != nil {
- t.Fatalf("Failed NewPixArray: %v", err)
- }
+ pixels := make([]byte, 100*3)
+ pa := newBaseArray(100, pixels, GRB)
  p1 := Pixel{10, 25, 45}
  p2 := Pixel{9, 7, 5}
 
@@ -230,10 +211,8 @@ func TestSetPerChanAlternate(t *testing.T) {
 }
 
 func BenchmarkSetAlternate(b *testing.B) {
- pa, err := NewPixArray(&FakeLEDDev{}, 100, 0, GRB)
- if err != nil {
- b.Fatalf("Failed NewPixArray: %v", err)
- }
+ pixels := make([]byte, 100*3)
+ pa := newBaseArray(100, pixels, GRB)
  p1 := Pixel{10, 25, 45}
  p2 := Pixel{9, 7, 5}
  for i := 0; i < b.N/2; i++ {
@@ -243,10 +222,8 @@ func BenchmarkSetAlternate(b *testing.B) {
 }
 
 func BenchmarkSetPerChanAlternate(b *testing.B) {
- pa, err := NewPixArray(&FakeLEDDev{}, 100, 0, GRB)
- if err != nil {
- b.Fatalf("Failed NewPixArray: %v", err)
- }
+ pixels := make([]byte, 100*3)
+ pa := newBaseArray(100, pixels, GRB)
  p1 := Pixel{10, 25, 45}
  p2 := Pixel{9, 7, 5}
  s1 := Pixel{5, 1, 2}

pixarray/lpd8806.go

@@ -7,20 +7,19 @@ import (
 )
 
 type LPD8806Array struct {
- ba baseArray
+ baseArray
  dev dev
  sendBytes []byte
 }
 
-func NewLPD8806(dev dev, numPixels int, spiSpeed uint32, order int) (*PixArray, error) {
+func NewLPD8806(dev dev, numPixels int, spiSpeed uint32, order int) (PixArray, error) {
  numReset := (numPixels + 31) / 32
  val := make([]byte, numPixels*3+numReset)
- offsets := offsets[order]
  ba := newBaseArray(numPixels, val[:numPixels*3], order)
- pa := PixArray{ba, dev, val}
+ la := LPD8806Array{*ba, dev, val}
 
  if spiSpeed != 0 {
- err := pa.setSPISpeed(spiSpeed)
+ err := la.setSPISpeed(spiSpeed)
  if err != nil {
  return nil, fmt.Errorf("couldn't set SPI speed: %v", err)
  }
@@ -31,17 +30,17 @@ func NewLPD8806(dev dev, numPixels int, spiSpeed uint32, order int) (*PixArray,
  if err != nil {
  return nil, fmt.Errorf("couldn't reset: %v", err)
  }
- return &pa, nil
+ return &la, nil
 }
 
 const (
  _SPI_IOC_WR_MAX_SPEED_HZ = 0x40046B04
 )
 
-func (pa *PixArray) setSPISpeed(s uint32) error {
+func (la *LPD8806Array) setSPISpeed(s uint32) error {
  _, _, errno := syscall.Syscall(
  syscall.SYS_IOCTL,
- uintptr(pa.dev.Fd()),
+ uintptr(la.dev.Fd()),
  uintptr(_SPI_IOC_WR_MAX_SPEED_HZ),
  uintptr(unsafe.Pointer(&s)),
  )
@@ -51,7 +50,7 @@ func (pa *PixArray) setSPISpeed(s uint32) error {
  return errno
 }
 
-func (pa *PixArray) Write() error {
- _, err := pa.dev.Write(pa.sendBytes)
+func (la *LPD8806Array) Write() error {
+ _, err := la.dev.Write(la.sendBytes)
  return err
 }