public void Init(IARMHost iHost)
{
mHost = iHost;
//set the load handler so we get called when all the plugins are loaded
mHost.Load += onLoad;
}
/// <summary>
/// Construct a timer control.
/// </summary>
/// <param name="host"></param>
/// <param name="buttonTimerDisplay"></param>
public TimerControl(IARMHost host, ButtonTimerDisplay buttonTimerDisplay)
{
//cache the simulator host interface and the timers user interface
mHost = host;
mButtonTimerDisplay = buttonTimerDisplay;
//subscribe to the Start and Stop events so we can track when the simulation is running
mHost.StartSimulation += mHost_Start;
mHost.StopSimulation += mHost_Stop;
//Create the 2 timers and set their notification events
mTimerBlocks[0] = new TimerBlock();
mTimerBlocks[1] = new TimerBlock();
mTimerBlocks[0].TimerNotify += TimerNotify;
mTimerBlocks[1].TimerNotify += TimerNotify;
//request to be notified when our area of the memory map is written or read
mHost.RequestMemoryBlock(0x01d30000, 0xffffff00, onMemoryAccessRead, onMemoryAccessWrite);
//request to be notified when cycles are expended so we can update the timers
mHost.Cycles += mHost_Cycles;
//request simulator restart notification so we can reset the timers to their default state
mHost.Restart += mHost_Restart;
//force timers into default state.
init();
}
/// <summary>
/// Load a string from memory. Read bytes from memory until a 0 is found.
/// </summary>
/// <param name="ihost">Simulator reference</param>
/// <param name="address">Address to load from</param>
/// <param name="maxSize">max number of bytes to load</param>
/// <returns>string read from memory</returns>
public static string loadStringFromMemory(IARMHost ihost, uint address, uint maxSize)
{
StringBuilder str = new StringBuilder();
uint bytesLeft = maxSize;
try
{
uint data;
do
{
data = ihost.GetMemory(address++, MemorySize.Byte);
if (data == 0)
{
break;
}
str.Append((char)data);
} while (--bytesLeft > 0);
}//try
catch (Exception ex)
{
ARMPluginInterfaces.Utils.OutputDebugString("Error while reading string from memory:" + ex.Message);
str.Length = 0;
} //catch
return(str.ToString());
} //loadStringFromMemory
/// <summary>
/// The Init method of the plugin. This method is called when the plugin has been created by ARMSim.
/// ARMSim will pass an instance of IARMHost to the plugin so that the plugin can make requests back to ARMSim.
/// </summary>
/// <param name="ihost"></param>
public void Init(IARMHost ihost)
{
//cache the interface to ARMSim
mHost = ihost;
//set the load handler so we get called when all the plugins are loaded
mHost.Load += onLoad;
}//Init
/// <summary>
/// The init function is called once the plugin has been loaded.
/// From this function you can subscribe to the events the
/// simulator supports.
/// </summary>
/// <param name="IHost"></param>
public void Init(IARMHost ihost)
{
//cache a copy of the host reference so we can communicate back to ARMSim
mIHost = ihost;
//and subscribe to the Load event so we will be notified once all the plugins have been created
mIHost.Load += onLoad;
}//init
/// <summary>
/// Called when plugin is first created. Host passes in interface here
/// </summary>
/// <param name="ihost"></param>
public void Init(IARMHost ihost)
{
//save the reference to the simulator
mIhost = ihost;
//subscribe to the Load event
mIhost.Load += onLoad;
}//Init
public LcdDisplay(IARMHost ihost, ARMSim.Plugins.UIControls.Lcd lcd)
{
mIhost = ihost;
mLcd = lcd;
mIhost.RequestMemoryBlock(0x0c300000, 0xffff0000, onMemoryAccessRead, onMemoryAccessWrite);
this.Restart();
}
public Leds(IARMHost ihost, IOPorts ioPorts, ARMSim.Plugins.UIControls.Leds ledsControl)
{
mIhost = ihost;
mIOPorts = ioPorts;
mLedsControl = ledsControl;
mIOPorts.RequestPortNotify(IOPorts.PortNumbers.PDATB, ioPortNotify);
this.Restart();
}
public EightSegmentDisplay(IARMHost ihost, ARMSim.Plugins.UIControls.EightSegmentDisplay eightSegmentDisplay)
{
mIHost = ihost;
mEightSegmentDisplay = eightSegmentDisplay;
//request reads/writes to the memory address of the display
mIHost.RequestMemoryBlock(0x02140000, 0xffffffff, this.onMemoryAccessRead, this.onMemoryAccessWrite);
this.Restart();
}
public InteruptController(IARMHost ihost, InterruptControllerDisplay interruptControllerDisplay)
{
mIhost = ihost;
mInterruptControllerDisplay = interruptControllerDisplay;
//request to be notified when our area of the memory map is written or read
mIhost.RequestMemoryBlock(0x01e00000, 0xffffffc0, onMemoryAccessRead, onMemoryAccessWrite);
this.Restart();
}
/// <summary>
/// Called when plugin is first created. Host passes in interface here
/// </summary>
/// <param name="ihost"></param>
public void Init(IARMHost iHost)
{
//save the reference to the simulator
mIhost = iHost;
//subscribe to the Load event
mIhost.Load += onLoad;
timer = System.Diagnostics.Stopwatch.StartNew(); // start the timer
}//init
public WatchDogTimer(IARMHost ihost, InteruptController interuptController)
{
mIhost = ihost;
_interuptController = interuptController;
//request to be notified when our area of the memory map is written or read
mIhost.RequestMemoryBlock(0x01d30000, 0xfffffff0, onMemoryAccessRead, onMemoryAccessWrite);
mIhost.Cycles += onClock;
this.Restart();
}
public BlueButtons(IARMHost ihost, IOPorts ioPorts, InteruptController interuptController, ARMSim.Plugins.UIControls.BlueButtons blueButtons)
{
mIhost = ihost;
mIOPorts = ioPorts;
mInteruptController = interuptController;
mBlueButtons = blueButtons;
mBlueButtons.Notify += ButtonPressPortNotify;
//request to be notified when our area of the memory map is written or read
mIhost.RequestMemoryBlock(keyboard_base, 0xffffff00, onMemoryAccessRead, onMemoryAccessWrite);
}
public Uarts(IARMHost ihost, InteruptController interuptController)
{
mIhost = ihost;
mInteruptController = interuptController;
mIhost.RequestMemoryBlock(mLowerAddress, 0xffff0000, onMemoryAccessRead, onMemoryAccessWrite);
mUart0.Create("COM1");
mUart1.Create("COM2");
this.Restart();
}
/// <summary>
/// Control ctor.
/// </summary>
/// <param name="host"></param>
/// <param name="BlackButtonsDisplay"></param>
public BlackButtonsControl(IARMHost host, BlackButtonsDisplay blackButtonsDisplay)
{
mHost = host;
mBlackButtonsDisplay = blackButtonsDisplay;
mBlackButtonsDisplay.Notify += BlackButtonPressNotify;
//request to be notified when our area of the memory map is written or read
mHost.RequestMemoryBlock(mBaseAddress, 0xffffffff, onMemoryAccessRead, onMemoryAccessWrite);
//get notified when the simulation is restarted so we can put buttons back to its initial state
mHost.Restart += mHost_Restart;
//and make sure display is init
init();
}
/// <summary>
/// Control ctor
/// </summary>
/// <param name="host"></param>
/// <param name="ledsDisplay"></param>
public LedsControl(IARMHost host, LedsDisplay ledsDisplay)
{
//cache the simulator host interface and the LEDs user interface
mHost = host;
mLedsDisplay = ledsDisplay;
//request to be notified when our area of the memory map is written or read
mHost.RequestMemoryBlock(0x01d20000, 0xffffffff, onMemoryAccessRead, onMemoryAccessWrite);
//request simulator restart notification so we can reset the LEDs to their default state
mHost.Restart += mHost_Restart;
//init LEDs to default state
init();
}
/// <summary>
/// Control ctor
/// </summary>
/// <param name="host"></param>
/// <param name="eightSegmentDisplay"></param>
public EightSegmentControl(IARMHost host, EightSegmentDisplay eightSegmentDisplay)
{
//cache the simulator host interface and the LEDs user interface
mHost = host;
mEightSegmentDisplay = eightSegmentDisplay;
//request to be notified when our area of the memory map is written or read
mHost.RequestMemoryBlock(0x01d10000, 0xffffffff, onMemoryAccessRead, onMemoryAccessWrite);
//request simulator restart notification so we can reset the 8 segment display to its default state
mHost.Restart += mHost_Restart;
//Force 8 segment display to a default state.
init();
}
/// <summary>
/// Control ctor.
/// </summary>
/// <param name="host"></param>
/// <param name="twoLineLCDDisplay"></param>
public TwoLineLCDControl(IARMHost host, TwoLineLCDDisplay twoLineLCDDisplay)
{
mHost = host;
mTwoLineLCDDisplay = twoLineLCDDisplay;
//request to be notified when our area of the memory map is written or read
//0x02f00000:Data Register
//0x02f00004:Command Register
mHost.RequestMemoryBlock(mBaseAddress, 0xfffffff0, onMemoryAccessRead, onMemoryAccessWrite);
//get notified when the simulation is restarted so we can put display back to its initial state
mHost.Restart += mHost_Restart;
//and make sure display is init
init();
}//TwoLineLCDControl
public TrackBarControl(IARMHost host, TrackBar trackBar, Label trackBarLabel)
{
mHost = host;
mTrackBar = trackBar;
mTrackBarLabel = trackBarLabel;
//request to be notified when our area of the memory map is read. We don't care about writes so use null.
mHost.RequestMemoryBlock(mBaseAddress, 0xffffffff, onMemoryAccessRead, null);
//get notified when the simulation is restarted so we can put buttons back to its initial state
mHost.Restart += mHost_Restart;
//set notification for scroll events on trackbar
mTrackBar.Scroll += new System.EventHandler(this.trackBar1_Scroll);
//and make sure display is init
init();
}
public IOPorts(IARMHost ihost)
{
mIhost = ihost;
//request to be notified when our area of the memory map is written or read
mIhost.RequestMemoryBlock(mLowerAddress, 0xffffff80, onMemoryAccessRead, onMemoryAccessWrite);
mPortDefinitions[0] = new PortDefinition(PortNumbers.PCONA, 10);
mPortDefinitions[1] = new PortDefinition(PortNumbers.PDATA, 10);
mPortDefinitions[2] = new PortDefinition(PortNumbers.PCONB, 11);
mPortDefinitions[3] = new PortDefinition(PortNumbers.PDATB, 11);
mPortDefinitions[4] = new PortDefinition(PortNumbers.PCONC, 32);
mPortDefinitions[5] = new PortDefinition(PortNumbers.PDATC, 16);
mPortDefinitions[6] = new PortDefinition(PortNumbers.PUPC, 16);
mPortDefinitions[7] = new PortDefinition(PortNumbers.PCOND, 16);
mPortDefinitions[8] = new PortDefinition(PortNumbers.PDATD, 8);
mPortDefinitions[9] = new PortDefinition(PortNumbers.PUPD, 8);
mPortDefinitions[10] = new PortDefinition(PortNumbers.PCONE, 18);
mPortDefinitions[11] = new PortDefinition(PortNumbers.PDATE, 9);
mPortDefinitions[12] = new PortDefinition(PortNumbers.PUPE, 8);
mPortDefinitions[13] = new PortDefinition(PortNumbers.PCONF, 22);
mPortDefinitions[14] = new PortDefinition(PortNumbers.PDATF, 9);
mPortDefinitions[15] = new PortDefinition(PortNumbers.PUPF, 9);
mPortDefinitions[16] = new PortDefinition(PortNumbers.PCONG, 16);
mPortDefinitions[17] = new PortDefinition(PortNumbers.PDATG, 8);
mPortDefinitions[18] = new PortDefinition(PortNumbers.PUPG, 8);
mPortDefinitions[19] = new PortDefinition(PortNumbers.SPUCR, 3);
mPortDefinitions[20] = new PortDefinition(PortNumbers.EXTINT, 31);
mPortDefinitions[21] = new PortDefinition(PortNumbers.EXTPND, 4, true);
this.Restart();
}//ctor
/// <summary>
/// The init function is called once the plugin has been loaded.
/// From this function you can subscribe to the events the
/// simulator supports.
/// </summary>
/// <param name="iHost"></param>
public void Init(IARMHost iHost)
{
mIHost = iHost;
mIHost.Load += onLoad;
}//init
public ZeroPage(IARMHost ihost)
{
mIhost = ihost;
}
/// <summary>
/// ARMSimConsoleStream ctor
/// </summary>
/// <param name="handle">handle of this console</param>
/// <param name="ihost">a reference back to the simulator</param>
public ARMSimConsoleStream(uint handle, IARMHost ihost)
{
_handle = handle;
_ihost = ihost;
}
/// <summary>
/// The init function is called once the plugin has been loaded.
/// From this function you can subscribe to the events the
/// simulator supports.
/// </summary>
/// <param name="IHost"></param>
public void Init(IARMHost IHost)
{
mIHost = IHost;
mIHost.Load += onLoad;
mIHost.Restart += onRestart;
}//init