raudi 0.0.1 → 0.0.2

data/.rvmrc

@@ -1 +1 @@
-rvm 1.9.3@raudi --create
+rvm 1.9.2@raudi --create

data/bin/raudi

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'raudi'
+rescue LoadError
+  require 'rubygems'
+  require 'raudi'
+end
+
+puts %Q{
+Usage:
+  raudi source_file.raudi [options]
+
+Options:
+  -o, [--output] # Set output file
+
+} unless Raudi.process(*ARGV)

data/configuration/atmega_328.yml

@@ -0,0 +1,69 @@
+frequency: 16000000
+max_frequency: 20000000
+ports:
+  b:
+    pc_number: 0
+    pins:
+      0:
+        - pcint_0
+      1:
+        - pcint_1
+      2:
+        - pcint_2
+      3:
+        - pcint_3
+      4:
+        - pcint_4
+      5:
+        - pcint_5
+      6:
+        - pcint_6
+      7:
+        - pcint_7
+  c:
+    pc_number: 1
+    pins:
+      0:
+        - pcint_8
+      1:
+        - pcint_9
+      2:
+        - pcint_10
+      3:
+        - pcint_11
+      4:
+        - pcint_12
+      5:
+        - pcint_13
+      6:
+        - pcint_14
+  d:
+    pc_number: 2
+    pins:
+      0:
+        - pcint_16
+      1:
+        - pcint_17
+      2:
+        - int_0
+        - pcint_18
+      3:
+        - int_1
+        - pcint_19
+      4:
+        - pcint_20
+        - timer_0
+      5:
+        - pcint_21
+        - timer_1
+      6:
+        - pcint_22
+      7:
+        - pcint_23
+timers:
+  timer_0:
+    length: 8
+  timer_1:
+    length: 16
+  timer_2:
+    length: 8

data/configuration/avr.yml

@@ -0,0 +1,61 @@
+headers:
+  avr:
+    - boot
+    - cpufunc
+    - eeprom
+    - fuse
+    - interrupt
+    - io
+    - lock
+    - pgmspace
+    - power
+    - sfr_defs
+    - signature
+    - sleep
+    - version
+    - wdt
+  common:
+    - alloca
+    - assert
+    - ctype
+    - errno
+    - inttypes
+    - math
+    - setjmp
+    - stdint
+    - stdio
+    - stdlib
+    - string
+  util:
+    - atomic
+    - crc16
+    - delay
+    - delay_basic
+    - parity
+    - setbaud
+    - twi
+
+gpio_states:
+  - input
+  - pullup
+  - output
+specific_pin_states:
+  - int
+  - pcint
+  - timer
+
+interrupts:
+  events:
+    low: 0
+    both: 1
+    falling: 2
+    rising: 3
+timers:
+  prescale:
+    1: 1
+    8: 2
+    64: 3
+    256: 4
+    1024: 5
+    falling: 6
+    rising: 7

data/lib/raudi.rb

@@ -1,5 +1,9 @@
+require 'forwardable'
+require 'yaml'
 require 'raudi/action_processor'
-require 'raudi/avr_controller'
+require 'raudi/core_ext'
+require 'raudi/info'
+require 'raudi/avr'
 
 module Raudi
 
@@ -8,18 +12,63 @@ module Raudi
     attr_accessor :controller
 
     def version
-      "0.0.1"
+      "0.0.2"
     end
 
-    def generate(config_file, actions_file)
-      absolute_config_path = File.expand_path(config_file)
-      absolute_actions_path = File.expand_path(actions_file)
-      raise 'Create configuration file config.rb before' unless File.exists?(absolute_config_path)
-      raise 'Create actions file actions.raudi before' unless File.exists?(absolute_actions_path)
-      load(absolute_config_path)
-      ActionProcessor.generate_source(absolute_config_path)
+    def configure(model_name, &block)
+      Raudi::AVR::Controller.new(model_name, &block)
+    end
+
+    def action
+      @action ||= Raudi::ActionProcessor.new
+    end
+
+    def process(*args)
+      return unless filename = check_filename(args)
+      begin
+        load filename
+        return write_file(filename, args)
+      rescue Exception => e
+        puts e.message
+      end
+      false
+    end
+
+    private
+
+    def check_filename(args)
+      filename = args.delete_at(0)
+      return unless filename
+      return unless File.exists?(filename)
+      return unless filename =~ /.*\.raudi$/i
+      filename
+    end
+
+    def param_alias(param)
+      {'--output' => '-o'}[param] or param
+    end
+
+    def write_file(source_path, args)
+      return unless source = controller.to_c
+      output = source_path.gsub(/\.raudi$/i, '.c')
+      args.each_with_index do |param, index|
+        next unless param_alias(param) == '-o'
+        custom_output = args[index + 1]
+        output = custom_output if custom_output
+        break
+      end
+      File.open(output, 'w') {|f| f.write(source) }
+      true
     end
 
   end
 
 end
+
+def action
+  Raudi.action
+end
+
+def configure(*args, &block)
+  Raudi.configure(*args, &block)
+end

data/lib/raudi/action_processor.rb

