void wxGridCellPathEditor::Reset()
{
wxASSERT_MSG(m_control,
wxT("The wxGridCellEditor must be Created first!"));
DoReset(m_startValue);
}
int main(int argc, char **argv)
{
int g,rep, i;
// Set up gpi pointer for direct register access
wiringPiSetupGpio ();
setup_io();
for (i = 0; i < 28; i++)
{
INP_GPIO(i);
printf("%d", GET_GPIO(i));
}
printf("\n");
//exit(0);
OUT_GPIO(INT); GPIO_SET(INT);
OUT_GPIO(NMI); GPIO_SET(NMI);
OUT_GPIO(CLK); GPIO_SET(CLK);
OUT_GPIO(WAIT); GPIO_SET(WAIT);
OUT_GPIO(BUSRQ); GPIO_SET(BUSRQ);
OUT_GPIO(RESET); GPIO_SET(RESET);
OUT_GPIO(SI); GPIO_SET(SI);
OUT_GPIO(CP); GPIO_SET(CP);
OUT_GPIO(CS_16); GPIO_SET(CS_16);
OUT_GPIO(M);
ResetSimulationVars();
WriteControlPins();
DoReset();
while(1)
loop();
}
/**
* Reset and re build any pointers
*/
void Project::Reset() {
if (addressable_ != nullptr) {
original_value_ = *addressable_;
}
if(model_->projection_final_phase())
DoReset();
}
void Linear::DoBuild() {
string error = "";
target_object_ = model_->objects().FindObject(parameter_, error);
Estimable::Type estimable_type = model_->objects().GetEstimableType(parameter_, error);
if( estimable_type != Estimable::kSingle)
LOG_ERROR_P(PARAM_TYPE) << "@time_varying blocks of type " << PARAM_LINEAR << " can only be implemented in parameters that are scalars or single values";
DoReset();
}
void MCPrinter::SetDeviceSettings(const MCString& p_settings)
{
if (p_settings . getlength() == 0)
DoReset(NULL);
else if (!DoResetSettings(p_settings))
{
MCresult -> sets("unknown printer");
return;
}
}
void wxGridCellNumberEditor::Reset()
{
#if wxUSE_SPINCTRL
if ( HasRange() )
{
Spin()->SetValue((int)m_value);
}
else
#endif
{
DoReset(GetString());
}
}
void CPUThread::Reset()
{
CloseStack();
SetPc(0);
cycle = 0;
m_is_branch = false;
m_status = Stopped;
m_error = 0;
DoReset();
}
void PPCThread::Reset()
{
CloseStack();
SetPc(0);
cycle = 0;
isBranch = false;
m_status = Stopped;
m_error = 0;
DoReset();
}
void CPUThread::Reset()
{
CloseStack();
m_sync_wait = 0;
m_wait_thread_id = -1;
SetPc(0);
cycle = 0;
m_is_branch = false;
m_status = Stopped;
m_error = 0;
DoReset();
}
void View::SetDoc(Doc *doc)
{
// Unset the doc
if (doc == NULL) {
m_doc = NULL;
DoReset();
}
else {
m_doc = doc;
}
m_currentElement = NULL;
m_currentLayer = NULL;
m_currentMeasure = NULL;
m_currentStaff = NULL;
m_currentSystem = NULL;
m_currentPage = NULL;
m_pageIdx = 0;
}
void FlightPathMovementGenerator::DoInitialize(Player &player)
{
DoReset(player);
InitEndGridInfo();
}
/**
* Reset the age length class.
*/
void AgeLength::Reset() {
DoReset();
BuildCV();
}
static DWORD CALLBACK MMDevApiMsgProc(void *ptr)
{
ThreadRequest *req = ptr;
IMMDeviceEnumerator *Enumerator;
ALuint deviceCount = 0;
MMDevApiData *data;
ALCdevice *device;
HRESULT hr, cohr;
MSG msg;
TRACE("Starting message thread\n");
cohr = CoInitialize(NULL);
if(FAILED(cohr))
{
WARN("Failed to initialize COM: 0x%08lx\n", cohr);
req->result = cohr;
SetEvent(req->FinishedEvt);
return 0;
}
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(FAILED(hr))
{
WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
CoUninitialize();
req->result = hr;
SetEvent(req->FinishedEvt);
return 0;
}
Enumerator = ptr;
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
TRACE("Starting message loop\n");
while(GetMessage(&msg, NULL, 0, 0))
{
TRACE("Got message %u\n", msg.message);
switch(msg.message)
{
case WM_USER_OpenDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
hr = cohr = S_OK;
if(++deviceCount == 1)
hr = cohr = CoInitialize(NULL);
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(SUCCEEDED(hr))
{
Enumerator = ptr;
if(!data->devid)
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &data->mmdev);
else
hr = IMMDeviceEnumerator_GetDevice(Enumerator, data->devid, &data->mmdev);
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
}
if(SUCCEEDED(hr))
hr = IMMDevice_Activate(data->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
if(SUCCEEDED(hr))
{
data->client = ptr;
device->DeviceName = get_device_name(data->mmdev);
}
if(FAILED(hr))
{
if(data->mmdev)
IMMDevice_Release(data->mmdev);
data->mmdev = NULL;
if(--deviceCount == 0 && SUCCEEDED(cohr))
CoUninitialize();
}
req->result = hr;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_ResetDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
req->result = DoReset(device);
SetEvent(req->FinishedEvt);
continue;
case WM_USER_StartDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
ResetEvent(data->NotifyEvent);
hr = IAudioClient_SetEventHandle(data->client, data->NotifyEvent);
if(FAILED(hr))
ERR("Failed to set event handle: 0x%08lx\n", hr);
else
{
hr = IAudioClient_Start(data->client);
if(FAILED(hr))
ERR("Failed to start audio client: 0x%08lx\n", hr);
}
if(SUCCEEDED(hr))
hr = IAudioClient_GetService(data->client, &IID_IAudioRenderClient, &ptr);
if(SUCCEEDED(hr))
{
data->render = ptr;
data->thread = StartThread(MMDevApiProc, device);
if(!data->thread)
{
if(data->render)
IAudioRenderClient_Release(data->render);
data->render = NULL;
IAudioClient_Stop(data->client);
ERR("Failed to start thread\n");
hr = E_FAIL;
}
}
req->result = hr;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_StopDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
if(data->thread)
{
data->killNow = 1;
StopThread(data->thread);
data->thread = NULL;
data->killNow = 0;
IAudioRenderClient_Release(data->render);
data->render = NULL;
IAudioClient_Stop(data->client);
}
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_CloseDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
IAudioClient_Release(data->client);
data->client = NULL;
IMMDevice_Release(data->mmdev);
data->mmdev = NULL;
if(--deviceCount == 0)
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_Enumerate:
req = (ThreadRequest*)msg.wParam;
hr = cohr = S_OK;
if(++deviceCount == 1)
hr = cohr = CoInitialize(NULL);
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(SUCCEEDED(hr))
{
EDataFlow flowdir;
DevMap **devlist;
ALuint *numdevs;
ALuint i;
Enumerator = ptr;
if(msg.lParam == CAPTURE_DEVICE_PROBE)
{
flowdir = eCapture;
devlist = &CaptureDeviceList;
numdevs = &NumCaptureDevices;
}
else
{
flowdir = eRender;
devlist = &PlaybackDeviceList;
numdevs = &NumPlaybackDevices;
}
for(i = 0;i < *numdevs;i++)
{
free((*devlist)[i].name);
free((*devlist)[i].devid);
}
free(*devlist);
*devlist = NULL;
*numdevs = 0;
*devlist = ProbeDevices(Enumerator, flowdir, numdevs);
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
}
if(--deviceCount == 0 && SUCCEEDED(cohr))
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
default:
ERR("Unexpected message: %u\n", msg.message);
continue;
}
}
TRACE("Message loop finished\n");
return 0;
}
LOCAL void Align_OnCommand(HWND hDlg, int id, HWND hControl, UINT codeNotify)
/************************************************************************/
{
LPRECT pRect;
LPALIGNOBJECTS_PARMS lpAlignParms;
int nType;
LPOBJECT lpObject;
LPIMAGE lpImage;
lpAlignParms = ( LPALIGNOBJECTS_PARMS )SendDlgItemMessage( hDlg,
IDC_ALIGN_COMBO, CB_GETITEMDATA, PARMS_INDEX, 0 );
switch (id)
{
case IDC_ALIGN_RIGHT:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_RIGHT;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_CENTER:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_CENTER;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_LEFT:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_LEFT;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_HSPACE:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->HorzAlign = HA_EQUAL;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_UP:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_TOP;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_MID:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_MID;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_DOWN:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_BOTTOM;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_ALIGN_VSPACE:
if (lpAlignParms->bPreview)
DoReset(hDlg, lpAlignParms);
lpAlignParms->VertAlign = VA_EQUAL;
AlignIcons( hDlg, lpAlignParms );
break;
case IDC_PREVIEW:
nType = ( int )SendDlgItemMessage( hDlg, IDC_ALIGN_COMBO,
CB_GETCURSEL, 0, 0 );
if( nType == 0 )
lpAlignParms->RectAlign = RA_IMAGE;
else if( nType == 1 )
lpAlignParms->RectAlign = RA_OBJECT;
else
lpAlignParms->RectAlign = RA_MASK;
lpAlignParms->bPreview = TRUE;
AlignObjects( GetActiveImage(), lpAlignParms );
EnableWindow( GetDlgItem( hDlg, IDC_PREVIEW ), FALSE );
break;
case IDOK:
ALIGNOBJECTS_PARMS AlignParms;
if( lpAlignParms->bPreview )
{
AlignParms = *lpAlignParms;
lpAlignParms->HorzAlign = HA_NONE;
lpAlignParms->VertAlign = VA_NONE;
pRect = lpAlignParms->lpRect;
if( !( lpImage = GetActiveImage() ) )
break;
if( !( lpObject = ImgGetBase( lpImage ) ) )
break;
while ( lpObject = ImgGetSelObject( lpImage, lpObject) )
lpObject->rObject = *pRect++;
AlignObjects( GetActiveImage(), lpAlignParms );
*lpAlignParms = AlignParms;
}
nType = ( int )SendDlgItemMessage( hDlg, IDC_ALIGN_COMBO,
CB_GETCURSEL, 0, 0 );
if( nType == 0 )
lpAlignParms->RectAlign = RA_IMAGE;
else if( nType == 1 )
lpAlignParms->RectAlign = RA_OBJECT;
else
lpAlignParms->RectAlign = RA_MASK;
lpAlignParms->bPreview = FALSE;
AstralDlgEnd( hDlg, TRUE );
break;
case IDC_RESET:
DoReset(hDlg, lpAlignParms);
break;
case IDCANCEL:
DoReset(hDlg, lpAlignParms);
AstralDlgEnd( hDlg, FALSE );
break;
default:
break;
}
}
int main(int argc, char* argv[])
{
int retval;
int ii;
int jj;
int this_arg = 1;
int found = 0;
int readings = 1;
int reading;;
int cartesian = 0;
int patience = PATIENCE;
int report_type;
int report_size;
int rx_num;
int tx_num;
char *report_data_8;
short *report_data_16;
int *report_data_32;
unsigned char data_8;
struct stat st;
if (argc == 1) {
usage(argv[0]);
error_exit(EINVAL);
}
for (ii = 0; ii < NUMBER_OF_INPUTS_TO_SCAN; ii++) {
memset(input_detect, 0x00, MAX_STRING_LEN);
snprintf(input_detect, MAX_STRING_LEN, "%s%d/%s", INPUT_PATH,
(unsigned int)ii, DETECT_FILENAME);
retval = stat(input_detect, &st);
if (retval == 0) {
snprintf(mySensor, MAX_STRING_LEN, "%s%d", INPUT_PATH,
(unsigned int)ii);
found = 1;
break;
}
}
if (!found) {
printf("ERROR: input driver not found\n");
error_exit(ENODEV);
}
while (this_arg < argc) {
if (!strcmp((const char *)argv[this_arg], "-n")) {
this_arg++;
readings = (unsigned int)strtoul(argv[this_arg], NULL, 0);
} else if (!strcmp((const char *)argv[this_arg], "-c")) {
cartesian = 1;
} else {
report_type = strtoul(argv[this_arg], NULL, 0);
}
this_arg++;
}
if (cartesian) {
rx_num = GetRxElectrodes();
tx_num = GetTxElectrodes();
}
switch (report_type) {
case F54_16BIT_IMAGE:
case F54_RAW_16BIT_IMAGE:
case F54_SENSOR_SPEED:
case F54_ADC_RANGE:
case F54_ABS_CAP:
case F54_ABS_DELTA:
break;
default:
DoPreparation(1);
break;
}
for (reading = 0; reading < readings; reading++) {
patience = PATIENCE;
SetReportType(report_type);
GetReport(1);
do {
if (GetStatus() == 0)
break;
} while (--patience > 0);
report_size = ReadReportSize();
if (report_size == 0) {
printf("ERROR: unable to read report\n");
DoReset(1);
error_exit(EINVAL);
}
if (!data_buffer) {
data_buffer = malloc(report_size);
if (!data_buffer) {
printf("ERROR: failed to allocate report data buffer\n");
DoReset(1);
error_exit(ENOMEM);
}
}
ReadBlockData((char *)&data_buffer[0], report_size);
printf("Reading %d\r\n", reading + 1);
switch (report_type) {
case F54_8BIT_IMAGE:
report_data_8 = (char *)data_buffer;
for (ii = 0; ii < report_size; ii++) {
printf("%03d: %d\r\n", ii, *report_data_8);
report_data_8++;
}
break;
case F54_16BIT_IMAGE:
case F54_RAW_16BIT_IMAGE:
case F54_TRUE_BASELINE:
case F54_FULL_RAW_CAP:
case F54_FULL_RAW_CAP_RX_COUPLING_COMP:
report_data_16 = (short *)data_buffer;
if (cartesian) {
printf(" ");
for (ii = 0; ii < rx_num; ii++)
printf(" %2d", ii);
printf("\r\n");
for (ii = 0; ii < tx_num; ii++) {
printf("%2d ", ii);
for (jj = 0; jj < rx_num; jj++) {
printf(" %5d", *report_data_16);
report_data_16++;
}
printf("\r\n");
}
} else {
for (ii = 0; ii < report_size; ii += 2) {
printf("%03d: %d\r\n", ii / 2, *report_data_16);
report_data_16++;
}
}
break;
case F54_HIGH_RESISTANCE:
case F54_FULL_RAW_CAP_MIN_MAX:
case F54_SENSOR_SPEED:
case F54_ADC_RANGE:
report_data_16 = (short *)data_buffer;
for (ii = 0; ii < report_size; ii += 2) {
printf("%03d: %d\r\n", ii / 2, *report_data_16);
report_data_16++;
}
break;
case F54_ABS_CAP:
case F54_ABS_DELTA:
report_data_32 = (int *)data_buffer;
if (cartesian) {
printf("Rx ");
for (ii = 0; ii < rx_num; ii++)
printf(" %2d", ii);
printf("\r\n");
printf(" ");
for (ii = 0; ii < rx_num; ii++) {
printf(" %5d", *report_data_32);
report_data_32++;
}
printf("\r\n");
printf("Tx ");
for (ii = 0; ii < tx_num; ii++)
printf(" %2d", ii);
printf("\r\n");
printf(" ");
for (ii = 0; ii < tx_num; ii++) {
printf(" %5d", *report_data_32);
report_data_32++;
}
printf("\r\n");
} else {
for (ii = 0; ii < report_size; ii += 4) {
printf("%03d: %d\r\n", ii / 4, *report_data_32);
report_data_32++;
}
}
break;
case F54_ABS_ADC:
report_data_16 = (short *)data_buffer;
for (ii = 0; ii < report_size; ii += 2) {
data_8 = (unsigned char)*report_data_16;
printf("%03d: %d\r\n", ii / 2, data_8);
report_data_16++;
}
break;
default:
for (ii = 0; ii < report_size; ii++)
printf("%03d: 0x%02x\r\n", ii, data_buffer[ii]);
break;
}
}
switch (report_type) {
case F54_16BIT_IMAGE:
case F54_RAW_16BIT_IMAGE:
case F54_SENSOR_SPEED:
case F54_ADC_RANGE:
case F54_ABS_CAP:
case F54_ABS_DELTA:
ResumeTouch(1);
break;
default:
DoReset(1);
break;
}
if (data_buffer)
free(data_buffer);
return 0;
}
void ResourceTracker::Reset()
{
TRACKER_LOG(Debug::General);
mComplete = false;
DoReset();
}
void wxGridCellFloatEditor::Reset()
{
DoReset(GetString());
}
void PVAuthorEngineNodeUtility::Run()
{
LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: Enter"));
if (iCmdQueue.empty())
return;
PVAENodeUtilCmd cmd = iCmdQueue[0];
if (cmd.iNodes.empty())
{
LOG_ERR((0, "PVAuthorEngineNodeUtility::Run: Error - cmd.iNodes is empty"));
CompleteUtilityCmd(cmd, PVMFFailure);
return;
}
PVMFStatus status = PVMFFailure;
LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: cmd.iType=%d", cmd.iType));
switch (cmd.iType)
{
case PVAENU_CMD_CONNECT:
status = DoConnect(cmd);
break;
case PVAENU_CMD_DISCONNECT:
status = DoDisconnect(cmd);
break;
case PVAENU_CMD_QUERY_UUID:
status = DoQueryUuid(cmd);
break;
case PVAENU_CMD_QUERY_INTERFACE:
status = DoQueryInterface(cmd);
break;
case PVAENU_CMD_INIT:
status = DoInit(cmd);
break;
case PVAENU_CMD_PREPARE:
status = DoPrepare(cmd);
break;
case PVAENU_CMD_START:
status = DoStart(cmd);
break;
case PVAENU_CMD_PAUSE:
status = DoPause(cmd);
break;
case PVAENU_CMD_STOP:
status = DoStop(cmd);
break;
case PVAENU_CMD_FLUSH:
status = DoFlush(cmd);
break;
case PVAENU_CMD_RESET:
status = DoReset(cmd);
break;
default:
status = PVMFFailure;
break;
}
if (status != PVMFPending)
CompleteUtilityCmd(cmd, status);
LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: Exit"));
}
void MCPrinter::SetDeviceName(const char *p_name)
{
if (!DoReset(p_name))
MCresult -> sets("unknown printer");
}
static void DoZ0Real(tJulie* me, double iZ0Real)
{ me->z0Real = iZ0Real; DoReset(me); }
void wxGridCellTextEditor::Reset()
{
wxASSERT_MSG( m_control, "wxGridCellTextEditor must be created first!" );
DoReset(m_value);
}
LRESULT CRepositoryView::OnReset(UINT /*uMsg*/, WPARAM, LPARAM /*lParam*/)
{
DoReset();
return 0;
}
PushButton::PushButton (int Pin) : DebounceInput(Pin, HIGH)
{
DoReset();
}
void loop()
{
int i, j;
// delay(1); GPIO_SET(CLK); delay(1);
GPIO_SET(CLK);
clkCountHi = 1;
clkCount++;
T++;
tracePauseCount++;
ReadControlState();
GetAddressFromAB();
if (Mlast==1 && m1==0)
T = 1, m1Count++;
Mlast = m1;
bool suppressDump = false;
if (!traceRefresh & !rfsh) suppressDump = true;
// If the number of M1 cycles has been reached, skip the rest since we dont
// want to execute this M1 phase
if (m1Count==stopAtM1)
{
sprintf(extraInfo, "Number of M1 cycles reached"), running = false;
printf("-----------------------------------------------------------+\r\n");
goto control;
}
// If the address is tri-stated, skip checking various combinations of
// control signals since they may also be floating and we can't detect that
if (!abTristated)
{
// Simulate read from RAM
if (!mreq && !rd)
{
SetDataToDB(ram[ab & 0xFFFF]);
if (!m1)
sprintf(extraInfo, "Opcode read from %03X -> %02X", ab, ram[ab & 0xFF]);
else
sprintf(extraInfo, "Memory read from %03X -> %02X", ab, ram[ab & 0xFF]);
if (++ab % 0x1000 == 0)
printf("%04X\n",ab);
}
else
// Simulate interrupt requesting a vector
if (!m1 && !iorq)
{
SetDataToDB(iorqVector);
sprintf(extraInfo, "Pushing vector %02X", iorqVector);
}
else
GetDataFromDB();
// Simulate write to RAM
if (!mreq && !wr)
{
ram[ab & 0xFFFF] = db;
sprintf(extraInfo, "Memory write to %03X <- %02X", ab, db);
}
// Detect I/O read: We don't place anything on the bus
if (!iorq && !rd)
{
sprintf(extraInfo, "I/O read from %03X", ab);
}
// Detect I/O write
if (!iorq && !wr)
{
sprintf(extraInfo, "I/O write to %03X <- %02X", ab, db);
}
// Capture memory refresh cycle
if (!mreq && !rfsh)
{
sprintf(extraInfo, "Refresh address %03X", ab);
}
}
else
GetDataFromDB();
DumpState(suppressDump);
// If the user wanted to pause simulation after a certain number of
// clocks, handle it here. If the key pressed to continue was not Enter,
// stop the simulation to issue that command
if (tracePause==tracePauseCount)
{
tracePauseCount = 0;
}
//--------------------------------------------------------
// Clock goes low
//--------------------------------------------------------
//delay(1); digitalWrite(CLK, LOW); delay(1);
digitalWrite(CLK, LOW);
clkCountHi = 0;
if (traceShowBothPhases)
{
ReadControlState();
GetAddressFromAB();
DumpState(suppressDump);
}
// Perform various actions at the requested clock number
// if the count is positive (we start it at -2 to skip initial 2T)
if (clkCount>=0)
{
if (clkCount==intAtClk) zint = 0;
if (clkCount==nmiAtClk) nmi = 0;
if (clkCount==busrqAtClk) busrq = 0;
if (clkCount==resetAtClk) reset = 0;
if (clkCount==waitAtClk) wait = 0;
// De-assert all control pins at this clock number
if (clkCount==clearAtClk)
zint = nmi = busrq = reset = wait = 1;
WriteControlPins();
// Stop the simulation under some conditions
if (clkCount==stopAtClk)
sprintf(extraInfo, "Number of clocks reached"), running = false;
if (stopAtHalt&!halt)
sprintf(extraInfo, "HALT instruction"), running = false;
}
//--------------------------------------------------------
// Trace/simulation control handler
//--------------------------------------------------------
control:
if (!running)
{
printf(":Simulation stopped: %s\r\n", extraInfo);
extraInfo[0] = 0;
digitalWrite(CLK, HIGH);
zint = nmi = busrq = wait = 1;
WriteControlPins();
while(!running)
{
// Expect a command from the serial port
// if (Serial.available()>0)
{
memset((void *)temp, 0, TEMP_SIZE);
gets(temp);
//Serial.readBytesUntil('\r', temp, TEMP_SIZE-1);
// Option ":" : this is not really a user option. This is used to
// Intel HEX format values into the RAM buffer
// Multiple lines may be pasted. They are separated by a space character.
char *pTemp = temp;
while (*pTemp==':')
{
byte bytes = hexFromTemprintf(pTemp, 0);
if (bytes>0)
{
int address = (hexFromTemprintf(pTemp, 1)<<8) + hexFromTemprintf(pTemp, 2);
byte recordType = hexFromTemprintf(pTemp, 3);
printf("%04X:", address);
for (i=0; i<bytes; i++)
{
ram[(address + i) & 0xFF] = hexFromTemprintf(pTemp, 4+i);
printf(" %02X", hexFromTemprintf(pTemp, 4+i));
}
printf("\r\n");
}
pTemp += bytes*2 + 12; // Skip to the next possible line of hex entry
}
// Option "r" : reset and run the simulation
if (temp[0]=='r')
{
// If the variable 9 (Issue RESET) is not set, perform a RESET and run the simulation.
// If the variable was set, skip reset sequence since we might be testing it.
if (resetAtClk<0)
DoReset();
running = true;
}
// Option "sc" : clear simulation variables to their default values
if (temp[0]=='s' && temp[1]=='c')
{
ResetSimulationVars();
temp[1] = 0; // Proceed to dump all variables...
}
// Option "s" : show and set internal control variables
if (temp[0]=='s' && temp[1]!='c')
{
// Show or set the simulation parameters
int var = 0, value;
int args = sscanf(&temp[1], "%d %d\r\n", &var, &value);
// Parameter for the option #12 is read in as a hex; others are decimal by default
if (var==12)
args = sscanf(&temp[1], "%d %x\r\n", &var, &value);
if (args==2)
{
if (var==0) traceShowBothPhases = value;
if (var==1) traceRefresh = value;
if (var==2) tracePause = value;
if (var==3) stopAtClk = value;
if (var==4) stopAtM1 = value;
if (var==5) stopAtHalt = value;
if (var==6) intAtClk = value;
if (var==7) nmiAtClk = value;
if (var==8) busrqAtClk = value;
if (var==9) resetAtClk = value;
if (var==10) waitAtClk = value;
if (var==11) clearAtClk = value;
if (var==12) iorqVector = value & 0xFF;
}
printf("------ Simulation variables ------\r\n");
printf("#0 Trace both clock phases = %d\r\n", traceShowBothPhases);
printf("#1 Trace refresh cycles = %d\r\n", traceRefresh);
printf("#2 Pause for keypress every = %d\r\n", tracePause);
printf("#3 Stop after clock # = %d\r\n", stopAtClk);
printf("#4 Stop after # M1 cycles = %d\r\n", stopAtM1);
printf("#5 Stop at HALT = %d\r\n", stopAtHalt);
printf("#6 Issue INT at clock # = %d\r\n", intAtClk);
printf("#7 Issue NMI at clock # = %d\r\n", nmiAtClk);
printf("#8 Issue BUSRQ at clock # = %d\r\n", busrqAtClk);
printf("#9 Issue RESET at clock # = %d\r\n", resetAtClk);
printf("#10 Issue WAIT at clock # = %d\r\n", waitAtClk);
printf("#11 Clear all at clock # = %d\r\n", clearAtClk);
printf("#12 Push IORQ vector #(hex) = %2X\r\n", iorqVector);
}
// Option "m" : dump RAM memory
if (temp[0]=='m' && temp[1]!='c')
{
// Dump the content of a RAM buffer
printf(" 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\r\n");
printf(" +-----------------------------------------------\r\n");
for(i=0; i<16; i++)
{
printf("%02X |", i);
for(j=0; j<16; j++)
{
printf("%02X ", ram[i*16+j]);
}
printf("\r\n");
}
}
// Option "mc" : clear RAM memory
if (temp[0]=='m' && temp[1]=='c')
{
memset(ram, 0, sizeof(ram));
printf("RAM cleared\r\n");
}
// Option "?" : print help
if (temp[0]=='?' || temp[0]=='h')
{
printf("s - show simulation variables\r\n");
printf("s #var value - set simulation variable number to a value\r\n");
printf("sc - clear simulation variables to their default values\r\n");
printf("r - restart the simulation\r\n");
printf(":INTEL-HEX - reload RAM buffer with a given data stream\r\n");
printf("m - dump the content of the RAM buffer\r\n");
printf("mc - clear the RAM buffer\r\n");
}
}
}
}
//return 0;
} // main
/**
* Reset our observation so it can be called again
*/
void Observation::Reset() {
comparisons_.clear();
scores_.clear();
DoReset();
}
