pixel_pi 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08cca7dba9a29b50641d0408dcbe81a1f5c86e7e
-  data.tar.gz: 7aaf72769a673bac2c41d23111fbec22658b0c73
+  metadata.gz: 1c158234b67ccd01d55b48cf274c5ccb437ae77a
+  data.tar.gz: 5125b6c0d47381ca23ba8fc942ac73d22f9f3bbb
 SHA512:
-  metadata.gz: 50a6c2996d7421024e4c657cc17936b7ee28da810fb6820fbb94199200d1e3025e9899c3338adb29bb40fa827acdc6fe419f2f3f9878e62949932d2761cfaf64
-  data.tar.gz: b9e70d44aeb4e8e7332f3d04f7321e0f3922c1253fb52f7afcea9deb4d004d1803df44b536de3759a33dbfbcdd837ba0870d5a37cd66d989695bbf2f6a743603
+  metadata.gz: d010f3d8e722cb39aea7cd13cb78e92621628014799899bb08def77a0b0e1333dcf88362aa797f88ccdf2949b6d524f80bf23fa3302951e875e974fbf0e7a80b
+  data.tar.gz: acdac849b6517a354918be99681e360592a8edb77ca18a77bc741aba66008c56b42a62a760500a9026f6bd41c7d6d1a7794d5085765e3a39fee56637ef8129e0

data/.gitignore

@@ -1 +1,2 @@
+*.gem
 tmp

data/examples/strandtest.rb

@@ -54,11 +54,11 @@ module StrandTest
     spacing    = opts.fetch(:spacing, 3)
 
     iterations.times do
-      spacing.times do |jj|
-        (0...self.length).step(spacing) { |ii| self[ii+jj] = color }
+      spacing.times do |sp|
+        self.clear
+        (sp...self.length).step(spacing) { |ii| self[ii] = color }
         self.show
         sleep(wait_ms / 1000.0)
-        (0...self.length).step(spacing) { |ii| self[ii+jj] = 0 }
       end
     end
 
@@ -71,6 +71,7 @@ module StrandTest
   #
   # Returns a 24-bit RGB color value.
   def wheel( pos )
+    pos = pos & 0xff
     if pos < 85
       return PixelPi::Color(pos * 3, 255 - pos * 3, 0)
     elsif pos < 170
@@ -94,7 +95,7 @@ module StrandTest
     iterations = opts.fetch(:iterations, 1)
 
     (0...256*iterations).each do |jj|
-      self.length.times { |ii| self[ii] = wheel((ii+jj) & 0xff) }
+      self.fill { |ii| wheel(ii+jj) }
       self.show
       sleep(wait_ms / 1000.0)
     end
@@ -114,7 +115,7 @@ module StrandTest
     iterations = opts.fetch(:iterations, 5)
 
     (0...256*iterations).each do |jj|
-      self.length.times { |ii| self[ii] = wheel(((ii * 256 / self.length) + jj) & 0xff) }
+      self.fill { |ii| wheel((ii * 256 / self.length) + jj) }
       self.show
       sleep(wait_ms / 1000.0)
     end
@@ -135,10 +136,10 @@ module StrandTest
 
     256.times do |jj|
       spacing.times do |sp|
-        (0...self.length).step(spacing) { |ii| self[ii+sp] = wheel((ii+jj) % 255) }
+        self.clear
+        (sp...self.length).step(spacing) { |ii| self[ii] = wheel((ii+jj) % 255) }
         self.show
         sleep(wait_ms / 1000.0)
-        (0...self.length).step(spacing) { |ii| self[ii+sp] = 0 }
       end
     end
 
@@ -158,10 +159,10 @@ strip = PixelPi::Leds.new \
 strip.extend StrandTest
 
 trap("SIGINT") do
-  strip.clear
-  strip.close  # not explicitly needed - the finalizer will gracefully shutdown
-  exit         # the PWM channel and release the DMA memory
-end
+  strip.clear.show  # turn off all the LEDs
+  strip.close       # close is not explicitly needed - the finalizer will
+  exit              # gracefully shutdown the PWM channel and release the
+end                 # DMA memory
 
 STDOUT.puts "Press Ctrl-C to quit."
 

data/ext/pixel_pi/leds.c

@@ -3,6 +3,10 @@
 
 #define RGB2COLOR(r,g,b) ((((r) & 0xff) << 16) | (((g) & 0xff) << 8) | ((b) & 0xff))
 
+#ifndef MIN
+#define MIN(a,b) (((a)<(b))?(a):(b))
+#endif
+
 VALUE mPixelPi;
 VALUE cLeds;
 VALUE ePixelPiError;
