程序员经验分享-hwhale

KY-RTI分布仿真技术：第七章 Visual C++程序设计

2023-05-16

第七章 Visual C++程序设计

       本章讲述如何基于Visual C++设计仿真程序。演示了2个程序：ping程序和pong程序进行相互之间的通信。程序使用HLA的交互类进行通信，Visual C++与GNU C++一样，头文件与DMSO RTI1.3NGv6完全一致，但KY-RTI效率要比其快很多。

7.1需求分析

       开发2个程序，一个为ping，一个为pong；前者不使用tick服务，后者使用tick服务。

       这两个程序就像2个人打乒乓球一样，1个程序向另一个程序发送1个事件；另一个人收到事件后再给对方发送1个事件；如此循环往复。

7.2项目设计

       按照需求，将要开发的两个程序叫做ping-notick和pong-tick。该项目与时间无关，不需要时间管理服务。本项目采用交互类，并借用KY-RTI的bin目录下已有的chat.fed文件来传输交互。该交互类名为chat，有name和sentence两个参数，如下列代码所示。

class chat {           //交互类

       string  name;     //参数

       string  sentence; //参数

}

       在本项目中，两个程序的name分别设为“ping”和“pong”；sentence为要传输的字符串，其长度可变，具体的值由用户输入确定。

       在本项目中存在一个问题，两个程序总有一个程序先启动，另一个后启动；先启动的程序需要等待另一个程序启动后再协同仿真。本项目让ping-notick先启动，具体方案如图7.1所示。在真实项目中可以采用一个管理成员，各个仿真成员启动后向其发送“启动”交互，当管理成员收到所有仿真成员的交互后就可通知仿真开始。这里只是一个演示项目，使得代码尽可能简单。

       在图7.1中，假定每个仿真成员发送2次交互后，仿真结束。在具体的程序代码中，这个数由用户输入。在程序中还使用了信号量的概念，当一个仿真成员的回调线程收到对方发来的交互时，则释放信号量，通知主线程继续。

       图7.1所示的整个流程为：

  1. ping-notick先启动；
  2. ping-notick主线程等待回调线程释放1个信号量；
  3. pong-tick启动；
  4. pong-tick向ping-notick发送1个交互；
  5. pong-tick主线程等待回调线程释放1个信号量；
  6. ping-notick的回调线程收到交互，释放1个信号量；通知主线程继续；
  7. ping-notick主线程向pong-tick发送1个交互；
  8. ping-notick主线程等待回调线程释放1个信号量；
  9. pong-tick的回调线程收到交互，释放1个信号量；通知主线程继续；
  10. pong-tick主线程向ping-notick发送1个交互；
  11. pong-tick主线程等待回调线程释放1个信号量；
  12. ping-notick的回调线程收到交互，释放1个信号量；通知主线程继续；
  13. ping-notick主线程向pong-tick发送1个交互；
  14. ping-notick已经发送了2个交互，结束仿真；在本项目中休眠一段时间后结束仿真；
  15. pong-tick的回调线程收到交互，释放1个信号量；通知主线程继续；
  16. pong-tick等到了2次回调，结束仿真。

       在实际的代码中，ping-notick采用了信号量，pong-tick采用了一个全局布尔变量，但基本原理与图7.1一样。

                                        图7.1 每个仿真成员发送2次交互后结束仿真

7.3 ping-notick代码设计

       该程序由ping-notick.cpp和HwFederateAmbassador.cpp两个文件组成。前者负责发送交互，后者负责从RTI接收交互，两者在执行时处于2个独立的线程中。

       ping-notick.cpp代码说明：

12行：定义变量STEP，用来表示发送多少次交互后仿真结束，初始值为100；

13行：发送1个交互时要传输的字节数；

16-18行：定义交互类及其参数句柄变量；

33-39行：输入要传输的字节数；

41-48行：输入要发送的交互数；

51-55行：创建1个信号量；

65-72行：创建联邦执行；

74-93行：加入联邦执行；

99-104行：获取交互类及其参数句柄；

107行：公布交互类，只有公布之后才能够向RTI发送交互；

109行：订购交互类，只有订购之后才能够从RTI收到其他人的聊天内容；

111-113行：根据要发送的字节数生成字符串；

115-121行：生成要传输的交互信息，将name和sentence打包，后面直接调用sendInteraction发送；

123-132行：循环操作，每次等待回调线程释放1个信号量，收到信号量后发送1个交互；

