void createPublisher() { DDS_PublisherQos* publisherQos = DDS_PublisherQos__alloc(); checkHandle(publisherQos, "DDS_PublisherQos__alloc"); g_status = DDS_DomainParticipant_get_default_publisher_qos(g_domainParticipant, publisherQos); checkStatus(g_status, "DDS_DomainParticipant_get_default_publisher_qos"); publisherQos->partition.name._length = 1; publisherQos->partition.name._maximum = 1; publisherQos->partition.name._buffer = DDS_StringSeq_allocbuf(1); checkHandle(publisherQos->partition.name._buffer, "DDS_StringSeq_allocbuf"); publisherQos->partition.name._buffer[0] = DDS_string_alloc(strlen(g_partitionName)); checkHandle(publisherQos->partition.name._buffer[0], "DDS_string_alloc"); strcpy(publisherQos->partition.name._buffer[0], g_partitionName); /* Create a Publisher for the application. */ g_Publisher = DDS_DomainParticipant_create_publisher(g_domainParticipant, publisherQos, NULL, DDS_ANY_STATUS); checkHandle(g_Publisher, "DDS_DomainParticipant_create_publisher"); DDS_free(publisherQos); }
DDS_Publisher createPublisher(char* publisherName) { DDS_Publisher publisher; DDS_PublisherQos* publisherQos = DDS_PublisherQos__alloc(); checkHandle(publisherQos, "DDS_PublisherQos__alloc"); g_status = DDS_DomainParticipant_get_default_publisher_qos(g_domainParticipant, publisherQos); checkStatus(g_status, "DDS_DomainParticipant_get_default_publisher_qos"); publisherQos->partition.name._length = 1; publisherQos->partition.name._maximum = 1; publisherQos->partition.name._buffer = DDS_StringSeq_allocbuf(1); checkHandle(publisherQos->partition.name._buffer, "DDS_StringSeq_allocbuf"); publisherQos->partition.name._buffer[0] = DDS_string_dup(g_partitionName); checkHandle(publisherQos->partition.name._buffer[0], "DDS_string_dup"); /* Create a Publisher for the application. */ publisher = DDS_DomainParticipant_create_publisher(g_domainParticipant, publisherQos, NULL, DDS_STATUS_MASK_NONE); checkHandle(publisher, "DDS_DomainParticipant_create_publisher"); DDS_free(publisherQos); return publisher; }
/* Creates a Publisher and a DataWriter within the Domain participant at the topics created previously by init_types(). - Return: the instantiated DataWriter */ void create_publisher(void) { if (verbose) printf("create_publisher()\n"); pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { printf ("create_publisher() DDS_DomainParticipant_create_publisher() failed!\r\n"); exit (1); } DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); #ifdef TRANSIENT_LOCAL wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL wr_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; wr_qos.history.depth = DDS_LENGTH_UNLIMITED; wr_qos.resource_limits.max_samples_per_instance = HISTORY; wr_qos.resource_limits.max_instances = HISTORY * 10; wr_qos.resource_limits.max_samples = HISTORY * 4; #else wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = HISTORY; #endif /* Create a Data Writer. */ dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, 0); if (!dw) { printf ("create_publisher() unable to create message writer.\r\n"); exit (1); } if (verbose) printf ("create_publisher() DDS message writer created.\r\n"); }
static void make_state_writer (int id) { DDS_DataWriterQos wr_qos; DDS_ReturnCode_t error; static DDS_InstanceHandle_t handle; MsgData_t data; printf ("Create Writer\r\n"); /* === create publisher === */ pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { fatal ("DDS_DomainParticipant_create_publisher () failed!"); DDS_DomainParticipantFactory_delete_participant (part); } /* Test get_qos() fynctionality. */ if ((error = DDS_Publisher_get_qos (pub, &pqos)) != DDS_RETCODE_OK) fatal ("DDS_Publisher_get_qos () failed (%s)!", DDS_error (error)); /* Setup writer QoS parameters. */ DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); /* === create the writer === */ wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = 1; wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; wr_qos.ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS; dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, sm); if (!dw) { fatal ("Unable to create a writer \r\n"); DDS_DomainParticipantFactory_delete_participant (part); } /* === While true, add sample, remove sample === */ if (tsm_type == 0) { data.key = id; data.counter = 100 + id; strcpy (data.message, "Hi folks!"); if (test == 3) { printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); return; } } else { if (test == 3) { _types1.i8 = key; printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &_types1); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &_types1, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &_types1, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); return; } } if (test == 0) { printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (2); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (2); if (reader) remove_state_reader (); } else if (test >= 1) { while (1) { printf ("Register instance\r\n"); handle = DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, handle))) printf ("Error writing data\r\n"); sleep (1); if (test == 1) { printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, handle))) printf ("Error unregistering instance\r\n"); } else { printf ("Dispose instance\r\n"); if ((error = DDS_DataWriter_dispose (dw, &data, handle))) printf ("Error disposing instance\r\n"); } sleep (1); } } }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; TreeDataWriter *Tree_writer = NULL; Tree *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; struct DDS_Duration_t send_period = {4,0}; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register type before creating topic */ type_name = TreeTypeSupport_get_type_name(); retcode = TreeTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic( participant, "Example Tree", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer = DDS_Publisher_create_datawriter( publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } Tree_writer = TreeDataWriter_narrow(writer); if (Tree_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Create data sample for writing */ instance = TreeTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("TreeTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = TreeDataWriter_register_instance( Tree_writer, instance); */ /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { printf("Writing Tree, count %d\n", count); /* Modify the data to be written here */ fill_tree(instance, 1, count, count); /* Write data */ retcode = TreeDataWriter_write( Tree_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } NDDS_Utility_sleep(&send_period); } /* retcode = TreeDataWriter_unregister_instance( Tree_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = TreeTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("TreeTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
int main (int argc, char ** argv) #endif { /* Generic DDS entities */ DDS_DomainParticipantFactory dpf; DDS_DomainParticipant participant; DDS_Topic chatMessageTopic; DDS_Topic nameServiceTopic; DDS_Publisher chatPublisher; /* QosPolicy holders */ DDS_TopicQos *reliable_topic_qos; DDS_TopicQos *setting_topic_qos; DDS_PublisherQos *pub_qos; DDS_DataWriterQos *dw_qos; /* DDS Identifiers */ DDS_DomainId_t domain = NULL; DDS_InstanceHandle_t userHandle; DDS_ReturnCode_t status; /* Type-specific DDS entities */ Chat_ChatMessageTypeSupport chatMessageTS; Chat_NameServiceTypeSupport nameServiceTS; Chat_ChatMessageDataWriter talker; Chat_NameServiceDataWriter nameServer; /* Sample definitions */ Chat_ChatMessage *msg; /* Example on Heap */ Chat_NameService ns; /* Example on Stack */ /* Others */ int ownID = 1; int i; char *chatMessageTypeName = NULL; char *nameServiceTypeName = NULL; char *chatterName = NULL; char *partitionName = NULL; #ifdef INTEGRITY #ifdef CHATTER_QUIT ownID = -1; #else ownID = 1; #endif chatterName = "dds_user"; #else /* Options: Chatter [ownID [name]] */ if (argc > 1) { sscanf(argv[1], "%d", &ownID); if (argc > 2) { chatterName = argv[2]; } } #endif /* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings). */ dpf = DDS_DomainParticipantFactory_get_instance (); checkHandle(dpf, "DDS_DomainParticipantFactory_get_instance"); participant = DDS_DomainParticipantFactory_create_participant ( dpf, domain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); checkHandle(participant, "DDS_DomainParticipantFactory_create_participant"); /* Register the required datatype for ChatMessage. */ chatMessageTS = Chat_ChatMessageTypeSupport__alloc(); checkHandle(chatMessageTS, "Chat_ChatMessageTypeSupport__alloc"); chatMessageTypeName = Chat_ChatMessageTypeSupport_get_type_name(chatMessageTS); status = Chat_ChatMessageTypeSupport_register_type( chatMessageTS, participant, chatMessageTypeName); checkStatus(status, "Chat_ChatMessageTypeSupport_register_type"); /* Register the required datatype for NameService. */ nameServiceTS = Chat_NameServiceTypeSupport__alloc(); checkHandle(nameServiceTS, "Chat_NameServiceTypeSupport__alloc"); nameServiceTypeName = Chat_NameServiceTypeSupport_get_type_name(nameServiceTS); status = Chat_NameServiceTypeSupport_register_type( nameServiceTS, participant, nameServiceTypeName); checkStatus(status, "Chat_NameServiceTypeSupport_register_type"); /* Set the ReliabilityQosPolicy to RELIABLE. */ reliable_topic_qos = DDS_TopicQos__alloc(); checkHandle(reliable_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); reliable_topic_qos->reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; /* Make the tailored QoS the new default. */ status = DDS_DomainParticipant_set_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_set_default_topic_qos"); /* Use the changed policy when defining the ChatMessage topic */ chatMessageTopic = DDS_DomainParticipant_create_topic( participant, "Chat_ChatMessage", chatMessageTypeName, reliable_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatMessageTopic, "DDS_DomainParticipant_create_topic (ChatMessage)"); /* Set the DurabilityQosPolicy to TRANSIENT. */ setting_topic_qos = DDS_TopicQos__alloc(); checkHandle(setting_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, setting_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); setting_topic_qos->durability.kind = DDS_TRANSIENT_DURABILITY_QOS; /* Create the NameService Topic. */ nameServiceTopic = DDS_DomainParticipant_create_topic( participant, "Chat_NameService", nameServiceTypeName, setting_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServiceTopic, "DDS_DomainParticipant_create_topic"); /* Adapt the default PublisherQos to write into the "ChatRoom" Partition. */ partitionName = "ChatRoom"; pub_qos = DDS_PublisherQos__alloc(); checkHandle(pub_qos, "DDS_PublisherQos__alloc"); status = DDS_DomainParticipant_get_default_publisher_qos (participant, pub_qos); checkStatus(status, "DDS_DomainParticipant_get_default_publisher_qos"); pub_qos->partition.name._length = 1; pub_qos->partition.name._maximum = 1; pub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); checkHandle(pub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf"); pub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName) ); checkHandle(pub_qos->partition.name._buffer[0], "DDS_string_alloc"); strcpy (pub_qos->partition.name._buffer[0], partitionName); /* Create a Publisher for the chatter application. */ chatPublisher = DDS_DomainParticipant_create_publisher(participant, pub_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatPublisher, "DDS_DomainParticipant_create_publisher"); /* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */ talker = DDS_Publisher_create_datawriter( chatPublisher, chatMessageTopic, DDS_DATAWRITER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(talker, "DDS_Publisher_create_datawriter (chatMessage)"); /* Create a DataWriter for the NameService Topic (using the appropriate QoS). */ dw_qos = DDS_DataWriterQos__alloc(); checkHandle(dw_qos, "DDS_DataWriterQos__alloc"); status = DDS_Publisher_get_default_datawriter_qos (chatPublisher, dw_qos); checkStatus(status, "DDS_Publisher_get_default_datawriter_qos"); status = DDS_Publisher_copy_from_topic_qos(chatPublisher, dw_qos, setting_topic_qos); checkStatus(status, "DDS_Publisher_copy_from_topic_qos"); dw_qos->writer_data_lifecycle.autodispose_unregistered_instances = FALSE; nameServer = DDS_Publisher_create_datawriter( chatPublisher, nameServiceTopic, dw_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServer, "DDS_Publisher_create_datawriter (NameService)"); /* Initialize the NameServer attributes located on stack. */ ns.userID = ownID; ns.name = DDS_string_alloc(Chat_MAX_NAME+1); checkHandle(ns.name, "DDS_string_alloc"); if (chatterName) { strncpy (ns.name, chatterName, Chat_MAX_NAME + 1); } else { snprintf(ns.name, Chat_MAX_NAME+1, "Chatter %d", ownID); } /* Write the user-information into the system (registering the instance implicitly). */ status = Chat_NameServiceDataWriter_write(nameServer, &ns, DDS_HANDLE_NIL); checkStatus(status, "Chat_ChatMessageDataWriter_write"); /* Initialize the chat messages on Heap. */ msg = Chat_ChatMessage__alloc(); checkHandle(msg, "Chat_ChatMessage__alloc"); msg->userID = ownID; msg->index = 0; msg->content = DDS_string_alloc(MAX_MSG_LEN); checkHandle(msg->content, "DDS_string_alloc"); if (ownID == TERMINATION_MESSAGE) { snprintf (msg->content, MAX_MSG_LEN, "Termination message."); } else { snprintf (msg->content, MAX_MSG_LEN, "Hi there, I will send you %d more messages.", NUM_MSG); } printf("Writing message: %s\n", msg->content); /* Register a chat message for this user (pre-allocating resources for it!!) */ userHandle = Chat_ChatMessageDataWriter_register_instance(talker, msg); /* Write a message using the pre-generated instance handle. */ status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_write"); sleep (1); /* do not run so fast! */ /* Write any number of messages, re-using the existing string-buffer: no leak!!. */ for (i = 1; i <= NUM_MSG && ownID != TERMINATION_MESSAGE; i++) { msg->index = i; snprintf ( msg->content, MAX_MSG_LEN, "Message no. %d", msg->index); printf("Writing message: %s\n", msg->content); status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_write"); sleep (1); /* do not run so fast! */ } /* Leave the room by disposing and unregistering the message instance. */ status = Chat_ChatMessageDataWriter_dispose(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_dispose"); status = Chat_ChatMessageDataWriter_unregister_instance(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_unregister_instance"); /* Also unregister our name. */ status = Chat_NameServiceDataWriter_unregister_instance(nameServer, &ns, DDS_HANDLE_NIL); checkStatus(status, "Chat_NameServiceDataWriter_unregister_instance"); /* Release the data-samples. */ DDS_free(ns.name); /* ns allocated on stack: explicit de-allocation of indirections!! */ DDS_free(msg); /* msg allocated on heap: implicit de-allocation of indirections!! */ /* Remove the DataWriters */ status = DDS_Publisher_delete_datawriter(chatPublisher, talker); checkStatus(status, "DDS_Publisher_delete_datawriter (talker)"); status = DDS_Publisher_delete_datawriter(chatPublisher, nameServer); checkStatus(status, "DDS_Publisher_delete_datawriter (nameServer)"); /* Remove the Publisher. */ status = DDS_DomainParticipant_delete_publisher(participant, chatPublisher); checkStatus(status, "DDS_DomainParticipant_delete_publisher"); /* Remove the Topics. */ status = DDS_DomainParticipant_delete_topic(participant, nameServiceTopic); checkStatus(status, "DDS_DomainParticipant_delete_topic (nameServiceTopic)"); status = DDS_DomainParticipant_delete_topic(participant, chatMessageTopic); checkStatus(status, "DDS_DomainParticipant_delete_topic (chatMessageTopic)"); /* De-allocate the QoS policies. */ DDS_free(reliable_topic_qos); DDS_free(setting_topic_qos); DDS_free(pub_qos); /* Note that DDS_free recursively de-allocates all indirections as well!! */ /* De-allocate the type-names and TypeSupport objects. */ DDS_free(nameServiceTypeName); DDS_free(chatMessageTypeName); DDS_free(nameServiceTS); DDS_free(chatMessageTS); /* Remove the DomainParticipant. */ status = DDS_DomainParticipantFactory_delete_participant(dpf, participant); checkStatus(status, "DDS_DomainParticipantFactory_delete_participant"); printf("Completed chatter example.\n"); fflush(stdout); return 0; }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; asyncDataWriter *async_writer = NULL; async *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; struct DDS_Duration_t send_period = {0,100000000}; /* struct DDS_DataWriterQos datawriter_qos = DDS_DataWriterQos_INITIALIZER;*/ /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register type before creating topic */ type_name = asyncTypeSupport_get_type_name(); retcode = asyncTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic( participant, "Example async", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer = DDS_Publisher_create_datawriter( publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } /* If you want to change the DataWriter's QoS programmatically rather than * using the XML file, you will need to add the following lines to your * code and comment out the create_datawriter call above. * * In this case, we set the publish mode qos to asynchronous publish mode, * which enables asynchronous publishing. We also set the flow controller * to be the fixed rate flow controller, and we increase the history depth. */ /* /* Start changes for Asynchronous_Publication */ /* Get default datawriter QoS to customize */ /* retcode = DDS_Publisher_get_default_datawriter_qos(publisher, &datawriter_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_datawriter_qos error\n"); return -1; } */ /* Since samples are only being sent once per second, datawriter will need to keep them on queue. History defaults to only keeping the last sample enqueued, so we increase that here. */ /* datawriter_qos.history.depth = 12; */ /* Set flowcontroller for datawriter */ /* datawriter_qos.publish_mode.kind = DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS; datawriter_qos.publish_mode.flow_controller_name = DDS_FIXED_RATE_FLOW_CONTROLLER_NAME; */ /* To create datawriter with default QoS, use DDS_DATAWRITER_QOS_DEFAULT instead of datawriter_qos */ /* writer = DDS_Publisher_create_datawriter( publisher, topic, &datawriter_qos, NULL, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } */ async_writer = asyncDataWriter_narrow(writer); if (async_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Create data sample for writing */ instance = asyncTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("asyncTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = asyncDataWriter_register_instance( async_writer, instance); */ /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { printf("Writing async, count %d\n", count); /* Modify the data to be written here */ /* send count as data. */ instance->x = count; /* Write data */ retcode = asyncDataWriter_write( async_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } NDDS_Utility_sleep(&send_period); } /* Changes for Asynchronous_Publication */ /* Give time for publisher to send out last few samples */ send_period.sec = 1; NDDS_Utility_sleep(&send_period); /* retcode = asyncDataWriter_unregister_instance( async_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = asyncTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("asyncTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
int main(int argc, char* argv[]) { int startTime = mstime(); DDS_PoolConstraints reqs; DDS_DomainParticipant domainParticipant; DDS_Publisher publisher; DDS_Subscriber subscriber; DDS_ReturnCode_t retCode; char *configTopicName[nofConfigTopics]; DDS_Topic configTopic[nofConfigTopics]; DDS_Topic stateTopic[nofStateTopics]; DDS_Topic statisticTopic[nofStatisticTopics]; DDS_DataWriterQos dataWriterQos; DDS_DataWriter configDataWriter[nofConfigTopics]; DDS_DataWriter stateDataWriter[nofStateTopics]; DDS_DataWriter statisticDataWriter[nofStatisticTopics]; DDS_DataReaderQos dataReaderQos; DDS_DataReader configDataReader[nofConfigTopics]; acceptance_high_end_Config config; acceptance_high_end_State state; acceptance_high_end_Statistic statistic; DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances]; DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances]; DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances]; int i = 0; int j = 0; int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0; int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0; int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0; int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0; printf("[0] Config topics start at %d...\r\n", firstConfigTopic); printf("[0] State topics start at %d...\r\n", firstStateTopic); printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic); printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off"); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic); struct stat buf; if (stat(file_name, &buf)) { printf ("[%d] Waiting for %s\r\n", mstime() - startTime, file_name); do { sleep(1); } while (stat(file_name, &buf)); printf ("[%d] Got %s!\r\n", mstime() - startTime, file_name); } } DDS_program_name (&argc, argv); DDS_entity_name ("Technicolor Limits Component"); DDS_get_default_pool_constraints(&reqs, ~0, 100); #ifdef MINIMAL_POOLS configure_minimal_pool_constraints (&reqs); #else configure_optimal_pool_constraints (&reqs); #endif DDS_set_pool_constraints(&reqs); #ifdef DDS_DEBUG DDS_Debug_start (); #endif /* Create domain participant... */ domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0); if (!domainParticipant) { fprintf(stderr, "Error creating domain participant.\r\n"); return -1; } printf("[%d] Created domain participant.\r\n", mstime() - startTime); sleep(1); /* Create publisher... */ publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0); if (!publisher) { fprintf(stderr, "Error creating publisher.\r\n"); return -1; } printf("[%d] Created publisher.\r\n", mstime() - startTime); sleep(1); /* Create subscriber... */ subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0); if (!subscriber) { fprintf(stderr, "Error creating subscriber.\r\n"); return -1; } printf("[%d] Created subscriber.\r\n", mstime() - startTime); sleep(1); /* Register types... */ retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered config type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered state type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered statistic type.\r\n", mstime() - startTime); sleep(1); /* Create topics... */ for (i = 0; i < nofConfigTopics; i++) { char topicName[32]; sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i); configTopicName[i] = strdup (topicName); configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0); if (!configTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics); for (i = 0; i < nofStateTopics; i++) { char topicName[32]; sprintf(topicName, "StateTopic%d", firstStateTopic + i); stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0); if (!stateTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics); for (i = 0; i < nofStatisticTopics; i++) { char topicName[32]; sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i); statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0); if (!statisticTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics); sleep(1); /* Create data writers... */ DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0); if (!configDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics); DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofStateTopics; i++) { stateDataWriter[i] = DDS_Publisher_create_datawriter(publisher, stateTopic[i], &dataWriterQos, NULL, 0); if (!stateDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d state data writers.\r\n", mstime() - startTime, nofStateTopics); DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); for (i = 0; i < nofStatisticTopics; i++) { statisticDataWriter[i] = DDS_Publisher_create_datawriter(publisher, statisticTopic[i], &dataWriterQos, NULL, 0); if (!statisticDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d statistic data writers.\r\n", mstime() - startTime, nofStatisticTopics); sleep(1); /* Create data readers... */ DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, NULL, 0); if (!configDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics); sleep(1); /* Register instances... */ for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; configInstance[i][j] = DDS_DataWriter_register_instance(configDataWriter[i], &config); if (!configInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; stateInstance[i][j] = DDS_DataWriter_register_instance(stateDataWriter[i], &state); if (!stateInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; statisticInstance[i][j] = DDS_DataWriter_register_instance(statisticDataWriter[i], &statistic); if (!statisticInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); sleep(1); /* Publish samples... */ for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; retCode = DDS_DataWriter_write(configDataWriter[i], &config, configInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d config samples.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; retCode = DDS_DataWriter_write(stateDataWriter[i], &state, stateInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d state samples.\r\n", mstime() - startTime, nofStateTopics * nofStateInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; retCode = DDS_DataWriter_write(statisticDataWriter[i], &statistic, statisticInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d statistic samples.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); sleep(1); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic + nofConfigTopics); FILE *f = fopen(file_name, "w"); fclose(f); } // dbg_printf ("Zzzzzzz ... \r\n"); sleep(TEST_TIME); // dbg_printf ("... o?\r\n"); /* Delete contained entities... */ // printf (" -- deleting contained entities.\r\n"); retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting contained entities.\r\n"); return -1; } for (i = 0; i < nofConfigTopics; i++) free (configTopicName[i]); // printf (" -- contained entities deleted!\r\n"); // sleep(TEST_TIME); /* Delete domain participants... */ retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting domain participant.\r\n"); return -1; } printf ("[%d] comp completed successfully.\r\n", mstime() - startTime); return 0; }
int main ( int argc, char *argv[]) { DDS_DomainParticipantFactory dpf; DDS_DomainParticipant dp; DDS_DomainId_t domain = DDS_DOMAIN_ID_DEFAULT; DDS_ReturnCode_t status; Chat_ChatMessageTypeSupport chatMessageTS; DDS_Topic chatMessageTopic; char *chatMessageTypeName; /* Create a DomainParticipantFactory and a DomainParticipant */ /* (using Default QoS settings). */ dpf = DDS_DomainParticipantFactory_get_instance(); if (!dpf) { printf("Creating ParticipantFactory failed!!\n"); exit(-1); } printf("Created ParticipantFactory.\n"); dp = DDS_DomainParticipantFactory_create_participant ( dpf, domain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (!dp) { printf("Creating Participant failed!!\n"); exit(-1); } printf("Created Participant.\n"); /* Register the required data type for ChatMessage. */ chatMessageTS = Chat_ChatMessageTypeSupport__alloc(); if (!chatMessageTS) { printf ("Allocating TypeSupport failed!!\n"); exit(-1); }; chatMessageTypeName = Chat_ChatMessageTypeSupport_get_type_name(chatMessageTS); status = Chat_ChatMessageTypeSupport_register_type( chatMessageTS, dp, chatMessageTypeName); if (status != DDS_RETCODE_OK) { printf("Registering data type failed. Status = %d\n", status); exit(-1); }; printf("Registered data type.\n"); /*Create the ChatMessage topic */ chatMessageTopic = DDS_DomainParticipant_create_topic( dp, "Chat_ChatMessage", chatMessageTypeName, DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (!chatMessageTopic) { printf("Creating ChatMessage topic failed!!\n"); exit(-1); }; printf("Created ChatMessage topic.\n"); DDS_PublisherQos *pub_qos; DDS_DataWriterQos *dw_qos; DDS_Publisher chatPublisher; Chat_ChatMessageDataWriter talker; Chat_NameServiceDataWriter nameServer; char *partitionName = NULL; DDS_Topic nameServiceTopic; /* Adapt the default PublisherQos to write into the "ChatRoom" Partition. */ partitionName = "ChatRoom"; pub_qos = DDS_PublisherQos__alloc(); if (!pub_qos) { printf("Allocating PublisherQos failed!!\n"); exit(-1); } status = DDS_DomainParticipant_get_default_publisher_qos ( dp, pub_qos); if (status != DDS_RETCODE_OK) { printf("Getting default publisher qos failed!!\n"); exit(-1); } pub_qos->partition.name._length = 1; pub_qos->partition.name._maximum = 1; pub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); if (!pub_qos->partition.name._buffer) { printf("Allocating partition name failed!!\n"); exit(-1); } pub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName)); if (!pub_qos->partition.name._buffer[0]) { printf("Allocating partition name failed!!\n"); exit(-1); } strcpy (pub_qos->partition.name._buffer[0], partitionName); /* Create a Publisher for the chatter application. */ chatPublisher = DDS_DomainParticipant_create_publisher( dp, pub_qos, NULL, DDS_STATUS_MASK_NONE); if (!chatPublisher) { printf("Creating publisher failed!!\n"); exit(-1); } printf("Created publisher.\n"); /* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */ talker = DDS_Publisher_create_datawriter( chatPublisher, chatMessageTopic, DDS_DATAWRITER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); if (!talker) { printf("Creating datawriter failed!!\n"); exit(-1); } printf("Created datawriter.\n"); // Initialize message int ownID = 0; Chat_ChatMessage *msg; msg = Chat_ChatMessage__alloc(); //checkHandle(msg, "Chat_ChatMessage__alolc"); msg->userID = ownID; msg->index = 0; msg->content = DDS_string_alloc(MAX_MSG_LEN); //checkHandle(msg->content, "DDS_string_alloc"); snprintf(msg->content, MAX_MSG_LEN, "hello world"); // register a chat message DDS_InstanceHandle_t userHandle; userHandle = Chat_ChatMessageDataWriter_register_instance(talker, msg); Chat_NameService ns; ns.userID = ownID; ns.name = DDS_string_alloc(Chat_MAX_NAME+1); //checkHandle(ns.name, "DDS_string_alloc"); char *chatterName; if (chatterName) { strncpy(ns.name, chatterName, Chat_MAX_NAME + 1); } else { snprintf(ns.name, Chat_MAX_NAME+1, "Chatter %d", ownID); } // Write user information status = Chat_NameServiceDataWriter_write(nameServer, &ns, DDS_HANDLE_NIL); //checkStatus(status, "Chat_ChatMessageDataWriter_write"); // Write a message status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); // checkStatus(status, "Chat_ChatMessageDataWriter_write"); // pause sleep(1); int i = 0; for (i = 1; i < 6; ++i) { msg->index = i; snprintf(msg->content, MAX_MSG_LEN, "Message number: %d", msg->index); status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); // checkStatus(status, "Chat_ChatMessageDataWriter_write"); sleep(1); } /* Remove the DataWriters */ status = DDS_Publisher_delete_datawriter(chatPublisher, talker); if (status != DDS_RETCODE_OK) { printf("Deleting datawriter failed!!\n"); exit(-1); } printf("Deleted datawriter.\n"); /*status = DDS_Publisher_delete_datawriter( chatPublisher, nameServer); if (status != DDS_RETCODE_OK) { printf("Deleting datawriter (NameService) failed!!\n"); exit(-1); } printf("Deleted datawriter (NameService).\n");*/ /* Remove the Publisher. */ status = DDS_DomainParticipant_delete_publisher( dp, chatPublisher); if (status != DDS_RETCODE_OK) { printf("Deleting publisher failed!!\n"); exit(-1); } /* De-allocate the PublisherQoS holder. */ DDS_free(pub_qos); // Note that DDS_free recursively // de-allocates all indirections!! printf("Deleted publisher.\n"); /* Deleting the Topic. */ status = DDS_DomainParticipant_delete_topic( dp, chatMessageTopic); if (status != DDS_RETCODE_OK) { printf("Deleting topic failed. Status = %d\n", status); exit(-1); }; printf("Deleted ChatMessage topic.\n"); /* Deleting the DomainParticipant */ status = DDS_DomainParticipantFactory_delete_participant( dpf, dp); if (status != DDS_RETCODE_OK) { printf("Deleting participant failed. Status = %d\n", status); exit(-1); }; printf("Deleted Participant.\n"); /* Everything is fine, return normally. */ return 0; };
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; queryconditionDataWriter *querycondition_writer = NULL; querycondition *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; /* Send a new sample every second */ struct DDS_Duration_t send_period = {1,0}; /* Set up some unique IDs that can be used for the data type */ char *myIds[] = {"GUID1", "GUID2", "GUID3"}; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register type before creating topic */ type_name = queryconditionTypeSupport_get_type_name(); retcode = queryconditionTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic( participant, "Example querycondition", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer = DDS_Publisher_create_datawriter( publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } querycondition_writer = queryconditionDataWriter_narrow(writer); if (querycondition_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Create data sample for writing */ instance = queryconditionTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("queryconditionTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = queryconditionDataWriter_register_instance( querycondition_writer, instance); */ /* Initialize random seed before entering the loop */ srand(time(NULL)); /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { /* Modify the data to be written here */ /* Set id to be one of the three options */ sprintf(instance->id, "%s", myIds[count%3]); /* Set x to a random number between 0 and 9 */ instance->value = (int)(rand()/(RAND_MAX/10.0)); printf("Writing querycondition, count %d, id = %s, value = %d\n", count, instance->id, instance->value); /* Write data */ retcode = queryconditionDataWriter_write( querycondition_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } NDDS_Utility_sleep(&send_period); } /* retcode = queryconditionDataWriter_unregister_instance( querycondition_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = queryconditionTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("queryconditionTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; deadline_contentfilterDataWriter *deadline_contentfilter_writer = NULL; DDS_ReturnCode_t retcode; const char *type_name = NULL; int count = 0; struct DDS_Duration_t deadline_period = {1, 500000000}; /* 1.5sec */ struct DDS_Duration_t send_period = {1,0}; deadline_contentfilter *instance0 = NULL; deadline_contentfilter *instance1 = NULL; DDS_InstanceHandle_t handle0 = DDS_HANDLE_NIL; DDS_InstanceHandle_t handle1 = DDS_HANDLE_NIL; /*struct DDS_DataWriterQos datawriter_qos = DDS_DataWriterQos_INITIALIZER;*/ /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register type before creating topic */ type_name = deadline_contentfilterTypeSupport_get_type_name(); retcode = deadline_contentfilterTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic( participant, "Example deadline_contentfilter", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer = DDS_Publisher_create_datawriter( publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } /* If you want to change the DataWriter's QoS programmatically rather than * using the XML file, you will need to add the following lines to your * code and comment out the create_datawriter call above. * * In this case, we set the deadline period to 1.5 seconds to trigger * a deadline if the DataWriter does not update often enough. */ /* Start changes for Deadline */ /* writer_listener.on_offered_deadline_missed = deadlineListener_on_offered_deadline_missed; retcode = DDS_Publisher_get_default_datawriter_qos(publisher, &datawriter_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_datawriter_qos error\n"); return -1; } */ /* Set deadline QoS */ /* datawriter_qos.deadline.period = deadline_period; writer = DDS_Publisher_create_datawriter( publisher, topic, &datawriter_qos, &writer_listener, DDS_OFFERED_DEADLINE_MISSED_STATUS); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } */ /* End changes for Deadline */ deadline_contentfilter_writer = deadline_contentfilterDataWriter_narrow(writer); if (deadline_contentfilter_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Start changes for Deadline */ /* Create data sample for writing */ instance0 = deadline_contentfilterTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); instance1 = deadline_contentfilterTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance0 == NULL || instance1 == NULL) { printf("deadlineTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* Set keys -- we specify 'code' as the key field in the .idl */ instance0->code = 0; instance1->code = 1; /* For data type that has key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ handle0 = deadline_contentfilterDataWriter_register_instance( deadline_contentfilter_writer, instance0); handle1 = deadline_contentfilterDataWriter_register_instance( deadline_contentfilter_writer, instance1); instance0->x = instance0->y = instance1->x = instance1->y = 0; /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { NDDS_Utility_sleep(&send_period); instance0->x++; instance0->y++; instance1->x++; instance1->y++; printf("Writing instance0, x = %d, y = %d\n", instance0->x, instance0->y); retcode = deadline_contentfilterDataWriter_write( deadline_contentfilter_writer, instance0, &handle0); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } if (count < 15) { printf("Writing instance1, x = %d, y = %d\n", instance1->x, instance1->y); retcode = deadline_contentfilterDataWriter_write( deadline_contentfilter_writer, instance1, &handle1); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } } else if (count == 15) { printf("Stopping writes to instance1\n"); } } retcode = deadline_contentfilterDataWriter_unregister_instance( deadline_contentfilter_writer, instance0, &handle0); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } retcode = deadline_contentfilterDataWriter_unregister_instance( deadline_contentfilter_writer, instance1, &handle1); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } /* Delete data sample */ retcode = deadline_contentfilterTypeSupport_delete_data_ex(instance0, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("deadline_contentfilterTypeSupport_delete_data_ex error %d\n", retcode); } retcode = deadline_contentfilterTypeSupport_delete_data_ex(instance1, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("deadline_contentfilterTypeSupport_delete_data_ex error %d\n", retcode); } /* End changes for Deadline */ /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; cftDataWriter *cft_writer = NULL; cft *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; /* Send a new sample every second */ struct DDS_Duration_t send_period = {1,0}; /* We need this structure in case we want to change the datawriter_qos * programmatically.*/ struct DDS_DataWriterQos datawriter_qos = DDS_DataWriterQos_INITIALIZER; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register type before creating topic */ type_name = cftTypeSupport_get_type_name(); retcode = cftTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic( participant, "Example cft", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer = DDS_Publisher_create_datawriter( publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } /* If you want to set the reliability and history QoS settings * programmatically rather than using the XML, you will need to add * the following lines to your code and comment out the create_datawriter * call above. */ /* retcode = DDS_Publisher_get_default_datawriter_qos(publisher, &datawriter_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_datawriter_qos error\n"); return -1; } datawriter_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; datawriter_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; datawriter_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; datawriter_qos.history.depth = 20; writer = DDS_Publisher_create_datawriter( publisher, topic, &datawriter_qos, NULL, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } */ cft_writer = cftDataWriter_narrow(writer); if (cft_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Create data sample for writing */ instance = cftTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("cftTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = cftDataWriter_register_instance( cft_writer, instance); */ /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { /* Modify the data to be written here */ /* Our purpose is to increment x every time we send a sample and to * reset the x counter to 0 every time we send 10 samples (x=0,1,..,9). * Using the value of count, we can get set x to the appropriate value * applying % 10 operation to it. */ instance->count = count; instance->x = count%10; printf("Writing cft, count %d\tx=%d\n", instance->count, instance->x); /* Write data */ retcode = cftDataWriter_write( cft_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } NDDS_Utility_sleep(&send_period); } /* retcode = cftDataWriter_unregister_instance( cft_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = cftTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("cftTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
static void test_qos (int enabled) { DDS_DomainParticipantFactoryQos qos; DDS_DomainParticipant p; DDS_Publisher pub; DDS_Subscriber sub; DDS_DataWriter dw; DDS_DataReader dr; DDS_Topic t; DDS_TopicDescription td; DDS_SubscriberQos psq, refsq; DDS_ReturnCode_t r; static char *buf [] = { "Hello", "World" }; static unsigned char data [] = { 0x77, 0x88, 0xaa, 0xbb, 0xcc }; unsigned char d2 [sizeof (data) + 1]; unsigned n; size_t i; int err; v_printf (" - Set factory QoS to %sabled.\r\n", (enabled) ? "en" : "dis"); r = DDS_DomainParticipantFactory_get_qos (&qos); fail_unless (r == DDS_RETCODE_OK); qos.entity_factory.autoenable_created_entities = enabled; r = DDS_DomainParticipantFactory_set_qos (&qos); fail_unless (r == DDS_RETCODE_OK); p = DDS_DomainParticipantFactory_create_participant (1, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); DDS_SubscriberQos__init (&refsq); for (i = 0; (size_t) i < sizeof (buf) / sizeof (char *); i++) { err = dds_seq_append (&refsq.partition.name, &buf [i]); fail_unless (err == 0); } err = dds_seq_from_array (&refsq.group_data, data, sizeof (data)); fail_unless (err == 0); v_printf (" - Create subscriber with specific QoS parameters.\r\n"); sub = DDS_DomainParticipant_create_subscriber (p, &refsq, NULL, 0); fail_unless (sub != NULL); memset (&psq, 0, sizeof (psq)); r = DDS_Subscriber_get_qos (sub, &psq); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (refsq.partition.name) == DDS_SEQ_LENGTH (psq.partition.name) && DDS_SEQ_LENGTH (refsq.group_data.value) == sizeof (data)); DDS_SEQ_FOREACH (refsq.partition.name, i) fail_unless (!strcmp (DDS_SEQ_ITEM (psq.partition.name, i), DDS_SEQ_ITEM (refsq.partition.name, i))); n = dds_seq_to_array (&psq.group_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_SubscriberQos__clear (&psq); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); v_printf (" - Create topic/publisher/writer/subscriber/reader entities.\r\n"); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); pub = DDS_DomainParticipant_create_publisher (p, DDS_PUBLISHER_QOS_DEFAULT, NULL, 0); fail_unless (pub != NULL); dw = DDS_Publisher_create_datawriter (pub, t, DDS_DATAWRITER_QOS_DEFAULT, NULL, 0); fail_unless (dw != NULL); sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); dr = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr != NULL); v_printf (" - Update subscriber QoS.\r\n"); r = DDS_Subscriber_get_qos (sub, &psq); fail_unless (r == DDS_RETCODE_OK); DDS_SubscriberQos__clear (&refsq); fail_unless (r == DDS_RETCODE_OK && !memcmp (&psq, &refsq, sizeof (refsq))); for (i = 0; (size_t) i < sizeof (buf) / sizeof (char *); i++) { err = dds_seq_append (&refsq.partition.name, &buf [i]); fail_unless (err == 0); } err = dds_seq_from_array (&refsq.group_data, data, sizeof (data)); fail_unless (err == 0); r = DDS_Subscriber_set_qos (sub, &refsq); fail_unless (r == DDS_RETCODE_OK); delay (); r = DDS_Subscriber_get_qos (sub, &psq); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (refsq.partition.name) == DDS_SEQ_LENGTH (psq.partition.name) && DDS_SEQ_LENGTH (psq.group_data.value) == sizeof (data)); DDS_SEQ_FOREACH (psq.partition.name, i) fail_unless (!strcmp (DDS_SEQ_ITEM (psq.partition.name, i), DDS_SEQ_ITEM (refsq.partition.name, i))); n = dds_seq_to_array (&psq.group_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_SubscriberQos__clear (&refsq); DDS_SubscriberQos__clear (&psq); delay (); if (!enabled) { v_printf (" - Enable child entities.\r\n"); r = DDS_DomainParticipant_enable (p); fail_unless (r == DDS_RETCODE_OK); r = DDS_Topic_enable (t); fail_unless (r == DDS_RETCODE_OK); r = DDS_Publisher_enable (pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_enable (sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataWriter_enable (dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_enable (dr); fail_unless (r == DDS_RETCODE_OK); sleep (1); } v_printf (" - Delete child entities.\r\n"); r = DDS_Publisher_delete_datawriter (pub, dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_publisher (p, pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; listenersDataWriter *listeners_writer = NULL; listeners *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; struct DDS_DataWriterListener writer_listener = DDS_DataWriterListener_INITIALIZER; DDS_Topic *inconsistent_topic = NULL; DDS_DataWriter *inconsistent_topic_writer = NULL; const char *inconsistent_topic_type_name = NULL; msgDataWriter *msg_writer = NULL; int count = 0; struct DDS_Duration_t send_period = {1,0}; struct DDS_Duration_t sleep_period = {2,0}; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant(DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher(participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Create ande Delete Inconsistent Topic * --------------------------------------------------------------- * Here we create an inconsistent topic to trigger the subscriber * application's callback. * The inconsistent topic is created with the topic name used in * the Subscriber application, but with a different data type -- * the msg data type defined in partitions.idl. * Once it is created, we sleep to ensure the applications discover * each other and delete the Data Writer and Topic. */ /* First we register the msg type -- we name it * inconsistent_topic_type_name to avoid confusion. */ printf("Creating Inconsistent Topic... \n"); inconsistent_topic_type_name = msgTypeSupport_get_type_name(); retcode = msgTypeSupport_register_type(participant, inconsistent_topic_type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } inconsistent_topic = DDS_DomainParticipant_create_topic(participant, "Example listeners", inconsistent_topic_type_name, &DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (inconsistent_topic == NULL) { printf("create_topic error (inconsistent topic)\n"); publisher_shutdown(participant); return -1; } /* We have to associate a writer to the topic, as Topic information is not * actually propagated until the creation of an associated writer. */ inconsistent_topic_writer = DDS_Publisher_create_datawriter(publisher, inconsistent_topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (inconsistent_topic_writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } msg_writer = msgDataWriter_narrow(inconsistent_topic_writer); if (msg_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Sleep to leave time for applications to discover each other */ NDDS_Utility_sleep(&sleep_period); /* Before creating the "consistent" topic, we delete the Data Writer and the * inconsistent topic. */ retcode = DDS_Publisher_delete_datawriter(publisher, inconsistent_topic_writer); if (retcode != DDS_RETCODE_OK) { printf("delete_datawriter error %d\n", retcode); publisher_shutdown(participant); return -1; } retcode = DDS_DomainParticipant_delete_topic(participant, inconsistent_topic); if (retcode != DDS_RETCODE_OK) { printf("delete_topic error %d\n", retcode); publisher_shutdown(participant); return -1; } printf("... Deleted Inconsistent Topic\n\n"); /* Create Consistent Topic * ----------------------------------------------------------------- * Once we have created the inconsistent topic with the wrong type, * we create a topic with the right type name -- listeners -- that we * will use to publish data. */ /* Register type before creating topic */ type_name = listenersTypeSupport_get_type_name(); retcode = listenersTypeSupport_register_type(participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic(participant, "Example listeners", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* We will use the Data Writer Listener defined above to print * a message when some of events are triggered in the DataWriter. * To do that, first we have to pass the writer_listener and then * we have to enable all status in the status mask. */ /* Set up participant listener */ writer_listener.on_offered_deadline_missed = DataWriterListener_on_offered_deadline_missed; writer_listener.on_liveliness_lost = DataWriterListener_on_liveliness_lost; writer_listener.on_offered_incompatible_qos = DataWriterListener_on_offered_incompatible_qos; writer_listener.on_publication_matched = DataWriterListener_on_publication_matched; writer_listener.on_reliable_writer_cache_changed = DataWriterListener_on_reliable_writer_cache_changed; writer_listener.on_reliable_reader_activity_changed = DataWriterListener_on_reliable_reader_activity_changed; writer = DDS_Publisher_create_datawriter(publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, &writer_listener /* listener */, DDS_STATUS_MASK_ALL /* enable all statuses */); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } listeners_writer = listenersDataWriter_narrow(writer); if (listeners_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Create data sample for writing */ instance = listenersTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("listenersTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = listenersDataWriter_register_instance( listeners_writer, instance); */ printf("Publishing data using Consinstent Topic... \n"); /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { printf("Writing listeners, count %d\n", count); /* Modify the data to be written here */ instance->x = count; /* Write data */ retcode = listenersDataWriter_write( listeners_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } NDDS_Utility_sleep(&send_period); } /* retcode = listenersDataWriter_unregister_instance( listeners_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = listenersTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("listenersTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
DDS_MultiTopic DDS_DomainParticipant_create_simulated_multitopic ( DDS_DomainParticipant participant, const DDS_char *name, const DDS_char *type_name, const DDS_char *subscription_expression, const DDS_StringSeq *expression_parameters ) { /* Type-specific DDS entities */ static Chat_ChatMessageDataReader chatMessageDR; static Chat_NameServiceDataReader nameServiceDR; static Chat_NamedMessageDataWriter namedMessageDW; /* Query related stuff */ static DDS_QueryCondition nameFinder; static DDS_StringSeq *nameFinderParams; /* QosPolicy holders */ DDS_TopicQos *namedMessageQos; DDS_SubscriberQos *sub_qos; DDS_PublisherQos *pub_qos; /* Others */ const char *partitionName = "ChatRoom"; const char *nameFinderExpr; struct MsgListenerState *listener_state; DDS_Duration_t infiniteTimeOut = DDS_DURATION_INFINITE; DDS_ReturnCode_t status; /* Lookup both components that constitute the multi-topic. */ chatMessageTopic = DDS_DomainParticipant_find_topic( participant, "Chat_ChatMessage", &infiniteTimeOut); checkHandle(chatMessageTopic, "DDS_DomainParticipant_find_topic (Chat_ChatMessage)"); nameServiceTopic = DDS_DomainParticipant_find_topic( participant, "Chat_NameService", &infiniteTimeOut); checkHandle(nameServiceTopic, "DDS_DomainParticipant_find_topic (Chat_NameService)"); /* Create a ContentFilteredTopic to filter out our own ChatMessages. */ filteredMessageTopic = DDS_DomainParticipant_create_contentfilteredtopic( participant, "Chat_FilteredMessage", chatMessageTopic, "userID <> %0", expression_parameters); checkHandle(filteredMessageTopic, "DDS_DomainParticipant_create_contentfilteredtopic"); /* Adapt the default SubscriberQos to read from the "ChatRoom" Partition. */ sub_qos = DDS_SubscriberQos__alloc(); checkHandle(sub_qos, "DDS_SubscriberQos__alloc"); status = DDS_DomainParticipant_get_default_subscriber_qos (participant, sub_qos); checkStatus(status, "DDS_DomainParticipant_get_default_subscriber_qos"); sub_qos->partition.name._length = 1; sub_qos->partition.name._maximum = 1; sub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); checkHandle(sub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf"); sub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName) ); checkHandle(sub_qos->partition.name._buffer[0], "DDS_string_alloc"); strcpy (sub_qos->partition.name._buffer[0], partitionName); /* Create a private Subscriber for the multitopic simulator. */ multiSub = DDS_DomainParticipant_create_subscriber(participant, sub_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(multiSub, "DDS_DomainParticipant_create_subscriber (for multitopic)"); /* Create a DataReader for the FilteredMessage Topic (using the appropriate QoS). */ chatMessageDR = DDS_Subscriber_create_datareader( multiSub, filteredMessageTopic, DDS_DATAREADER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatMessageDR, "DDS_Subscriber_create_datareader (ChatMessage)"); /* Create a DataReader for the nameService Topic (using the appropriate QoS). */ nameServiceDR = DDS_Subscriber_create_datareader( multiSub, nameServiceTopic, DDS_DATAREADER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServiceDR, "DDS_Subscriber_create_datareader (NameService)"); /* Define the SQL expression (using a parameterized value). */ nameFinderExpr = "userID = %0"; /* Allocate and assign the query parameters. */ nameFinderParams = DDS_StringSeq__alloc(); checkHandle(nameFinderParams, "DDS_StringSeq__alloc"); nameFinderParams->_length = 1; nameFinderParams->_maximum = 1; nameFinderParams->_buffer = DDS_StringSeq_allocbuf (1); checkHandle(nameFinderParams->_buffer, "DDS_StringSeq_allocbuf"); nameFinderParams->_buffer[0] = DDS_string_alloc ( MAX_INT_LENGTH ); checkHandle(nameFinderParams->_buffer[0], "DDS_string_alloc"); strcpy(nameFinderParams->_buffer[0], "0"); DDS_sequence_set_release(nameFinderParams, TRUE); /* Create a QueryCondition to only read corresponding nameService information by key-value. */ nameFinder = DDS_DataReader_create_querycondition( nameServiceDR, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE, nameFinderExpr, nameFinderParams); checkHandle(nameFinder, "DDS_DataReader_create_querycondition (nameFinder)"); /* Create the Topic that simulates the multi-topic (use Qos from chatMessage).*/ namedMessageQos = DDS_TopicQos__alloc(); checkHandle(namedMessageQos, "DDS_TopicQos__alloc"); status = DDS_Topic_get_qos(chatMessageTopic, namedMessageQos); checkStatus(status, "DDS_Topic_get_qos"); /* Create the NamedMessage Topic whose samples simulate the MultiTopic */ namedMessageTopic = DDS_DomainParticipant_create_topic( participant, "Chat_NamedMessage", type_name, namedMessageQos, NULL, DDS_STATUS_MASK_NONE); checkHandle(namedMessageTopic, "DDS_DomainParticipant_create_topic (NamedMessage)"); /* Adapt the default PublisherQos to write into the "ChatRoom" Partition. */ pub_qos = DDS_PublisherQos__alloc(); checkHandle(pub_qos, "DDS_PublisherQos__alloc"); status = DDS_DomainParticipant_get_default_publisher_qos (participant, pub_qos); checkStatus(status, "DDS_DomainParticipant_get_default_publisher_qos"); pub_qos->partition.name._length = 1; pub_qos->partition.name._maximum = 1; pub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); checkHandle(pub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf"); pub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName) ); checkHandle(pub_qos->partition.name._buffer[0], "DDS_string_alloc"); strcpy (pub_qos->partition.name._buffer[0], partitionName); /* Create a private Publisher for the multitopic simulator. */ multiPub = DDS_DomainParticipant_create_publisher(participant, pub_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(multiPub, "DDS_DomainParticipant_create_publisher (for multitopic)"); /* Create a DataWriter for the multitopic. */ namedMessageDW = DDS_Publisher_create_datawriter( multiPub, namedMessageTopic, DDS_DATAWRITER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(namedMessageDW, "DDS_Publisher_create_datawriter (NamedMessage)"); /* Allocate the DataReaderListener interface. */ msgListener = DDS_DataReaderListener__alloc(); checkHandle(msgListener, "DDS_DataReaderListener__alloc"); /* Fill the listener_data with pointers to all entities needed by the Listener implementation. */ listener_state = malloc(sizeof(struct MsgListenerState)); checkHandle(listener_state, "malloc"); listener_state->chatMessageDR = chatMessageDR; listener_state->nameServiceDR = nameServiceDR; listener_state->namedMessageDW = namedMessageDW; listener_state->nameFinder = nameFinder; listener_state->nameFinderParams = nameFinderParams; msgListener->listener_data = listener_state; /* Assign the function pointer attributes to their implementation functions. */ msgListener->on_data_available = (void (*)(void *, DDS_DataReader)) on_message_available; msgListener->on_requested_deadline_missed = NULL; msgListener->on_requested_incompatible_qos = NULL; msgListener->on_sample_rejected = NULL; msgListener->on_liveliness_changed = NULL; msgListener->on_subscription_matched = NULL; msgListener->on_sample_lost = NULL; /* Attach the DataReaderListener to the DataReader, only enabling the data_available event. */ status = DDS_DataReader_set_listener(chatMessageDR, msgListener, DDS_DATA_AVAILABLE_STATUS); checkStatus(status, "DDS_DataReader_set_listener"); /* Free up all resources that are no longer needed. */ DDS_free(namedMessageQos); DDS_free(sub_qos); DDS_free(pub_qos); /* Return the simulated Multitopic. */ return namedMessageTopic; }
int OSPL_MAIN (int argc, char ** argv) #endif { DDS_ConditionSeq *conditionList; DDS_WaitSet w; DDS_DomainParticipantQos *dpQos; DDS_TopicQos *tQos; DDS_PublisherQos *pQos; DDS_DataWriterQos *dwQos; DDS_SubscriberQos *sQos; DDS_DataReaderQos *drQos; DDS_Condition exp_condition = NULL; pong_handler *active_handler = NULL; DDS_Duration_t wait_timeout = {3,0}; DDS_boolean finish_flag = FALSE; DDS_boolean timeout_flag = FALSE; DDS_boolean terminate = FALSE; DDS_ReturnCode_t result; int imax = 1; int i; unsigned int block; printf ("Starting ping example\n"); fflush(stdout); /* * init timing statistics */ init_stats (&roundtrip, "round_trip"); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); /* * Evaluate cmdline arguments */ #ifdef INTEGRITY nof_blocks = 100; nof_cycles = 100; #if defined (PING1) topic_id = 'm'; #elif defined (PING2) topic_id = 'q'; #elif defined (PING3) topic_id = 's'; #elif defined (PING4) topic_id = 'f'; #elif defined (PING5) topic_id = 'b'; #elif defined (PING6) nof_blocks = 1; nof_cycles = 10; topic_id = 't'; #endif write_partition = "PongRead"; read_partition = "PongWrite"; #else if (argc != 1) { if (argc != 6) { printf ("Invalid.....\n Usage: %s [blocks blocksize topic_id WRITE_PARTITION READ_PARTITION]\n", argv[0]); exit (1); } nof_blocks = atoi (argv[1]); nof_cycles = atoi (argv[2]); topic_id = argv[3][0]; write_partition = argv[4]; read_partition = argv[5]; } #endif #ifdef _WIN32 init_clock(); #endif /* * Create WaitSet */ w = DDS_WaitSet__alloc (); /* * Initialize Qos variables */ dpQos = DDS_DomainParticipantQos__alloc(); tQos = DDS_TopicQos__alloc(); pQos = DDS_PublisherQos__alloc(); dwQos = DDS_DataWriterQos__alloc(); sQos = DDS_SubscriberQos__alloc(); drQos = DDS_DataReaderQos__alloc(); /* * Initialize condition list */ conditionList = NULL; /* * Create participant */ dpf = DDS_DomainParticipantFactory_get_instance (); dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (dp == DDS_HANDLE_NIL) { printf ("%s PING: ERROR - Splice Daemon not running", argv[0]); exit (1); } /* * Create PING publisher */ DDS_DomainParticipant_get_default_publisher_qos (dp, pQos); pQos->partition.name._length = 1; pQos->partition.name._maximum = 1; pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); pQos->partition.name._buffer[0] = DDS_string_dup (write_partition); p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (pQos); /* * Create PONG subscriber */ DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos); sQos->partition.name._length = 1; sQos->partition.name._maximum = 1; sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); sQos->partition.name._buffer[0] = DDS_string_dup (read_partition); s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (sQos); /* * PP_min_msg */ /* Create Topic */ PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc (); pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg"); PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); DDS_Publisher_get_default_datawriter_qos(p, dwQos); dwQos->reliability.kind = DDS_BEST_EFFORT_RELIABILITY_QOS; dwQos->history.kind = DDS_KEEP_ALL_HISTORY_QOS; /* Create datawriter */ PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader); DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_min_sc); /* * PP_seq_msg */ /* Create Topic */ PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc (); pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg"); PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader); DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_seq_sc); /* * PP_string_msg */ /* Create Topic */ PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc (); pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg"); PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader); DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_string_sc); /* * PP_fixed_msg */ /* Create Topic */ PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc (); pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg"); PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader); DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_fixed_sc); /* * PP_array_msg */ /* Create Topic */ PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc (); pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg"); PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader); DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_array_sc); /* * PP_bseq_msg */ /* Create Topic */ PP_bseq_dt = pingpong_PP_bseq_msgTypeSupport__alloc (); pingpong_PP_bseq_msgTypeSupport_register_type (PP_bseq_dt, dp, "pingpong::PP_bseq_msg"); PP_bseq_topic = DDS_DomainParticipant_create_topic (dp, "PP_bseq_topic", "pingpong::PP_bseq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_bseq_writer = DDS_Publisher_create_datawriter (p, PP_bseq_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_bseq_reader = DDS_Subscriber_create_datareader (s, PP_bseq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_bseq_sc = DDS_DataReader_get_statuscondition (PP_bseq_reader); DDS_StatusCondition_set_enabled_statuses (PP_bseq_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_bseq_sc); /* * PP_quit_msg */ /* Create Topic */ PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc (); pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg"); PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_quit_writer = DDS_Publisher_create_datawriter (p, PP_quit_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Fr: workarround for ticket dds1712 */ conditionList = DDS_ConditionSeq__alloc(); assert(conditionList); DDS_WaitSet_wait (w, conditionList, &wait_timeout); DDS_free(conditionList); for (block = 0; block < nof_blocks && !terminate ; block++) { while (!finish_flag) { /* * Send Initial message */ timeout_flag = FALSE; switch(topic_id) { case 'm': { /* printf ("PING: sending initial ping_min\n"); */ pingpong_PP_min_msg *PPdata = pingpong_PP_min_msg__alloc (); exp_condition = PP_min_sc; active_handler = &PP_min_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); pingpong_PP_min_msgDataWriter_write (PP_min_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'q': { /* printf ("PING: sending initial ping_seq\n"); */ pingpong_PP_seq_msg *PPdata = pingpong_PP_seq_msg__alloc (); exp_condition = PP_seq_sc; active_handler = &PP_seq_handler; PPdata->count = 0; PPdata->block = block; { int i = 0; PPdata->payload._buffer = pingpong_seq_char_allocbuf(SEQ_PAYLOAD_SIZE); PPdata->payload._length = SEQ_PAYLOAD_SIZE; PPdata->payload._maximum = SEQ_PAYLOAD_SIZE; for (i=0; i<SEQ_PAYLOAD_SIZE; i++) { PPdata->payload._buffer[i] = (char)i; } } preWriteTime = timeGet (); pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 's': { /* printf ("PING: sending initial ping_string\n"); */ pingpong_PP_string_msg *PPdata = pingpong_PP_string_msg__alloc (); exp_condition = PP_string_sc; active_handler = &PP_string_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_string = DDS_string_dup ("a_string"); preWriteTime = timeGet (); pingpong_PP_string_msgDataWriter_write (PP_string_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'f': { /* printf ("PING: sending initial ping_fixed\n"); */ pingpong_PP_fixed_msg *PPdata = pingpong_PP_fixed_msg__alloc (); exp_condition = PP_fixed_sc; active_handler = &PP_fixed_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_bstring = DDS_string_dup ("a_bstring"); preWriteTime = timeGet (); pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'a': { /* printf ("PING: sending initial ping_array\n"); */ pingpong_PP_array_msg *PPdata = pingpong_PP_array_msg__alloc (); exp_condition = PP_array_sc; active_handler = &PP_array_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); pingpong_PP_array_msgDataWriter_write (PP_array_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'b': { /* printf ("PING: sending initial ping_bseq_msg\n"); */ pingpong_PP_bseq_msg *PPdata = pingpong_PP_bseq_msg__alloc (); exp_condition = PP_bseq_sc; active_handler = &PP_bseq_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); pingpong_PP_bseq_msgDataWriter_write (PP_bseq_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 't': { /* printf ("PING: sending initial ping_quit\n"); */ pingpong_PP_quit_msg *PPdata = pingpong_PP_quit_msg__alloc(); PPdata->quit = TRUE; terminate = TRUE; finish_flag = TRUE; sleep(1); preWriteTime = timeGet (); pingpong_PP_quit_msgDataWriter_write (PP_quit_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); sleep(1); DDS_free (PPdata); } break; default: printf("Invalid topic-id\n"); exit(1); } if (!terminate) { roundTripTime = preWriteTime; add_stats (&write_access, 1E6 * timeToReal (timeSub (postWriteTime, preWriteTime))); /* * Wait for response, calculate timing, and send another data if not ready */ while (!(timeout_flag || finish_flag)) { conditionList = DDS_ConditionSeq__alloc(); result = DDS_WaitSet_wait (w, conditionList, &wait_timeout); if(result == DDS_RETCODE_OK || result == DDS_RETCODE_NO_DATA || result == DDS_RETCODE_TIMEOUT) { if (conditionList) { imax = conditionList->_length; if (imax != 0) { for (i = 0; i < imax; i++) { if (conditionList->_buffer[i] == exp_condition) { finish_flag = active_handler (nof_cycles); } else { printf ("PING: unexpected condition triggered: %lx\n", (unsigned long)conditionList->_buffer[i]); } } } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } DDS_free(conditionList); } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } } else { printf ("PING: Waitset wait failed (code %d), terminating.\n", result); finish_flag = TRUE; terminate = TRUE; } } } } if (!terminate) { finish_flag = FALSE; if (block == 0) { printf ("# PING PONG measurements (in us) \n"); printf ("# Roundtrip time [us] Write-access time [us] Read-access time [us]\n"); printf ("# Block Count mean min max Count mean min max Count mean min max\n"); } printf ("%6d %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f\n", block, roundtrip.count, roundtrip.average, roundtrip.min, roundtrip.max, write_access.count, write_access.average, write_access.min, write_access.max, read_access.count, read_access.average, read_access.min, read_access.max); fflush (stdout); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); init_stats (&roundtrip, "round_trip"); } } DDS_Subscriber_delete_datareader (s, PP_min_reader); DDS_Publisher_delete_datawriter (p, PP_min_writer); DDS_Subscriber_delete_datareader (s, PP_seq_reader); DDS_Publisher_delete_datawriter (p, PP_seq_writer); DDS_Subscriber_delete_datareader (s, PP_string_reader); DDS_Publisher_delete_datawriter (p, PP_string_writer); DDS_Subscriber_delete_datareader (s, PP_fixed_reader); DDS_Publisher_delete_datawriter (p, PP_fixed_writer); DDS_Subscriber_delete_datareader (s, PP_array_reader); DDS_Publisher_delete_datawriter (p, PP_array_writer); DDS_Subscriber_delete_datareader (s, PP_bseq_reader); DDS_Publisher_delete_datawriter (p, PP_bseq_writer); DDS_Publisher_delete_datawriter (p, PP_quit_writer); DDS_DomainParticipant_delete_subscriber (dp, s); DDS_DomainParticipant_delete_publisher (dp, p); DDS_DomainParticipant_delete_topic (dp, PP_min_topic); DDS_DomainParticipant_delete_topic (dp, PP_seq_topic); DDS_DomainParticipant_delete_topic (dp, PP_string_topic); DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic); DDS_DomainParticipant_delete_topic (dp, PP_array_topic); DDS_DomainParticipant_delete_topic (dp, PP_bseq_topic); DDS_DomainParticipant_delete_topic (dp, PP_quit_topic); DDS_DomainParticipantFactory_delete_participant (dpf, dp); DDS_free (w); DDS_free (PP_min_dt); DDS_free (PP_seq_dt); DDS_free (PP_string_dt); DDS_free (PP_fixed_dt); DDS_free (PP_array_dt); DDS_free (PP_bseq_dt); DDS_free (PP_quit_dt); DDS_free (dpQos); DDS_free (tQos); DDS_free (dwQos); DDS_free (drQos); printf ("Completed ping example\n"); fflush(stdout); return 0; }
int main ( int argc, char *argv[] ) { DDS_ConditionSeq *conditionList; DDS_WaitSet w; DDS_Condition exp_condition; pong_handler *active_handler; DDS_DomainParticipantQos *dpQos; DDS_TopicQos *tQos; DDS_PublisherQos *pQos; DDS_DataWriterQos *dwQos; DDS_SubscriberQos *sQos; DDS_DataReaderQos *drQos; time_t clock = time (NULL); DDS_Duration_t wait_timeout = {3,0}; DDS_ReturnCode_t result; DDS_boolean finish_flag = FALSE; DDS_boolean timeout_flag = FALSE; DDS_boolean terminate = FALSE; int imax = 1; int i; unsigned int block; init_clock(); /* * init timing statistics */ init_stats (&roundtrip, "round_trip"); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); /* * Evaluate cmdline arguments */ if (argc != 1) { if (argc != 6) { printf ("Invalid.....\n Usage: %s [blocks blocksize topic_id WRITE_PARTITION READ_PARTITION]\n", argv[0]); exit (1); } nof_blocks = atoi (argv[1]); nof_cycles = atoi (argv[2]); topic_id = argv[3][0]; write_partition = argv[4]; read_partition = argv[5]; } /* * Create WaitSet */ w = DDS_WaitSet__alloc (); /* * Initialize Qos variables */ dpQos = DDS_DomainParticipantQos__alloc(); tQos = DDS_TopicQos__alloc(); pQos = DDS_PublisherQos__alloc(); dwQos = DDS_DataWriterQos__alloc(); sQos = DDS_SubscriberQos__alloc(); drQos = DDS_DataReaderQos__alloc(); /* * Initialize condition list */ conditionList = NULL; /* * Create participant */ dpf = DDS_DomainParticipantFactory_get_instance (); dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (dp == DDS_HANDLE_NIL) { printf ("%s PING: ERROR - Splice Daemon not running", argv[0]); exit (1); } /* * Create PING publisher */ DDS_DomainParticipant_get_default_publisher_qos (dp, pQos); pQos->partition.name._length = 1; pQos->partition.name._maximum = 1; pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); pQos->partition.name._buffer[0] = DDS_string_alloc (strlen(write_partition) + 1); strcpy (pQos->partition.name._buffer[0], write_partition); p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (pQos); /* * Create PONG subscriber */ DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos); sQos->partition.name._length = 1; sQos->partition.name._maximum = 1; sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); sQos->partition.name._buffer[0] = DDS_string_alloc (strlen(read_partition) + 1); strcpy (sQos->partition.name._buffer[0], read_partition); s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (sQos); /* * PP_min_msg */ /* Create Topic */ PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc (); pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg"); PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader); DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_min_sc); /* * PP_seq_msg */ /* Create Topic */ PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc (); pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg"); PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader); DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_seq_sc); /* * PP_string_msg */ /* Create Topic */ PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc (); pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg"); PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader); DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_string_sc); /* * PP_fixed_msg */ /* Create Topic */ PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc (); pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg"); PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader); DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_fixed_sc); /* * PP_array_msg */ /* Create Topic */ PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc (); pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg"); PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader); DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_array_sc); /* * PP_quit_msg */ /* Create Topic */ PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc (); pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg"); PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_quit_writer = DDS_Publisher_create_datawriter (p, PP_quit_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); for (block = 0; block < nof_blocks ; block++) { while (!finish_flag) { /* * Send Initial message */ timeout_flag = FALSE; switch(topic_id) { case 'm': { /* printf ("PING: sending initial ping_min\n"); */ pingpong_PP_min_msg *PPdata = pingpong_PP_min_msg__alloc (); exp_condition = PP_min_sc; active_handler = &PP_min_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); result = pingpong_PP_min_msgDataWriter_write (PP_min_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'q': { /* printf ("PING: sending initial ping_seq\n"); */ pingpong_PP_seq_msg *PPdata = pingpong_PP_seq_msg__alloc (); exp_condition = PP_seq_sc; active_handler = &PP_seq_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); result = pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 's': { /* printf ("PING: sending initial ping_string\n"); */ pingpong_PP_string_msg *PPdata = pingpong_PP_string_msg__alloc (); exp_condition = PP_string_sc; active_handler = &PP_string_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_string = DDS_string_alloc (8); strcpy (PPdata->a_string, "a_string"); preWriteTime = timeGet (); result = pingpong_PP_string_msgDataWriter_write (PP_string_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'f': { /* printf ("PING: sending initial ping_fixed\n"); */ pingpong_PP_fixed_msg *PPdata = pingpong_PP_fixed_msg__alloc (); exp_condition = PP_fixed_sc; active_handler = &PP_fixed_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_bstring = DDS_string_alloc (9); strcpy (PPdata->a_bstring, "a_bstring"); preWriteTime = timeGet (); result = pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'a': { /* printf ("PING: sending initial ping_array\n"); */ pingpong_PP_array_msg *PPdata = pingpong_PP_array_msg__alloc (); exp_condition = PP_array_sc; active_handler = &PP_array_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); result = pingpong_PP_array_msgDataWriter_write (PP_array_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 't': { /* printf ("PING: sending initial ping_quit\n"); */ pingpong_PP_quit_msg *PPdata = pingpong_PP_quit_msg__alloc(); PPdata->quit = TRUE; terminate = TRUE; finish_flag = TRUE; preWriteTime = timeGet (); result = pingpong_PP_quit_msgDataWriter_write (PP_quit_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; default: printf("Invalid topic-id\n"); exit(1); } if (!terminate) { roundTripTime = preWriteTime; add_stats (&write_access, 1E6 * timeToReal (timeSub (postWriteTime, preWriteTime))); /* * Wait for response, calculate timing, and send another data if not ready */ while (!(timeout_flag || finish_flag)) { conditionList = DDS_ConditionSeq__alloc(); result = DDS_WaitSet_wait (w, conditionList, &wait_timeout); if (conditionList) { imax = conditionList->_length; if (imax != 0) { for (i = 0; i < imax; i++) { if (conditionList->_buffer[i] == exp_condition) { finish_flag = active_handler (nof_cycles); } else { printf ("PING: unexpected condition triggered: %x\n", (unsigned int)conditionList->_buffer[i]); } } } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } DDS_free(conditionList); } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } } } } if (!terminate) { finish_flag = FALSE; if (block == 0) { printf ("# PING PONG measurements (in us) \n"); printf ("# Executed at: %s", ctime(&clock)); printf ("# Roundtrip time [us] Write-access time [us] Read-access time [us]\n"); printf ("# Block Count mean min max Count mean min max Count mean min max\n"); } printf ("%6d %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f\n", block, roundtrip.count, roundtrip.average, roundtrip.min, roundtrip.max, write_access.count, write_access.average, write_access.min, write_access.max, read_access.count, read_access.average, read_access.min, read_access.max); fflush (NULL); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); init_stats (&roundtrip, "round_trip"); } } result = DDS_Subscriber_delete_datareader (s, PP_min_reader); result = DDS_Publisher_delete_datawriter (p, PP_min_writer); result = DDS_Subscriber_delete_datareader (s, PP_seq_reader); result = DDS_Publisher_delete_datawriter (p, PP_seq_writer); result = DDS_Subscriber_delete_datareader (s, PP_string_reader); result = DDS_Publisher_delete_datawriter (p, PP_string_writer); result = DDS_Subscriber_delete_datareader (s, PP_fixed_reader); result = DDS_Publisher_delete_datawriter (p, PP_fixed_writer); result = DDS_Subscriber_delete_datareader (s, PP_array_reader); result = DDS_Publisher_delete_datawriter (p, PP_array_writer); result = DDS_Publisher_delete_datawriter (p, PP_quit_writer); result = DDS_DomainParticipant_delete_subscriber (dp, s); result = DDS_DomainParticipant_delete_publisher (dp, p); result = DDS_DomainParticipant_delete_topic (dp, PP_min_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_seq_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_string_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_array_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_quit_topic); result = DDS_DomainParticipantFactory_delete_participant (dpf, dp); DDS_free (w); DDS_free (PP_min_dt); DDS_free (PP_seq_dt); DDS_free (PP_string_dt); DDS_free (PP_fixed_dt); DDS_free (PP_array_dt); DDS_free (PP_quit_dt); DDS_free (dpQos); DDS_free (tQos); DDS_free (dwQos); DDS_free (drQos); return 0; }
int main ( int argc, char *argv[]) { DDS_DomainId_t myDomain = DDS_OBJECT_NIL; DDS_DomainParticipantFactory dpf = DDS_OBJECT_NIL; DDS_DomainParticipant dp = DDS_OBJECT_NIL; DDS_Publisher p = DDS_OBJECT_NIL; DDS_Subscriber s = DDS_OBJECT_NIL; pingpong_PP_min_msgDataWriter PP_min_writer = DDS_OBJECT_NIL; pingpong_PP_seq_msgDataWriter PP_seq_writer = DDS_OBJECT_NIL; pingpong_PP_string_msgDataWriter PP_string_writer = DDS_OBJECT_NIL; pingpong_PP_fixed_msgDataWriter PP_fixed_writer = DDS_OBJECT_NIL; pingpong_PP_array_msgDataWriter PP_array_writer = DDS_OBJECT_NIL; pingpong_PP_bseq_msgDataWriter PP_bseq_writer = DDS_OBJECT_NIL; pingpong_PP_min_msgDataReader PP_min_reader = DDS_OBJECT_NIL; pingpong_PP_seq_msgDataReader PP_seq_reader = DDS_OBJECT_NIL; pingpong_PP_string_msgDataReader PP_string_reader = DDS_OBJECT_NIL; pingpong_PP_fixed_msgDataReader PP_fixed_reader = DDS_OBJECT_NIL; pingpong_PP_array_msgDataReader PP_array_reader = DDS_OBJECT_NIL; pingpong_PP_bseq_msgDataReader PP_bseq_reader = DDS_OBJECT_NIL; pingpong_PP_quit_msgDataReader PP_quit_reader = DDS_OBJECT_NIL; pingpong_PP_min_msgTypeSupport PP_min_dt; pingpong_PP_seq_msgTypeSupport PP_seq_dt; pingpong_PP_string_msgTypeSupport PP_string_dt; pingpong_PP_fixed_msgTypeSupport PP_fixed_dt; pingpong_PP_array_msgTypeSupport PP_array_dt; pingpong_PP_bseq_msgTypeSupport PP_bseq_dt; pingpong_PP_quit_msgTypeSupport PP_quit_dt; DDS_sequence_pingpong_PP_min_msg PP_min_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_seq_msg PP_seq_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_string_msg PP_string_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_fixed_msg PP_fixed_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_array_msg PP_array_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_bseq_msg PP_bseq_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_quit_msg PP_quit_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_StatusCondition PP_min_sc; DDS_StatusCondition PP_seq_sc; DDS_StatusCondition PP_string_sc; DDS_StatusCondition PP_fixed_sc; DDS_StatusCondition PP_array_sc; DDS_StatusCondition PP_bseq_sc; DDS_StatusCondition PP_quit_sc; DDS_Topic PP_min_topic = DDS_OBJECT_NIL; DDS_Topic PP_seq_topic = DDS_OBJECT_NIL; DDS_Topic PP_string_topic = DDS_OBJECT_NIL; DDS_Topic PP_fixed_topic = DDS_OBJECT_NIL; DDS_Topic PP_array_topic = DDS_OBJECT_NIL; DDS_Topic PP_bseq_topic = DDS_OBJECT_NIL; DDS_Topic PP_quit_topic = DDS_OBJECT_NIL; DDS_ConditionSeq *conditionList; DDS_SampleInfoSeq infoList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_WaitSet w; DDS_DomainParticipantQos *dpQos; DDS_TopicQos *tQos; DDS_PublisherQos *pQos; DDS_DataWriterQos *dwQos; DDS_SubscriberQos *sQos; DDS_DataReaderQos *drQos; DDS_boolean terminate = FALSE; DDS_ReturnCode_t result; int i; int imax; int j; int jmax; printf ("Starting pong example\n"); fflush(stdout); /* * Evaluate cmdline arguments */ #ifdef INTEGRITY read_partition = "PongRead"; write_partition = "PongWrite"; #else if (argc != 1) { if (argc != 3) { printf ("Invalid.....\n Usage: %s [READ_PARTITION WRITE_PARTITION]\n", argv[0]); exit (1); } read_partition = argv[1]; write_partition = argv[2]; } #endif /* * Create WaitSet */ w = DDS_WaitSet__alloc (); /* * Initialize Qos variables */ dpQos = DDS_DomainParticipantQos__alloc(); tQos = DDS_TopicQos__alloc(); pQos = DDS_PublisherQos__alloc(); dwQos = DDS_DataWriterQos__alloc(); sQos = DDS_SubscriberQos__alloc(); drQos = DDS_DataReaderQos__alloc(); /* * Initialize condition list */ conditionList = NULL; /* * Create participant */ dpf = DDS_DomainParticipantFactory_get_instance (); dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (dp == DDS_OBJECT_NIL) { printf ("%s PONG: ERROR - Splice Daemon not running\n", argv[0]); exit(1); } /* * Create PONG publisher */ DDS_DomainParticipant_get_default_publisher_qos (dp, pQos); pQos->partition.name._length = 1; pQos->partition.name._maximum = 1; pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); pQos->partition.name._buffer[0] = DDS_string_alloc (strlen (write_partition) + 1); strcpy (pQos->partition.name._buffer[0], write_partition); p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (pQos); /* * Create PING subscriber */ DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos); sQos->partition.name._length = 1; sQos->partition.name._maximum = 1; sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); sQos->partition.name._buffer[0] = DDS_string_alloc (strlen (read_partition) + 1); strcpy (sQos->partition.name._buffer[0], read_partition); s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (sQos); /* * PP_min_msg */ /* Create Topic */ PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc (); pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg"); PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader); DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_min_sc); /* * PP_seq_msg */ /* Create Topic */ PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc (); pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg"); PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader); DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_seq_sc); /* * PP_string_msg */ /* Create Topic */ PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc (); pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg"); PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader); DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_string_sc); /* * PP_fixed_msg */ /* Create Topic */ PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc (); pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg"); PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader); DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_fixed_sc); /* * PP_array_msg */ /* Create Topic */ PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc (); pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg"); PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader); DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_array_sc); /* * PP_bseq_msg */ /* Create Topic */ PP_bseq_dt = pingpong_PP_bseq_msgTypeSupport__alloc (); pingpong_PP_bseq_msgTypeSupport_register_type (PP_bseq_dt, dp, "pingpong::PP_bseq_msg"); PP_bseq_topic = DDS_DomainParticipant_create_topic (dp, "PP_bseq_topic", "pingpong::PP_bseq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_bseq_writer = DDS_Publisher_create_datawriter (p, PP_bseq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_bseq_reader = DDS_Subscriber_create_datareader (s, PP_bseq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_bseq_sc = DDS_DataReader_get_statuscondition (PP_bseq_reader); DDS_StatusCondition_set_enabled_statuses (PP_bseq_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_bseq_sc); /* * PP_quit_msg */ /* Create Topic */ PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc (); pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg"); PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_quit_reader = DDS_Subscriber_create_datareader (s, PP_quit_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_quit_sc = DDS_DataReader_get_statuscondition (PP_quit_reader); DDS_StatusCondition_set_enabled_statuses (PP_quit_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_quit_sc); while (!terminate) { DDS_Duration_t wait_timeout = DDS_DURATION_INFINITE; /* printf ("PONG: waiting for PING\n"); */ conditionList = DDS_ConditionSeq__alloc(); result = DDS_WaitSet_wait (w, conditionList, &wait_timeout); if (result == DDS_RETCODE_OK) { imax = conditionList->_length; for (i = 0; i < imax; i++) { if (conditionList->_buffer[i] == PP_min_sc) { /* printf ("PONG: PING_min arrived\n"); */ result = pingpong_PP_min_msgDataReader_take (PP_min_reader, &PP_min_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_min_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_min_msgDataWriter_write (PP_min_writer, &PP_min_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_min_msgDataReader_return_loan (PP_min_reader, &PP_min_dataList, &infoList); } else { printf ("PONG: PING_min triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_seq_sc) { /* printf ("PONG: PING_seq arrived\n"); */ result = pingpong_PP_seq_msgDataReader_take (PP_seq_reader, &PP_seq_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_seq_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, &PP_seq_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_seq_msgDataReader_return_loan (PP_seq_reader, &PP_seq_dataList, &infoList); } else { printf ("PONG: PING_seq triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_string_sc) { /* printf ("PONG: PING_string arrived\n"); */ result = pingpong_PP_string_msgDataReader_take (PP_string_reader, &PP_string_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_string_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_string_msgDataWriter_write (PP_string_writer, &PP_string_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_string_msgDataReader_return_loan (PP_string_reader, &PP_string_dataList, &infoList); } else { printf ("PONG: PING_string triggered, but no data available\n"); exit(1); } } else if (conditionList->_buffer[i] == PP_fixed_sc) { /* printf ("PONG: PING_fixed arrived\n"); */ result = pingpong_PP_fixed_msgDataReader_take (PP_fixed_reader, &PP_fixed_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_fixed_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, &PP_fixed_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_fixed_msgDataReader_return_loan (PP_fixed_reader, &PP_fixed_dataList, &infoList); } else { printf ("PONG: PING_fixed triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_array_sc) { /* printf ("PONG: PING_array arrived\n"); */ result = pingpong_PP_array_msgDataReader_take (PP_array_reader, &PP_array_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_array_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_array_msgDataWriter_write (PP_array_writer, &PP_array_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_array_msgDataReader_return_loan (PP_array_reader, &PP_array_dataList, &infoList); } else { printf ("PONG: PING_array triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_bseq_sc) { /* printf ("PONG: PING_bseq arrived\n"); */ result = pingpong_PP_bseq_msgDataReader_take (PP_bseq_reader, &PP_bseq_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_bseq_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_bseq_msgDataWriter_write (PP_bseq_writer, &PP_bseq_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_bseq_msgDataReader_return_loan (PP_bseq_reader, &PP_bseq_dataList, &infoList); } else { printf ("PONG: PING_bseq triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_quit_sc) { /* printf ("PONG: PING_quit arrived\n"); */ result = pingpong_PP_quit_msgDataReader_take (PP_quit_reader, &PP_quit_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_quit_dataList._length; if (jmax != 0) { if (PP_quit_dataList._buffer[0].quit) { terminate = TRUE; } result = pingpong_PP_quit_msgDataReader_return_loan (PP_quit_reader, &PP_quit_dataList, &infoList); } else { printf ("PONG: PING_quit triggered, but no data available\n"); } } else { printf ("PONG: unknown condition triggered: %lx\n", (unsigned long)conditionList->_buffer[i]); } } } else { if (result == DDS_RETCODE_ALREADY_DELETED) { terminate = TRUE; } printf ("PONG: wait returned not ok: %d\n", result); } DDS_free(conditionList); } result = DDS_Subscriber_delete_datareader (s, PP_min_reader); result = DDS_Publisher_delete_datawriter (p, PP_min_writer); result = DDS_Subscriber_delete_datareader (s, PP_seq_reader); result = DDS_Publisher_delete_datawriter (p, PP_seq_writer); result = DDS_Subscriber_delete_datareader (s, PP_string_reader); result = DDS_Publisher_delete_datawriter (p, PP_string_writer); result = DDS_Subscriber_delete_datareader (s, PP_fixed_reader); result = DDS_Publisher_delete_datawriter (p, PP_fixed_writer); result = DDS_Subscriber_delete_datareader (s, PP_array_reader); result = DDS_Publisher_delete_datawriter (p, PP_array_writer); result = DDS_Subscriber_delete_datareader (s, PP_bseq_reader); result = DDS_Publisher_delete_datawriter (p, PP_bseq_writer); result = DDS_Subscriber_delete_datareader (s, PP_quit_reader); result = DDS_DomainParticipant_delete_subscriber (dp, s); result = DDS_DomainParticipant_delete_publisher (dp, p); result = DDS_DomainParticipant_delete_topic (dp, PP_min_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_seq_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_string_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_array_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_bseq_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_quit_topic); result = DDS_DomainParticipantFactory_delete_participant (dpf, dp); DDS_free (w); DDS_free (PP_min_dt); DDS_free (PP_seq_dt); DDS_free (PP_string_dt); DDS_free (PP_fixed_dt); DDS_free (PP_array_dt); DDS_free (PP_bseq_dt); DDS_free (PP_quit_dt); DDS_free (dpQos); DDS_free (tQos); DDS_free (dwQos); DDS_free (drQos); printf ("Completed pong example\n"); fflush(stdout); return 0; }
int main_subscriber (int argc, const char **argv) { DDS_DataWriterQos wr_qos; DDS_DataReaderQos rd_qos; DDS_ReturnCode_t error; sprintf (user_name, ".pid.%u", getpid ()); DDS_entity_name ("Technicolor Chatroom"); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) enable_security (); #endif part = DDS_DomainParticipantFactory_create_participant (domain_id, NULL, NULL, 0); if (!part) { printf ("Can't create participant!\r\n"); exit (1); } if (verbose) printf ("DDS Domain Participant created.\r\n"); ts = Vector3_type_new (); if (!ts) { printf ("Can't create vector3 message type!\r\n"); exit (1); } error = DDS_DynamicTypeSupport_register_type (ts, part, "simple_msgs::dds_::Vector3_"); if (error) { printf ("Can't register vector3 message type.\r\n"); exit (1); } if (verbose) printf ("DDS Topic type ('%s') registered.\r\n", "simple_msgs::dds_::Vector3_"); topic = DDS_DomainParticipant_create_topic (part, "imu", "simple_msgs::dds_::Vector3_", NULL, NULL, 0); if (!topic) { printf ("Can't register vector3 message type.\r\n"); exit (1); } if (verbose) printf ("DDS Vector3 Topic created.\r\n"); td = DDS_DomainParticipant_lookup_topicdescription (part, "imu"); if (!td) { printf ("Can't get topicdescription.\r\n"); exit (1); } pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { printf ("DDS_DomainParticipant_create_publisher () failed!\r\n"); exit (1); } DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); #ifdef TRANSIENT_LOCAL wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL wr_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; wr_qos.history.depth = DDS_LENGTH_UNLIMITED; wr_qos.resource_limits.max_samples_per_instance = HISTORY; wr_qos.resource_limits.max_instances = HISTORY * 10; wr_qos.resource_limits.max_samples = HISTORY * 4; #else wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = HISTORY; #endif /* Create a Data Writer. */ dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, 0); if (!dw) { printf ("Unable to create vector3 message writer.\r\n"); exit (1); } if (verbose) printf ("DDS Vector3 message writer created.\r\n"); sub = DDS_DomainParticipant_create_subscriber (part, NULL, NULL, 0); if (!sub) { printf ("DDS_DomainParticipant_create_subscriber () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Subscriber created.\r\n"); DDS_Subscriber_get_default_datareader_qos (sub, &rd_qos); #ifdef TRANSIENT_LOCAL rd_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE rd_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL rd_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; rd_qos.history.depth = DDS_LENGTH_UNLIMITED; rd_qos.resource_limits.max_samples_per_instance = HISTORY; rd_qos.resource_limits.max_instances = HISTORY * 10; rd_qos.resource_limits.max_samples = HISTORY * 4; #else rd_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; rd_qos.history.depth = HISTORY; #endif dr = DDS_Subscriber_create_datareader (sub, td, &rd_qos, #ifndef WAITSETS &msg_listener, DDS_DATA_AVAILABLE_STATUS); #else NULL, 0); #endif if (!dr) { printf ("DDS_DomainParticipant_create_datareader () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Vector message reader created.\r\n"); #ifdef WAITSETS start_imu_reader (dr); #endif // publisher thread //thread_create (rt2, dds_send_imu, dr); // DDS Debug shell thread do_dds_shell (dw); #ifdef WAITSETS stop_imu_reader (dr); #endif DDS_Publisher_delete_datawriter (pub, dw); usleep (200000); error = DDS_DomainParticipant_delete_contained_entities (part); if (verbose) printf ("DDS Entities deleted (error = %u).\r\n", error); Vector3_type_free (ts); if (verbose) printf ("Vector3 Type deleted.\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (verbose) printf ("DDS Participant deleted (error = %u).\r\n", error); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) cleanup_security (); #endif return (0); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; /* Declaration of Topics */ DDS_Topic *topic1 = NULL; DDS_Topic *topic2 = NULL; DDS_Topic *topic3 = NULL; /* Declaration of DataWriters */ DDS_DataWriter *writer1 = NULL; DDS_DataWriter *writer2 = NULL; DDS_DataWriter *writer3 = NULL; ordered_groupDataWriter * ordered_group_writer1 = NULL; ordered_groupDataWriter * ordered_group_writer2 = NULL; ordered_groupDataWriter * ordered_group_writer3 = NULL; /* Declaration of instances */ ordered_group *instance1 = NULL; ordered_group *instance2 = NULL; ordered_group *instance3 = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; struct DDS_Duration_t send_period = {1,0}; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register DATA TYPES. In this example, only one data type */ /* Register type before creating topic */ type_name = ordered_groupTypeSupport_get_type_name(); retcode = ordered_groupTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* TOPICS */ /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic1 = DDS_DomainParticipant_create_topic( participant, "Topic1", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic1 == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } topic2 = DDS_DomainParticipant_create_topic( participant, "Topic2", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic2 == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } topic3 = DDS_DomainParticipant_create_topic( participant, "Topic3", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic3 == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* DATAWRITERS */ /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer1 = DDS_Publisher_create_datawriter( publisher, topic1, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer1 == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } ordered_group_writer1 = ordered_groupDataWriter_narrow(writer1); if (ordered_group_writer1 == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } writer2 = DDS_Publisher_create_datawriter( publisher, topic2, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer2 == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } ordered_group_writer2 = ordered_groupDataWriter_narrow(writer2); if (ordered_group_writer2 == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } writer3 = DDS_Publisher_create_datawriter( publisher, topic3, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer3 == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } ordered_group_writer3 = ordered_groupDataWriter_narrow(writer3); if (ordered_group_writer3 == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* INSTANCES */ /* Create data sample for writing */ instance1 = ordered_groupTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance1 == NULL) { printf("ordered_groupTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } instance2 = ordered_groupTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance2 == NULL) { printf("ordered_groupTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } instance3 = ordered_groupTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance3 == NULL) { printf("ordered_groupTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = ordered_groupDataWriter_register_instance( ordered_group_writer, instance); */ /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { printf("Writing ordered_group, count %d\n", count); /* Modify the data to be sent and Write data */ instance1->message = "First sample, Topic 1 sent by DataWriter number 1"; retcode = ordered_groupDataWriter_write( ordered_group_writer1, instance1, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } instance1->message = "Second sample, Topic 1 sent by DataWriter number 1"; retcode = ordered_groupDataWriter_write( ordered_group_writer1, instance1, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } instance2->message = "First sample, Topic 2 sent by DataWriter number 2"; retcode = ordered_groupDataWriter_write( ordered_group_writer2, instance2, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } instance2->message = "Second sample, Topic 2 sent by DataWriter number 2"; retcode = ordered_groupDataWriter_write( ordered_group_writer2, instance2, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } instance3->message = "First sample, Topic 3 sent by DataWriter number 3"; retcode = ordered_groupDataWriter_write( ordered_group_writer3, instance3, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } instance3->message = "Second sample, Topic 3 sent by DataWriter number 3"; retcode = ordered_groupDataWriter_write( ordered_group_writer3, instance3, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } NDDS_Utility_sleep(&send_period); } /* retcode = ordered_groupDataWriter_unregister_instance( ordered_group_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = ordered_groupTypeSupport_delete_data_ex(instance1, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("ordered_groupTypeSupport_delete_data error %d\n", retcode); } /* Delete data sample */ retcode = ordered_groupTypeSupport_delete_data_ex(instance2, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("ordered_groupTypeSupport_delete_data error %d\n", retcode); } /* Delete data sample */ retcode = ordered_groupTypeSupport_delete_data_ex(instance3, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("ordered_groupTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; coherentDataWriter *coherent_writer = NULL; coherent *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; struct DDS_Duration_t send_period = { 1, 0 }; struct DDS_PublisherQos publisher_qos = DDS_PublisherQos_INITIALIZER; struct DDS_DataWriterQos datawriter_qos = DDS_DataWriterQos_INITIALIZER; int mod = 0; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher(participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } /* If you want to change the DataWriter's QoS programmatically rather than * using the XML file, you will need to add the following lines to your * code and comment out the create_publisher call above. */ /* Start changes for coherent_presentation */ /* Get default publisher QoS to customize */ /* retcode = DDS_DomainParticipant_get_default_publisher_qos(participant, &publisher_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_publisher_qos error\n"); return -1; } */ /* Topic access scope means that writes from a particular datawriter to * multiple instances will be viewed coherently. */ /* publisher_qos.presentation.access_scope = DDS_TOPIC_PRESENTATION_QOS; publisher_qos.presentation.coherent_access = DDS_BOOLEAN_TRUE; */ /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ /* publisher = DDS_DomainParticipant_create_publisher(participant, &publisher_qos, NULL, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } */ /* End changes for coherent_presentation */ /* Register type before creating topic */ type_name = coherentTypeSupport_get_type_name(); retcode = coherentTypeSupport_register_type(participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic(participant, "Example coherent", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } writer = DDS_Publisher_create_datawriter(publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } /* If you want to change the DataWriter's QoS programmatically rather than * using the XML file, you will need to add the following lines to your * code and comment out the create_datawriter call above. */ /* Start changes for coherent_presentation */ /* Get default datawriter QoS to customize */ /* retcode = DDS_Publisher_get_default_datawriter_qos(publisher, &datawriter_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_datawriter_qos error\n"); return -1; } datawriter_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; datawriter_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; datawriter_qos.protocol.rtps_reliable_writer.heartbeats_per_max_samples = 0; */ /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ /* writer = DDS_Publisher_create_datawriter(publisher, topic, &datawriter_qos, NULL, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } */ /* End changes for coherent_presentation */ coherent_writer = coherentDataWriter_narrow(writer); if (coherent_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } /* Create data sample for writing */ instance = coherentTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("coherentTypeSupport_create_data error\n"); publisher_shutdown(participant, &publisher_qos, &datawriter_qos); return -1; } /* Start changes for coherent_presentation */ /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ instance->id = 0; instance_handle = coherentDataWriter_register_instance(coherent_writer, instance); DDS_Publisher_begin_coherent_changes(publisher); printf("Begin Coherent Changes\n"); /* Main loop */ for (count = 0; (sample_count == 0) || (count < sample_count); ++count) { NDDS_Utility_sleep(&send_period); mod = count % 7; if (mod == 6) { DDS_Publisher_begin_coherent_changes(publisher); printf("Begin Coherent Changes\n"); continue; } /* Choose a random value for each field */ instance->field = 'a' + mod; instance->value = (int) (rand() / (RAND_MAX / 10.0)); printf(" Updating instance, %c->%d\n", instance->field, instance->value); /* Write data */ retcode = coherentDataWriter_write(coherent_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } /* Begin a new change group after sending 6 samples */ if (mod == 5) { DDS_Publisher_end_coherent_changes(publisher); printf("End Coherent Changes\n\n"); } } retcode = coherentDataWriter_unregister_instance(coherent_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } /* Delete data sample */ retcode = coherentTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("coherentTypeSupport_delete_data error %d\n", retcode); } /* End changes for coherent_presentation */ /* Cleanup and delete delete all entities */ return publisher_shutdown(participant, &publisher_qos, &datawriter_qos); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; numbersDataWriter *numbers_writer = NULL; numbers *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; struct DDS_Duration_t send_period = {4,0}; /* To customize participant QoS, use the configuration file USER_QOS_PROFILES.xml */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant); return -1; } /* If you want to change the DomainParticipant's QoS programmatically * rather than using the XML file, you will need to add the following lines * to your code and comment out the create_participant call above. * * In this case, we set the transport settings in the XML by default, but * in the numbers_common_create_participant call, we set up the transport * properties either using the Properties QoS or with the transport * property objects. */ /*participant = numbers_common_create_participant(domainId); if (participant == NULL) { publisher_shutdown(participant); return -1; }*/ if (numbers_common_verify_qos(participant) != 0) { publisher_shutdown(participant); return -1; } /* To customize publisher QoS, use DDS_DomainParticipant_get_default_publisher_qos() */ publisher = DDS_DomainParticipant_create_publisher( participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant); return -1; } /* Register type before creating topic */ type_name = numbersTypeSupport_get_type_name(); retcode = numbersTypeSupport_register_type( participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant); return -1; } /* To customize topic QoS, use DDS_DomainParticipant_get_default_topic_qos() */ topic = DDS_DomainParticipant_create_topic( participant, "Example numbers", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant); return -1; } /* To customize data writer QoS, use DDS_Publisher_get_default_datawriter_qos() */ writer = DDS_Publisher_create_datawriter( publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant); return -1; } numbers_writer = numbersDataWriter_narrow(writer); if (numbers_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant); return -1; } /* Create data sample for writing */ instance = numbersTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("numbersTypeSupport_create_data error\n"); publisher_shutdown(participant); return -1; } /* For data type that has key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = numbersDataWriter_register_instance( numbers_writer, instance); */ instance->number = 1000; instance->halfNumber = (float)(instance->number)/2; /* Main loop */ for (count=0; (sample_count == 0) || (count < sample_count); ++count) { printf("Writing numbers, count %d\n", count); /* Modify the data to be written here */ /* Write data */ retcode = numbersDataWriter_write( numbers_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } instance->number = instance->halfNumber; instance->halfNumber = (float)(instance->number)/2; NDDS_Utility_sleep(&send_period); } /* retcode = numbersDataWriter_unregister_instance( numbers_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = numbersTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("numbersTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant); }
static int publisher_main(int domainId, int sample_count) { DDS_DomainParticipant *participant = NULL; DDS_Publisher *publisher = NULL; DDS_Topic *topic = NULL; DDS_DataWriter *writer = NULL; cfcDataWriter *cfc_writer = NULL; cfc *instance = NULL; DDS_ReturnCode_t retcode; DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL; const char *type_name = NULL; int count = 0; int i; int sample; struct DDS_Duration_t send_period = { 1, 0 }; const char* cfc_name = "custom_flowcontroller"; struct DDS_FlowControllerProperty_t custom_fcp; DDS_FlowController* cfc = NULL; struct DDS_DataWriterQos datawriter_qos = DDS_DataWriterQos_INITIALIZER; struct DDS_DomainParticipantQos participant_qos = DDS_DomainParticipantQos_INITIALIZER; participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &DDS_PARTICIPANT_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* Start changes for custom_flowcontroller */ /* If you want to change the Participant's QoS programmatically rather than * using the XML file, you will need to add the following lines to your * code and comment out the create_participant call above. */ /* Get default participant QoS to customize */ /* retcode = DDS_DomainParticipantFactory_get_default_participant_qos( DDS_TheParticipantFactory, &participant_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_participant_qos error\n"); return -1; } */ /* By default, data will be sent via shared memory _and_ UDPv4. Because * the flowcontroller limits writes across all interfaces, this halves the * effective send rate. To avoid this, we enable only the UDPv4 transport */ /* participant_qos.transport_builtin.mask = DDS_TRANSPORTBUILTIN_UDPv4; */ /* To create participant with default QoS, use DDS_PARTICIPANT_QOS_DEFAULT instead of participant_qos */ /* participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, domainId, &participant_qos, NULL, DDS_STATUS_MASK_NONE); if (participant == NULL) { printf("create_participant error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } */ /* End changes for Custom_Flowcontroller */ /* To customize publisher QoS, use the configuration file USER_QOS_PROFILES.xml */ publisher = DDS_DomainParticipant_create_publisher(participant, &DDS_PUBLISHER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (publisher == NULL) { printf("create_publisher error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* Register type before creating topic */ type_name = cfcTypeSupport_get_type_name(); retcode = cfcTypeSupport_register_type(participant, type_name); if (retcode != DDS_RETCODE_OK) { printf("register_type error %d\n", retcode); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* To customize topic QoS, use the configuration file USER_QOS_PROFILES.xml */ topic = DDS_DomainParticipant_create_topic(participant, "Example cfc", type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (topic == NULL) { printf("create_topic error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* To customize data writer QoS, use the configuration file USER_QOS_PROFILES.xml */ writer = DDS_Publisher_create_datawriter(publisher, topic, &DDS_DATAWRITER_QOS_DEFAULT, NULL /* listener */, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* Start changes for custom_flowcontroller */ /* If you want to change the Datawriter's QoS programmatically rather than * using the XML file, you will need to add the following lines to your * code and comment out the create_datawriter call above. * * In this case we create the flowcontroller and the neccesary QoS * for the datawriter. */ /* retcode = DDS_DomainParticipant_get_default_flowcontroller_property( participant, &custom_fcp); if (retcode != DDS_RETCODE_OK) { printf("get_default_flowcontroller_property error \n"); return -1; } */ /* Don't allow too many tokens to accumulate */ /* custom_fcp.token_bucket.max_tokens = custom_fcp.token_bucket.tokens_added_per_period = 2; custom_fcp.token_bucket.tokens_leaked_per_period = DDS_LENGTH_UNLIMITED; */ /* 100ms */ /* custom_fcp.token_bucket.period.sec = 0; custom_fcp.token_bucket.period.nanosec = 100000000; */ /* The sample size is 1000, but the minimum bytes_per_token is 1024. * Furthermore, we want to allow some overhead. */ /* custom_fcp.token_bucket.bytes_per_token = 1024; */ /* So, in summary, each token can be used to send about one message, * and we get 2 tokens every 100ms, so this limits transmissions to * about 20 messages per second. */ /* Create flowcontroller and set properties */ /* cfc = DDS_DomainParticipant_create_flowcontroller( participant, DDS_String_dup(cfc_name), &custom_fcp); if (cfc == NULL) { printf("create_flowcontroller error\n"); return -1; } */ /* Get default datawriter QoS to customize */ /* retcode = DDS_Publisher_get_default_datawriter_qos(publisher, &datawriter_qos); if (retcode != DDS_RETCODE_OK) { printf("get_default_datawriter_qos error\n"); return -1; } */ /* As an alternative to increasing history depth, we can just * set the qos to keep all samples */ /* datawriter_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; */ /* Set flowcontroller for datawriter */ /* datawriter_qos.publish_mode.kind = DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS; datawriter_qos.publish_mode.flow_controller_name = DDS_String_dup(cfc_name); */ /* To create datawriter with default QoS, use DDS_DATAWRITER_QOS_DEFAULT instead of datawriter_qos */ /* writer = DDS_Publisher_create_datawriter( publisher, topic, &datawriter_qos, NULL, DDS_STATUS_MASK_NONE); if (writer == NULL) { printf("create_datawriter error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } */ /* End changes for Custom_Flowcontroller */ cfc_writer = cfcDataWriter_narrow(writer); if (cfc_writer == NULL) { printf("DataWriter narrow error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* Create data sample for writing */ instance = cfcTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE); if (instance == NULL) { printf("cfcTypeSupport_create_data error\n"); publisher_shutdown(participant, &participant_qos, &datawriter_qos); return -1; } /* For a data type that has a key, if the same instance is going to be written multiple times, initialize the key here and register the keyed instance prior to writing */ /* instance_handle = cfcDataWriter_register_instance( cfc_writer, instance); */ /* Main loop */ for (count = 0; (sample_count == 0) || (count < sample_count); ++count) { /* Changes for custom_flowcontroller */ /* Simulate bursty writer */ NDDS_Utility_sleep(&send_period); for (i = 0; i < 10; ++i) { sample = count * 10 + i; printf("Writing cfc, sample %d\n", sample); instance->x = sample; memset(instance->str, 1, 999); instance->str[999] = 0; retcode = cfcDataWriter_write(cfc_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("write error %d\n", retcode); } } } /* This new sleep it is for let time to the subscriber to read all the * sent samples. */ send_period.sec = 4; NDDS_Utility_sleep(&send_period); /* retcode = cfcDataWriter_unregister_instance( cfc_writer, instance, &instance_handle); if (retcode != DDS_RETCODE_OK) { printf("unregister instance error %d\n", retcode); } */ /* Delete data sample */ retcode = cfcTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE); if (retcode != DDS_RETCODE_OK) { printf("cfcTypeSupport_delete_data error %d\n", retcode); } /* Cleanup and delete delete all entities */ return publisher_shutdown(participant, &participant_qos, &datawriter_qos); }
int dds_chat_main(int argc, char *argv[]) #endif { DDS_DataWriterQos wr_qos; DDS_DataReaderQos rd_qos; DDS_ReturnCode_t error; struct in_addr addr; /* Configure the network */ /* Set up our host address */ addr.s_addr = HTONL(CONFIG_EXAMPLES_UDP_IPADDR); netlib_sethostaddr("eth0", &addr); /* Set up the default router address */ addr.s_addr = HTONL(CONFIG_EXAMPLES_UDP_DRIPADDR); netlib_setdraddr("eth0", &addr); /* Setup the subnet mask */ addr.s_addr = HTONL(CONFIG_EXAMPLES_UDP_NETMASK); netlib_setnetmask("eth0", &addr); /* Start the application */ printf("Network configured, starting DDS chat:\n"); sprintf (user_name, ".pid.%u", getpid ()); do_switches (argc, argv); if (verbose > 1) DDS_Log_stdio (1); DDS_entity_name ("ROS 2.0 embedded"); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) enable_security (); #endif part = DDS_DomainParticipantFactory_create_participant (domain_id, NULL, NULL, 0); if (!part) { printf ("Can't create participant!\r\n"); exit (1); } if (verbose) printf ("DDS Domain Participant created.\r\n"); ts = ChatMsg_type_new (); if (!ts) { printf ("Can't create chat message type!\r\n"); exit (1); } error = DDS_DynamicTypeSupport_register_type (ts, part, "ChatMsg"); if (error) { printf ("Can't register chat message type.\r\n"); exit (1); } if (verbose) printf ("DDS Topic type ('%s') registered.\r\n", "ChatMsg"); topic = DDS_DomainParticipant_create_topic (part, "Chat", "ChatMsg", NULL, NULL, 0); if (!topic) { printf ("Can't register chat message type.\r\n"); exit (1); } if (verbose) printf ("DDS ChatMsg Topic created.\r\n"); td = DDS_DomainParticipant_lookup_topicdescription (part, "Chat"); if (!td) { printf ("Can't get topicdescription.\r\n"); exit (1); } pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { printf ("DDS_DomainParticipant_create_publisher () failed!\r\n"); exit (1); } DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); #ifdef TRANSIENT_LOCAL wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL wr_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; wr_qos.history.depth = DDS_LENGTH_UNLIMITED; wr_qos.resource_limits.max_samples_per_instance = HISTORY; wr_qos.resource_limits.max_instances = HISTORY * 10; wr_qos.resource_limits.max_samples = HISTORY * 4; #else wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = HISTORY; #endif /* Create a Data Writer. */ dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, 0); if (!dw) { printf ("Unable to create chat message writer.\r\n"); exit (1); } if (verbose) printf ("DDS Chat message writer created.\r\n"); sub = DDS_DomainParticipant_create_subscriber (part, NULL, NULL, 0); if (!sub) { printf ("DDS_DomainParticipant_create_subscriber () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Subscriber created.\r\n"); DDS_Subscriber_get_default_datareader_qos (sub, &rd_qos); #ifdef TRANSIENT_LOCAL rd_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE rd_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL rd_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; rd_qos.history.depth = DDS_LENGTH_UNLIMITED; rd_qos.resource_limits.max_samples_per_instance = HISTORY; rd_qos.resource_limits.max_instances = HISTORY * 10; rd_qos.resource_limits.max_samples = HISTORY * 4; #else rd_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; rd_qos.history.depth = HISTORY; #endif dr = DDS_Subscriber_create_datareader (sub, td, &rd_qos, #ifndef WAITSETS &msg_listener, DDS_DATA_AVAILABLE_STATUS); #else NULL, 0); #endif if (!dr) { printf ("DDS_DomainParticipant_create_datareader () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Chat message reader created.\r\n"); #ifdef WAITSETS start_chat_reader (dr); #endif do_chat (dw); #ifdef WAITSETS stop_chat_reader (dr); #endif DDS_Publisher_delete_datawriter (pub, dw); usleep (200000); error = DDS_DomainParticipant_delete_contained_entities (part); if (verbose) printf ("DDS Entities deleted (error = %u).\r\n", error); ChatMsg_type_free (ts); if (verbose) printf ("Chat Type deleted.\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (verbose) printf ("DDS Participant deleted (error = %u).\r\n", error); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) cleanup_security (); #endif return (0); }
static void test_qos (int enabled) { DDS_DomainParticipantFactoryQos qos; DDS_DomainParticipant p; DDS_Publisher pub; DDS_Subscriber sub; DDS_DataWriter dw; DDS_DataReader dr; DDS_Topic t; DDS_TopicDescription td; DDS_DataReaderQos rq, refrq; DDS_ReturnCode_t r; static unsigned char data [] = { 0x77, 0x88, 0xaa, 0xbb, 0xcc, 0xdd }; unsigned char d2 [sizeof (data) + 1]; unsigned n; int err; v_printf (" - Set factory QoS to %sabled.\r\n", (enabled) ? "en" : "dis"); r = DDS_DomainParticipantFactory_get_qos (&qos); fail_unless (r == DDS_RETCODE_OK); qos.entity_factory.autoenable_created_entities = enabled; r = DDS_DomainParticipantFactory_set_qos (&qos); fail_unless (r == DDS_RETCODE_OK); p = DDS_DomainParticipantFactory_create_participant (0, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); sub = DDS_DomainParticipant_create_subscriber (p, NULL, NULL, 0); fail_unless (sub != NULL); DDS_DataReaderQos__init (&refrq); err = dds_seq_from_array (&refrq.user_data, data, sizeof (data)); fail_unless (err == 0); v_printf (" - Create datareader with specific QoS parameters.\r\n"); dr = DDS_Subscriber_create_datareader (sub, td, &refrq, NULL, 0); fail_unless (dr != NULL); memset (&rq, 0, sizeof (rq)); r = DDS_DataReader_get_qos (dr, &rq); n = dds_seq_to_array (&rq.user_data, d2, sizeof (d2)); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (refrq.user_data.value) == sizeof (data)); n = dds_seq_to_array (&rq.user_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_DataReaderQos__clear (&rq); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); v_printf (" - Create datareader with default QoS parameters.\r\n"); dr = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr != NULL); pub = DDS_DomainParticipant_create_publisher (p, DDS_PUBLISHER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); dw = DDS_Publisher_create_datawriter (pub, t, DDS_DATAWRITER_QOS_DEFAULT, NULL, 0); fail_unless (dw != NULL); v_printf (" - Update datareader QoS parameters.\r\n"); r = DDS_DataReader_get_qos (dr, &rq); fail_unless (r == DDS_RETCODE_OK); DDS_DataReaderQos__clear (&refrq); fail_unless (r == DDS_RETCODE_OK && !memcmp (&rq, &refrq, sizeof (refrq))); err = dds_seq_from_array (&refrq.user_data, data, sizeof (data)); fail_unless (err == 0); r = DDS_DataReader_set_qos (dr, &refrq); fail_unless (r == DDS_RETCODE_OK); delay (); r = DDS_DataReader_get_qos (dr, &rq); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (rq.user_data.value) == sizeof (data)); n = dds_seq_to_array (&rq.user_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_DataReaderQos__clear (&refrq); DDS_DataReaderQos__clear (&rq); delay (); if (!enabled) { v_printf (" - Enable all entities.\r\n"); r = DDS_DomainParticipant_enable (p); fail_unless (r == DDS_RETCODE_OK); r = DDS_Topic_enable (t); fail_unless (r == DDS_RETCODE_OK); r = DDS_Publisher_enable (pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_enable (sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataWriter_enable (dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_enable (dr); fail_unless (r == DDS_RETCODE_OK); sleep (1); } r = DDS_Publisher_delete_datawriter (pub, dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_publisher (p, pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
int main(int argc, char* argv[]) { int startTime = mstime(); DDS_PoolConstraints reqs; DDS_DomainParticipant domainParticipant; DDS_Publisher publisher; DDS_Subscriber subscriber; DDS_ReturnCode_t retCode; char *configTopicName[nofConfigTopics]; char *stateTopicName[nofStateTopics]; char *statisticTopicName[nofStatisticTopics]; DDS_Topic configTopic[nofConfigTopics]; DDS_Topic stateTopic[nofStateTopics]; DDS_Topic statisticTopic[nofStatisticTopics]; DDS_DataWriterQos dataWriterQos; DDS_DataWriter configDataWriter[nofConfigTopics]; DDS_DataReaderQos dataReaderQos; DDS_DataReader configDataReader[nofConfigTopics]; DDS_DataReader stateDataReader[nofStateTopics]; DDS_DataReader statisticDataReader[nofStatisticTopics]; #if 0 acceptance_high_end_Config config; acceptance_high_end_State state; acceptance_high_end_Statistic statistic; DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances]; DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances]; DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances]; #endif int i = 0; /*int j = 0;*/ int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0; int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0; int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0; int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0; printf("[0] Config topics start at %d...\r\n", firstConfigTopic); printf("[0] State topics start at %d...\r\n", firstStateTopic); printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic); printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off"); DDS_program_name (&argc, argv); DDS_entity_name ("Technicolor Limits Manager"); DDS_get_default_pool_constraints(&reqs, ~0, 100); #ifdef MINIMAL_POOLS configure_minimal_pool_constraints (&reqs); #else configure_optimal_pool_constraints (&reqs); #endif DDS_set_pool_constraints (&reqs); #ifdef DDS_DEBUG DDS_Debug_start (); #endif #ifdef TRACE_DATA rtps_dtrace_set (DRTRC_TRACE_ALL); #endif /* Create domain participant... */ domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0); if (!domainParticipant) { fprintf(stderr, "Error creating domain participant.\r\n"); return -1; } printf("[%d] Created domain participant.\r\n", mstime() - startTime); // sleep(1); /* Create publisher... */ publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0); if (!publisher) { fprintf(stderr, "Error creating publisher.\r\n"); return -1; } printf("[%d] Created publisher.\r\n", mstime() - startTime); // sleep(1); /* Create subscriber... */ subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0); if (!subscriber) { fprintf(stderr, "Error creating subscriber.\r\n"); return -1; } printf("[%d] Created subscriber.\r\n", mstime() - startTime); // sleep(1); /* Register types... */ retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered config type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered state type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered statistic type.\r\n", mstime() - startTime); // sleep(1); /* Create topics... */ for (i = 0; i < nofConfigTopics; i++) { char topicName[32]; sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i); configTopicName[i] = topicName; configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0); if (!configTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics); for (i = 0; i < nofStateTopics; i++) { char topicName[32]; sprintf(topicName, "StateTopic%d", firstStateTopic + i); stateTopicName[i] = topicName; stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0); if (!stateTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics); for (i = 0; i < nofStatisticTopics; i++) { char topicName[32]; sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i); statisticTopicName[i] = topicName; statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0); if (!statisticTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics); // sleep(1); /* Create data writers... */ DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0); if (!configDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics); // sleep(1); /* Create data readers... */ DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, &configDataReaderListener, DDS_DATA_AVAILABLE_STATUS); if (!configDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics); DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofStateTopics; i++) { stateDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, stateTopicName[i]), &dataReaderQos, &stateDataReaderListener, DDS_DATA_AVAILABLE_STATUS); if (!stateDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d state data readers.\r\n", mstime() - startTime, nofStateTopics); DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); for (i = 0; i < nofStatisticTopics; i++) { statisticDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, statisticTopicName[i]), &dataReaderQos, &statisticDataReaderListener, DDS_DATA_AVAILABLE_STATUS); if (!statisticDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d statistic data readers.\r\n", mstime() - startTime, nofStatisticTopics); // sleep(1); /* Lookup instances... */ /*for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; configInstance[i][j] = acceptance_high_end_ConfigDataReader_lookup_instance(configDataReader[i], &config); if (!configInstance[i][j]) { fprintf(stderr, "Error looking up instance.\r\n"); break; } } } printf("[%d] Looked up %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; stateInstance[i][j] = acceptance_high_end_StateDataReader_lookup_instance(stateDataReader[i], &state); if (!stateInstance[i][j]) { fprintf(stderr, "Error looking up instance.\r\n"); break; } } } printf("[%d] Looked up %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; statisticInstance[i][j] = acceptance_high_end_StatisticDataReader_lookup_instance(statisticDataReader[i], &statistic); if (!statisticInstance[i][j]) { fprintf(stderr, "Error looking up instance.\r\n"); break; } } } printf("[%d] Looked up %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);*/ // sleep(1); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad0"); FILE *f = fopen(file_name, "w"); fclose(f); } int waitTime = mstime(); int _nofConfigSamples = 0; int _nofStateSamples = 0; int _nofStatisticSamples = 0; while ((mstime() - waitTime) < (TEST_TIME * 1000)) { if ((nofConfigSamples > _nofConfigSamples) || (nofStateSamples > _nofStateSamples) || (nofStatisticSamples > _nofStatisticSamples)) { printf("[%d] Received %d config samples.\r\n", mstime() - startTime, nofConfigSamples); printf("[%d] Received %d state samples.\r\n", mstime() - startTime, nofStateSamples); printf("[%d] Received %d statistic samples.\r\n", mstime() - startTime, nofStatisticSamples); _nofConfigSamples = nofConfigSamples; _nofStateSamples = nofStateSamples; _nofStatisticSamples = nofStatisticSamples; } sleep(1); } /* Delete contained entities... */ // printf (" -- Deleting contained entities.\r\n"); retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting contained entities.\r\n"); return -1; } // printf ("contained entities deleted!\r\n"); /* Delete domain participants... */ retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting domain participant.\r\n"); return -1; } printf ("[%d] mgmt completed successfully.\r\n", mstime() - startTime); return 0; }