rpicsim 0.1.0

data/lib/rpicsim/mplab/mplab_simulator.rb

@@ -0,0 +1,102 @@
+require_relative 'mplab_memory'
+require_relative 'mplab_processor'
+
+module RPicSim::Mplab
+  # DeviceInfo is a wrapper for the MPLAB xPIC class which gives us information
+  # about the target PIC device.
+  class MplabSimulator
+    # Makes a new DeviceInfo object.
+    # @param simulator [com.microchip.mplab.mdbcore.simulator.Simulator]
+    def initialize(simulator)
+      @simulator = simulator
+    end
+
+    def stopwatch_value
+      @simulator.GetStopwatchValue
+    end
+
+    def fr_memory
+      @fr_memory ||= MplabMemory.new data_store.getFileMemory
+    end
+    
+    def sfr_memory
+      @sfr_memory ||= MplabMemory.new data_store.getSFRMemory
+    end
+
+    def nmmr_memory
+      @nmmr_memory ||= MplabMemory.new data_store.getNMMRMemory
+    end
+    
+    def program_memory
+      @program_memory ||= MplabMemory.new data_store.getProgMemory
+    end
+    
+    def stack_memory
+      @stack_memory ||= MplabMemory.new data_store.getStackMemory
+    end
+    
+    def test_memory
+      @test_memory ||= MplabMemory.new data_store.getTestMemory
+    end
+    
+    def processor
+      @processor ||= MplabProcessor.new data_store.getProcessor
+    end
+    
+    def pins
+      pin_descs = (0...data_store.getNumPins).collect { |i| data_store.getPinDesc(i) }
+
+      pin_set = data_store.getProcessor.getPinSet
+
+      # The PinSet class has strangely-implemented lazy loading.
+      # We call getPin(String name) to force it to load pin data from
+      # the SimulatorDataStore.
+      pin_descs.each do |pin_desc|
+        name = pin_desc.getSignal(0).name  # e.g. "RA0"
+        pin_set.getPin name                # Trigger the lazy loading.
+      end
+
+      pins = (0...pin_set.getNumPins).collect do |i|
+        MplabPin.new pin_set.getPin(i)
+      end
+    end
+    
+    def check_peripherals
+      check_peripherals_in_data_store
+      check_peripheral_set
+    end
+
+    private
+
+    def data_store
+      @simulator.getDataStore
+    end
+    
+    def check_peripherals_in_data_store
+      if data_store.getNumPeriphs == 0
+        raise "MPLAB X failed to load any peripheral descriptions into the data store."
+      end
+    end
+
+    def check_peripheral_set
+      peripherals = data_store.getProcessor.getPeripheralSet
+      if peripherals.getNumPeripherals == 0
+        raise "MPLAB X failed to load any peripherals into the PeripheralSet."
+      end
+    end
+    
+    # This is commented out because MPLAB X v2.00 with the PIC18F25K50
+    # reports three missing peripherals:
+    #  PBADEN_PCFG
+    #  config
+    #  CONFIG3H.PBADEN
+    #
+    #def check_missing_peripherals
+    #  peripherals = data_store.getProcessor.getPeripheralSet
+    #  if peripherals.getMissingPeripherals.to_a.size > 0
+    #    raise "This device has missing peripherals: " + peripherals.getMissingReasons().to_a.inspect
+    #  end
+    #end
+    
+  end
+end

data/lib/rpicsim/pin.rb

@@ -0,0 +1,61 @@
+module RPicSim
+  # This class represents an external pin of the simulated device.
+  # It provides methods for reading the pin's output value and setting
+  # its input value.
+  class Pin
+    # Initializes a new Pin object to wrap the given MplabPin.
+    # @param mplab_pin [Mplab::MplabPin]
+    def initialize(mplab_pin)
+      raise ArgumentError, "mplab_pin is nil" if mplab_pin.nil?
+      @mplab_pin = mplab_pin
+    end
+
+    # Sets the external stimulus input voltage applied to the pin.
+    # The boolean values true and false correspond to high and low, respectively.
+    # Numeric values (e.g. Float or Integer) correspond to analog voltages.
+    def set(state)
+      case state
+      when false   then @mplab_pin.set_low
+      when true    then @mplab_pin.set_high
+      when Numeric then @mplab_pin.set_analog(state)
+      else raise ArgumentError, "Invalid pin state: #{state.inspect}."
+      end
+    end
+
+    # Returns true if the pin is currently configured to be an output.
+    def output?
+      @mplab_pin.output?
+    end
+    
+    # Returns true if the pin is currently configured to be an input.
+    def input?
+      !@mplab_pin.output?
+    end
+    
+    # Returns true if the pin is currently configured to be an output and
+    # it is driving high.
+    def driving_high?
+      output? && @mplab_pin.high?
+    end
+
+    # Returns true if the pin is currently configured to be an output and
+    # it is driving low.
+    def driving_low?
+      output? && !@mplab_pin.high?
+    end
+
+    # Returns an array of all the pin's names from the datasheet, like
+    # "RA4" or "TX".
+    def names
+      @mplab_pin.names
+    end
+    
+    def to_s
+      @mplab_pin.name
+    end    
+
+    def inspect
+      "#<%s %s>" % [self.class, to_s]
+    end
+  end
+end