@@ -1,33 +1,41 @@
-module ActionProcessor
-  
-  class << self
-    
-    def generate_source(actions_file)
-      raise %q{Controller isn't specified in config.rb file} unless Raudi.controller
-      define_actions(actions_file)
-      output = ''
-      output << append_libs(Raudi.controller.libs)
-      output << block_delimiter
-      output << main_block
+module Raudi
+
+  class ActionProcessor
+
+    attr_accessor :collection
+
+    def initialize
+      self.collection = {}
     end
-    
-    def append_libs(libs)
-      libs.map do |lib_name| 
-        lib_name = lib_name.to_s
-        lib_name << '.h' unless lib_name =~ /\.h$/
-        "#include <#{lib_name}>"
-      end.join("\n")
+
+    def [](*keys)
+      collection[prepare_key(*keys)]
     end
-    
-    def block_delimiter
-      "\n"
+
+    def []=(*keys, value)
+      collection[prepare_key(*keys)] = value
     end
-    
-    def define_actions(actions_file)
-      File.open(actions_file) do |file|
+
+    private
+
+    def prepare_key(*keys)
+      number = if keys.last.is_a?(Fixnum)
+        keys.pop
       end
+
+      key = keys.map{|key| key.to_s.downcase}.join('_')
+      key = key_alias(key)
+
+      key << number.to_s if number
+      key.to_sym
     end
-    
+
+    def key_alias(key)
+      {
+        'interrupt' => 'int'
+      }[key] or key
+    end
+
   end
 
-end
+end

data/lib/raudi/avr.rb

@@ -0,0 +1,4 @@
+require 'raudi/avr/controller'
+require 'raudi/avr/port'
+require 'raudi/avr/pin'
+require 'raudi/avr/timer'

data/lib/raudi/avr/controller.rb

@@ -0,0 +1,73 @@
+require 'raudi/proxy/controller'
+require 'raudi/source/controller'
+require 'raudi/state_list'
+
+module Raudi
+
+  module AVR
+
+    class Controller
+
+      extend Forwardable
+      include Raudi::StateList
+
+      attr_accessor :model_name, :headers, :ports, :timers, :interrupt
+
+      def_delegator :source, :to_c
+
+      def initialize(model_name, &block)
+        self.model_name = model_name
+        load_ports
+        load_timers
+        self.headers = ['avr/io']
+        Proxy::Controller.new(self, &block) if block_given?
+        Raudi.controller = self
+      end
+
+      def ports(port_name = nil)
+        if port_name
+          @ports.detect{|port| port.name == port_name.to_s.upcase}
+        else
+          @ports
+        end
+      end
+
+      def pins
+        ports.map(&:pins).flatten
+      end
+
+      def source
+        @source ||= Source::Controller.new(self)
+      end
+
+      private
+
+      def config
+        @config ||= begin
+          path = File.join(File.dirname(__FILE__), '/../../../configuration', "/#{model_name}.yml")
+          raise "Unknow controller model" unless File.exist?(path)
+          YAML.load_file(path)
+        end
+      end
+
+      def load_ports
+        self.ports = config['ports'].map {|port_name, config| Port.new(port_name, config)}
+      end
+
+      def load_timers
+        self.timers = config['timers'].map{|timer_name, config| Timer.new(timer_name, config)}
+      end
+
+      def method_missing(method_name, *args, &block)
+        if value = config[method_name.to_s]
+          value
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/avr/pin.rb

@@ -0,0 +1,30 @@
+require 'raudi/avr/pin_states'
+
+module Raudi
+
+  module AVR
+
+    class Pin
+
+      extend Forwardable
+      include PinStates
+
+      attr_accessor :port, :number
+
+      def_delegator :port, :name
+
+      def initialize(port, number, types)
+        self.port = port
+        self.number = number
+        load_states(types)
+      end
+
+      def to_s
+        "Pin #{name}#{number} <#{state}>"
+      end
+
+    end
+
+  end
+
+end

data/lib/raudi/avr/pin_states.rb

@@ -0,0 +1,73 @@
+module Raudi
+
+  module AVR
+
+    module PinStates
+
+      DELIMITER = '_'
+      
+      def self.included(klass)
+        
+        klass.class_eval do
+
+          attr_accessor :states, :state, :state_params
+
+          Info.pin_states.each do |pin_state|
+
+            define_method :get_state do |pin_state|
+              states.detect { |state| state =~ Regexp.new("\\A(#{pin_state})(_\d+)?") }
+            end
+
+            define_method :get_state! do |pin_state|
+              valid_state = get_state(pin_state)
+              raise "#{to_s} can be #{pin_state}" unless valid_state
+              valid_state
+            end
+
+            define_method "#{pin_state}!" do |*args|
+              self.state = get_state!(pin_state)
+              self.state_params = args.first
+            end
+
+            define_method "#{pin_state}?" do |*args|
+              self.state == get_state(pin_state)
+            end
+
+            define_method "can_be_#{pin_state}?" do |*args|
+              return unless full_state = get_state(pin_state)
+              if(number = args.first)
+                return unless full_state[number.to_s]
+              end
+              true
+            end
+
+          end
+
+        end
+
+      end
+
+      def state_number
+        state.split(DELIMITER).last
+      end
+
+      def to_c
+        if Info.gpio_states.include?(state)
+          "PIN#{name}#{number}"
+        else
+          state.to_s.gsub(DELIMITER, '').upcase
+        end
+      end
+
+      private
+
+      def load_states(states)
+        self.states = (Info.gpio_states + states).uniq
+        self.state = self.states.first
+      end
+
+    end
+
+  end
+
+end