void mtsMicroScribeDigitizer::Cleanup(void) { if (DeviceConnected) { ArmDisconnect(); ArmEnd(); DeviceConnected = false; CMN_LOG_CLASS_INIT_VERBOSE << "Cleanup: MicroScribe Digitizer session cleaned up." << std::endl; } }
void mtsMicroScribeDigitizer::InitComponent(void) { mtsInterfaceProvided * provided = AddInterfaceProvided(DigitizerInterfaceName); if (provided) { StateTable.AddData(DeviceStatus, "DeviceStatus"); StateTable.AddData(TipPosition, "TipPosition"); StateTable.AddData(TipOrientation, "TipOrientation"); StateTable.AddData(TipOrientationUnitVector, "TipOrientationUnitVector"); StateTable.AddData(ButtonState, "ButtonState"); StateTable.AddData(JointReadings, "JointReadings"); provided->AddCommandReadState(StateTable, DeviceStatus, DigitizerCommandNames::GetDeviceStatus); provided->AddCommandReadState(StateTable, TipPosition, DigitizerCommandNames::GetTipPosition); provided->AddCommandReadState(StateTable, TipOrientation, DigitizerCommandNames::GetTipOrientation); provided->AddCommandReadState(StateTable, TipOrientationUnitVector, DigitizerCommandNames::GetTipOrientationUnitVector); provided->AddCommandReadState(StateTable, ButtonState, DigitizerCommandNames::GetButtonState); provided->AddCommandReadState(StateTable, JointReadings, DigitizerCommandNames::GetJointReadings); provided->AddCommandRead(&mtsMicroScribeDigitizer::GetDigitizerInfo, this, DigitizerCommandNames::GetDigitizerInfo); provided->AddEventVoid(EventButton1Up, DigitizerEventNames::EventButton1Up); provided->AddEventVoid(EventButton1Down, DigitizerEventNames::EventButton1Down); provided->AddEventVoid(EventButton2Up, DigitizerEventNames::EventButton2Up); provided->AddEventVoid(EventButton2Down, DigitizerEventNames::EventButton2Down); provided->AddEventVoid(EventDigitizerConnected, DigitizerEventNames::EventDigitizerConnected); provided->AddEventVoid(EventDigitizerDisconnected, DigitizerEventNames::EventDigitizerDisconnected); } // Device initialization if (ARM_SUCCESS != ArmStart(NULL)) { // Retry after calling ArmEnd() ArmEnd(); if (ARM_SUCCESS != ArmStart(NULL)) { cmnThrow("mtsMicroScribeDigitizer: Startup: Failed to initialize MicroScribe Digitizer"); } } // Custom error handler registration if (ARM_SUCCESS != ArmSetErrorHandlerFunction(NO_HCI_HANDLER, ErrorHandler_NoHCI)) { cmnThrow("mtsMicroScribeDigitizer: Startup: Failed to register error handler: NO_HCI_HANDLER"); } if (ARM_SUCCESS != ArmSetErrorHandlerFunction(BAD_PORT_HANDLER, ErrorHandler_BadPort)) { cmnThrow("mtsMicroScribeDigitizer: Startup: Failed to register error handler: BAD_PORT_HANDLER"); } if (ARM_SUCCESS != ArmSetErrorHandlerFunction(CANT_OPEN_HANDLER, ErrorHandler_CantOpen)) { cmnThrow("mtsMicroScribeDigitizer: Startup: Failed to register error handler: CANT_OPEN_HANDLER"); } if (ARM_SUCCESS != ArmSetErrorHandlerFunction(CANT_BEGIN_HANDLER, ErrorHandler_CantBegin)) { cmnThrow("mtsMicroScribeDigitizer: Startup: Failed to register error handler: CANT_BEGIN_HANDLER"); } }
void mtsMicroScribeDigitizer::Configure(const std::string & filename) { // Setup error handlers #define SETUP_ERROR_HANDLER(_errorCode, _handlerName)\ if (ARM_SUCCESS != ArmSetErrorHandlerFunction(_errorCode, ErrorHandler_##_handlerName)) {\ CMN_LOG_CLASS_INIT_ERROR << "Startup: Failed to set error handler: "#_errorCode << std::endl;\ cmnThrow("Startup: Failed to set error handler: "#_errorCode);\ } SETUP_ERROR_HANDLER(NO_HCI_HANDLER, NoHCI); SETUP_ERROR_HANDLER(BAD_PORT_HANDLER, BadPort); SETUP_ERROR_HANDLER(CANT_OPEN_HANDLER, CantOpen); SETUP_ERROR_HANDLER(CANT_BEGIN_HANDLER, CantBegin); // MJ: TIMED_OUT_HANDLER and BAD_PACKET_HANDLER are not overridden because the SDK explicitly // recommends not to do that as follows (see BAD_PACKET_handler and TIMED_OUT_handler): // // "Although this function is still exported for backward compatibility issue, user // shouldn't have any reason to provide any custom TIMED_OUT_handler because the default // ArmDll32's TIMED_OUT_handler should be enough. Any incorrect behavior in such custom // error handler function could affect ArmDll32's performance." #undef SETUP_ERROR_HANDLER // Connect to hardware if (ARM_SUCCESS != ArmConnect(0, 0)) { CMN_LOG_CLASS_INIT_ERROR << "Startup: Unable to connect to ArmDll32" << std::endl; ArmEnd(); cmnThrow("Startup: Unable to connect to ArmDll32"); } else { OnDeviceConnection(); } // Get device product information const size_t len = 256; char buf[len]; // Product name if (ARM_SUCCESS == ArmGetProductName(buf, len)) { DigitizerInfo.ProductName = buf; } else { DigitizerInfo.ProductName = "Failed to fetch"; } // Model name if (ARM_SUCCESS == ArmGetModelName(buf, len)) { DigitizerInfo.ModelName = buf; } else { DigitizerInfo.ModelName = "Failed to fetch"; } // Serial number if (ARM_SUCCESS == ArmGetSerialNumber(buf, len)) { DigitizerInfo.SerialNumber = buf; } else { DigitizerInfo.SerialNumber = "Failed to fetch"; } // Driver and firmware version char buf2[len]; if (ARM_SUCCESS == ArmGetVersion(buf, buf2, len)) { DigitizerInfo.DriverVersion = buf; DigitizerInfo.FirmwareVersion = buf2; } else { DigitizerInfo.DriverVersion = "Failed to fetch"; DigitizerInfo.FirmwareVersion = "Failed to fetch"; } // Num of DoF int dof; if (ARM_SUCCESS == ArmGetNumDOF(&dof)) { // -1 if DoF cannot be determined (e.g., pre-G2 versions of the MicroScribe) DigitizerInfo.NumDoF = dof; } else { DigitizerInfo.NumDoF = -1; } CMN_LOG_CLASS_INIT_VERBOSE << "Startup: " << DigitizerInfo << std::endl; // Set refresh rate if (ARM_SUCCESS != ArmSetUpdateEx(ARM_FULL, (UINT) (this->Period * 1000))) { // second argument in msec CMN_LOG_CLASS_INIT_ERROR << "Startup: Unable to set update for ArmDll32" << std::endl; ArmDisconnect(); ArmEnd(); cmnThrow("Startup: Unable to set update for ArmDll32"); } // Check device status (device can be disonncected after all getters succeeded) if (ARM_SUCCESS == ArmGetDeviceStatus(&DeviceStatusVendor)) { DeviceStatus(STATUS) = DeviceStatusVendor.status; DeviceStatus(BAUD) = DeviceStatusVendor.Baud; DeviceStatus(PORT_NUMBER) = DeviceStatusVendor.PortNumber; if (!(DeviceStatus(STATUS) & ARM_CONNECTED)) { OnDeviceDisconnection(); return; } } }
// This creates a vrpn_3DMicroscribe and sets it to reset mode. vrpn_3DMicroscribe::vrpn_3DMicroscribe (const char * name, vrpn_Connection * c, const char * Port, long int BaudRate, float OffsetX/* = 0.0f*/, float OffsetY/* = 0.0f*/, float OffsetZ/* = 0.0f*/, float Scale/*=1.0f*/): vrpn_Tracker(name, c), vrpn_Button_Filter(name, c), _numbuttons(2) { // Set the parameters in the parent classes vrpn_Button::num_buttons = _numbuttons; if(!strcmp(Port, "COM1") ) m_PortNumber=1; else if(!strcmp(Port, "COM2") ) m_PortNumber=2; else if(!strcmp(Port, "COM3") ) m_PortNumber=3; else if(!strcmp(Port, "COM4") ) m_PortNumber=4; m_BaudRate=BaudRate; m_OffSet[0]=OffsetX; m_OffSet[1]=OffsetY; m_OffSet[2]=OffsetZ; m_Scale=Scale; // Set the status of the buttons and analogs to 0 to start clear_values(); #ifdef VRPN_USE_MICROSCRIBE int iResult; iResult=ArmStart(NULL); if(ARM_SUCCESS != iResult) { //error starting the MicroScribe drivers VRPN_MSG_ERROR( "Unable to start MicroScribe ArmDll32." ); return; } //don't use error handlers iResult = ArmSetErrorHandlerFunction(NO_HCI_HANDLER, NULL); iResult = ArmSetErrorHandlerFunction(BAD_PORT_HANDLER, NULL); iResult = ArmSetErrorHandlerFunction(CANT_OPEN_HANDLER, NULL); iResult = ArmSetErrorHandlerFunction(CANT_BEGIN_HANDLER, NULL); //connect to the correct port switch(m_PortNumber) { case 1: iResult = ArmConnect(1, m_BaudRate); break; case 2: iResult = ArmConnect(2, m_BaudRate); break; case 3: iResult = ArmConnect(3, m_BaudRate); break; case 4: iResult = ArmConnect(4, m_BaudRate); break; default: iResult = ArmConnect(0, 0); //try all available ports and baud rates break; } if(ARM_SUCCESS != iResult) { //error connecting, end the thread ArmEnd(); VRPN_MSG_ERROR( "Unable to connect to the MicroScribe." ); return; } #endif // Set the mode to reset status = STATUS_RESETTING; }