data/lib/rpicsim/program_counter.rb

@@ -0,0 +1,19 @@
+module RPicSim
+
+  # Instances of this class represent the program counter in a
+  # simulated microcontroller.
+  class ProgramCounter
+    # @param processor [Mplab::Processor]
+    def initialize(processor)
+      @processor = processor
+    end
+    
+    def value
+      @processor.get_pc
+    end
+    
+    def value=(val)
+      @processor.set_pc(val)
+    end
+  end
+end

data/lib/rpicsim/program_file.rb

@@ -0,0 +1,160 @@
+require_relative 'mplab'
+require_relative 'label'
+require_relative 'instruction'
+
+module RPicSim
+  # Represents a PIC program file (e.g. COF or HEX).
+  class ProgramFile
+    attr_reader :filename
+    attr_reader :device
+  
+    # @param filename [String] The path to the program file.
+    # @param device [String] The name of the device the file is for (e.g. "PIC10F322").
+    def initialize(filename, device)
+      @filename = filename
+      @device = device
+      @mplab_program_file = Mplab::MplabProgramFile.new(filename, device)
+      
+      @assembly = Mplab::MplabAssembly.new(device)
+      @assembly.load_file(filename)
+      @address_increment = @assembly.device_info.code_address_increment
+      
+      @instructions = []
+    end
+    
+    # Returns a hash associating RAM variable names (as symbols) to their addresses.
+    # @return (Hash)
+    def var_addresses
+      @var_addresses ||= @mplab_program_file.symbols_in_ram
+    end
+    
+    # Returns a hash associating program memory label names (as symbols) to their addresses.
+    # @return (Hash)
+    def labels
+      @labels ||= begin
+        hash = {}
+        @mplab_program_file.symbols_in_code_space.each do |name, address|
+          hash[name] = Label.new(name, address)
+        end
+        hash
+      end
+    end
+
+    # Returns a {Label} object if a program label by that name is found.
+    # The name is specified in the code that defined the label.  If you are using a C compiler,
+    # you will probably need to prefix the name with an underscore.
+    # @return [Label]
+    def label(name)
+      name = name.to_sym
+      label = labels[name]
+      if !label
+        raise ArgumentError, message_for_label_not_found(name)
+      end
+      return label
+    end
+
+    # Generates a friendly human-readable string description of the given address in
+    # program memory.
+    # @param address [Integer] An address in program memory.
+    # @return [String]
+    def address_description(address)
+      desc = address < 0 ? address.to_s : ("0x%04x" % [address])
+      reference_points = labels.values.reject { |label| label.address > address }
+      label = reference_points.max_by &:address
+      
+      if label
+        offset = address - label.address
+        desc << " = " + label.name.to_s
+        desc << "+%#x" % [offset] if offset != 0
+      end
+      
+      return desc
+    end
+    
+    # Gets an {Instruction} object representing the PIC instruction at the given
+    # address in program memory.
+    # @param address [Integer]
+    # @return [Instruction]
+    def instruction(address)
+      @instructions[address] ||= make_instruction(address)
+    end
+    
+    private
+    def message_for_label_not_found(name)
+      message = "Cannot find label named '#{name}'."
+
+      maybe_intended_labels = labels.keys.select do |label_sym|
+        name.to_s.start_with?(label_sym.to_s)
+      end
+      if !maybe_intended_labels.empty?
+        message << "  MPASM truncates labels.  You might have meant: " +
+                   maybe_intended_labels.join(", ") + "."
+      end
+      message
+    end
+
+    def make_instruction(address)
+      mplab_instruction = @assembly.disassembler.disassemble(address)
+      
+      # Convert the increment, which is the number of bytes, into 'size',
+      # which is the same units as the flash address space.
+      if @address_increment == 1
+        # Non-PIC18 architectures: flash addresses are in terms of words
+        # so we devide by two to convert from bytes to words.
+        size = mplab_instruction.inc / 2
+      elsif @address_increment == 2
+        # PIC18 architecture: No change necessary because both are in terms
+        # of bytes.
+        size = mplab_instruction.inc
+      else
+        raise "Cannot handle address increment value of #{@address_increment}."
+      end
+
+      # TODO: add support for all other 8-bit PIC architectures
+      properties = Array case mplab_instruction.opcode
+      when 'ADDWF'
+      when 'ANDWF'
+      when 'CPFSEQ' then [:conditional_skip]
+      when 'CLRF'
+      when 'CLRW'
+      when 'COMF'
+      when 'DECF'
+      when 'DECFSZ' then [:conditional_skip]
+      when 'INCF'
+      when 'INCFSZ' then [:conditional_skip]
+      when 'IORWF'
+      when 'MOVWF'
+      when 'MOVF'
+      when 'NOP'
+      when 'RLF'
+      when 'RRF'
+      when 'SUBWF'
+      when 'SWAPF'
+      when 'XORWF'
+      when 'BCF'
+      when 'BSF'
+      when 'BTFSC'  then [:conditional_skip]
+      when 'BTFSS'  then [:conditional_skip]
+      when 'ADDLW'
+      when 'ANDLW'
+      when 'CALL'   then [:call]
+      when 'CLRWDT'
+      when 'GOTO'   then [:goto]
+      when 'IORLW'
+      when 'MOVLW'
+      when 'RETFIE' then [:return]
+      when 'RETLW'  then [:return]
+      when 'RETURN' then [:return]
+      when 'SLEEP'
+      when 'XORLW'
+      else
+        raise "Unrecognized opcode #{mplab_instruction.opcode} " +
+          "(#{address_description(address)}, operands #{mplab_instruction.operands.inspect})."
+      end
+      
+      Instruction.new(address, self, mplab_instruction.opcode,
+        mplab_instruction.operands, size, @address_increment,
+        mplab_instruction.instruction_string, properties)
+    end
+  end
+end

