freerun.cpp

通过VC源代码

// freerun: The routines associated with freerun management

#include "stdafx.h"
#include "Simulator.h"
#include <sys\timeb.h>
#include "TraceWnd.h"
#include "Regvars.h"
#include "NumericEdit.h"
  #include "InterruptMgt.h"
#include "SpinnerButton.h"
#include "register.h"
#include "RegData.h"
  #include "RegDisplay.h"
    #include "SimulatorDlg.h"
#include "buzzword.h"
#include "uwm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define TIMER_SET_DONE_IN  1
#define TIMER_SET_DONE_OUT 2


/****************************************************************************
*                          CSimulatorDlg::OnFreerun
* Result: void
*       
* Effect: 
*       Releases the automatic polling thread to do its thing
****************************************************************************/

void CSimulatorDlg::OnFreerun() 
{
 	if(!manual)
	   return; // already freerunning

 	TraceItem * item = new TraceItem(TRACE_TYPE_ANNOTATION, TRUE,
					_T("Free Run Mode"));
        c_Trace.AddString(item);


	manual = FALSE;
	singleStep = FALSE;

	OpenRegisterTransaction("OnFreeRun");
	updateControls(); 
	CloseRegisterTransaction("OnFreeRun");

 	::SetEvent(freerun);
}

/****************************************************************************
*                          CSimulatorDlg::OnIEInSet
* Inputs:
*       WPARAM: ignored
*	LPARAM: ignored
* Result: LRESULT
*       0, always
* Effect: 
*       Handles user setting IE bit
****************************************************************************/

LRESULT CSimulatorDlg::OnIEInSet(WPARAM, LPARAM)
    {
     return 0;
    }

/****************************************************************************
*                          CSimulatorDlg::OnIEOutSet
* Inputs:
*       WPARAM: ignored
*	LPARAM: ignored
* Result: LRESULT
*       0, always
* Effect: 
*       Handles user setting IE bit
****************************************************************************/

LRESULT CSimulatorDlg::OnIEOutSet(WPARAM, LPARAM)
    {
     return 0;
    }

/****************************************************************************
*                         CSimulatorDlg::OnRstOutSet
* Inputs:
*       WPARAM: ignored
*	LAPRAM: ignored
* Result: LRESULT
*       Logically void, 0, always
* Effect: 
*       Clears the RST out flag
****************************************************************************/

LRESULT CSimulatorDlg::OnRstOutSet(WPARAM, LPARAM)
    {
     ASSERT(!manual);
     BYTE status = registers.get(REGISTER_OUT_STATUS);
     BYTE newstatus = status;
     newstatus &= ~(REGISTER_OUT_STATUS_ERR | REGISTER_OUT_STATUS_UND); // clear ERR and OVR
     registers.set(REGISTER_OUT_STATUS, newstatus);
     OutStatusToControls(newstatus);
     TraceItem * item = new TraceItem(TRACE_TYPE_RST_OUT, TRUE, _T(""));
     c_Trace.AddString(item);

     // If we cleared the ERR bit, record this
     if(status & REGISTER_OUT_STATUS_ERR)
	{ /* cleared err */
	 item = new TraceItem(TRACE_TYPE_ERR_OUT, FALSE);
	 c_Trace.AddString(item);
	} /* cleared err */
     if(status & REGISTER_OUT_STATUS_UND)
	{ /* cleared UND */
	 item = new TraceItem(TRACE_TYPE_UND_OUT, FALSE);
	 c_Trace.AddString(item);
	} /* cleared UND */

     // Now clear the RST bit
     BYTE command = registers.get(REGISTER_IN_COMMAND);
     command &= ~REGISTER_IN_COMMAND_RST; // clear RST
     registers.set(REGISTER_IN_COMMAND, command);

     item = new TraceItem(TRACE_TYPE_RST_IN, FALSE, _T("Auto-reset"));
     c_Trace.AddString(item);

     InCommandToControls(command);
     return 0;
    } // CSimulatorDlg::OnRstOutSet

/****************************************************************************
*                           CSimulatorDlg::OnGoOutSet
* Inputs:
*       WPARAM: ignored
*	LPARAM: ignored
* Result: LRESULT
*       0, always
* Effect: 
*       Handles the recognition that the "Go" bit has been set.
*		- Clears the GO bit
*		- Sets up a delay
*		- At the end of the delay will cause the Done bit to be set
* Notes:
*	This only occurs within a register transaction
****************************************************************************/