138-147行：退出联邦执行，不再参加仿真；

156-169行：销毁联邦。如果是最后一个仿真成员执行该操作，则整个仿真结束。

                                        表7.1  Visual C++ ping-notick示例：ping-notick.cpp

  1. #include "stdafx.h"
  3. #include "HwFederateAmbassador.hh"
  5. #include <RTI.hh>
  6. #include <fedtime.hh>
  8. #include <windows.h>   // for "Sleep"
  9. #include <iostream>
  10. using namespace std;
  12. int STEP=100;
  13. int data_size=1024 ;
  15. //定义交互类句柄和参数句柄
  16. RTI::InteractionClassHandle hChatClass;     //对应chat.xml中的chat交互类
  17. RTI::ParameterHandle        hChatName;      //对应chat交互类的name参数
  18. RTI::ParameterHandle        hChatSentence;  //对应chat交互类的sentence参数
  20. HANDLE  syt;
  22. int hw_main(int argc, char *argv[])
  23. {
  24.     char federationExecutionName[50];//联盟名称
  25.     strcpy(federationExecutionName, "chat");
  27.     char FDDfile[50];//FDD文件
  28.     strcpy(FDDfile, "chat.fed");
  30.     char federateType[50];//盟员名称
  31.     strcpy(federateType, "ping");
  33.     cout << endl << "请输入要传输的字节数:" ; //ping和pong要一致
  34.     cin >> data_size;
  36.     if (data_size < 0) {
  37.         cerr << "字节数不正确" << endl;
  38.         exit(1);
  39.     }
  41.     cout << endl << "请输入交互次数：" ;  //ping和pong要一致
  42.     cin >> STEP;
  43.     cout << endl;
  45.     if (STEP < 1) {
  46.         cerr << "交互次数不正确" << endl;
  47.         exit(1);
  48.     }
  50.     //syt = CreateSemaphore(NULL, 0, 1, syt_name.c_str()); //no data to read
  51.     syt = CreateSemaphore(NULL, 0, 1, _T("ps")); //no data to read
  53.     if (syt != NULL && GetLastError() == ERROR_ALREADY_EXISTS) {
  54.         printf("Semaphore has been created.\n");
  55.     }
  57.     try {
  58.         RTI::RTIambassador       rti;           // libRTI provided
  59.         HwFederateAmbassador     fedAmb;        // User-defined
  61.         RTI::FederateHandle      federateId;
  62.         RTI::Boolean Joined    = RTI::RTI_FALSE;
  63.         int   numTries  = 0;
  65.         try {
  66.             rti.createFederationExecution(federationExecutionName, FDDfile);
  67.         } catch ( RTI::FederationExecutionAlreadyExists& e ) {
  68.             cerr << "FED_HW: Note: Federation execution already exists." << e << endl;
  69.         } catch ( RTI::Exception& e ) {
  70.             cerr << "FED_HW: ERROR:" << e << endl;
  71.             return -1;
  72.         }
  74.         try {
  75.             cout << "FED_HW: JOINING FEDERATION EXECUTION: " << endl;
  77.             federateId = rti.joinFederationExecution( federateType,
  78.                          federationExecutionName,
  79.                          &fedAmb);
  80.         } catch (RTI::FederateAlreadyExecutionMember& e) {
  81.             cerr << "FED_HW: ERROR: " << argv[1]
  82.                  << " already exists in the Federation Execution "
  83.                  << federationExecutionName << "." << endl;
  84.             cerr << e << endl;
  85.             return -1;
  86.         } catch (RTI::FederationExecutionDoesNotExist&) {
  87.             cerr << "FED_HW: ERROR: Federation Execution "
  88.                  << "does not exists."<< endl;
  89.             rti.tick(2.0, 2.0);
  90.         } catch ( RTI::Exception& e ) {
  91.             cerr << "FED_HW: ERROR:" << e << endl;
  92.             return -1;
  93.         }
  95.         cout << "FED_HW: JOINED SUCCESSFULLY: " << ": Federate Handle = " << federateId << endl;
  97.         
  99.             //获取交互类句柄
  100.         hChatClass = rti.getInteractionClassHandle("chat");
  102.         //获取交互类参数句柄
  103.         hChatName = rti.getParameterHandle("name", hChatClass);
  104.         hChatSentence = rti.getParameterHandle("sentence", hChatClass);
  106.         //公布交互类，这样可以向RTI发送信息
  107.         rti.publishInteractionClass(hChatClass);
  108.         //定购交互类，这样可以接受来自其它发布者的信息
  109.         rti.subscribeInteractionClass(hChatClass);
  111.         string szSentence;
  112.         szSentence.resize(data_size);
  113.         szSentence.assign(data_size, 'a');
  115.         RTI::ParameterHandleValuePairSet* pParams = NULL;
  116.         long numParams(2);
  117.         pParams = RTI::ParameterSetFactory::create (numParams);
  119.         // Add Name
  120.         pParams->add(hChatName,(char*)federateType, strlen(federateType)+1);
  121.         pParams->add(hChatSentence,(char*)szSentence.c_str(), data_size);
  123.         for(int i=0; i<STEP; i++) {
  124.             WaitForSingleObject(syt, INFINITE); //ping先启动，i=0时在这里等待pong启动后向其发送1个交互
  125.             //发送交互，所有定购者(不包括自己)都会在HwFederateAmbassador.cpp中的receiveInteraction服务中收到该交互。
  127.             try {
  128.                 rti.sendInteraction(hChatClass, *pParams, "");
  129.             } catch(...) {
  130.                 cerr << "error for send interaction" << endl;
  131.             }
  132.         }
  133.         pParams->empty();
  134.         delete pParams;   // Deallocate the memory
  136.         Sleep(3000); //3 seconds
  138.         try {
  139.             cout << "FED_HW: RESIGN FEDERATION EXECUTION CALLED" << endl;
  141.             rti.resignFederationExecution(
  142.                 RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES );
  143.                  cout << "FED_HW: SUCCESSFUL RESIGN FEDERATION EXECUTION CALLED" << endl;
  144.         } catch ( RTI::Exception& e ) {
  145.             cerr << "FED_HW: ERROR:" << e << endl;
  146.             return -1;
  147.         }
  149.         //------------------------------------------------------
  150.         // Destroy the federation execution in case we are the
  151.         // last federate. This will not do anything bad if there
  152.         // other federates joined.  The RTI will throw us an
  153.         // exception telling us that other federates are joined
  154.         // and we can just ignore that.
  155.         //------------------------------------------------------
  156.         try {
  157.             cout << "FED_HW: DESTROY FEDERATION EXECUTION CALLED" << endl;
  158.             rti.destroyFederationExecution( federationExecutionName );
  159.                  cout << "FED_HW: SUCCESSFUL DESTROY FEDERATION EXECUTION CALLED" << endl;
  160.         } catch ( RTI::FederatesCurrentlyJoined& /* e */ ) {
  161.             cerr << "FED_HW: FederatesCurrentlyJoined" << endl;
  162.             return 0;
  163.         } catch ( RTI::FederationExecutionDoesNotExist& /* e */) {
  164.             cerr << "FED_HW: FederationExecutionDoesNotExist" << endl;
  165.             return 0;
  166.         } catch ( RTI::Exception& e ) {
  167.             cerr << "FED_HW: ERROR:" << e << endl;
  168.             return -1;
  169.         }
  170.     } catch (RTI::ConcurrentAccessAttempted& e) {
  171.         cerr << e << endl;
  172.         return -1;
  173.     } catch ( RTI::Exception& e ) {
  174.         cerr << "FED_HW: ERROR:" << e << endl;
  175.         return -1;
  176.     }
  178.     cout << "FED_HW: Exiting ." << endl;
  180.     return 0;
  181. }
  183. int
  184. main(int argc, char** argv)
  185. {
  186.     return hw_main(argc, argv);
  187. }

       HwFederateAmbassador.cpp代码说明：

