ws2812 0.0.2

data/examples/binaryclock.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'ws2812'
+
+# Single 1x4 pixels binary "digit"
+class BinaryDigit
+	def initialize(hat, x, y, color, off_color = nil)
+		off_color ||= Ws2812::Color.new(0, 0, 0)
+		@hat, @x, @y, @color, @off_color = hat, x, y, color, off_color
+	end
+	attr_reader :hat
+	attr_accessor :x, :y, :color, :off_color
+
+	def show(value, do_show = false, &pixel_set)
+		pixel_set ||= method(:default_pixel_set)
+		raise ArgumentError, "invalid value" unless (0..9).include?(value)
+		x = 0
+		0.upto(3) do |y|
+			if value[3-y].zero?
+				pixel_set.call(@hat,@x + x, @y + y, @off_color)
+			else
+				pixel_set.call(@hat,@x + x, @y + y, @color)
+			end
+		end
+		@hat.show if do_show
+	end
+
+	def default_pixel_set(hat, x, y, color)
+		hat[x, y] = color
+	end
+	private :default_pixel_set
+end
+
+# Two BinaryDigits next to each other with no pixel gap
+class TwoBinaryDigits
+	def initialize(hat, x, y, color, off_color = nil)
+		@tens = BinaryDigit.new(hat, x, y, color, off_color)
+		@singles = BinaryDigit.new(hat, x + 1, y, color, off_color)
+		@hat, @x, @y, @color = hat, x, y, color
+	end
+	attr_reader :hat, :x, :y, :color, :off_color
+
+	def show(value, do_show = false, &pixel_set)
+		tens_value = value / 10
+		@tens.show(tens_value, false, &pixel_set)
+		@singles.show(value % 10, false, &pixel_set)
+		@hat.show if do_show
+	end
+
+	def off_color
+		@tens.off_color
+	end
+
+	def off_color=(val)
+		@tens.off_color = @singles.off_color = val
+	end
+
+	def color=(val)
+		@tens.color = @singles.color = val
+	end
+
+	def x=(val)
+		@tens.x = val
+		@singles.x = val + 1
+	end
+
+	def y=(val)
+		@tens.y = @singles.y = val
+	end
+end
+
+# A 6x4 matrix that represents binary clock
+class BinaryClock
+	def initialize(hat, x, y, color)
+		@h = TwoBinaryDigits.new(hat, x, y, color)
+		@m = TwoBinaryDigits.new(hat, x+2, y, color)
+		@s = TwoBinaryDigits.new(hat, x+4, y, color)
+	end
+
+	def show(time)
+		@h.show(time.hour, false)
+		@m.show(time.min, false)
+		@s.show(time.sec, false)
+	end
+end
+
+# A 8x4 matrix that represents binary calendar (ddmmyyyy)
+class BinaryCalendar
+	def initialize(hat, x, y, color)
+		@d = TwoBinaryDigits.new(hat, x, y, color)
+		@m = TwoBinaryDigits.new(hat, x+2, y, color)
+		@y1 = TwoBinaryDigits.new(hat, x+4, y, color)
+		@y2 = TwoBinaryDigits.new(hat, x+6, y, color)
+	end
+
+	def show(time)
+		@d.show(time.day, false)
+		@m.show(time.month, false)
+		@y1.show(time.year/100, false)
+		@y2.show(time.year%100, false)
+	end
+end
+
+if __FILE__ == $0
+	# Init
+	hat = Ws2812::UnicornHAT.new
+	hat.rotation = 180
+	hat.brightness = 20
+
+	frame = Ws2812::Color.new(0x00, 0x00, 0x66)
+	red = Ws2812::Color.new(0xff, 0, 0)
+	green = Ws2812::Color.new(0, 0xff, 0)
+	if true
+		# Calendar + Clock
+		calendar = BinaryCalendar.new(hat, 0, 0, green)
+		clock = BinaryClock.new(hat, 1, 4, red)
+		show_calendar = true
+		frame_proc = proc do
+			4.upto(7) do |y|
+				hat[0, y] = hat[7, y] = frame
+			end
+		end
+	else
+		# Just clock, with a frame around it
+		clock = BinaryClock.new(hat, 1, 2, red)
+		show_calendar = false
+		frame_proc = proc do
+			0.upto(7) do |x|
+				#hat[x, 7] = hat[x, 0] = frame
+				hat[x, 6] = hat[x, 1] = frame
+			end
+			2.upto(5) do |y|
+				hat[0, y] = hat[7, y] = frame
+			end
+		end
+	end
+	ot = nil
+
+	# Show it...
+	begin
+		loop do	
+			t = Time.now
+
+			# set the display anew if hour/minute/sec changed
+			if ot.nil? || (ot.hour != t.hour || ot.min != t.min || ot.sec != t.sec)
+				ot = t
+				hat.clear(false)
+				clock.show(t)
+				calendar.show(t) if show_calendar
+				frame_proc.call
+				hat.show
+			end
+
+			sleep 0.1
+		end
+	rescue Interrupt
+	end
+
+	# cleanup
+	hat.clear
+end

