atduskgreg-rad 0.2.5

data/lib/rad/rad_type_checker.rb

@@ -0,0 +1,26 @@
+require 'ruby_to_ansi_c'
+
+class RADTypeChecker < TypeChecker
+  
+  def process_const(exp)
+    c = exp.shift
+    if c.to_s =~ /^[A-Z]/ then
+      # TODO: validate that it really is a const? 
+      # uber hackery
+      # since constants are defined in the arduino_sketch define method and 
+      # we can't inject them into the methods 
+      # transport them here with a $define_types hash
+
+      $define_types.each do |k,v|
+        if k == c.to_s
+          @const_type = eval "Type.#{v}"
+        end
+      end
+      return t(:const, c, @const_type)
+    else
+      raise "I don't know what to do with const #{c.inspect}. It doesn't look like a class."
+    end
+    raise "need to finish process_const in #{self.class}"
+  end
+  
+end

data/lib/rad/sim/arduino_sketch.rb

@@ -0,0 +1,57 @@
+ON = true
+OFF = !ON
+HIGH = ON
+LOW = !HIGH
+
+class ArduinoSketch
+  attr_accessor :pins  
+   
+  def initialize
+    @pins = self.class.instance_variable_get("@pins")
+  end
+  
+  def self.output_pin(num, opts)
+    module_eval "@pins ||= []"
+    module_eval do 
+      @pins <<  Pin.new( num, :type => :output )
+    end
+
+    if opts[:as]
+       module_eval <<-CODE
+         def #{opts[:as]}
+           pins.select{|p| p.num == #{num}}.first
+         end
+       CODE
+     end
+  end
+
+  def loop    
+  end
+  
+  def digitalWrite( pin, value )
+    to_change = pins.select{|p| p.num == pin.num}.first
+    to_change.value = value
+  end
+
+  def delay( millis )
+  end
+  
+  # def serial_read
+  # end
+
+  # def serial_available
+  # end
+
+  # def blink
+  # end
+end
+
+class Pin
+  attr_accessor :num, :type, :value
+
+  def initialize num, opts
+    @num = num
+    @type = opts[:type]
+    @value = opts[:value] || false
+  end
+end

data/lib/rad/sketch_compiler.rb

@@ -0,0 +1,47 @@
+# TODO:
+#   compilation
+#   gather pieces of code we need as strings
+#   translate non-loop methods
+#   do plugin stuff
+#   deal with examples/ exception
+#   manage upload process
+#   compose_setup should move in here entirely
+
+# require 'arduino_sketch'
+
+class SketchCompiler
+  attr_accessor :path, :body, :klass, :target_dir, :name
+  
+  def initialize path_to_sketch 
+    @path = File.expand_path(path_to_sketch)
+    @body = open(@path).read
+    @name = @path.split("/").last.split(".").first
+    @klass = @name.split(".").first.split("_").collect{|c| c.capitalize}.join("")     
+    @target_dir = parent_dir
+  end
+  
+  def parent_dir
+    self.path.split("/")[0..@path.split("/").length-2].join("/")
+  end
+  
+  def build_dir
+    "#{self.target_dir}/#{self.name}"
+  end
+
+  def create_build_dir! optional_path_prefix=nil
+    self.target_dir = optional_path_prefix if optional_path_prefix
+    mkdir_p build_dir
+  end
+  
+  def process_constants
+    self.body.gsub!("HIGH", "1")
+    self.body.gsub!("LOW", "0")
+    self.body.gsub!("ON", "1")
+    self.body.gsub!("OFF", "0")
+  end
+  
+  def sketch_methods
+    self.body.scan(/^\s*def\s.\w*/).collect{ |m| m.gsub(/\s*def\s*/, "") }
+  end
+  
+end

data/lib/rad/tasks/build_and_make.rake

@@ -0,0 +1,210 @@
+require File.expand_path(File.dirname(__FILE__) + "/../init.rb")
+require 'ruby_to_ansi_c'
+
+C_VAR_TYPES = "unsigned|int|long|double|str|char|byte|bool"
+
+# incredibly primitive tests 
+# rake test:compile or rake test:upload
+# runs through all sketches in the example directory
+
+def run_tests(sketch, type)
+  sh %{rake make:#{type} sketch=examples/#{sketch}}
+end
+
+namespace :test do
+  
+  desc "iterate through all the sketches in the example directory"
+  task :upload => :gather do 
+    @examples.each {|e| run_tests(e, "upload")}
+  end
+  
+  task :compile => :gather do 
+
+    @examples.each {|e| run_tests(e, "compile")}
+  end
+  
+  desc "gather all tests"
+  task :gather do # => "make:upload" do
+    @examples = []
+    if ENV['sketch']
+      @examples << ENV['sketch']
+    else
+      Dir.entries( File.expand_path("#{RAD_ROOT}/examples/") ).each do |f|
+        @examples << f.split('.').first if (f =~ /\.rb$/)
+      end
+    end
+  end
+
+end
+
+
+namespace :make do
+  
+  desc "compile the sketch and then upload it to your Arduino board"
+  task :upload => :compile do
+    if Makefile.hardware_params['physical_reset']
+      puts "Reset the Arduino and hit enter.\n==If your board doesn't need it, you can turn off this prompt in config/software.yml=="
+      STDIN.gets.chomp
+    end
+    sh %{cd #{@sketch.build_dir}; make upload}
+  end
+    
+  desc "generate a makefile and use it to compile the .cpp"
+  task :compile => [:clean_sketch_dir, "build:sketch"] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make}
+  end
+  
+  desc "generate a makefile and use it to compile the .cpp using the current .cpp file"
+  task :compile_cpp => ["build:sketch_dir", "build:gather_required_plugins", "build:plugin_setup", "build:setup", :clean_sketch_dir] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make}
+  end
+  
+  desc "generate a makefile and use it to compile the .cpp and upload it using current .cpp file"
+  task :upload_cpp => ["build:sketch_dir", "build:gather_required_plugins", "build:plugin_setup", "build:setup", :clean_sketch_dir] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make upload}
+  end
+  
+  task :clean_sketch_dir => ["build:file_list", "build:sketch_dir"] do
+    FileList.new(Dir.entries("#{@sketch.build_dir}")).exclude("#{@sketch.name}.cpp").exclude(/^\./).each do |f|
+      sh %{rm #{@sketch.build_dir}/#{f}}
+    end
+  end
+  
+end
+
+namespace :build do
+
+  desc "actually build the sketch"
+  task :sketch => [:file_list, :sketch_dir, :gather_required_plugins, :plugin_setup, :setup] do
+    c_methods = []
+    sketch_signatures = []
+    # until we better understand RubyToC let's see what's happening on errors
+    @sketch.sketch_methods.each do |meth|   
+      raw_rtc_meth = RADProcessor.translate(constantize(@sketch.klass), meth)
+      puts "Translator Error: #{raw_rtc_meth.inspect}" if raw_rtc_meth =~ /\/\/ ERROR:/ 
+      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
+    c_methods.each {|meth| sketch_signatures << "#{meth.scan(/^\w*\s?\*?\n.*\)/)[0].gsub("\n", " ")};" }
+    clean_c_methods = []
+    # 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() {")
+    # 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] << "\tadditional_setup();" # call from setup 
+      @setup[5] << @additional_setup.join("") # 
+    end
+    result = "#{@setup.join( "\n" )}\n#{c_methods_with_timer}\n"
+    File.open("#{@sketch.build_dir}/#{@sketch.name}.cpp", "w"){|f| f << result}
+  end
+
+  # needs to write the library include and the method signatures
+  desc "build setup function"
+  task :setup do
+    eval "class #{@sketch.klass} < ArduinoSketch; end;"
+    
+    @@as = HardwareLibrary.new
+    
+    delegate_methods = @@as.methods - Object.new.methods
+    delegate_methods.reject!{|m| m == "compose_setup"}
+        
+    delegate_methods.each do |meth|
+       constantize(@sketch.klass).module_eval <<-CODE
+       def self.#{meth}(*args)
+       @@as.#{meth}(*args)
+       end
+       CODE
+    end
+    # allow variable declaration without quotes: @foo = int 
+    ["long","unsigned","int","byte","short"].each do |type|
+      constantize(@sketch.klass).module_eval <<-CODE
+       def self.#{type}
+        return "#{type}"
+       end
+       CODE
+    end   
+    
+    @sketch.process_constants
+    
+    eval ArduinoSketch.pre_process(@sketch.body)
+    @@as.process_external_vars(constantize(@sketch.klass))
+    @setup = @@as.compose_setup
+  end
+  
+  desc "add plugin methods"
+  task :plugin_setup do
+    $plugins_to_load.each do |name|
+       klass = name.split(".").first.split("_").collect{|c| c.capitalize}.join("")
+       eval "class #{klass} < ArduinoPlugin; end;"
+    
+       @@ps = ArduinoPlugin.new
+       plugin_delegate_methods = @@ps.methods - Object.new.methods
+       plugin_delegate_methods.reject!{|m| m == "compose_setup"}
+    
+       plugin_delegate_methods.each do |meth|
+         constantize(klass).module_eval <<-CODE
+         def self.#{meth}(*args)
+           @@ps.#{meth}(*args)
+         end
+         CODE
+       end
+
+      eval ArduinoPlugin.process(File.read("vendor/plugins/#{name}"))
+      
+    end
+    @@no_plugins = ArduinoPlugin.new if @plugin_names.empty?
+  end
+  
+  desc "determine which plugins to load based on use of methods in sketch"
+  task :gather_required_plugins do
+    @plugin_names.each do |name|
+       ArduinoPlugin.check_for_plugin_use(@sketch.body, File.read("vendor/plugins/#{name}"), name )
+    end
+    puts "#{$plugins_to_load.length} of #{$plugin_methods_hash.length} plugins are being loaded:  #{$plugins_to_load.join(", ")}"
+  end
+  
+  desc "setup target directory named after your sketch class"
+  task :sketch_dir => [:file_list] do
+    @sketch.create_build_dir!
+  end
+
+  task :file_list do
+    # take another look at this, since if the root directory name is changed, everything breaks
+    # perhaps we generate a constant when the project is generated an pop it here or in the init file
+    if ENV['sketch']
+      @sketch = SketchCompiler.new File.expand_path("#{ENV['sketch']}.rb")
+    else
+      # assume the only .rb file in the sketch dir is the sketch:
+      @sketch = SketchCompiler.new Dir.glob("#{File.expand_path(File.dirname(__FILE__))}/../../../*.rb").first
+    end
+
+    @plugin_names = []
+    Dir.entries( File.expand_path("#{RAD_ROOT}/vendor/plugins/") ).each do |f|
+      if (f =~ /\.rb$/)
+        @plugin_names << f
+      end
+    end
+  end
+end
+
+#yoinked from Rails
+def constantize(camel_cased_word)
+  unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+    raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+  end
+
+  Object.module_eval("::#{$1}", __FILE__, __LINE__)
+end

data/lib/rad/tasks/rad.rb

@@ -0,0 +1,2 @@
+require 'rake'
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }

data/lib/rad/todo.txt

@@ -0,0 +1,13 @@
+TODO:
+=====
+	
+Future:
+	- complete library system: script/install library some_library
+	- bin/rad:
+		- setup and use a ~/.rad for new project defaults
+	- put repository on git
+	- project gallery (examples with movies)
+	- testing framework
+	- implement wire lib
+	- subclasses of ArduinoSketch (should just work, but what are they for?)
+	- simulator

data/lib/rad/variable_processing.rb

@@ -0,0 +1,153 @@
+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)
+          else
+            value = var.split(",").first.lstrip
+            type = var.split(",")[1].nil? ?  nil : var.split(",")[1].lstrip
+            translate_variables( name , type, value )
+          end
+        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)
+        when Array
+          post_process_arrays(name, var)
+        else
+          raise ArgumentError, "not sure what to do here...  got #{name} with value #{var} which is a #{var.class}" 
+        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 =~ /^-(\d|x)*$/ 
+        value = value.to_i
+        type = "int" if type.nil?
+      elsif value =~ /^-(\d|\.|x)*$/ 
+        value = value.to_f
+        unless type.nil?
+          raise ArgumentError, "#{value} should be a float got  #{type}" unless type == "float"
+        end
+        type = "float" if type.nil?   
+
+      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 post_process_arrays(name, var)
+      type = c_type(var[0])
+      $array_types[name] = type
+      assignment = var.inspect.gsub("[","{").gsub("]","}")      
+      c_style_array = "#{type} __#{name}[] = #{assignment};"
+      $external_var_identifiers << "__#{name}" unless $external_var_identifiers.include?("__#{name}")
+      $external_array_vars << c_style_array unless $external_array_vars.include?(c_style_array)
+    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
+    
+    def c_type(typ)
+      type = 
+        case typ 
+        when Integer
+          "int"
+        when String
+          "char*"
+        when TrueClass
+          "bool"
+        when FalseClass
+          "bool"
+        else
+          raise "Bug! Unknown type #{typ.inspect} in c_type"
+        end
+
+        type
+    end
+   
+end