rpicsim 0.1.0

data/lib/rpicsim/mplab/mplab_assembly.rb

@@ -0,0 +1,102 @@
+require_relative 'mplab_device_info'
+require_relative 'mplab_simulator'
+require_relative 'mplab_disassembler'
+
+module RPicSim::Mplab
+  class MplabAssembly
+    attr_reader :device
+  
+    def initialize(device)
+      @device = device
+      assembly_factory = Lookup.default.lookup(Mdbcore.assemblies.AssemblyFactory.java_class)
+      RPicSim::Mplab.mute_stdout do
+        @assembly = assembly_factory.create(device)
+      end
+    end
+    
+    # Connect the assembly to a simulator and debugger.
+    def start_simulator_and_debugger(filename)
+      # In MPLAB X v1.70, this line had to be before the call to SetTool, or else when we run
+      # debugger.Connect we will get two lines of: [Fatal Error] :1:1: Premature end of file.
+      simulator
+    
+      sim_meta = Mdbcore.platformtool.PlatformToolMetaManager.getTool("Simulator")
+      @assembly.SetTool(sim_meta.configuration_object_id, sim_meta.class_name, sim_meta.flavor, "")
+      if !sim_meta.getToolSupportForDevice(device).all? &:isSupported
+        raise "Microchip's simulator does not support " + device + "."
+      end
+      @assembly.SetHeader("")  # The Microchip documentation doesn't say what this is.
+      debugger.Connect(Mdbcore.debugger.Debugger::CONNECTION_TYPE::DEBUGGER)
+      
+      # Load our firmware into the simulator.
+      load_file(filename)
+      debugger.Program(Mdbcore.debugger.Debugger::PROGRAM_OPERATION::AUTO_SELECT)
+
+      check_for_errors
+      
+      nil
+    end
+
+    def load_file(filename)
+      loader.Load(filename)
+    end
+
+    def debugger_step
+      debugger.StepInstr
+    end
+
+    # Gets a com.microchip.mplab.mdbcore.simulator.Simulator object.
+    def simulator
+      @simulator ||= MplabSimulator.new lookup Mdbcore.simulator.Simulator.java_class
+    end
+
+    # Gets a com.microchip.mplab.mdbcore.disasm.Disasm object which we can
+    # use to disassemble the program binary.
+    def disassembler
+      @disassembler ||= MplabDisassembler.new lookup Mdbcore.disasm.DisAsm.java_class
+    end
+    
+    def device_info
+      @device_info ||= MplabDeviceInfo.new(@assembly.GetDevice)
+    end
+    
+    private
+    # Gets a com.microchip.mplab.mdbcore.debugger.Debugger object.
+    def debugger
+      lookup Mdbcore.debugger.Debugger.java_class
+    end
+    
+    def loader
+      lookup Mdbcore.loader.Loader.java_class
+    end
+
+    def lookup(klass)
+      @assembly.getLookup.lookup klass
+    end
+    
+    def check_for_errors
+      warn_about_5C
+      warn_about_path_retrieval
+      @simulator.check_peripherals
+    end
+
+    def warn_about_5C
+      # Detect a problem that once caused peripherals to load incorrectly.
+      # More info: http://stackoverflow.com/q/15794170/28128
+      f = DocumentLocator.java_class.resource("MPLABDocumentLocator.class").getFile()
+      if f.include?("%5C")
+        $stderr.puts "warning: A %5C character was detected in the MPLABDocumentLoator.class file location.  This might cause errors in the Microchip code."
+      end
+    end
+
+    def warn_about_path_retrieval
+      # See spec/mplab_x/path_retrieval_spec.rb for more info.
+      retrieval = com.microchip.mplab.open.util.pathretrieval.PathRetrieval
+      path = retrieval.getPath(DocumentLocator.java_class)
+      if !java.io.File.new(path).exists()
+        $stderr.puts "warning: MPLAB X will be looking for files at a bad path: #{path}"
+      end
+    end
+
+  end
+end

data/lib/rpicsim/mplab/mplab_device_info.rb