32-45行：由于不处理时间参数，因此如果接收到这种类型的receiveInteraction交互，则直接调用不带时间参数的服务来统一处理；

47-58行：接收到交互后，释放信号量。

                                        表7.2  Visual C++ ping-notick示例：HwFederateAmbassador.cpp

  1. //-----------------------------------------------------------------
  2. // Project Include Files
  3. //-----------------------------------------------------------------
  4. #include "fedtime.hh"
  5. #include "HwFederateAmbassador.hh"
  7. //-----------------------------------------------------------------
  8. // System Include Files
  9. //-----------------------------------------------------------------
  10. #ifndef _MSC_VER
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <iostream.h>
  14. #else
  15. #include <iostream>
  16. using std::cout;
  17. using std::cerr;
  18. using std::endl;
  19. #endif
  20. #include <windows.h>
  22. //-----------------------------------------------------------------
  23. // Bad C like global variables being externed - bad boy!!!
  24. //-----------------------------------------------------------------
  26. extern HANDLE syt;
  28. extern RTI::InteractionClassHandle  hChatClass;
  29. extern RTI::ParameterHandle         hChatName;
  30. extern RTI::ParameterHandle         hChatSentence;
  32. void HwFederateAmbassador::receiveInteraction (
  33.     RTI::InteractionClassHandle       theInteraction, // supplied C1
  34.     const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
  35.     const RTI::FedTime&                     theTime,        // supplied C4
  36.     const char                             *theTag,         // supplied C4
  37.     RTI::EventRetractionHandle        theHandle)      // supplied C1
  38. throw (
  39.     RTI::InteractionClassNotKnown,
  40.     RTI::InteractionParameterNotKnown,
  41.     RTI::InvalidFederationTime,
  42.     RTI::FederateInternalError)
  43. {
  44.     this->receiveInteraction( theInteraction, theParameters, theTag );
  45. }
  47. void HwFederateAmbassador::receiveInteraction (
  48.     RTI::InteractionClassHandle       theInteraction, // supplied C1
  49.     const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
  50.     const char                             *theTag)         // supplied C4
  51. throw (
  52.     RTI::InteractionClassNotKnown,
  53.     RTI::InteractionParameterNotKnown,
  54.     RTI::FederateInternalError)
  55. {
  56.     cout << "received an interaction from pong" << endl;
  57.     ReleaseSemaphore(syt,1,NULL);
  58. }