data/examples/digiclock.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'ws2812'
+
+# Single 3x5 pixels "digit" (think 7-segment display)
+class Digit
+	n = nil # just to have the table below pretty
+	VALUES = {
+		n => [ 0b000, 0b000, 0b000, 0b000, 0b000, ],
+		0 => [ 0b111, 0b101, 0b101, 0b101, 0b111, ],
+		#1 => [ 0b010, 0b110, 0b010, 0b010, 0b010, ], # 1 in the middle
+		1 => [ 0b001, 0b011, 0b001, 0b001, 0b001, ], # 1 at the left
+		2 => [ 0b111, 0b001, 0b111, 0b100, 0b111, ],
+		3 => [ 0b111, 0b001, 0b111, 0b001, 0b111, ],
+		4 => [ 0b101, 0b101, 0b111, 0b001, 0b001, ],
+		5 => [ 0b111, 0b100, 0b111, 0b001, 0b111, ],
+		#6 => [ 0b111, 0b100, 0b111, 0b101, 0b111, ], # "full" six
+		6 => [ 0b100, 0b100, 0b111, 0b101, 0b111, ], # "sparse" six
+		7 => [ 0b111, 0b001, 0b001, 0b001, 0b001, ],
+		8 => [ 0b111, 0b101, 0b111, 0b101, 0b111, ],
+		#9 => [ 0b111, 0b101, 0b111, 0b001, 0b111, ], # "full" nine
+		9 => [ 0b111, 0b101, 0b111, 0b001, 0b001, ], # "sparse" nine
+	}
+
+	def initialize(hat, x, y, color, off_color = nil)
+		off_color ||= Ws2812::Color.new(0, 0, 0)
+		@hat, @x, @y, @color, @off_color = hat, x, y, color, off_color
+	end
+	attr_reader :hat
+	attr_accessor :x, :y, :color, :off_color
+
+	def show(value, do_show = false, &pixel_set)
+		pixel_set ||= method(:default_pixel_set)
+		raise ArgumentError, "invalid value" unless VALUES[value]
+		0.upto(4) do |y|
+			0.upto(2) do |x|
+				if VALUES[value][y][2-x].zero?
+					pixel_set.call(@hat,@x + x, @y + y, @off_color)
+				else
+					pixel_set.call(@hat,@x + x, @y + y, @color)
+				end
+			end
+		end
+		@hat.show if do_show
+	end
+
+	def default_pixel_set(hat, x, y, color)
+		hat[x, y] = color
+	end
+	private :default_pixel_set
+end
+
+# Two Digits next to each other with one pixel gap
+# (think two 7-segment displays next to each other)
+class TwoDigits
+	def initialize(hat, x, y, color, off_color = nil)
+		@tens = Digit.new(hat, x, y, color, off_color)
+		@singles = Digit.new(hat, x + 4, y, color, off_color)
+		@hat, @x, @y, @color = hat, x, y, color
+		@leading_zero = false
+	end
+	attr_reader :hat, :x, :y, :color, :off_color
+	attr_accessor :leading_zero
+
+	def show(value, do_show = false, &pixel_set)
+		tens_value = value / 10
+		tens_value = nil if !@leading_zero && tens_value.zero?
+		@tens.show(tens_value, false, &pixel_set)
+		@singles.show(value % 10, false, &pixel_set)
+		@hat.show if do_show
+	end
+
+	def off_color
+		@tens.off_color
+	end
+
+	def off_color=(val)
+		@tens.off_color = @singles.off_color = val
+	end
+
+	def color=(val)
+		@tens.color = @singles.color = val
+	end
+
+	def x=(val)
+		@tens.x = val
+		@singles.x = val + 4
+	end
+
+	def y=(val)
+		@tens.y = @singles.y = val
+	end
+end
+
+if __FILE__ == $0
+	# Init
+	hat = Ws2812::UnicornHAT.new
+	hat.rotation = 180
+
+	gc = Ws2812::GammaCorrection.new(20) # => "brightness" set to 20
+	hat.direct = true
+	# Note: I'm using direct mode with custom +gc+ here so I can better
+	# "animate" the pixels where hours and minutes overlap (both set)
+	#
+	# Without direct mode you're flying blind and changing the uncorrected
+	# values, while possible, looks fugly in lower brightness (i.e. 20)
+	black = gc.correct(Ws2812::Color.new(0, 0, 0))
+	red = gc.correct(Ws2812::Color.new(0xff, 0, 0))
+	green = gc.correct(Ws2812::Color.new(0, 0xaa, 0))
+	both = gc.correct(Ws2812::Color.new(0xff, 0xaa, 0))
+	h = TwoDigits.new(hat, 0, 0, red, black)
+	m = TwoDigits.new(hat, 1, 3, green, black)
+	m.leading_zero = true
+
+	# The following proc block allows us to merge individual red+green pixels
+	# into one aggregate "both" pixel (same Ws2812::Color instance). Thus
+	# allowing us to change one value (and then call +#push_all_pixels+) for
+	# update of the whole array.
+	green_ps = proc do |hat, x, y, color|
+		if hat[x, y] == red
+			hat[x, y] = both if color == green
+			# otherwise stays red
+		else
+			hat[x, y] = color
+		end
+	end
+
+	begin
+		ticks = 25
+		tick = 0
+		direction = 1
+		ot = nil
+		loop do	
+			t = Time.now
+
+			# set the display anew if hour/minute changed
+			if ot.nil? || (ot.hour != t.hour || ot.min != t.min)
+				ot = t
+				hat.clear(false)
+				h.show(t.hour, false)
+				m.show(t.min, false, &green_ps)
+			end
+
+
+			# animate "both" pixels (where hour & minute overlay)
+			both.r = (red.r * tick.to_f/ticks).to_i
+			both.g = (green.g * ((ticks - tick).to_f/ticks)).to_i
+			both.r = both.g = 1 if both.r.zero? && both.g.zero?
+			hat.push_all_pixels
+
+			if direction > 0
+				direction = -1 if tick + 1 >= ticks
+				tick = tick + 1
+			else
+				direction = 1 if tick - 1 <= 0
+				tick = tick - 1
+			end
+
+			hat.show
+			sleep 0.1
+		end
+	rescue Interrupt
+	end
+
+	# cleanup
+	hat.clear
+end

