int
dds_datawriter_delete(
dds_entity_t wr)
{
int result;
struct DataWriterInfo *info = NULL;
DDS_Publisher publisher;
result = DDS_Entity_claim_user_data(wr, (DDS_EntityUserData *)&info);
if (result == DDS_RETCODE_OK) {
publisher = DDS_DataWriter_get_publisher(wr);
if (publisher) {
if (info->ownPublisher) {
result = dds_publisher_delete(publisher);
} else {
result = DDS_Publisher_delete_datawriter(publisher, wr);
}
} else {
result = DDS_RETCODE_ALREADY_DELETED;
}
DDS_Entity_release_user_data((DDS_EntityUserData)info);
}
return DDS_ERRNO(result, DDS_MOD_WRITER, DDS_ERR_Mx);
}
/*
Deletes the DataWritter
*/
void delete_publisher(void)
{
DDS_Publisher_delete_datawriter (pub, dw);
/* usleep (200000); */
if (verbose)
printf ("delete_publisher() DDS message writer deleted.\r\n");
}
DDS_ReturnCode_t
DDS_DomainParticipant_delete_simulated_multitopic(
DDS_DomainParticipant participant,
DDS_TopicDescription smt
)
{
DDS_ReturnCode_t status;
struct MsgListenerState *listener_state;
/* Obtain all entities mentioned in the listener state. */
listener_state = (struct MsgListenerState *) msgListener->listener_data;
/* Remove the DataWriter */
status = DDS_Publisher_delete_datawriter(multiPub, listener_state->namedMessageDW);
checkStatus(status, "DDS_Publisher_delete_datawriter");
/* Remove the Publisher. */
status = DDS_DomainParticipant_delete_publisher(participant, multiPub);
checkStatus(status, "DDS_DomainParticipant_delete_publisher");
/* Remove the QueryCondition and its parameters. */
DDS_free(listener_state->nameFinderParams);
status = DDS_DataReader_delete_readcondition(
listener_state->nameServiceDR,
listener_state->nameFinder);
checkStatus(status, "DDS_DataReader_delete_readcondition");
/* Remove the DataReaders. */
status = DDS_Subscriber_delete_datareader(multiSub, listener_state->nameServiceDR);
checkStatus(status, "DDS_Subscriber_delete_datareader");
status = DDS_Subscriber_delete_datareader(multiSub, listener_state->chatMessageDR);
checkStatus(status, "DDS_Subscriber_delete_datareader");
/* Remove the DataReaderListener and its state. */
free(listener_state);
DDS_free(msgListener);
/* Remove the Subscriber. */
status = DDS_DomainParticipant_delete_subscriber(participant, multiSub);
checkStatus(status, "DDS_DomainParticipant_delete_subscriber");
/* Remove the ContentFilteredTopic. */
status = DDS_DomainParticipant_delete_contentfilteredtopic(participant, filteredMessageTopic);
checkStatus(status, "DDS_DomainParticipant_delete_contentfilteredtopic");
/* Remove all other topics. */
status = DDS_DomainParticipant_delete_topic(participant, namedMessageTopic);
checkStatus(status, "DDS_DomainParticipant_delete_topic (namedMessageTopic)");
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)");
return status;
}
static void remove_state_writer ()
{
DDS_ReturnCode_t error;
DDS_DataWriter_set_listener (dw, NULL, 0);
if ((error = DDS_Publisher_delete_datawriter (pub, dw)))
fatal ("DDS_Publisher_delete_datawriter() failed (%s)!", DDS_error (error));
if ((error = DDS_Publisher_delete_contained_entities (pub)))
fatal ("DDS_Publisher_delete_contained_entities () failed (%s)!", DDS_error (error));
}
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[])
{
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;
}
void deleteDataWriter()
{
g_status = DDS_Publisher_delete_datawriter(g_Publisher, g_DataWriter);
checkStatus(g_status, "DDS_Publisher_delete_datawriter (g_DataWriter)");
}
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);
}
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;
}
void deleteDataWriter(DDS_Publisher publisher, DDS_DataWriter dataWriter)
{
g_status = DDS_Publisher_delete_datawriter(publisher, dataWriter);
checkStatus(g_status, "DDS_Publisher_delete_datawriter");
}
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;
}
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_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);
}
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_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;
};