7.4 pong-tick代码设计

       pong-tick.cpp代码说明：

13行：定义变量STEP，用来表示发送多少次交互后仿真结束，初始值为100；

14行：发送1个交互时要传输的字节数；

17-19行：定义交互类及其参数句柄变量；

34-40行：输入要传输的字节数；

42-49行：输入要发送的交互数；

59-66行：创建联邦执行；

68-87行：加入联邦执行；

92-96行：获取交互类及其参数句柄；

99行：公布交互类，只有公布之后才能够向RTI发送交互；

101行：订购交互类，只有订购之后才能够从RTI收到其他人的聊天内容；

103-105行：根据要发送的字节数生成字符串；

107-113行：生成要传输的交互信息，将name和sentence打包，后面直接调用sendInteraction发送；

115-127行：循环操作，每次发送1个交互后等待回调线程通知收到交互；124行调用tick获取回调；

134-143行：退出联邦执行，不再参加仿真；

152-165行：销毁联邦。如果是最后一个仿真成员执行该操作，则整个仿真结束。

                                        表7.3  Visual C++ pong示例：pong-tick.cpp

  1. #include "stdafx.h"
  3. #include "HwFederateAmbassador.hh"
  5. #include <RTI.hh>
  6. #include <fedtime.hh>
  8. #  include <windows.h>   // for "Sleep"
  9. #  include <sys/timeb.h> // for "struct _timeb"
  10. #  include <iostream>
  11. using namespace std;
  13. int STEP=100;
  14. int data_size=1024;
  16. //定义交互类句柄和参数句柄
  17. RTI::InteractionClassHandle hChatClass;     //对应chat.xml中的chat交互类
  18. RTI::ParameterHandle        hChatName;      //对应chat交互类的name参数
  19. RTI::ParameterHandle        hChatSentence;  //对应chat交互类的sentence参数
  21. bool  svt = false;
  23. int hw_main(int argc, char *argv[])
  24. {
  25.     char federationExecutionName[50];//联盟名称
  26.     strcpy(federationExecutionName, "chat");
  28.     char FDDfile[50];//FDD文件
  29.     strcpy(FDDfile, "chat.fed");
  31.     char federateType[50];//盟员名称
  32.     strcpy(federateType, "pong");
  34.     cout << endl << "请输入要传输的字节数:" ;  //与ping要一致
  35.     cin >> data_size;
  37.     if (data_size < 0) {
  38.         cerr << "字节数不正确" << endl;
  39.         exit(1);
  40.     }
  42.     cout << endl << "请输入交互次数：" ;  //与ping要一致
  43.     cin >> STEP;
  44.     cout << endl;
  46.     if (STEP < 1) {
  47.         cerr << "交互次数不正确" << endl;
  48.         exit(1);
  49.     }
  51.     try {
  52.         RTI::RTIambassador       rti;           // libRTI provided
  53.         HwFederateAmbassador     fedAmb;        // User-defined
  55.         RTI::FederateHandle      federateId;
  56.         RTI::Boolean Joined    = RTI::RTI_FALSE;
  57.         int          numTries  = 0;
  59.         try {
  60.             rti.createFederationExecution(federationExecutionName, FDDfile);
  61.         } catch ( RTI::FederationExecutionAlreadyExists& e ) {
  62.             cerr << "FED_HW: Note: Federation execution already exists." << e << endl;
  63.         } catch ( RTI::Exception& e ) {
  64.             cerr << "FED_HW: ERROR:" << e << endl;
  65.             return -1;
  66.         }
  68.         try {
  69.             cout << "FED_HW: JOINING FEDERATION EXECUTION: " << endl;
  71.             federateId = rti.joinFederationExecution( federateType,
  72.                          federationExecutionName,
  73.                          &fedAmb);
  74.         } catch (RTI::FederateAlreadyExecutionMember& e) {
  75.             cerr << "FED_HW: ERROR: " << argv[1]
  76.                  << " already exists in the Federation Execution "
  77.                  << federationExecutionName << "." << endl;
  78.             cerr << e << endl;
  79.             return -1;
  80.         } catch (RTI::FederationExecutionDoesNotExist&) {
  81.             cerr << "FED_HW: ERROR: Federation Execution "
  82.                  << "does not exists."<< endl;
  83.             rti.tick(2.0, 2.0);
  84.         } catch ( RTI::Exception& e ) {
  85.             cerr << "FED_HW: ERROR:" << e << endl;
  86.             return -1;
  87.         }
  89.         /
  91.         //获取交互类句柄
  92.         hChatClass = rti.getInteractionClassHandle("chat");
  94.         //获取交互类参数句柄
  95.         hChatName = rti.getParameterHandle("name", hChatClass);
  96.         hChatSentence = rti.getParameterHandle("sentence", hChatClass);
  98.         //公布交互类，这样可以向RTI发送信息
  99.         rti.publishInteractionClass(hChatClass);
  100.         //定购交互类，这样可以接受来自其它发布者的信息
  101.         rti.subscribeInteractionClass(hChatClass);
  103.         string szSentence;
  104.         szSentence.resize(data_size);
  105.         szSentence.assign(data_size, 'a');
  107.         RTI::ParameterHandleValuePairSet* pParams = NULL;
  108.         long numParams(2);
  109.         pParams = RTI::ParameterSetFactory::create (numParams);
  111.         // Add Name
  112.         pParams->add(hChatName,(char*)federateType, strlen(federateType)+1);
  113.         pParams->add(hChatSentence,(char*)szSentence.c_str(), data_size);
  115.         for(int i=0; i<STEP; i++) {
  116.             //发送交互，所有定购者(不包括自己)都会在HwFederateAmbassador.cpp中的receiveInteraction服务中收到该交互。
  117.             try {
  118.                 rti.sendInteraction(hChatClass, *pParams, "");
  119.             } catch(...) {
  120.                 cerr << "error for send interaction" << endl;
  121.             }
  123.             while(!svt) { //等待ping发交互
  124.                 rti.tick(0.001, 1.0);
  125.             }
  126.             svt = false;
  127.         }
  129.         pParams->empty();
  130.         delete pParams;   // Deallocate the memory
  132.         Sleep(3000); //3 seconds
  134.         try {
  135.             cout << "FED_HW: RESIGN FEDERATION EXECUTION CALLED" << endl;
  137.             rti.resignFederationExecution(
  138.                 RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES );
  139.             cout << "FED_HW: SUCCESSFUL RESIGN FEDERATION EXECUTION CALLED" << endl;
  140.         } catch ( RTI::Exception& e ) {
  141.             cerr << "FED_HW: ERROR:" << e << endl;
  142.             return -1;
  143.         }
  145.         //------------------------------------------------------
  146.         // Destroy the federation execution in case we are the
  147.         // last federate. This will not do anything bad if there
  148.         // other federates joined.  The RTI will throw us an
  149.         // exception telling us that other federates are joined
  150.         // and we can just ignore that.
  151.         //------------------------------------------------------
  152.         try {
  153.             cout << "FED_HW: DESTROY FEDERATION EXECUTION CALLED" << endl;
  154.             rti.destroyFederationExecution( federationExecutionName );
  155.             cout << "FED_HW: SUCCESSFUL DESTROY FEDERATION EXECUTION CALLED" << endl;
  156.         } catch ( RTI::FederatesCurrentlyJoined& /* e */ ) {
  157.             cerr << "FED_HW: FederatesCurrentlyJoined" << endl;
  158.             return 0;
  159.         } catch ( RTI::FederationExecutionDoesNotExist& /* e */) {
  160.             cerr << "FED_HW: FederationExecutionDoesNotExist" << endl;
  161.             return 0;
  162.         } catch ( RTI::Exception& e ) {
  163.             cerr << "FED_HW: ERROR:" << e << endl;
  164.             return -1;
  165.         }
  166.     } catch (RTI::ConcurrentAccessAttempted& e) {
  167.         cerr << e << endl;
  168.         return -1;
  169.     } catch ( RTI::Exception& e ) {
  170.         cerr << "FED_HW: ERROR:" << e << endl;
  171.         return -1;
  172.     }
  174.     cout << "FED_HW: Exiting ." << endl;
  176.     return 0;
  177. }
  179. int
  180. main(int argc, char** argv)
  181. {
  182.     return hw_main(argc, argv);
  183. }

       HwFederateAmbassador.cpp代码说明：