LRESULT CSimulatorDlg::OnGoOutSet(WPARAM, LPARAM)
    {
     BYTE command = registers.get(REGISTER_OUT_COMMAND);
     BYTE newcommand = command & ~REGISTER_OUT_COMMAND_GO;

     c_GoOut.SetCheck(BST_UNCHECKED);
     TraceItem * item = new TraceItem(TRACE_TYPE_GO_OUT, FALSE);
     c_Trace.AddString(item);

     registers.set(REGISTER_OUT_COMMAND, newcommand);
     OutCommandToControls(newcommand);

     BYTE status = registers.get(REGISTER_OUT_STATUS);
     BYTE newstatus = status | REGISTER_OUT_STATUS_BUSY;

     // This handles the simulator restrictions and triggers an INT on
     // GO being cleared
     if(command & REGISTER_OUT_COMMAND_IE)
        { /* interrupt */
	 newstatus |= REGISTER_OUT_STATUS_INT;
	 generateAndLogInterrupt(_T("by GO OUT bit cleared"));
	} /* interrupt */

     registers.set(REGISTER_OUT_STATUS, newstatus);

     logStatusChangeOut(status, newstatus);
     OutStatusToControls(newstatus);
     
     // Set up a timer to clear the Busy bit and set the Done bit 

     if(debug)
        { /* debug */
	 TraceItem * e = new TraceItem(TRACE_TYPE_COMMENT, _T("Requesting Timer Out"));
	 c_Trace.AddString(e);
	} /* debug */

     PostMessage(UWM_SET_TIMER_OUT);

     updateControls();
     return 0;
    }

/****************************************************************************
*                          CSimulatorDlg::OnRstInSet
* Inputs:
*       WPARAM: ignored
*	LPARAM: ignored
* Result: LRESULT
*       Logically void, 0, always
* Effect: 
*       Handles the change in the RST bit
****************************************************************************/

LPARAM CSimulatorDlg::OnRstInSet(WPARAM, LPARAM)
    {
     ASSERT(!manual);
     BYTE status = registers.get(REGISTER_IN_STATUS);
     BYTE newstatus = status;
     newstatus &= ~(REGISTER_IN_STATUS_ERR | REGISTER_IN_STATUS_OVR); // clear ERR and UND
     registers.set(REGISTER_IN_STATUS, newstatus);
     InStatusToControls(newstatus);
     TraceItem * item = new TraceItem(TRACE_TYPE_RST_IN, TRUE, _T(""));
     c_Trace.AddString(item);
     
     // If we cleared the ERR bit, record this
     if(status & REGISTER_IN_STATUS_ERR)
	{ /* cleared err */
	 item = new TraceItem(TRACE_TYPE_ERR_IN, FALSE);
	 c_Trace.AddString(item);
	} /* cleared err */
     if(status & REGISTER_IN_STATUS_OVR)
	{ /* cleared UND */
	 item = new TraceItem(TRACE_TYPE_OVR_IN, FALSE);
	 c_Trace.AddString(item);
	} /* cleared UND */

     // Now clear the RST bit
     BYTE command = registers.get(REGISTER_IN_COMMAND);
     command &= ~REGISTER_IN_COMMAND_RST; // clear RST
     registers.set(REGISTER_IN_COMMAND, command);

     item = new TraceItem(TRACE_TYPE_RST_IN, FALSE, _T("Auto-reset"));
     c_Trace.AddString(item);

     InCommandToControls(command);
     return 0;
    } // CSimulatorDlg::OnRstInSet

/****************************************************************************
*                           CSimulatorDlg::OnGoInSet
* Inputs:
*       WPARAM: ignored
*	LPARAM: ignored
* Result: LRESULT
*       0, always
* Effect: 
*       Handles the recognition that the "Go" bit has been set by the remote
*	driver
*		- Clears the GO bit
*		- Sets up a delay
*		- At the end of the delay will cause the Done bit to be set
* Notes:
*	This is only called in freerunning mode, from within a register
*	transaction
****************************************************************************/

