raudi 0.0.1 → 0.0.2

data/lib/raudi/proxy/external_interrupt.rb

@@ -0,0 +1,30 @@
+module Raudi
+
+  module Proxy
+
+    module ExternalInterrupt
+      
+      def external_interrupt(*args)
+        set_interrupt(*args) do |arg|
+          next unless arg.is_a?(Hash)
+          arg.each do |pin_name, interrupt_event|
+            pin = get_pin(pin_name)
+            pin.int!(interrupt_event)
+            pin.port.add_interrupt :int
+          end
+        end
+      end
+
+      def pc_interrupt(*args)
+        set_interrupt(*args) do |arg|
+          pin = get_pin(arg)
+          pin.pcint!
+          pin.port.add_interrupt :pcint
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/proxy/gpio.rb

@@ -0,0 +1,19 @@
+module Raudi
+
+  module Proxy
+
+    module GPIO
+
+      def output(*args)
+        set_pin_mode(*args){|pin| pin.output!}
+      end
+
+      def pullup(*args)
+        set_pin_mode(*args){|pin| pin.pullup!}
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/proxy/headers.rb

@@ -0,0 +1,31 @@
+module Raudi
+
+  module Proxy
+
+    module Headers
+
+      def headers(*args)
+        args.each do |param|
+          case param
+          when String
+            next if param == ""
+          when Symbol
+            param = "avr/#{param}"
+          else
+            next
+          end
+          controller.headers << param if allow_header?(param)
+        end
+      end
+
+      private
+
+      def allow_header?(name)
+        Info.headers.include?(name) and !controller.headers.include?(name)
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/proxy/timer.rb

@@ -0,0 +1,61 @@
+module Raudi
+
+  module Proxy
+
+    module Timer
+
+      def activate_timer(number, params = {})
+        timer = get_tc_devise(number)
+        timer.prescale = prepare_prescale(params[:prescale]) || 1
+        base_tc_setting(timer, params)
+      end
+
+      def activate_counter(number, params = {})
+        counter = get_tc_devise(number)
+        counter.counter = get_counter_pin(number)
+        counter.prescale = prepare_prescale(params[:mode].to_s) || 6
+        base_tc_setting(counter, params)
+      end
+
+      private
+
+      def base_tc_setting(devise, params)
+        [:a, :b].each do |number|
+          if value = params[number] and devise.range.include?(value)
+            devise.ctc!
+            devise.mode_params[number] = value
+          end
+        end
+        if params[:interrupt]
+          devise.interrupt = true
+          set_interrupt
+        end
+        devise.active = true
+      end
+
+      def get_counter_pin(number)
+        pin = controller.pins.detect { |pin| pin.can_be_timer?(number) }
+        raise_timer_error(number, "can be timer pin") unless pin
+        pin.timer!
+        pin
+      end
+
+      def get_tc_devise(number)
+        devise = controller.timers.detect{|devise| devise.number == number}
+        raise_timer_error(number, "doesn't present") unless devise
+        devise
+      end
+
+      def prepare_prescale(value)
+        Info.timers['prescale'][value]
+      end
+
+      def raise_timer_error(number, message)
+        raise "Timer/Counter #{number} #{message} in controller #{controller.model_name}"
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source.rb

@@ -0,0 +1,48 @@
+require 'raudi/source/action'
+require 'raudi/source/bit_operations'
+require 'raudi/source/block'
+require 'raudi/source/variable'
+require 'raudi/source/function'
+
+module Raudi
+
+  module Source
+
+    class Base
+
+      include Action
+      include BitOperations
+      include Block
+      include Function
+      include Variable
+
+      attr_accessor :source_text
+
+      def code_line(line, params = {})
+        source_text << indent_line
+        source_text << line
+        source_text << ';' unless params[:skip_semicolon]
+        source_text << new_line unless params[:same_line]
+      end
+
+      def code_lines(lines)
+        lines.each_line{ |line| code_line(line, skip_semicolon: true, same_line: true) }
+      end
+
+      def new_line
+        "\r\n"
+      end
+
+      def reset_source_text
+        self.source_text = ""
+      end
+
+      def source_text
+        @source_text || reset_source_text
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source/action.rb

@@ -0,0 +1,16 @@
+module Raudi
+
+  module Source
+
+    module Action
+
+      def insert_action(*names)
+        code = Raudi.action[*names]
+        code_lines(code) if code
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source/bit_operations.rb