33-46行：由于不处理时间参数，因此如果接收到这种类型的receiveInteraction交互，则直接调用不带时间参数的服务来统一处理；

48-59行：接收到交互后，通过全局布尔变量通知主线程继续。

                                        表7.4  Visual C++ pong示例：HwFederateAmbassador.cpp

  1. //-----------------------------------------------------------------
  2. // Project Include Files
  3. //-----------------------------------------------------------------
  4. #include "fedtime.hh"
  5. #include "HwFederateAmbassador.hh"
  7. //-----------------------------------------------------------------
  8. // System Include Files
  9. //-----------------------------------------------------------------
  10. #ifndef _MSC_VER
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <iostream.h>
  14. #else
  15. #include <iostream>
  16. using std::cout;
  17. using std::cerr;
  18. using std::endl;
  19. #endif
  20. #include <windows.h>
  22. //-----------------------------------------------------------------
  23. // Bad C like global variables being externed - bad boy!!!
  24. //-----------------------------------------------------------------
  26. extern bool svt;
  28. extern RTI::InteractionClassHandle  hChatClass;
  29. extern RTI::ParameterHandle         hChatName;
  30. extern RTI::ParameterHandle         hChatSentence;
  33. void HwFederateAmbassador::receiveInteraction (
  34.     RTI::InteractionClassHandle       theInteraction, // supplied C1
  35.     const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
  36.     const RTI::FedTime&                     theTime,        // supplied C4
  37.     const char                             *theTag,         // supplied C4
  38.     RTI::EventRetractionHandle        theHandle)      // supplied C1
  39. throw (
  40.     RTI::InteractionClassNotKnown,
  41.     RTI::InteractionParameterNotKnown,
  42.     RTI::InvalidFederationTime,
  43.     RTI::FederateInternalError)
  44. {
  45.     this->receiveInteraction( theInteraction, theParameters, theTag );
  46. }
  48. void HwFederateAmbassador::receiveInteraction (
  49.     RTI::InteractionClassHandle       theInteraction, // supplied C1
  50.     const RTI::ParameterHandleValuePairSet& theParameters,  // supplied C4
  51.     const char                             *theTag)         // supplied C4
  52. throw (
  53.     RTI::InteractionClassNotKnown,
  54.     RTI::InteractionParameterNotKnown,
  55.     RTI::FederateInternalError)
  56. {
  57.     cout << "received an interaction from ping" << endl;
  58.     svt = true;
  59. }