LRESULT CSimulatorDlg::OnGoInSet(WPARAM, LPARAM)
    {
     // Clear the GO bit
     BYTE command = registers.get(REGISTER_IN_COMMAND);
     command &= ~REGISTER_IN_COMMAND_GO;
     registers.set(REGISTER_IN_COMMAND, command); // clear GO bit

     c_GoIn.SetCheck(BST_UNCHECKED);
     TraceItem * item = new TraceItem(TRACE_TYPE_GO_IN, FALSE);

     c_Trace.AddString(item);

     // Clear all status bits

     BYTE status = registers.get(REGISTER_IN_STATUS);
     BYTE newstatus = 0;

     // This handles the simulator restrictions and triggers an INT on
     // GO being cleared
     if(command & REGISTER_IN_COMMAND_IE)
        { /* interrupt */
	 newstatus |= REGISTER_IN_STATUS_INT;
	 generateAndLogInterrupt(_T("by GO IN bit cleared"));
	} /* interrupt */

     registers.set(REGISTER_IN_STATUS, newstatus);

     InStatusToControls(newstatus);
     logStatusChangeIn(status, newstatus);

     // Set up a timer 
     if(debug)
        { /* debug */
	 TraceItem * e = new TraceItem(TRACE_TYPE_COMMENT, _T("Requesting Timer In"));
	 c_Trace.AddString(e);
	} /* debug */

     PostMessage(UWM_SET_TIMER_IN);

     updateControls();
     return 0;
    }

/****************************************************************************
*                           CSimulatorDlg::OnGoHackIn
* Result: void
*       
* Effect: 
*       This allows us to test the GO-bit logic even when there isn't another
*	driver loaded.  That's why the "hack" in the name!
****************************************************************************/

void CSimulatorDlg::OnGoHackIn() 
{
 ASSERT(!manual);
 if(!c_GoHackIn.getMode())
    return;

 c_GoHackIn.setMode(FALSE);  // no longer accepting input
 PostMessage(UWM_GO_HACK_IN);
}


LRESULT CSimulatorDlg::OnExecuteGoHackIn(WPARAM, LPARAM)
{	    
 if(manual)
    return 0; // handles race condition
 OpenRegisterTransaction(_T("Execute Go Hack In"));
 BYTE command = registers.get(REGISTER_IN_COMMAND);

 if( (command & REGISTER_IN_COMMAND_GO) == 0)
    { /* set go */
     command |= REGISTER_IN_COMMAND_GO;
     registers.set(REGISTER_IN_COMMAND, command);

     // Note that we don't actually send this to the controls...
     // (that seems a reasonable misfeature given the "hack" nature)
     TraceItem * item = new TraceItem(TRACE_TYPE_GO_IN, TRUE, _T("Hack"));
     c_Trace.AddString(item);
    } /* set go */
 
 CloseRegisterTransaction(_T("Register Go Hack In"));
 return 0;
}

/****************************************************************************
*                           CSimulatorDlg::OnGoHackOut
* Result: void
*       
* Effect: 
*       This allows us to test the GO-bit logic even when there isn't another
*	driver loaded.  That's why the "hack" in the name!
****************************************************************************/

void CSimulatorDlg::OnGoHackOut() 
{
 ASSERT(!manual);
 if(!c_GoHackOut.getMode())
    return;

 c_GoHackOut.setMode(FALSE);  // no longer accepting input
 PostMessage(UWM_GO_HACK_OUT);
}

LRESULT CSimulatorDlg::OnExecuteGoHackOut(WPARAM, LPARAM)
{	    
 if(manual)
    return 0; // handles race condition

 OpenRegisterTransaction(_T("Register Go Hack Out"));

 BYTE command = registers.get(REGISTER_OUT_COMMAND);
 if( (command & REGISTER_OUT_COMMAND_GO) == 0)
    { /* set go */
     command |= REGISTER_OUT_COMMAND_GO;

     if(output.GetLength() == 0)
	buzzphrase(output);
     BYTE ch = (BYTE) *(LPCTSTR)output;
     output = output.Mid(1);

     registers.set(REGISTER_OUT_DATA, ch);

     registers.set(REGISTER_OUT_COMMAND, command);
     // Note that we don't actually send this to the controls...
     // (that seems a reasonable misfeature given the "hack" nature)
     TraceItem * item = new TraceItem(TRACE_TYPE_GO_OUT, TRUE, _T("Hack"));
     c_Trace.AddString(item);