@@ -0,0 +1,40 @@
+require_relative 'mplab_sfr_info'
+require_relative 'mplab_nmmr_info'
+
+module RPicSim::Mplab
+  # DeviceInfo is a wrapper for the MPLAB xPIC class which gives us information
+  # about the target PIC device.
+  class MplabDeviceInfo
+    # Makes a new DeviceInfo object.
+    # @param xpic [com.microchip.mplab.crownkingx.xPIC]
+    def initialize(xpic)
+      @xpic = xpic
+    end
+  
+    def code_word_max_value
+      # Assumption: the initial value is the same as the maximum value
+      # because all bits start as 1.
+      @xpic.getMemTraits.getCodeWordTraits.getInitValue
+    end
+    
+    # The number that a flash address increases when you
+    # advance to the next word of flash.
+    # For PIC18s this is 2.
+    # For other architectures this is 1.
+    def code_address_increment
+      @xpic.getMemTraits.getCodeWordTraits.getAddrInc
+    end
+    
+    def sfrs
+      @sfrs ||= @xpic.getAddrOntoSFR.map do |addr, node|
+        MplabSfrInfo.new addr, com.microchip.crownking.edc.Register.new(node)
+      end
+    end
+    
+    def nmmrs
+      @xpic.getIDOntoCoreNMMR.map do |id, node|
+        MplabNmmrInfo.new id, com.microchip.crownking.edc.Register.new(node)
+      end
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_disassembler.rb

@@ -0,0 +1,23 @@
+require_relative 'mplab_instruction'
+
+module RPicSim::Mplab
+  class MplabDisassembler
+    # @param disasm [com.microchip.mplab.mdbcore.disasm.DisAsm]
+    def initialize(disasm)
+      @disasm = disasm
+    end
+    
+    def disassemble(address)
+      # To avoid showing a large, difficult to understand Java trace, we
+      # catch the InvalidInstructionException here.
+      begin
+        instr = @disasm.Disassemble(address, nil, nil)
+      rescue Java::ComMicrochipMplabMdbcoreDisasm::InvalidInstructionException => e
+        # TODO: actually this should not be an exception because it is expected;
+        # so probably you should return nil
+        raise "Invalid instruction at address 0x%x." % address
+      end
+      MplabInstruction.new instr
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_instruction.rb

@@ -0,0 +1,32 @@
+module RPicSim::Mplab
+  class MplabInstruction
+    # @param instruction [com.microchip.mplab.mdbcore.disasm.Instruction]
+    def initialize(instruction)
+      @instruction = instruction
+    end
+    
+    def opcode
+      @instruction.opcode
+    end
+    
+    def instruction_string
+      @instruction.instruction
+    end
+    
+    def operands
+      @operands ||= operands_hash(@instruction.operands)
+    end
+    
+    # The number of bytes that the instruction takes.
+    def inc
+      @instruction.inc
+    end
+    
+    private
+    def operands_hash(map)
+      # Convert from Map<String, Integer> to a Ruby hash.
+      # TODO: use symbols for keys instead of strings
+      map.to_hash
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_memory.rb

@@ -0,0 +1,33 @@
+require_relative 'mplab_observer'
+
+module RPicSim::Mplab
+  class MplabMemory
+    # @param memory Should implement the interface com.microchip.mplab.mdbcore.memory.Memory
+    def initialize(memory)
+      @memory = memory
+    end
+    
+    def write_word(address, value)
+      @memory.WriteWord(address, value)
+      value
+    end
+    
+    def read_word(address)
+      @memory.ReadWord(address)
+    end
+    
+    def is_valid_address?(address)
+      @memory.IsValidAddress(address)
+    end
+    
+    def on_change(&callback)
+      MplabObserver.new(@memory) do |event|
+        next if event.EventType != Mdbcore.memory::MemoryEvent::EVENTS::MEMORY_CHANGED
+        address_ranges = event.AffectedAddresses.map do |mr|
+          mr.Address...(mr.Address+mr.Size)
+        end
+        yield address_ranges
+      end
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_nmmr_info.rb

@@ -0,0 +1,21 @@
+module RPicSim::Mplab
+  class MplabNmmrInfo
+    attr_reader :id
+  
+    # @param id The id of the register.  This is like an address.
+    # @param register [com.microchip.crownking.edc.Register]
+    def initialize(id, register)
+      @id = id
+      @register = register
+    end
+    
+    # Returns how many bits the register has.
+    def width
+      @register.width
+    end
+    
+    def name
+      @register.name
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_observer.rb

@@ -0,0 +1,12 @@
+class MplabObserver
+  include Java::comMicrochipMplabUtilObservers::Observer
+
+  def initialize(subject, &callback)
+    @callback = callback
+    subject.Attach(self, nil)
+  end
+  
+  def Update(event)
+    @callback.call(event)
+  end
+end

data/lib/rpicsim/mplab/mplab_pin.rb

