From a0f12c800e59f7e09218d31864da8b9058a8a51e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1ximo=20Cuadros?= Date: Mon, 24 Oct 2016 01:46:51 +0200 Subject: [PATCH] canvas and toolkit --- canvas.go | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ matrix.go | 22 ++++++++++++++-- toolkit.go | 66 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 162 insertions(+), 2 deletions(-) create mode 100644 canvas.go create mode 100644 toolkit.go diff --git a/canvas.go b/canvas.go new file mode 100644 index 0000000..bc908a3 --- /dev/null +++ b/canvas.go @@ -0,0 +1,76 @@ +package rgbmatrix + +import ( + "image" + "image/color" + "image/draw" +) + +// Canvas is a image.Image representation of a WS281x matrix, it implements +// image.Image interface and can be used with draw.Draw for example +type Canvas struct { + w, h int + m Matrix + closed bool +} + +// NewCanvas returns a new Canvas using the given width and height and creates +// a new WS281x matrix using the given config +func NewCanvas(m Matrix) *Canvas { + w, h := m.Geometry() + return &Canvas{ + w: w, + h: h, + m: m, + } +} + +// Render update the display with the data from the LED buffer +func (c *Canvas) Render() error { + return c.m.Render() +} + +// ColorModel returns the canvas' color model, always color.RGBAModel +func (c *Canvas) ColorModel() color.Model { + return color.RGBAModel +} + +// Bounds return the topology of the Canvas +func (c *Canvas) Bounds() image.Rectangle { + return image.Rect(0, 0, c.w, c.h) +} + +// At returns the color of the pixel at (x, y) +func (c *Canvas) At(x, y int) color.Color { + return c.m.At(c.position(x, y)) +} + +// Set set LED at position x,y to the provided 24-bit color value +func (c *Canvas) Set(x, y int, color color.Color) { + c.m.Set(c.position(x, y), color) +} + +func (c *Canvas) position(x, y int) int { + return x + (y * c.w) +} + +// Clear set all the leds on the matrix with color.Black +func (c *Canvas) Clear() error { + draw.Draw(c, c.Bounds(), &image.Uniform{color.Black}, image.ZP, draw.Src) + return c.m.Render() +} + +// Close clears the matrix and close the matrix +func (c *Canvas) Close() error { + c.Clear() + return c.m.Close() +} + +type Matrix interface { + Geometry() (width, height int) + At(position int) color.Color + Set(position int, c color.Color) + Apply([]color.Color) error + Render() error + Close() error +} diff --git a/matrix.go b/matrix.go index 2d9045d..e5769cc 100644 --- a/matrix.go +++ b/matrix.go @@ -5,8 +5,11 @@ package rgbmatrix #cgo LDFLAGS: -lrgbmatrix -L${SRCDIR}/vendor/rpi-rgb-led-matrix/lib -lstdc++ -lm #include -void led_matrix_swap(struct LedCanvas *offscreen_canvas, +void led_matrix_swap(struct RGBLedMatrix *matrix, int width, int height, const uint32_t pixels[]) { + struct LedCanvas *offscreen_canvas; + offscreen_canvas = led_matrix_create_offscreen_canvas(matrix); + int i, x, y; uint32_t color; for (y = 0; y < height; ++y) { @@ -18,6 +21,8 @@ void led_matrix_swap(struct LedCanvas *offscreen_canvas, (color >> 16) & 255, (color >> 8) & 255, color & 255); } } + + led_matrix_swap_on_vsync(matrix, offscreen_canvas); } */ import "C" @@ -112,7 +117,7 @@ type RGBLedMatrix struct { } // NewRGBLedMatrix returns a new matrix using the given size and config -func NewRGBLedMatrix(config *HardwareConfig) (Matrix, error) { +func NewRGBLedMatrix(config *HardwareConfig) (*RGBLedMatrix, error) { w, h := config.geometry() c := &RGBLedMatrix{ @@ -140,6 +145,14 @@ func (c *RGBLedMatrix) Geometry() (width, height int) { return c.width, c.height } +func (c *RGBLedMatrix) Apply(leds []color.Color) error { + for position, l := range leds { + c.Set(position, l) + } + + return c.Render() +} + // Render update the display with the data from the LED buffer func (c *RGBLedMatrix) Render() error { C.led_matrix_swap( @@ -148,6 +161,7 @@ func (c *RGBLedMatrix) Render() error { (*C.uint32_t)(unsafe.Pointer(&c.leds[0])), ) + c.leds = make([]C.uint32_t, 2048) return nil } @@ -169,6 +183,10 @@ func (c *RGBLedMatrix) Close() error { } func colorToUint32(c color.Color) uint32 { + if c == nil { + return 0 + } + // A color's RGBA method returns values in the range [0, 65535] red, green, blue, _ := c.RGBA() return (red>>8)<<16 | (green>>8)<<8 | blue>>8 diff --git a/toolkit.go b/toolkit.go new file mode 100644 index 0000000..1070943 --- /dev/null +++ b/toolkit.go @@ -0,0 +1,66 @@ +package rgbmatrix + +import ( + "image" + "image/draw" + "image/gif" + "io" + "time" +) + +type ToolKit struct { + Canvas *Canvas +} + +func (tk *ToolKit) PlayImage(i image.Image, delay time.Duration) error { + start := time.Now() + defer func() { time.Sleep(delay - time.Since(start)) }() + + draw.Draw(tk.Canvas, tk.Canvas.Bounds(), i, image.ZP, draw.Over) + return tk.Canvas.Render() +} + +func (tk *ToolKit) PlayImages(images []image.Image, delay []time.Duration, loop int) chan bool { + quit := make(chan bool, 0) + + go func() { + l := len(images) + i := 0 + for { + select { + case <-quit: + return + default: + tk.PlayImage(images[i], delay[i]) + } + + i++ + if i >= l { + if loop == 0 { + i = 0 + continue + } + + break + } + } + }() + + return quit +} + +func (tk *ToolKit) PlayGIF(r io.Reader) (chan bool, error) { + gif, err := gif.DecodeAll(r) + if err != nil { + return nil, err + } + + delay := make([]time.Duration, len(gif.Delay)) + images := make([]image.Image, len(gif.Image)) + for i, image := range gif.Image { + images[i] = image + delay[i] = time.Millisecond * time.Duration(gif.Delay[i]) * 10 + } + + return tk.PlayImages(images, delay, gif.LoopCount), nil +}