data/examples/gamma-vs-direct.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'ws2812'
+
+# Init
+n = 64 # num leds
+ws = Ws2812::Basic.new(n, 18) # +n+ leds at pin 18, using defaults
+ws.open
+ws.brightness = 255
+if ARGV.first
+	puts 'Using direct mode.'
+	puts 'Remove all positional parameters to switch to gamma-corrected mode.'
+	ws.direct = true
+else
+	puts 'Using gamma-corrected mode.'
+	puts 'Add (any) positional parameter to switch to direct mode.'
+end
+
+# up...
+0.upto(255) do |i|
+	ws[0..63] = Ws2812::Color.new(i, i, i)
+	ws.show
+	sleep 0.01
+end
+
+# and down...
+255.downto(0) do |i|
+	ws[0..63] = Ws2812::Color.new(i, i, i)
+	ws.show
+	sleep 0.01
+end

data/examples/unicornhat-test.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'ws2812'
+
+# Init
+hat = Ws2812::UnicornHAT.new
+
+# first corner set to red
+red = Ws2812::Color.new(0xff, 0, 0)
+hat[0, 0] = red
+hat[0, 1] = red
+hat[1, 0] = red
+
+# second to green
+green = Ws2812::Color.new(0, 0xff, 0)
+hat[6, 7] = green
+hat[7, 7] = green
+hat[7, 6] = green
+
+# middle part
+hat[3, 3] = red
+hat[4, 4] = green
+
+
+# show it
+hat.show
+
+sleep 0.5
+
+# rotate around till ^C
+puts "Spinning... ^C to terminate"
+begin
+	loop do
+		# rotate around
+		for rot in [90, 180, 270, 0]
+			hat.rotation = rot
+			hat.show
+
+			sleep 0.5
+		end
+	end
+rescue Interrupt
+end
+
+# Clear the display at the end
+hat.clear
+hat.show

