raudi 0.0.1 → 0.0.2

data/lib/raudi/avr/port.rb

@@ -0,0 +1,36 @@
+require 'raudi/state_list'
+
+module Raudi
+
+  module AVR
+    
+    class Port
+      
+      include StateList
+
+      attr_accessor :name, :pins, :interrupts, :pc_number
+
+      def initialize(name, config)
+        self.name = name.upcase
+        self.pins = config['pins'].map{|pin_number, types|  Pin.new(self, pin_number, types)}
+        self.pc_number= config['pc_number']
+        self.interrupts = []
+      end
+
+      def add_interrupt(new_interrupt)
+        self.interrupts << new_interrupt unless interrupts.include?(new_interrupt)
+      end
+
+      def pins(pin_number = nil)
+        if pin_number
+          @pins.detect{|pin| pin.number == pin_number.to_i}
+        else
+          @pins
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/avr/timer.rb

@@ -0,0 +1,49 @@
+module Raudi
+
+  module AVR
+
+    class Timer
+
+      attr_accessor :active, :counter, :interrupt, :mode, :mode_params, :name, :length, :prescale
+
+      [:normal, :ctc].each do |timer_mode|
+        define_method("#{timer_mode}?") do
+          self.mode == timer_mode
+        end
+
+        define_method("#{timer_mode}!") do
+          self.mode = timer_mode
+        end
+      end
+
+      def initialize(name, params)
+        self.name = name
+        self.length = params['length']
+        self.normal!
+      end
+
+      def number
+        name[/\d+/].to_i
+      end
+
+      def range
+        0...max_number
+      end
+
+      def max_number
+        2**length
+      end
+
+      def mode=(new_mode)
+        if @mode != new_mode
+          @mode = new_mode
+          self.mode_params = {}
+          self.interrupt = nil
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/core_ext.rb

@@ -0,0 +1 @@
+require 'raudi/core_ext/fixnum'

data/lib/raudi/core_ext/fixnum.rb

@@ -0,0 +1,16 @@
+Fixnum.class_eval do
+  
+  def to_bits(length, options = {})
+    if prefix = options[:prefix]
+      length.times.inject([]) do |list, index|
+        if self[index] == 1
+          list << "#{prefix}#{index}"
+        end
+        list
+      end
+    else
+      length.times.map{ |index| self[index] == 1 }
+    end
+  end
+
+end

data/lib/raudi/info.rb

@@ -0,0 +1,52 @@
+module Raudi
+    
+  module Info
+
+    class << self
+
+      def config
+        @config ||= begin
+          path = File.join(File.dirname(__FILE__), '../../', 'configuration/avr.yml')
+          YAML.load_file(path)
+        end
+      end
+
+      def method_missing(method_name, *args)
+        if result = config[method_name.to_s]
+          result
+        else
+          super(method_name, *args)
+        end
+      end
+
+      def pin_states
+        gpio_states + specific_pin_states
+      end
+
+      def headers
+        @headers ||= begin
+          list = []
+          config['headers'].each do |namespace, headers|
+            list += headers.map{|header| "#{process_namespace(namespace)}#{header}"}
+          end
+          list
+        end
+      end
+
+      def interrupt_event(event_name)
+        list = config['interrupts']['events'][event_name.to_s]
+        raise "Undefined interrupt event - #{event_name}" unless list.is_a?(Fixnum)
+        list
+      end
+
+      private
+
+      def process_namespace(name)
+        (name == 'common') ? '' : name + '/'
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/processing.rb

@@ -0,0 +1,63 @@
+module Raudi
+
+  module Processing
+
+    class << self
+
+      attr_accessor :list
+
+      def list
+        @list ||= []
+      end
+
+    end
+
+    class Base
+
+      attr_accessor :controller, :source
+
+      def self.inherited(klass)
+        Processing.list << klass
+      end
+
+      def initialize(controller, source)
+        self.controller = controller
+        self.source = source
+      end
+
+      def generate_interrupts
+        return unless can_process?
+        interrupts
+      end
+
+      def generate_config
+        return unless can_process?
+        config
+      end
+
+      def method_missing(method_name, *args, &block)
+        [source, controller].each do |delegate|
+          return delegate.send(method_name, *args, &block) if delegate.respond_to?(method_name)
+        end
+        super
+      end
+
+      private
+
+      def interrupts
+      end
+
+      def config
+      end
+
+      def can_process?
+        true
+      end
+
+    end
+
+  end
+
+end
+
+Dir[File.dirname(__FILE__) + '/processing/*.rb'].each{ |file_name| require file_name }

data/lib/raudi/processing/gpio.rb