@@ -0,0 +1,35 @@
+module Raudi
+  
+  module Source
+
+    module BitOperations
+      
+      def write_register(register_name, bits)
+        unless bits.empty?
+          source = register_name.to_s.upcase
+          source << " |= "
+          source << join_bits(bits)
+          code_line(source)
+        end
+      end
+
+      def clear_register(register_name, bits)
+        unless bits.empty?
+          source = register_name.to_s.upcase
+          source << " &= "
+          source << "~("
+          source << join_bits(bits)
+          source << ")"
+          code_line(source)
+        end
+      end
+
+      def join_bits(bits)
+        bits.map{|bit| "1 << #{bit}"}.join(" | ")
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source/block.rb

@@ -0,0 +1,44 @@
+module Raudi
+
+  module Source
+
+    module Block
+
+      def code_block(header)
+        code_line header, skip_semicolon: true
+        block_in
+        yield if block_given?
+        block_out 
+      end
+
+      def indent_count
+        @indent_count || reset_indent_count
+      end
+
+      def indent_count=(value)
+        @indent_count = value unless value < 0
+      end
+
+      def reset_indent_count
+        @indent_count = 0
+      end
+
+      def indent_line
+        "  " * indent_count 
+      end
+
+      def block_in
+        code_line '{', skip_semicolon: true 
+        self.indent_count += 1
+      end
+
+      def block_out
+        self.indent_count -= 1
+        code_line '}', skip_semicolon: true
+      end
+
+    end
+  
+  end
+
+end

data/lib/raudi/source/controller.rb

@@ -0,0 +1,56 @@
+require 'raudi/processing'
+require 'raudi/source'
+require 'raudi/source/interrupt'
+
+module Raudi
+
+  module Source
+
+    class Controller < Base
+
+      include Interrupt
+
+      attr_accessor :controller
+
+      def initialize(controller)
+        self.controller = controller
+      end
+
+      def generate_headers
+        controller.headers.each do |name|
+          code_line "#include <#{name}.h>", skip_semicolon: true
+        end
+        new_line
+      end
+
+      def to_c
+        generate_headers
+        generate_interrupts
+
+        function_block(:main) do
+          generate_config
+          insert_action :setup
+          allow_interrupt
+          code_block('while(1)') do
+            insert_action :main
+          end
+        end
+
+        source_text
+      end
+
+      private
+
+      def generate_config
+        processings.each(&:generate_config)
+      end
+
+      def processings
+        Processing.list.map{|klass| klass.new(controller, self)}
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source/function.rb

@@ -0,0 +1,50 @@
+module Raudi
+
+  module Source
+
+    module Function
+
+      def function_block(name, params = {}, &block_source)
+        function_header = generate_function_header(name, params)
+        code_block(function_header, &block_source)
+      end
+
+      def generate_function_header(name, params = {})
+        source = ''
+        source << generate_result(name, params[:result])
+      end
+
+      def generate_result(name, result = nil)
+        if result.is_a?(Hash)
+          result[:type] ||= :void
+          result[:name] = name
+          generate_variable result
+        else
+          result ||= :void
+          generate_variable name: name, type: result
+        end
+      end
+
+      def function_arguments(params)
+        arguments_line = "("
+        arguments_line << if params
+          params = [params] unless params.is_a? Array
+          params.map do |param|
+            argument = result_to_c(param)
+            if param[:array]
+              param[:array] = 1 unless param[:array].is_a?(Integer)
+              argument << ('*' * param[:array])
+            end
+            argument << param[:name].to_s
+          end.join(", ")
+        else
+          'void'
+        end
+        arguments_line << ")"
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source/interrupt.rb

@@ -0,0 +1,35 @@
+module Raudi
+
+  module Source
+
+    module Interrupt
+
+      def allow_interrupt
+        code_line("sei()") if controller.interrupt
+      end
+
+      def interrupt_block(*names, &block)
+        interrupt_header = "ISR(#{vector_name(*names)})"
+        new_block = lambda do
+          insert_action(*names)
+          block.call if block_given?
+        end
+        code_block(interrupt_header, &new_block)
+        new_line
+      end
+
+      def generate_interrupts
+        return unless controller.interrupt
+        processings.each(&:generate_interrupts)
+      end
+
+      def vector_name(*args)
+        vector_name = args.map(&:upcase).join('_')
+        vector_name << "_vect"
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/source/variable.rb

@@ -0,0 +1,31 @@
+module Raudi
+
+  module Source
+
+    module Variable
+      
+      def generate_variable(variable)
+        source = ""
+
+        [:static, :const, :unsigned].each do |prefix|
+          source << "#{prefix} " if variable[prefix] or variable[prefix.to_s]
+        end
+
+        source << variable[:type].to_s
+        source << ' '
+
+        variable[:pointer] ||= variable[:array]
+        if variable[:pointer]
+          variable[:pointer] = 1 unless variable[:pointer].is_a?(Integer)
+          source << ('*' * variable[:pointer])
+        end
+
+        source << variable[:name].to_s
+        source
+      end
+
+    end
+
+  end
+
+end