@@ -69,9 +73,9 @@ pp_leds_struct( VALUE self )
 static int
 pp_rgb_to_color( VALUE red, VALUE green, VALUE blue )
 {
-  int r = NUM2INT(red);
-  int g = NUM2INT(green);
-  int b = NUM2INT(blue);
+  int r = FIX2INT(red);
+  int g = FIX2INT(green);
+  int b = FIX2INT(blue);
   return RGB2COLOR(r, g, b);
 }
 
@@ -110,7 +114,7 @@ pp_leds_initialize( int argc, VALUE* argv, VALUE self )
 
   /* get the number of pixels */
   if (TYPE(length) == T_FIXNUM) {
-    ledstring->channel[0].count = NUM2INT(length);
+    ledstring->channel[0].count = FIX2INT(length);
     if (ledstring->channel[0].count < 0) {
       rb_raise( rb_eArgError, "length cannot be negative: %d", ledstring->channel[0].count );
     }
@@ -120,7 +124,7 @@ pp_leds_initialize( int argc, VALUE* argv, VALUE self )
 
   /* get the GPIO number */
   if (TYPE(gpio) == T_FIXNUM) {
-    ledstring->channel[0].gpionum = NUM2INT(gpio);
+    ledstring->channel[0].gpionum = FIX2INT(gpio);
     if (ledstring->channel[0].gpionum < 0) {
       rb_raise( rb_eArgError, "GPIO cannot be negative: %d", ledstring->channel[0].gpionum );
     }
@@ -135,7 +139,7 @@ pp_leds_initialize( int argc, VALUE* argv, VALUE self )
     tmp = rb_hash_lookup( opts, sym_dma );
     if (!NIL_P(tmp)) {
       if (TYPE(tmp) == T_FIXNUM) {
-        ledstring->dmanum = NUM2INT(tmp);
+        ledstring->dmanum = FIX2INT(tmp);
         if (ledstring->dmanum < 0) {
           rb_raise( rb_eArgError, "DMA channel cannot be negative: %d", ledstring->dmanum );
         }
@@ -148,7 +152,7 @@ pp_leds_initialize( int argc, VALUE* argv, VALUE self )
     tmp = rb_hash_lookup( opts, sym_frequency );
     if (!NIL_P(tmp)) {
       if (TYPE(tmp) == T_FIXNUM) {
-        ledstring->freq = NUM2UINT(tmp);
+        ledstring->freq = FIX2UINT(tmp);
       } else {
         rb_raise( rb_eTypeError, "frequency must be a number: %s", rb_obj_classname(tmp) );
       }
@@ -158,7 +162,7 @@ pp_leds_initialize( int argc, VALUE* argv, VALUE self )
     tmp = rb_hash_lookup( opts, sym_brightness );
     if (!NIL_P(tmp)) {
       if (TYPE(tmp) == T_FIXNUM) {
-        ledstring->channel[0].brightness = (NUM2UINT(tmp) & 0xff);
+        ledstring->channel[0].brightness = (FIX2UINT(tmp) & 0xff);
         if (ledstring->channel[0].brightness < 0) {
           rb_raise( rb_eArgError, "brightness cannot be negative: %d", ledstring->channel[0].brightness );
         }
@@ -273,7 +277,7 @@ static VALUE
 pp_leds_brightness_set( VALUE self, VALUE brightness )
 {
   ws2811_t *ledstring = pp_leds_struct( self );
-  ledstring->channel[0].brightness = (NUM2UINT(brightness) & 0xff);
+  ledstring->channel[0].brightness = (FIX2UINT(brightness) & 0xff);
   return brightness;
 }
 
@@ -308,24 +312,23 @@ pp_leds_clear( VALUE self )
 {
   ws2811_t *ledstring = pp_leds_struct( self );
   ws2811_channel_t channel = ledstring->channel[0];
-  int ii, resp;
+  int ii;
 
   for (ii=0; ii<channel.count; ii++) {
     channel.leds[ii] = 0;
   }
 
-  resp = ws2811_render( ledstring );
-  if (resp < 0) {
-    rb_raise( rb_eRuntimeError, "PixelPi::Leds failed to render: %d", resp );
-  }
-
   return self;
 }
 
 /* call-seq:
  *    close
  *
- * FIXME
+ * Shutdown the NeoPixels connected to the DMA / PWM channel. After this method
+ * the current PixelPi::Leds instance will no longer be usable; a new instance
+ * will need to be created. This method is automatically invoked when the
+ * instance is deallcoated by the Ruby garbage collector. It does not need to be
+ * explicitly invoked.
  *
  * Returns `nil`.
  */
@@ -350,7 +353,7 @@ pp_leds_get_pixel_color( VALUE self, VALUE num )
   ws2811_t *ledstring = pp_leds_struct( self );
   ws2811_channel_t channel = ledstring->channel[0];
 
-  int n = NUM2INT(num);
+  int n = FIX2INT(num);
   if (n < 0 || n >= channel.count) {
     rb_raise( rb_eIndexError, "index %d is outside of LED range: 0...%d", n, channel.count-1 );
   }
@@ -372,9 +375,9 @@ pp_leds_set_pixel_color( VALUE self, VALUE num, VALUE color )
   ws2811_t *ledstring = pp_leds_struct( self );
   ws2811_channel_t channel = ledstring->channel[0];
 
-  int n = NUM2INT(num);
+  int n = FIX2INT(num);
   if (n >= 0 && n < channel.count) {
-    channel.leds[n] = NUM2INT(color);
+    channel.leds[n] = FIX2UINT(color);
   }
   return self;
 }
@@ -415,6 +418,204 @@ pp_leds_set_pixel_color2( int argc, VALUE* argv, VALUE self )
   return self;
 }
 
+/* call-seq:
+ *    to_a
+ *
+ * Takes the current list of 24-bit RGB values stored in the LED strings and
+ * returns them as an Array. These colors might not be actively displayed; it
+ * all depends if `show` has been called on the PixelPi::Leds instance.
+ *
+ * Returns an Array of 24-bit RGB values.
+ */
+static VALUE
+pp_leds_to_a( VALUE self )
+{
+  ws2811_t *ledstring = pp_leds_struct( self );
+  ws2811_channel_t channel = ledstring->channel[0];
+  int ii;
+  VALUE ary;
+
+  ary = rb_ary_new2( channel.count );
+  for (ii=0; ii<channel.count; ii++) {
+    rb_ary_push( ary, INT2NUM(channel.leds[ii]) );
+  }
+
+  return ary;
+}
+
+/* call-seq:
+ *    replace( ary )
+ *
+ * Replace the LED colors with the 24-bit RGB color values found in the `ary`.
+ * If the `ary` is longer than the LED string then the extra color values will
+ * be ignored. If the `ary` is shorter than the LED string then only the LEDS
+ * up to `ary.length` will be changed.
+ *
+ * You must call `show` for the new colors to be displayed.
+ *
+ * Returns this PixelPi::Leds instance.
+ */
+static VALUE
+pp_leds_replace( VALUE self, VALUE ary )
+{
+  ws2811_t *ledstring = pp_leds_struct( self );
+  ws2811_channel_t channel = ledstring->channel[0];
+  int ii, min;
+
+  Check_Type( ary, T_ARRAY );
+  min = MIN(channel.count, RARRAY_LEN(ary));
+
+  for (ii=0; ii<min; ii++) {
+    channel.leds[ii] = FIX2UINT(rb_ary_entry( ary, ii ));
+  }
+
+  return self;
+}
+
+static void
+pp_leds_reverse( ws2811_led_t *p1, ws2811_led_t *p2 )
+{
+  while (p1 < p2) {
+    ws2811_led_t tmp = *p1;
+    *p1++ = *p2;
+    *p2-- = tmp;
+  }
+}
+
+/* call-seq:
+ *    reverse
+ *
+ * Reverse the order of the LED colors.
+ *
+ * Returns this PixelPi::Leds instance.
+ */
+static VALUE
+pp_leds_reverse_m( VALUE self )
+{
+  ws2811_t *ledstring = pp_leds_struct( self );
+  ws2811_channel_t channel = ledstring->channel[0];
+  ws2811_led_t *ptr = channel.leds;
+  int len = channel.count;
+
+  if (--len > 0) pp_leds_reverse( ptr, ptr + len );
+
+  return self;
+}
+
+/* call-seq:
+ *   rotate( count = 1 )
+ *
+ * Rotates the LED colors in place so that the color at `count` comes first. If
+ * `count` is negative then it rotates in the opposite direction, starting from
+ * the end of the LEDs where -1 is the last LED.
+ *
+ * Returns this PixelPi::Leds instance.
+ */
+static VALUE
+pp_leds_rotate( int argc, VALUE* argv, VALUE self )
+{
+  ws2811_t *ledstring = pp_leds_struct( self );
+  ws2811_channel_t channel = ledstring->channel[0];
+  int cnt = 1;
+
+  switch (argc) {
+    case 1: cnt = FIX2INT(argv[0]);
+    case 0: break;
+    default: rb_scan_args( argc, argv, "01", NULL );
+  }
+
+  if (cnt != 0) {
+    ws2811_led_t *ptr = channel.leds;
+    int len = channel.count;
+    cnt = (cnt < 0) ? (len - (~cnt % len) - 1) : (cnt % len);
+
+    if (len > 0 && cnt > 0) {
+      --len;
+      if (cnt < len) pp_leds_reverse( ptr + cnt, ptr + len );
+      if (--cnt > 0) pp_leds_reverse( ptr, ptr + cnt );
+      if (len > 0) pp_leds_reverse( ptr, ptr + len );
+    }
+  }
+
+  return self;
+}
+
+/* call-seq:
+ *    fill( color )
+ *    fill( color, start [, length] )
+ *    fill( color, range )
+ *    fill { |index| block }
+ *    fill( start [, length] ) { |index| block }
+ *    fill( range ) { |index| block }
+ *
+ * Set the selected LEDs to the given `color`. The `color` msut be given as a
+ * 24-bit RGB value. You can also supply a block that receives an LED index and
+ * returns a 24-bit RGB color.
+ *
+ * Examples:
+ *    leds.fill( 0x00FF00 )
+ *    leds.fill( 0xFF0000, 2, 2 )
+ *    leds.fill( 0x0000FF, (4...8) )
+ *    leds.fill { |i| 256 << i }
+ *
+ * Returns this PixelPi::Leds instance.
+ */
+static VALUE
+pp_leds_fill( int argc, VALUE* argv, VALUE self )
+{
+  ws2811_t *ledstring = pp_leds_struct( self );
+  ws2811_channel_t channel = ledstring->channel[0];
+  ws2811_led_t color = 0;
+
+  VALUE item, arg1, arg2, v;
+  long ii, beg = 0, end = 0, len = 0;
+  int block_p = 0;
+
+  if (rb_block_given_p()) {
+    block_p = 1;
+    rb_scan_args( argc, argv, "02", &arg1, &arg2 );
+    argc += 1;
+  } else {
+    rb_scan_args( argc, argv, "12", &item, &arg1, &arg2 );
+    color = FIX2UINT(item);
+  }
+
+  switch (argc) {
+    case 1:
+      beg = 0;
+      len = channel.count;
+      break;
+    case 2:
+      if (rb_range_beg_len(arg1, &beg, &len, channel.count, 1)) {
+        break;
+      }
+      /* fall through */
+    case 3:
+      beg = NIL_P(arg1) ? 0 : NUM2LONG(arg1);
+      if (beg < 0) {
+        beg = channel.count + beg;
+        if (beg < 0) beg = 0;
+      }
+      len = NIL_P(arg2) ? channel.count - beg : NUM2LONG(arg2);
+      break;
+  }
+
+  if (len < 0) return self;
+
+  end = beg + len;
+  end = MIN((long) channel.count, end);
+
+  for (ii=beg; ii<end; ii++) {
+    if (block_p) {
+      v = rb_yield(INT2NUM(ii));
+      color = FIX2UINT(v);
+    }
+    channel.leds[ii] = color;
+  }
+
+  return self;
+}
+
 /* call-seq:
  *    PixelPi::Color(red, green, blue)  #=> 24-bit color
  *
@@ -456,6 +657,11 @@ void Init_leds( )
   rb_define_method( cLeds, "[]",          pp_leds_get_pixel_color,   1 );
   rb_define_method( cLeds, "[]=",         pp_leds_set_pixel_color,   2 );
   rb_define_method( cLeds, "set_pixel",   pp_leds_set_pixel_color2, -1 );
+  rb_define_method( cLeds, "to_a",        pp_leds_to_a,              0 );
+  rb_define_method( cLeds, "replace",     pp_leds_replace,           1 );
+  rb_define_method( cLeds, "reverse",     pp_leds_reverse_m,         0 );
+  rb_define_method( cLeds, "rotate",      pp_leds_rotate,           -1 );
+  rb_define_method( cLeds, "fill",        pp_leds_fill,             -1 );
 
   rb_define_module_function( mPixelPi, "Color", pp_color, 3 );
 

data/lib/pixel_pi/version.rb

@@ -1,3 +1,3 @@
 module PixelPi
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pixel_pi
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Tim Pease
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-21 00:00:00.000000000 Z
+date: 2014-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler