madrona-rad 0.2.4 → 0.2.5

data/lib/rad/generators/makefile/makefile.erb

@@ -92,8 +92,8 @@ CDEFS = -DF_CPU=$(F_CPU)
 CXXDEFS = -DF_CPU=$(F_CPU)
 
 # Place -I options here
-CINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)<% params['libraries'].each do |l| %> -I$(LIBRARY_ROOT)/<%= l %><% end %> <%= params['wire_h'] %>
-+CXXINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)<% params['libraries'].each do |l| %> -I$(LIBRARY_ROOT)/<%= l %><% end %> <%= params['wire_h'] %>
+CINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)<% params['libraries'].each do |l| %> -I$(LIBRARY_ROOT)/<%= l %><% end %>
++CXXINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)<% params['libraries'].each do |l| %> -I$(LIBRARY_ROOT)/<%= l %><% end %>
 
 # Compiler flag to set the C Standard level.
 # c89   - "ANSI" C

data/lib/rad/generators/makefile/makefile.rb

@@ -8,13 +8,13 @@ class Makefile
     def compose_for_sketch(sketch_name)
       params = hardware_params.merge software_params
       params['target'] = sketch_name.split("/").last
-      
-      params['wire_h'] = $include_wire == true ? "-I#{params['arduino_root']}/hardware/libraries/Wire/" : ""
-      params['twi_c'] = $include_wire == true ? "#{params['arduino_root']}/hardware/libraries/Wire/utility/twi.c" : ""
-      
+           
       params['libraries_root'] = "#{File.expand_path(RAD_ROOT)}/vendor/libraries"
       params['libraries'] = $load_libraries # load only libraries used 
       
+      # needed along with ugly hack of including another copy of twi.h in wire, when using the Wire.h library
+      params['twi_c'] = $load_libraries.include?("Wire") ? "#{params['arduino_root']}/hardware/libraries/Wire/utility/twi.c" : "" 
+      
       params['asm_files'] = Dir.entries( File.expand_path(RAD_ROOT) + "/" + PROJECT_DIR_NAME ).select{|e| e =~ /\.S/}            
             
       e = ERB.new File.read("#{File.dirname(__FILE__)}/makefile.erb")
@@ -23,11 +23,7 @@ class Makefile
         f << e.result(binding)
       end
     end
-    
-    # def libraries
-    #   Dir.entries("#{RAD_ROOT}/vendor/libraries").select{|e| !(e =~ /\./)}
-    # end
-    
+        
     def hardware_params
       return @hardware_params if @hardware_params
       return @hardware_params = YAML.load_file( "#{RAD_ROOT}/config/hardware.yml")

data/lib/rad/init.rb

@@ -5,8 +5,10 @@ unless defined?(PROJECT_DIR_NAME)
   PROJECT_DIR_NAME = a[a.length-1]
 end
 
+PLUGIN_C_VAR_TYPES = "int|void|unsigned|long|short|uint8_t|static|byte"
 
-%w(generators/makefile/makefile.rb rad_processor.rb rad_rewriter.rb arduino_sketch.rb arduino_plugin.rb tasks/rad.rb).each do |path|
+
+%w(generators/makefile/makefile.rb rad_processor.rb rad_rewriter.rb variable_processing.rb arduino_sketch.rb arduino_plugin.rb tasks/rad.rb).each do |path|
   require File.expand_path("#{RAD_ROOT}/vendor/rad/#{path}")
 end
 

data/lib/rad/rad_processor.rb

@@ -24,6 +24,17 @@ class RADProcessor < RubyToAnsiC
     end
     @translator
   end
+  
+  def process_iasgn(exp)
+    name = exp.shift
+    val = process exp.shift
+    "__#{name.to_s.sub(/^@/, '')} = #{val}"
+  end
+  
+  def process_ivar(exp)
+    name = exp.shift
+    "__#{name.to_s.sub(/^@/, '')}"
+  end
     
   def process_lasgn(exp)
     out = ""

data/lib/rad/rad_rewriter.rb

@@ -61,7 +61,7 @@ class RADRewriter < Rewriter
          result = s(:dummy,
                     s(:lasgn, var_name, start_value),
                     s(:while,
-                      s(:call, s(:lvar, var_name), :<=,
+                      s(:call, s(:lvar, var_name), :<,
                         s(:arglist, finish_value)),
                       s(:block,
                         body,

data/lib/rad/tasks/build_and_make.rake

@@ -89,22 +89,25 @@ namespace :build do
     $sketch_methods.each do |meth| 
       raw_rtc_meth = RADProcessor.translate(constantize(klass), meth) 
       puts "Translator Error: #{raw_rtc_meth.inspect}" if raw_rtc_meth[0..8] == "// ERROR:"
-      c_methods << raw_rtc_meth
+      c_methods << raw_rtc_meth unless meth == "setup"
+      # treat the setup method differently
+      @additional_setup = [] if meth == "setup"
+      raw_rtc_meth.each {|m| @additional_setup << ArduinoSketch.add_to_setup(m) } if meth == "setup"
     end
-    #$sketch_methods.each {|m| c_methods << RADProcessor.translate(constantize(klass), m) }
     c_methods.each {|meth| sketch_signatures << "#{meth.scan(/^\w*\s?\*?\n.*\)/)[0].gsub("\n", " ")};" }
     clean_c_methods = []
-    c_methods.join("\n").each_with_index do |e,i|
-      # need to take a look at the \(unsigned in the line below not sure if we are really trying to catch something like that
-      if e !~ /^\s*(#{C_VAR_TYPES})(\W{1,6}|\(unsigned\()(#{$external_var_identifiers.join("|")})/ || $external_var_identifiers.empty?
-        # use the list of identifers the external_vars method of the sketch and remove the parens the ruby2c sometime adds to variables
-        e.gsub(/((#{$external_var_identifiers.join("|")})\(\))/, '\2')  unless $external_var_identifiers.empty? 
-        clean_c_methods << e
-      end
-    end
+    # remove external variables that were previously injected
+    c_methods.join("\n").each { |meth| clean_c_methods << ArduinoSketch.post_process_ruby_to_c_methods(meth) }
     c_methods_with_timer = clean_c_methods.join.gsub(/loop\(\)\s\{/,"loop() {\ntrack_total_loop_time();")
-    @setup.gsub!("// sketch signatures", "// sketch signatures\n#{ sketch_signatures.join("\n")}") unless sketch_signatures.empty?
-    result = "#{@setup}\n#{c_methods_with_timer}\n"
+    # last chance to add/change setup
+    @setup[2] << sketch_signatures.join("\n") unless sketch_signatures.empty?
+    # add special setup method to existing setup if present
+    if @additional_setup
+      @setup[2] << "void additional_setup();" # declaration
+      @setup[4] << "additional_setup();" # call from setup
+      @setup[5] << @additional_setup.join("") # 
+    end
+    result = "#{@setup.join( "\n" )}\n#{c_methods_with_timer}\n"
     name = @sketch_class.split(".").first
     File.open("#{@test_dir}#{name}/#{name}.cpp", "w"){|f| f << result}
   end
@@ -127,7 +130,16 @@ namespace :build do
        end
        CODE
     end
+    # allow variable declaration without quotes: @foo = int 
+    ["long","unsigned","int","byte","short"].each do |type|
+      constantize(klass).module_eval <<-CODE
+       def self.#{type}
+        return "#{type}"
+       end
+       CODE
+    end   
     eval File.read(@test_dir + @sketch_class)
+    @@as.process_external_vars(constantize(klass))
     @setup = @@as.compose_setup
   end
   
@@ -180,6 +192,7 @@ namespace :build do
       @test_dir = "examples/"
     end
     @sketch_class = ENV['sketch'] ? "#{ENV['sketch']}.rb" : "#{@sketch_directory}.rb"
+    $sketch_file_location = @test_dir + @sketch_class
     @file_names = []
     @plugin_names = []
     Dir.entries( File.expand_path(RAD_ROOT) ).each do |f|

data/lib/rad/variable_processing.rb

@@ -0,0 +1,116 @@
+module ExternalVariableProcessing
+  # issues
+  # testing
+  # add checking for colon
+
+    
+    ## need to clean this up
+    ## need to test 
+    def process_external_vars(klass)
+      vars = eval "#{klass}.instance_variables"
+      local_vars = []
+      vars.each { |v| local_vars << ":#{v.gsub("@", "")}" }
+      loc_vars = local_vars.join(", ")
+      # add accessors 
+      klass.module_eval "class << self; attr_accessor #{loc_vars} end"
+      local_vars.each do |symbol|
+        name = symbol.gsub(":","")
+        t_var = eval "#{klass}.#{name}"
+        pre_process_vars(name, t_var)
+      end
+    end
+    
+    
+    def pre_process_vars(name, var)
+        # puts 
+        # puts
+        case var
+        when Integer
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} 29"
+          value = var
+          type = "int"
+          post_process_vars(name, type, value)
+        when Float
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} 34"
+          value = var
+          type = "float"
+          post_process_vars(name, type, value)
+        when String
+          # puts "pre_process: #{name}, #{var.inspect} got #{var.class} on 39"
+          if var.match(",").nil? && var =~ /long|byte|unsigned|int|short/
+            # puts "pre_process #{name}, #{var.inspect} got #{var.class} level three sublevel"
+            type = var
+            value = nil
+            post_process_vars(name, type, value)
+            return
+          end
+          value = var.split(",").first.lstrip
+          type = var.split(",")[1].nil? ?  nil : var.split(",")[1].lstrip
+          translate_variables( name , type, value )
+        when TrueClass
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} on 50"
+          value = 1
+          type = "bool"
+          post_process_vars(name, type, value)
+        when FalseClass
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} on 55"
+          value = 0
+          type = "bool"
+          post_process_vars(name, type, value)
+        else
+          raise ArgumentError, "error message here.. got #{name}" 
+        end
+		    
+      
+    end     
+    
+    def translate_variables(name, type = nil, value = nil)
+      
+      unless type.nil?
+        check_variable_type(type)
+      end
+
+      # classify the values
+      if value.class == Fixnum 
+        # puts "translate_variables: #{name}, #{value}, #{type} is a fixnum, got #{value.class} on 74"
+      elsif value.class == Float 
+        # puts "translate_variables: #{name}, #{value}, #{type} is a float, got #{value.class} on 76"
+      elsif value[0,1] !~ /\d/
+        # puts value[0,1]
+        # puts "translate_variables: #{name}, #{value}, #{type} is a number of some type, got #{value.class} on 79"
+        type = "char*"
+        value = "\"#{value}\""
+      elsif value !~ /(\.|x)/
+        # puts "translate_variables: #{name}, #{value}, #{type} is an integer, got #{value.class} on 83"
+        value = value.to_i
+        type = "int" if type.nil?
+      elsif value =~ /(\d*\.\d*)/ # and no 
+        # puts "translate_variables: #{name}, #{value}, #{type} is a float, got #{value.class} on 87"
+        value = value.to_f
+        type = "float"
+      elsif value =~ /0x\d\d/
+        # puts "translate_variables: #{name}, #{value}, #{type} is a byte, got #{value.class} on 91"
+        type = "byte"
+      else
+        raise ArgumentError, "not sure what to do with a value of #{value} with a type like #{type}" 
+      end
+     
+      post_process_vars(name, type, value)
+    end
+    
+
+    
+    def post_process_vars(name, type, value = nil)
+      value = " = #{value}" if value
+      
+      $external_var_identifiers << "__#{name}" unless $external_var_identifiers.include?("__#{name}")
+      $external_vars << "#{type} __#{name}#{value};"
+    end
+    
+    def check_variable_type(type)
+      unless type =~ /#{C_VAR_TYPES}/
+        raise ArgumentError, "the following variable types are supported \n #{C_VAR_TYPES.gsub("|",", ")} got #{type}" 
+      end
+    end
+   
+end

data/lib/test/test_array_processing.rb

@@ -0,0 +1,78 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+# need to tell it where we are
+# lets review these
+C_VAR_TYPES = "int|void|unsigned|long|short|uint8_t|static|byte|float"
+require 'vendor/rad/variable_processing'
+require 'vendor/rad/arduino_sketch'
+require 'test/unit'
+
+
+
+class TestArrayProcessing < Test::Unit::TestCase
+
+  def setup
+    @t = ArduinoSketch.new
+    # vars
+  end
+  
+  def test_int_array
+    name = "foo_a"
+    value_string = 1
+    expected = "int tomatoes[];"
+    result = @t.array("int tomatoes[]")
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_array_with_semi
+    name = "foo_a"
+    value_string = 1
+    expected = "int tomatoes[];"
+    result = @t.array("int tomatoes[];")
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_array_with_assignment
+    name = "foo_a"
+    value_string = 1
+    expected = "int tomatoes[4];"
+    result = @t.array("int tomatoes[] = {1,2,3,4}")
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_array_with_assignment_and_semi
+    name = "foo_a"
+    value_string = 1
+    expected = "int tomatoes[3];"
+    result = @t.array("int tomatoes[] = {1,2,3};")
+    assert_equal(expected, result[0])
+  end
+  
+  def test_unsigned_int_array
+    name = "foo_a"
+    value_string = 1
+    expected = "unsigned int tomatoes[];"
+    result = @t.array("unsigned int tomatoes[]")
+    assert_equal(expected, result[0])
+  end
+  
+  def test_unsigned_int_array_with_assignment
+    name = "foo_a"
+    value_string = 1
+    expected = "unsigned int tomatoes[3];"
+    result = @t.array("unsigned int tomatoes[] = {1,2,3};")
+    assert_equal(expected, result[0])
+  end
+  
+  
+  
+  
+  
+  
+  
+  
+  # question for brian... do we need variable assignment with no value when
+  # we have "" and 0
+end

data/lib/test/test_variable_processing.rb

@@ -0,0 +1,188 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+# need to tell it where we are
+# lets review these
+C_VAR_TYPES = "int|void|unsigned|long|short|uint8_t|static|byte|float"
+require 'vendor/rad/variable_processing'
+require 'vendor/rad/arduino_sketch'
+require 'test/unit'
+
+
+
+class TestVariableProcessing < Test::Unit::TestCase
+
+  def setup
+    @t = ArduinoSketch.new
+  end
+  
+  # question for brian... do we need variable assignment with no value when
+  # we have "" and 0
+  
+
+
+  def test_int_as_int
+    name = "foo_a"
+    value_string = 1
+    expected = "int __foo_a = 1;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_string_as_int
+    name = "foo_b"
+    value_string = "1"
+    expected = "int __foo_b = 1;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_float_as_float
+    name = "foo_c"
+    value_string = 0.10
+    expected = "float __foo_c = 0.1;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_string_as_float
+    name = "foo_d"
+    value_string = "0.10"
+    expected = "float __foo_d = 0.1;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_byte # would this to return hex
+    name = "foo_f"
+    value_string = 0x00
+    expected = "int __foo_f = 0;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_byte_with_string_input
+    name = "foo_g"
+    value_string = "0x00"
+    expected = "byte __foo_g = 0x00;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_string
+    name = "foo_h"
+    value_string = "arduino"
+    expected = "char* __foo_h = \"arduino\";"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_type
+    name = "foo_i"
+    value_string = "int"
+    expected = "long __foo_i;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_odd_name
+    name = "bacon_j"
+    value_string = "arduino"
+    expected = "char* __bacon_j = \"arduino\";"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_type
+    name = "foo_k"
+    value_string = "2, int"
+    expected = "int __foo_k = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_long
+    name = "foo_l"
+    value_string = "2, int"
+    expected = "int __foo_l = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_byte
+    name = "foo_m"
+    value_string = "2, byte"
+    expected = "byte __foo_m = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_unsigned_int
+    name = "foo_n"
+    value_string = "2, unsigned int"
+    expected = "unsigned int __foo_n = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_unsigned_long
+    name = "foo_o"
+    value_string = "2, unsigned long"
+    expected = "unsigned long __foo_o = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_unsigned_long
+    name = "foo_p"
+    value_string = "2, long unsigned"
+    expected = "long unsigned __foo_p = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_short_int
+    name = "foo_q"
+    value_string = "2, short int"
+    expected = "short int __foo_q = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_int_with_unsigned_short_int
+    name = "foo_r"
+    value_string = "2, unsigned short int"
+    expected = "unsigned short int __foo_r = 2;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_float_with_type
+    name = "foo_s"
+    value_string = "2.0, float"
+    expected = "float __foo_s = 2.0;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_true
+    name = "foo_t"
+    value_string = true
+    expected = "bool __foo_t = 1;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  def test_false
+    name = "foo_v"
+    value_string = false
+    expected = "bool __foo_v = 0;"
+    result = @t.pre_process_vars(name, value_string)
+    assert_equal(expected, result[0])
+  end
+  
+  
+
+  
+end