7.5编译运行

       下面以Visual C++ 2010为例说明编译运行过程。

       第1步：编译。以ping-notick程序为例说明，pong-tick程序的设置与此相同。

       （1）选择左侧“ping-notick”根节点，按右键选择“属性”，打开属性对话框；

                                        图7.2 选择项目属性

       （2）设置项目属性

  1. 在“配置”处选择Debug或Release等；
  2. 在“平台”处选择32位或64位等；
  3. 选择“C/C++”的“常规”属性，设置KY-RTI的头文件目录，这里设置为“C:\KY-RTI\include;.”。注意，这里有两个目录，一个是KY-RTI的include目录，另一个是当前目录，用‘.’表示，中间用‘;’隔开。
  4. 选择“链接器”的“常规”属性，设置KY-RTI的库文件目录，这里设置为“C:\KY-RTI\lib”。
  5. 选择“链接器”的“输入”属性，设置项目需要的库文件，依照VC版本以及平台属性设置需要的库文件，这里设置为VC2010的64位版本库“libFedTime64VC2010.lib;libRTI-NG64VC2010.lib”。

                                        图7.3 设置项目属性

                                        图7.4 设置库文件目录

                                        图7.5 设置库

       （3）编译，生成可执行程序。

       第2步：修改RTI.rid，查看tick开关。

       ping-notick没有使用tick服务，则关闭tick开关；pong-tick使用了tick服务，则打开tick开关。

       如果当前目录下没有RTI.rid，则运行程序后会自动产生。

       第3步：启动KY-RTI。注意，KY-RTI的IP地址和端口号要与RTI.rid一致。

       第4步：开启两个终端，分别运行ping-notick和pong-tick这2个仿真成员，开始仿真。如图7.6和图7.7所示。在这个例子中，每次传输的字节数为100个字节，一共来回10次。

                                        图7.6 ping-notick运行结果

                                        图7.7 pong-tick运行结果

