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(); }