@@ -0,0 +1,61 @@
+module RPicSim::Mplab
+  class MplabPin
+    # Initializes a new Pin object to wrap the given PinPhysical.
+    # @param pin_physical [com.microchip.mplab.mdbcore.simulator.PinPhysical]
+    def initialize(pin_physical)
+      raise ArgumentError, "pin_physical is nil" if pin_physical.nil?
+      @pin_physical = pin_physical
+    end
+
+    def set_low
+      @pin_physical.externalSet PinState::LOW
+    end
+
+    def set_high
+      @pin_physical.externalSet PinState::HIGH
+    end
+
+    def set_analog(value)
+      @pin_physical.externalSetAnalogValue value
+    end
+
+    # Returns true if the pin is currently configured to be an output,
+    # or false if it is configured as an input.  Raises an exception
+    # if MPLAB X claims the state is neither, which we think is
+    # impossible.
+    def output?
+      io_state = @pin_physical.getIOState
+      case io_state
+      when IoState::OUTPUT then true
+      when IoState::INPUT  then false
+      else
+        raise "Invalid IO state: #{io_state}"
+      end
+    end
+
+    # Returns true if the pin is currently in a "high" state, or false
+    # if it is in a "low" state.  Raises an exception if MPLAB X
+    # claims the state is neither, which we think is impossible.
+    def high?
+      pin_state = @pin_physical.get
+      case pin_state
+      when PinState::HIGH then true
+      when PinState::LOW  then false
+      else
+        raise "Invalid pin state: #{pin_state}"
+      end
+    end
+
+    def names
+      @pin_physical.collect(&:name)
+    end
+
+    def name
+      @pin_physical.pinName
+    end    
+
+    PinState = Mdbcore.simulator.Pin::PinState   # HIGH or LOW
+    IoState = Mdbcore.simulator.Pin::IOState     # INPUT or OUTPUT
+    private_constant :PinState, :IoState
+  end
+end

data/lib/rpicsim/mplab/mplab_processor.rb

@@ -0,0 +1,30 @@
+require_relative 'mplab_register'
+
+module RPicSim::Mplab
+  class MplabProcessor
+    # @param processor [com.microchip.mplab.mdbcore.simulator.Processor]
+    def initialize(processor)
+      @processor = processor
+    end
+    
+    def get_pc
+      @processor.getPC
+    end
+    
+    def set_pc(value)
+      @processor.setPC(value)
+    end
+    
+    def get_sfr(name)
+      reg = @processor.getSFRSet.getSFR(name)
+      raise "Cannot find SFR named '#{name}'." if !reg
+      MplabRegister.new(reg)
+    end
+    
+    def get_nmmr(name)
+      reg = @processor.getNMMRSet.getNMMR(name)
+      raise "Cannot find NMMR named '#{name}'." if !reg
+      MplabRegister.new(reg)
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_program_file.rb

@@ -0,0 +1,35 @@
+module RPicSim::Mplab
+  # This class creates and wraps a com.microchip.mplab.mdbcore.program.interfaces.IProgramFile
+  class MplabProgramFile
+    def initialize(filename, device)
+      raise "File does not exist: #{filename}" if !File.exist?(filename)  # Avoid a Java exception.
+      
+      if !File.realdirpath(filename).split("/").include?("dist")
+        raise "The file must be inside a directory named dist or else the MCLoader " +
+              "class will throw an exception saying that it cannot find the COF file."
+      end
+      
+      factory = Lookup.getDefault.lookup(Mdbcore.program.spi.IProgramFileProviderFactory.java_class)      
+      @program_file = factory.getProvider(filename, device)
+      @program_file.Load
+    end
+    
+    def symbols_in_code_space
+      @symbols_in_code_space ||= Hash[
+        symbols.select { |s| s.m_lType != 0 }.map { |s| [s.m_Symbol.to_sym, s.address] }
+      ]
+    end
+    
+    def symbols_in_ram
+      @symbols_in_ram ||= Hash[
+        symbols.select { |s| s.m_lType == 0 }.map { |s| [s.m_Symbol.to_sym, s.address] }
+      ]
+    end
+    
+    private
+    
+    def symbols
+      @program_file.getSymbolTable.getSymbols(0, 0)
+    end
+  end 
+end

data/lib/rpicsim/mplab/mplab_register.rb

@@ -0,0 +1,25 @@
+module RPicSim::Mplab
+  class MplabRegister
+    # @param register [com.microchip.mplab.mdbcore.simulator.Register]
+    def initialize(register)
+      @register = register
+    end
+    
+    def write(value)
+      @register.write(value)
+      value
+    end
+    
+    def read
+      @register.read
+    end
+    
+    def name
+      @register.getName
+    end
+    
+    def address
+      @register.getAddress
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_sfr_info.rb

@@ -0,0 +1,21 @@
+module RPicSim::Mplab
+  class MplabSfrInfo
+    attr_reader :address
+  
+    # @param address The address of the register.
+    # @param register [com.microchip.crownking.edc.Register]
+    def initialize(address, register)
+      @address = address
+      @register = register
+    end
+    
+    # Returns how many bits the register has.
+    def width
+      @register.width
+    end
+    
+    def name
+      @register.name
+    end
+  end
+end