KY-RTI的Linux、Windows版本和源码请联系作者:walt_lbq@163.com

KY-RTI分布仿真技术：前 言

KY-RTI分布仿真技术：第一章 简介

KY-RTI分布仿真技术：第二章 系统安装

KY-RTI分布仿真技术：第三章 KY-OMT对象模型模板工具

KY-RTI分布仿真技术：第四章 C++程序设计

KY-RTI分布仿真技术：第五章 Qt程序设计

KY-RTI分布仿真技术：第六章 Java程序设计

KY-RTI分布仿真技术：第七章 Visual C++程序设计

KY-RTI分布仿真技术：第八章 Visual C#程序设计

KY-RTI分布仿真技术：第九章 综合演示

KY-RTI分布仿真技术：附录1 分组聊天（HLA数据分发管理的应用）

KY-RTI分布仿真技术：附录2 大联邦（构建1000个成员的HLA/RTI仿真系统）

KY-RTI分布仿真技术：附录3 国产化（操作系统+CPUs）

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

KY-RTI分布仿真技术：第七章 Visual C++程序设计 的相关文章

随机推荐

  • Docker 初学者指南 — 如何使用 Docker-Compose 创建客户端/服务器端

    您是一名开发人员并且想探索 docker compose xff1f 这篇文章是为你而写的 在对 Docker Compose 进行简短介绍后 xff0c 您将能够使用 Docker 创建您的第一个客户端 服务器端应用程序 注意 xff1a

  • WSTOOL中止下载后的错误。{ROS}

    运行wstool init j8 src hydro desktop full wet rosinstall时 xff0c 由于网络原因中止 xff0c 再开的时候会报错 错误提示 xff1a Error There already is

  • FreeRTOS 启动流程浅析 vTaskStartScheduler --待续

    1 Scheduler status xff1a 全局标志 xff1a static volatile BaseType t xSchedulerRunning 61 pdFALSE 取值 xff1a define taskSCHEDULE

  • Windows的linux子系统无法使用NFS

    需求 xff1a 不能装双系统 xff0c 虚拟机本地文件共享又不方便 xff0c 所以想要用win10商店的linux子系统 xff08 ubuntu18 04 xff09 配合NFS实现本地的linux环境编程测试 xff0c 再同步到

  • Docker

    文章目录 Docker1 Docker简介1 1 什么是虚拟化1 2 什么是Docker1 3 容器与虚拟机比较1 4 Docker 组件1 4 1 Docker服务器与客户端1 4 2 Docker镜像与容器1 4 3 Registry

  • tensorflow图优化详解

    一 运行时优化 Grappler是TensorFlow提供的运行时优化功能 xff0c 图1为Grappler模块主要功能的UML关系图 其中tensorflow grappler GrapplerItem 表示待优化的TensforFlo

  • 理解一维数组中 buf、buf[0]、&buf[0]、&buf 四个符号的含义

    本文内容摘自 C语言内核深度解析 一书的深入学习数组部分 以 int buf 100 61 0 为例 xff0c 集中讨论 buf buf 0 amp buf 0 amp buf 四个字符含义的内涵 1 buf xff1a 有两层含义 xf

  • 无人机航线规划软件[航线通]

    无人机航线规划软件 航线通 xff08 RoutePlan xff09 是数据禾 xff08 databox store xff09 研发的具有自主知识产权的无人机航线规划及飞行的移动端控制软件 xff0c 主要适用于大疆无人机 xff0c

  • Ubuntu20.04安装Cartographer_ros，conda环境X11问题

    absl的解决 conda 环境的 X11 问题 xff1a conda span class token function install span c conda forge xorg libx11

  • 单目视觉定位测距的两种方式

    单目定位和双目定位的选择 xff0c 我觉得主要还是成本和时间的考虑 之前也尝试过双目定位 xff0c 感觉要更精准些 xff0c 但双目测距需要对两幅图像进行图像变换和极线匹配 xff0c 稍微耗时了一些 这几天尝试了一下单摄像头进行测距

  • KY-RTI分布仿真技术：附录3 国产化（操作系统+CPUs）

    以操作系统和CPU为代表的国产化是当前仿真系统实现的必然趋势 本章以聊天程序为例 xff0c 展示了KY RTI在多种国产操作系统和国产CPU上的运行结果 聊天程序是一个入门程序 xff0c 本身比较简单 xff0c 不追求界面的美观 相信

  • KY-RTI分布仿真技术：前言

    前 言 自从美国国防部建模与仿真办公室 xff08 DMSO xff09 首次提出高层体系结构 xff08 High Level Architecture xff0c HLA xff09 概念以来 xff0c HLA仿真技术得到了迅猛发展

  • KY-RTI分布仿真技术：第一章 简介

    第一章 简介 高层体系结构 xff08 High Level Architecture xff0c HLA xff09 是美国国防部为了解决美军在各个领域开发出来的多种模型和各类仿真系统的互联和互操作问题而提出的一种分布式仿真标准 xff0

  • KY-RTI分布仿真技术：第二章 系统安装

    第二章 系统安装 本章介绍KY RTI在Linux和Windows操作系统下的安装方法 2 1 Linux安装 安装程序 xff1a RTI 1 3NGv6 tar gz 假设当前的Linux用户名为lbq xff0c HOME目录为 ho

  • KY-RTI分布仿真技术：第三章 KY-OMT对象模型模板工具

    第三章 KY OMT对象模型模板工具 本章介绍了对象模型模板的相关知识 xff0c 以及如何使用KY OMT对象模型模板工具创建对象模型文件 3 1 对象模型模板 HLA1 3包含3个标准 xff0c 第一个是描述整个联邦和联邦成员必须遵循

  • 基于SSM的后台管理系统总结

    文章目录 SSM环境搭建环境准备1 1 数据库与表结构1 2 maven工程搭建 pom 1 3编写实体类编写接口 SSM整合 web 与产品查询Spring环境搭建web xml 配置Spring MVC 环境搭建测试运行 资源地址 首先

  • KY-RTI分布仿真技术：第四章 C++程序设计

    第四章 C 43 43 程序设计 本章讲述如何在Linux操作系统上设计GNU C 43 43 程序 演示了2个程序 xff1a 聊天程序chat和时间管理程序time chat使用HLA的交互类进行通信 xff0c 没有采用tick服务

  • KY-RTI分布仿真技术：第五章 Qt程序设计

    第五章 Qt程序设计 本章讲述了如何基于Qt Creator设计控制台程序和图形界面程序 控制台程序相当于4 3节的聊天程序 xff1b 图形界面程序相当于4 4节的时间管理程序 图形界面程序近似于真实仿真项目 xff0c 讲述了如何设计仿

  • KY-RTI分布仿真技术：第六章 Java程序设计

    第六章 Java程序设计 本章讲述了如何基于Java设计聊天程序和时间管理程序 xff0c 两个程序都是控制台程序 聊天程序相当于4 3节的GNU C 43 43 聊天程序 xff1b 时间管理程序相当于4 4节的GNU C 43 43 程

  • KY-RTI分布仿真技术：第七章 Visual C++程序设计

    第七章 Visual C 43 43 程序设计 本章讲述如何基于Visual C 43 43 设计仿真程序 演示了2个程序 xff1a ping程序和pong程序进行相互之间的通信 程序使用HLA的交互类进行通信 xff0c Visual

热门标签