@@ -0,0 +1,25 @@
+module Raudi
+
+  module Processing
+
+    class GPIO < Base
+      
+      private
+
+      def config
+        ports.each do |port|
+          register_name = "DDR#{port.name}"
+          bits = port.output_pins.map(&:number)
+          write_register(register_name, bits)
+
+          register_name = "PORT#{port.name}"
+          bits = port.pullup_pins.map(&:number)
+          write_register(register_name, bits)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/processing/int.rb

@@ -0,0 +1,36 @@
+module Raudi
+
+  module Processing
+
+    class Int < Base
+
+      private
+
+      def interrupts
+        int_pins.each do |pin|
+          interrupt_block pin.to_c
+        end
+      end
+
+      def config
+        register_name = "EICRA"
+        bits = []
+        int_pins.each do |pin|
+          bits += Info.interrupt_event(pin.state_params).to_bits(2, :prefix => "ISC#{pin.state_number}")
+        end
+        write_register(register_name, bits)
+
+        register_name = "EIMSK"
+        bits = int_pins.map(&:to_c)
+        write_register(register_name, bits)
+      end
+
+      def can_process?
+        int_present?
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/processing/pcint.rb

@@ -0,0 +1,35 @@
+module Raudi
+
+  module Processing
+
+    class PCInt < Base
+
+      private
+
+      def interrupts
+        ports.each do |port|
+          next unless port.pcint_present?
+          interrupt_block "PCINT#{port.pc_number}"
+        end
+      end
+
+      def config
+        pc_ports = []
+        ports.map do |port|
+          next unless port.pcint_present?
+          register_name = "PCMSK#{port.pc_number}"
+          bits = port.pcint_pins.map(&:to_c)
+          write_register(register_name, bits)
+
+          pc_ports << "PCIE#{port.pc_number}"
+        end
+
+        register_name = "PCICR"
+        write_register(register_name, pc_ports)
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/processing/timer.rb

@@ -0,0 +1,56 @@
+module Raudi
+
+  module Processing
+
+    class Timer < Base
+
+      private
+
+      def active_timers
+        timers.select(&:active)
+      end
+
+      def config
+        active_timers.each do |timer|
+          set_timer_mask(timer)
+          set_mode(timer)
+        end
+      end
+
+      def interrupts
+        active_timers.each do |timer|
+          next unless timer.interrupt
+          prefix = "timer#{timer.number}"
+          case
+          when timer.normal?
+            interrupt_block(prefix, "ovf")
+          when timer.ctc?
+            timer.mode_params.keys.each do |register_name|
+              interrupt_block(prefix, "comp#{register_name}")
+            end
+          end
+        end
+      end
+
+      def set_mode(timer)
+        register_name = "TCCR#{timer.number}B"
+        bits = timer.prescale.to_bits(3, :prefix => "CS#{timer.number}")
+        bits << "WGM#{timer.number}2" if timer.ctc?
+        write_register(register_name, bits)
+      end
+
+      def set_timer_mask(timer)
+        return unless timer.interrupt
+        case
+        when timer.normal?
+          register_name = "TIMSK#{timer.number}"
+          bits = ["TOIE#{timer.number}"]
+          write_register(register_name, bits)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/proxy/controller.rb

@@ -0,0 +1,65 @@
+require 'raudi/proxy/external_interrupt'
+require 'raudi/proxy/gpio'
+require 'raudi/proxy/headers'
+require 'raudi/proxy/timer'
+
+module Raudi
+
+  module Proxy
+
+    class Controller
+
+      include ExternalInterrupt
+      include GPIO
+      include Headers
+      include Timer
+
+      attr_accessor :controller
+
+      def initialize(controller, &block)
+        self.controller = controller
+        instance_eval(&block) if block_given?
+      end
+
+      private
+
+      def get_pin(pin_name)
+        port_name = pin_name[/[a-z]+/i]
+        raise "Port is not specified" unless port_name
+        pin_number = pin_name[/\d+/]
+        raise "Pin is not specified" unless pin_number
+        port = controller.ports(port_name)
+        raise "Port #{port_name} doesn't exists in controller" unless port
+        pin = port.pins(pin_number)
+        raise "Pin #{pin_number} doesn't exists in port #{port_name}" unless pin
+        pin
+      end
+
+      def method_missing(method_name, *args)
+        if controller.respond_to?("#{method_name}=")
+          controller.send("#{method_name}=", *args)
+        else
+          raise "Illegal property #{method_name}, check configuration file"
+        end
+      end
+
+      def set_interrupt(*args)
+        headers :interrupt
+        controller.interrupt = true
+        return if args.empty? or !block_given?
+        args.each do |arg|
+          yield arg
+        end
+      end
+
+      def set_pin_mode(*args, &block)
+        args.each do |arg|
+          block.call(get_pin(arg))
+        end
+      end
+
+    end
+
+  end
+
+end