arbol 0.0.2

data/lib/functions/phasor.rb

@@ -0,0 +1,96 @@
+class Phasor < Base
+  Arbol.add_mapped_class(
+    'phasor', 
+    Phasor,
+%{void phasor(long mils, long cycle[3], long out[3]) {
+  out[0] = long_div((mils % cycle[0]), cycle[0]);
+  out[1] = long_div((mils % cycle[1]), cycle[1]);
+  out[2] = long_div((mils % cycle[2]), cycle[2]);
+}}
+  )
+  attr_accessor :cycles
+  
+  def param_keys
+    [:cycles]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "phasor(mils, #{@cycles.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "phasor(mils, #{@cycles.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def phasor 
+%{--
+### phasor(cycle_ms)
+
+* **cycle_ms**
+
+Outputs a ramp wave from 0-~1.0 over a period of cycle_ms milliseconds.
+
+`phasor` is very important because it highlights a key way to bring motion into
+the system. There are many ways of using phasor.
+
+```
+# go from 0-~1.0 over a period of 10 seconds:
+phasor(10000)
+
+# each of the three channels goes from 0-~1.0 at different millisecond intervals:
+phasor([1000, 1100, 1200])
+
+# phasor is input into a triangle function, which then creates a triangle
+# wave that goes from 0-~1.0-0 over a period of 5 seconds specified
+# to the phasor
+tri = triangle(phasor(5000))
+
+# multiple two triangles together to to get a pointy triangle
+tri_squared = tri * tri
+
+# using `lamp_phase` function in conjunction with `add_constrain` you can
+# create motion in the lamps.
+
+strip(
+  512, # 512 pixels
+  0,   # attached to pin 0
+  add_constrain(
+    lamp_phase,
+    phasor([1000, 1200, 1300])  
+  )
+```
+
+}
+  end
+
+  end
+end
+
+def phasor(cycles)
+  h = ArbolHash.new
+  h[:type] = 'phasor'
+  h[:cycles] = resolve(cycles)
+  h
+end

data/lib/functions/ref.rb

@@ -0,0 +1,34 @@
+class Ref < Base
+  Arbol.add_mapped_class('ref', Ref, nil)
+  attr_accessor :identifier
+  attr_accessor :ref_name
+  
+  def initialize(params)
+    super(params)
+    @identifier = params[:identifier]
+    if $refs.has_key?(@identifier)
+      @ref_name = $refs[@identifier]
+      @frame_optimized = $refs_frame_optimized[@identifier]
+    else
+      raise "non-existant ref #{@identifier}"
+    end
+  end
+  
+  def arduino_code
+    [
+    ]
+  end
+
+  def top_level_scope_code
+    [
+      "long *#{@name} = #{@ref_name};"
+    ]
+  end
+end
+
+def ref(identifier)
+  h = ArbolHash.new
+  h[:type] = 'ref'
+  h[:identifier] = identifier
+  h
+end

data/lib/functions/scale.rb

@@ -0,0 +1,71 @@
+class Scale < Base
+  Arbol.add_mapped_class(
+    'scale', 
+    Scale,
+%{void scale(long input[3], long lo_in[3], long hi_in[3], long lo_out[3], long hi_out[3], long out[3]) {
+  out[0] = map(input[0], lo_in[0], hi_in[0], lo_out[0], hi_out[0]);
+  out[1] = map(input[1], lo_in[1], hi_in[1], lo_out[1], hi_out[1]);
+  out[2] = map(input[2], lo_in[2], hi_in[2], lo_out[2], hi_out[2]);
+}}
+  )
+  
+  attr_accessor :input
+  attr_accessor :lo_in
+  attr_accessor :hi_in
+  attr_accessor :lo_out
+  attr_accessor :hi_out
+  
+  def param_keys
+    [:input, :lo_in, :hi_in, :lo_out, :hi_out]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "scale(#{@input.name}, #{@lo_in.name}, #{@hi_in.name}, #{@lo_out.name}, #{@hi_out.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "scale(#{@input.name}, #{@lo_in.name}, #{@hi_in.name}, #{@lo_out.name}, #{@hi_out.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def scale
+%{--
+### scale needs doc
+
+}
+  end
+
+  end
+end
+
+def scale(input, lo_in, hi_in, lo_out, hi_out)
+  h = ArbolHash.new
+  h[:type] = 'scale'
+  h[:input] = resolve(input)
+  h[:lo_in] = resolve(lo_in)
+  h[:hi_in] = resolve(hi_in)
+  h[:lo_out] = resolve(lo_out)
+  h[:hi_out] = resolve(hi_out)
+  h
+end

data/lib/functions/table.rb

@@ -0,0 +1,16 @@
+class ArbolTable
+  attr_accessor :table
+  
+  def initialize(tbl)
+    @table = tbl
+  end
+end
+    
+
+# really this is just a pass through for arrays
+# used in lookup table creation
+def table(contents)
+  if contents.class == Array
+    ArbolTable.new(contents)
+  end
+end

data/lib/functions/times.rb

@@ -0,0 +1,70 @@
+class Times < Base
+  Arbol.add_mapped_class(
+    'times', 
+    Times,
+%{void times(long op1[3], long op2[3], long out[3]) {
+  out[0] = long_mult(op1[0], op2[0]);
+  out[1] = long_mult(op1[1], op2[1]);
+  out[2] = long_mult(op1[2], op2[2]);
+}}
+  )
+  
+  attr_accessor :op1
+  attr_accessor :op2
+  
+  def param_keys
+    [:op1, :op2]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "times(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "times(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];",
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def times 
+%{--
+### times(operator1, operator2)
+
+* **operator1**
+* **operator2**
+
+Multiplication of the two operators. Can also be used with the form `operator1 * operator2`.
+
+}
+  end
+
+  end
+end
+
+def times(op1, op2)
+  h = ArbolHash.new
+  h[:type] = 'times'
+  h[:op1] = resolve(op1)
+  h[:op2] = resolve(op2)
+  h
+end

data/lib/functions/triangle.rb

@@ -0,0 +1,69 @@
+class PhaseTriangle < Base
+  Arbol.add_mapped_class(
+    'triangle', 
+    PhaseTriangle,
+%{//long twice_int_scale_vec[3] = {long(INTEGER_SCALE * 2), long(INTEGER_SCALE * 2), long(INTEGER_SCALE * 2)};
+void triangle(long mils, long phase[3], long out[3]) {
+  long times_result[3];
+  times(phase, twice_int_scale_vec, times_result);
+  if(times_result[0] > INTEGER_SCALE) { out[0] = (twice_int_scale_vec[0] - times_result[0]); } else { out[0] = times_result[0]; }
+  if(times_result[1] > INTEGER_SCALE) { out[1] = (twice_int_scale_vec[1] - times_result[1]); } else { out[1] = times_result[1]; }
+  if(times_result[2] > INTEGER_SCALE) { out[2] = (twice_int_scale_vec[2] - times_result[2]); } else { out[2] = times_result[2]; }
+}}
+  )
+  attr_accessor :phase
+  
+  def param_keys
+    [:phase]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "triangle(mils, #{@phase.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "triangle(mils, #{@phase.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];",
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def triangle 
+%{--
+### triangle(phase)
+
+* **phase**
+
+`phase` input 0.0-1.0 input is transformed into a triangle.
+
+}
+  end
+
+  end
+end
+
+def triangle(phase)
+  h = ArbolHash.new
+  h[:type] = 'triangle'
+  h[:phase] = resolve(phase)
+  h
+end

data/lib/templates/arduino_library.ino.erb

@@ -0,0 +1,75 @@
+#include <malloc.h>
+#include <Thread.h>
+#include <Adafruit_NeoPixel_ZeroDMA.h>
+
+#define INTEGER_SCALE <%= integer_scale %>
+#define PIXEL_COUNT <%= pixels %>
+
+long long_div(long numerator, long denominator)
+{
+  return (numerator * INTEGER_SCALE) / denominator;
+}
+
+long long_mult(long op1, long op2)
+{
+  return op1 * op2 / INTEGER_SCALE;
+}
+
+byte byte_mult(byte op1, byte op2)
+{
+  return (byte)((uint16_t)op1 * (uint16_t)op2 / (uint16_t)INTEGER_SCALE);
+}
+
+int neoPixelPin = <%= pin %>;
+int pixelCount = PIXEL_COUNT;
+
+
+<%= code %>
+
+//END OF ARBOL LIBRARY
+
+// Instatiate the NeoPixel from the library
+Adafruit_NeoPixel_ZeroDMA strip = Adafruit_NeoPixel_ZeroDMA(pixelCount, neoPixelPin, NEO_GRB + NEO_KHZ800);
+
+Thread calculate_strip_thread = Thread();
+
+void setup() {
+  analogReadResolution(12);
+  
+  calculate_strip_thread.setInterval(33);
+  calculate_strip_thread.onRun(calculate_strip);
+  strip.begin();
+}
+
+void loop() {
+  if(calculate_strip_thread.shouldRun()) calculate_strip_thread.run();
+}
+
+// beginning of top level scope definition
+
+<%= tls %>
+
+// end of top level scope definition
+
+void calculate_strip() {
+  long mils = millis();
+  for (int i=0; i < pixelCount; i++) {
+    long this_phase = long_div(i, pixelCount - 1);
+    if(i == 0) {
+// beginning of code that executes once per frame
+
+<%= cycle %>
+
+//
+    }
+// beginning of code that executes for every pixel
+
+<%= body %>
+
+// end of generated code
+  }
+  strip.show();
+}
+
+
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: arbol
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- jeremy winters
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-07 00:00:00.000000000 Z
+dependencies: []
+description: define DSP-like function chains for your lights
+email: jeremyranierwinters@gmail.com
+executables:
+- arbol
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/arbol
+- lib/arbol.rb
+- lib/base.rb
+- lib/builder.rb
+- lib/documentation.rb
+- lib/dsl.rb
+- lib/functions/add.rb
+- lib/functions/add_constrain.rb
+- lib/functions/add_modulo.rb
+- lib/functions/analog_pin.rb
+- lib/functions/choose.rb
+- lib/functions/const.rb
+- lib/functions/create_lookup.rb
+- lib/functions/create_ref.rb
+- lib/functions/crossfade.rb
+- lib/functions/divide.rb
+- lib/functions/feedback.rb
+- lib/functions/feedback_offset.rb
+- lib/functions/gamma.rb
+- lib/functions/greater_than.rb
+- lib/functions/greater_than_equals.rb
+- lib/functions/lamp_phase.rb
+- lib/functions/less_than.rb
+- lib/functions/less_than_equals.rb
+- lib/functions/lfo_square.rb
+- lib/functions/lfo_triangle.rb
+- lib/functions/lookup.rb
+- lib/functions/max.rb
+- lib/functions/min.rb
+- lib/functions/minus.rb
+- lib/functions/modulo.rb
+- lib/functions/noise.rb
+- lib/functions/noise_pixel.rb
+- lib/functions/phasor.rb
+- lib/functions/ref.rb
+- lib/functions/scale.rb
+- lib/functions/table.rb
+- lib/functions/times.rb
+- lib/functions/triangle.rb
+- lib/templates/arduino_library.ino.erb
+homepage: https://www.github.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: functional streams for neopixel strips
+test_files: []