data/ext/ws2812/COMPILING.txt

@@ -0,0 +1,4 @@
+# make sure you have swig2.0 if you're planning to regen
+# lowlevel_wrap.c from lowlevel.i
+ruby extconf.rb
+make

data/ext/ws2812/SOURCES.txt

@@ -0,0 +1,2 @@
+lowlevel.i is https://github.com/pimoroni/unicorn-hat/blob/master/python/rpi-ws281x/rpi_ws281x.i
+*.[ch] are https://github.com/pimoroni/unicorn-hat/tree/master/python/rpi-ws281x/lib/*.[ch]

data/ext/ws2812/board_info.c

@@ -0,0 +1,143 @@
+/*
+ * This needs cleaning up and expanding.  The MODEL_* defines shoudl be in
+ * board_info.h, it currently identifies everything not a B2 as a B, it
+ * should have an accessor function for the board model and revision, etc.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "board_info.h"
+
+enum
+{
+   MODEL_UNKNOWN,
+   MODEL_A,
+   MODEL_A_PLUS,
+   MODEL_B,
+   MODEL_B_PLUS,
+   MODEL_B_2,
+};
+
+static int board_info_initialised = 0;
+static int board_model = MODEL_UNKNOWN;
+static int board_revision;
+
+static void
+fatal(char *fmt, ...)
+{
+   va_list ap;
+   
+   va_start(ap, fmt);
+   vfprintf(stderr, fmt, ap);
+   va_end(ap);
+   exit(1);
+}
+
+static unsigned get_dt_ranges(const char *filename, unsigned offset)
+{
+   unsigned address = ~0;
+   FILE *fp = fopen(filename, "rb");
+   if (fp)
+   {
+      unsigned char buf[4];
+      fseek(fp, offset, SEEK_SET);
+      if (fread(buf, 1, sizeof buf, fp) == sizeof buf)
+         address = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3] << 0;
+      fclose(fp);
+   }
+   return address;
+}
+
+uint32_t board_info_peripheral_base_addr(void)
+{
+   unsigned address = get_dt_ranges("/proc/device-tree/soc/ranges", 4);
+
+   board_info_init();
+
+   if (address == ~0)
+   {
+      if (board_model == MODEL_B_2)
+         return 0x3f000000;
+      else
+         return 0x20000000;
+   }
+   else
+   {
+      return address;
+   }
+}
+
+uint32_t board_info_sdram_address(void)
+{
+   unsigned address = get_dt_ranges("/proc/device-tree/axi/vc_mem/reg", 8);
+
+   board_info_init();
+
+   if (address == ~0)
+   {
+      if (board_model == MODEL_B_2)
+         return 0xc0000000;
+      else
+         return 0x40000000;
+   }
+   else
+   {
+      return address;
+   }
+}
+
+int board_info_init(void)
+{
+   char buf[128], revstr[128], modelstr[128];
+   char *ptr, *end, *res;
+   FILE *fp;
+
+   if (board_info_initialised)
+      return 0;
+
+   revstr[0] = modelstr[0] = '\0';
+
+   fp = fopen("/proc/cpuinfo", "r");
+
+   if (!fp)
+      fatal("Unable to open /proc/cpuinfo: %m\n");
+
+   while ((res = fgets(buf, 128, fp))) {
+      if (!strncasecmp("model name", buf, 8))
+         memcpy(modelstr, buf, 128);
+      else if (!strncasecmp(buf, "revision", 8))
+         memcpy(revstr, buf, 128);
+   }
+   fclose(fp);
+
+   if (modelstr[0] == '\0')
+      fatal("No 'Model name' record in /proc/cpuinfo\n");
+   if (revstr[0] == '\0')
+      fatal("No 'Revision' record in /proc/cpuinfo\n");
+
+   if (strstr(modelstr, "ARMv6"))
+      board_model = MODEL_B;
+   else if (strstr(modelstr, "ARMv7"))
+      board_model = MODEL_B_2;
+   else
+      fatal("Cannot parse the model name string\n");
+
+   ptr = revstr + strlen(revstr) - 3;
+   board_revision = strtol(ptr, &end, 16);
+   if (end != ptr + 2)
+      fatal("Failed to parse Revision string\n");
+   if (board_revision < 1)
+      fatal("Invalid board Revision\n");
+   else if (board_revision < 4)
+      board_revision = 1;
+   else
+      board_revision = 2;
+
+   board_info_initialised = 1;
+
+   return 0;
+}
+