data/lib/rpicsim/register.rb

@@ -0,0 +1,78 @@
+module RPicSim
+  class Register
+    attr_reader :name
+    
+    # The size of the register in bytes.
+    attr_reader :size
+  
+    # @param mplab_register [Mplab::MplabRegister]
+    # @param memory An optional parameter that enables memory_value.
+    def initialize(mplab_register, memory, width)
+      @mplab_register = mplab_register
+      @name = mplab_register.name.to_sym
+      
+      @size = case width
+              when 8 then 1
+              when 16 then 2
+              when 24 then 3
+              when 32 then 4
+              else raise "Unsupported register width: #{name} is #{width}-bit."
+              end
+      
+      var_type = case size
+                 when 1 then VariableU8
+                 when 2 then VariableU16
+                 when 3 then VariableU24
+                 when 4 then VariableU32
+                 end
+      
+      @var = var_type.new(name, address).bind(memory)
+    end
+
+    # Sets the value of the register.
+    # @param val [Integer]
+    def value=(val)
+      @mplab_register.write val
+    end
+    
+    # Reads the value of the register.
+    # @return [Integer]
+    def value
+      @mplab_register.read
+    end
+    
+    # For some registers, like STATUS, you cannot read and write the full
+    # range of possible values using {#value=} because some bits are not
+    # writable by the CPU.
+    # This setter gets around that by writing directly to the memory object
+    # that backs the register.
+    def memory_value=(value)
+      @var.value = value
+    end
+    
+    # Reads the value directly from the memory object backing the register.
+    def memory_value
+      @var.value
+    end
+
+    # Gets the address of the register.
+    # @return [Integer]
+    def address
+      @mplab_register.address
+    end
+    
+    # Gets the range of addresses occupied.
+    # @return [Range] A range of integers.
+    def addresses
+      address...(address + size)
+    end
+    
+    def to_s
+      name.to_s
+    end
+    
+    def inspect
+      "<%s %s 0x%x>" % [self.class, name, address]
+    end
+  end
+end

data/lib/rpicsim/rspec.rb

@@ -0,0 +1,11 @@
+require 'rpicsim'
+require 'rspec'
+
+require_relative 'rspec/helpers'
+require_relative 'rspec/sim_diagnostics'
+require_relative 'rspec/be_predicate'
+
+RSpec.configure do |config|
+  config.add_setting :sim_shortcuts, default: :all
+  config.include RPicSim::RSpec::Helpers
+end

data/lib/rpicsim/rspec/be_predicate.rb

@@ -0,0 +1,12 @@
+# We override some parts of RSpec to provide better error messages.
+# Instead of 'expected driving_high? to return true, got false' RSpec will actually
+# tell us what object it called driving_high on.
+class RSpec::Matchers::BuiltIn::BePredicate
+  def failure_message_for_should
+    "expected #{actual.inspect}.#{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+  end
+
+  def failure_message_for_should_not
+    "expected #{actual.inspect}.#{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+  end
+end