// The NetConnection keeps a pointer to the passed NetplayPeerOptions; // do not free it as long as the NetConnection exists. NetConnection * NetConnection_open(int player, const NetplayPeerOptions *options, NetConnection_ConnectCallback connectCallback, NetConnection_CloseCallback closeCallback, NetConnection_ErrorCallback errorCallback, NetConnection_DeleteCallback deleteCallback, void *extra) { NetConnection *conn; conn = malloc(sizeof (NetConnection)); conn->nd = NULL; conn->player = player; conn->state = NetState_unconnected; conn->options = options; conn->extra = extra; PacketQueue_init(&conn->queue); conn->connectCallback = connectCallback; conn->closeCallback = closeCallback; conn->errorCallback = errorCallback; conn->deleteCallback = deleteCallback; conn->readyCallback = NULL; conn->readyCallbackArg = NULL; conn->resetCallback = NULL; conn->resetCallbackArg = NULL; conn->readBuf = malloc(NETPLAY_READBUFSIZE); conn->readEnd = conn->readBuf; conn->stateData = NULL; conn->stateFlags.connected = false; conn->stateFlags.disconnected = false; conn->stateFlags.myTurn = false; conn->stateFlags.endingTurn = false; conn->stateFlags.pendingTurnChange = false; conn->stateFlags.discriminant = false; conn->stateFlags.handshake.localOk = false; conn->stateFlags.handshake.remoteOk = false; conn->stateFlags.handshake.canceling = false; conn->stateFlags.ready.localReady = false; conn->stateFlags.ready.remoteReady = false; conn->stateFlags.reset.localReset = false; conn->stateFlags.reset.remoteReset = false; conn->stateFlags.agreement = Agreement_nothingAgreed; conn->stateFlags.inputDelay = 0; #ifdef NETPLAY_CHECKSUM conn->stateFlags.checksumInterval = NETPLAY_CHECKSUM_INTERVAL; #endif #ifdef NETPLAY_STATISTICS { size_t i; conn->statistics.packetsReceived = 0; conn->statistics.packetsSent = 0; for (i = 0; i < PACKET_NUM; i++) { conn->statistics.packetTypeReceived[i] = 0; conn->statistics.packetTypeSent[i] = 0; } } #endif NetConnection_go(conn); return conn; }
//-------------------------------------------------------------------------------- int main(void) { // Declare used variables XsDevice* foundDevice; XsControl* control; XsPortInfo* portInfo; XsPortInfo* foundPort; XsDeviceId* foundDeviceId; // Make sure to call the proper xxx_INIT macros to properly initialize structs XsPortInfoArray portInfoArray = XSPORTINFOARRAY_INITIALIZER; XsCallbackPlainC callbackHandler = XSCALLBACK_INITIALIZER; XsString deviceIdString = XSSTRING_INITIALIZER; XsString portNameString = XSSTRING_INITIALIZER; XsQuaternion quaternion = XSQUATERNION_INITIALIZER; XsEuler euler = XSEULER_INITIALIZER; XsOutputConfigurationArray mtmk4_configArray = XSOUTPUTCONFIGURATIONARRAY_INITIALIZER; XsDeviceMode mtix_deviceMode = XSDEVICEMODE_INITIALIZER; XsOutputConfiguration mtmk4_config = XSOUTPUTCONFIGURATION_INITIALIZER; XsSize portInfoIdx; int deviceFound; int configSucceeded; if (!setSerialKey()) { printf("Invalid serial key\n"); printf("Press a key to continue.\n"); (void)_getch(); return 1; } // Initialize global packet queue PacketQueue_init(&packetQueue); // Create XsControl object printf("Creating XsControl object...\n"); control = XsControl_construct(); assert(control != 0); // Scan for connected devices printf("Scanning for devices...\n"); (void)XsScanner_scanPorts(&portInfoArray, XBR_Invalid, 100, TRUE, TRUE); // Find an MTi / MTx / MTmk4 device foundPort = 0; foundDeviceId = 0; portInfo = portInfoArray.m_data; deviceFound = FALSE; for (portInfoIdx = 0; portInfoIdx < portInfoArray.m_size; ++portInfoIdx) { foundPort = &portInfo[portInfoIdx]; foundDeviceId = &foundPort->m_deviceId; if (XsDeviceId_isMtix(foundDeviceId) || XsDeviceId_isMtMk4(foundDeviceId)) { deviceFound = TRUE; break; } } if (deviceFound) { XsDeviceId_toString(foundDeviceId, &deviceIdString); printf("Found a device with id: %s @ port: %s, baudrate: %d\n", deviceIdString.m_data, foundPort->m_portName, foundPort->m_baudrate); // Open the port with the detected device printf("Opening port...\n"); XsString_assignCharArray(&portNameString, foundPort->m_portName); if (XsControl_openPort(control, &portNameString, foundPort->m_baudrate, 0, TRUE)) { // Get the device object foundDevice = XsControl_device(control, foundDeviceId); assert(foundDevice != 0); // Print information about detected MTi / MTx / MTmk4 device printf("Device: %s openend.\n", XsDevice_productCode(foundDevice, &deviceIdString)->m_data); // Attach callback handler to device callbackHandler.m_onDataAvailable = onDataAvailable; XsDevice_addCallbackHandler(foundDevice, &callbackHandler, TRUE); // Put the device in configuration mode printf("Putting device into configuration mode...\n"); configSucceeded = FALSE; if (XsDevice_gotoConfig(foundDevice)) // Put the device into configuration mode before configuring the device { // Configure the device. Note the differences between MTix and MTmk4 printf("Configuring the device...\n"); if (XsDeviceId_isMtix(foundDeviceId)) { memset(&mtix_deviceMode, 0, sizeof(XsDeviceMode)); mtix_deviceMode.m_outputMode = XOM_Orientation; // output orientation data mtix_deviceMode.m_outputSettings = XOS_OrientationMode_Quaternion; // output orientation data as quaternion XsDeviceMode_setUpdateRate(&mtix_deviceMode, 100);// make a device mode with update rate: 100 Hz // set the device configuration if (XsDevice_setDeviceMode(foundDevice, &mtix_deviceMode)) { configSucceeded = TRUE; } } else if (XsDeviceId_isMtMk4(foundDeviceId)) { mtmk4_config.m_dataIdentifier = XDI_Quaternion; mtmk4_config.m_frequency = XDI_MAX_FREQUENCY; XsOutputConfigurationArray_construct(&mtmk4_configArray, 1, &mtmk4_config); if (XsDevice_setOutputConfiguration(foundDevice, &mtmk4_configArray)) { configSucceeded = TRUE; } } else { printf("Unknown device while configuring. Aborting."); } } else { printf("Could not put device into configuration mode. Aborting.\n"); } if (configSucceeded) { // Put the device in measurement mode printf("Putting device into measurement mode...\n"); if (XsDevice_gotoMeasurement(foundDevice)) { printf("\nMain loop (press any key to quit)\n"); printf("-------------------------------------------------------------------------------\n"); while (!_kbhit()) { // Retrieve a packet from queue XsDataPacket packet = XSDATAPACKET_INITIALIZER; if (PacketQueue_remove(&packetQueue, &packet)) { // Get the quaternion data XsDataPacket_orientationQuaternion(&packet, &quaternion, XDI_CoordSysEnu); // Convert packet to euler XsDataPacket_orientationEuler(&packet, &euler, XDI_CoordSysEnu); printf("\rq0:%5.2f,q1:%5.2f,q2:%5.2f,q3:%5.2f,roll:%7.2f,pitch:%7.2f,yaw:%7.2f", quaternion.m_w, quaternion.m_x, quaternion.m_y, quaternion.m_z, euler.m_roll, euler.m_pitch, euler.m_yaw ); fflush(stdout); } XsTime_msleep(0); } _getch(); printf("\n-------------------------------------------------------------------------------\n"); } else { printf("Could not put device into measurement mode. Aborting.\n"); } } else { printf("Could not configure device. Aborting.\n"); } // Close port printf("Closing port...\n"); XsControl_closePort(control, &portNameString); } else { printf("Could not open port. Aborting.\n"); } } else { printf("No MTi / MTx device found. Aborting.\n"); } // Free XsControl object printf("Freeing XsControl object...\n"); XsControl_destruct(control); // free global packet queue PacketQueue_destruct(&packetQueue); printf("Successful exit.\n"); printf("Press a key to continue.\n"); (void)_getch(); return 0; }