void createWriter()
{
// Create a DataWriter for the Topic (using the appropriate QoS).
g_DataWriterQos = DDS_DataWriterQos__alloc();
checkHandle(g_DataWriterQos, "DDS_DataWriterQos__alloc");
g_status = DDS_Publisher_get_default_datawriter_qos(g_Publisher, g_DataWriterQos);
checkStatus(g_status, "DDS_Publisher_get_default_datawriter_qos");
g_status = DDS_Publisher_copy_from_topic_qos(g_Publisher, g_DataWriterQos, g_TopicQos);
checkStatus(g_status, "DDS_Publisher_copy_from_topic_qos");
// If autodispose_unregistered_instances is true, when the writer is stopped,
// the instances of the topic will be suppressed from the persistence file;
// If it is false the data will still be accessible after the Writer has stopped,
// even if a Reader starts after the Writer's end and then reads the Topic's persistent samples.
g_DataWriterQos->writer_data_lifecycle.autodispose_unregistered_instances = g_autodispose_unregistered_instances;
g_DataWriter = DDS_Publisher_create_datawriter(g_Publisher, g_Topic, g_DataWriterQos, NULL, DDS_ANY_STATUS);
checkHandle(g_DataWriter, "DDS_Publisher_create_datawriter (g_DataWriter)");
}
DDS_DataWriter createDataWriter(DDS_Publisher publisher, DDS_Topic topic)
{
DDS_DataWriter dataWriter;
DDS_TopicQos *topicQos = DDS_TopicQos__alloc();
DDS_DataWriterQos *dataWriterQos = DDS_DataWriterQos__alloc();
checkHandle(dataWriterQos, "DDS_DataWriterQos__alloc");
g_status = DDS_Publisher_get_default_datawriter_qos(publisher, dataWriterQos);
checkStatus(g_status, "DDS_Publisher_get_default_datawriter_qos");
g_status = DDS_Topic_get_qos(topic, topicQos);
checkStatus(g_status, "DDS_Topic_get_qos");
g_status = DDS_Publisher_copy_from_topic_qos(publisher, dataWriterQos, topicQos);
checkStatus(g_status, "DDS_Publisher_copy_from_topic_qos");
dataWriterQos->writer_data_lifecycle.autodispose_unregistered_instances = FALSE;
dataWriter = DDS_Publisher_create_datawriter(publisher, topic, dataWriterQos, NULL, DDS_STATUS_MASK_NONE);
checkHandle(dataWriter, "DDS_Publisher_create_datawriter");
return dataWriter;
}
int
dds_writer_create (
dds_entity_t pp_or_pub,
dds_entity_t * writer,
dds_entity_t topic,
const dds_qos_t * qos,
const dds_writerlistener_t * listener)
{
DDS_ReturnCode_t result = DDS_RETCODE_OK;
dds_entity_t publisher = NULL;
struct DataWriterInfo *info;
struct DDS_DataWriterListener dpl;
struct DDS_DataWriterListener *lp = NULL;
DDS_StatusMask mask = (listener) ? DDS_STATUS_MASK_ANY : DDS_STATUS_MASK_NONE;
DDS_DataWriterQos *wQos;
bool ownPublisher = false;
DDS_REPORT_STACK();
if (!writer) {
result = DDS_RETCODE_BAD_PARAMETER;
DDS_REPORT(result, "Writer parameter is NULL.");
}
if (!topic) {
result = DDS_RETCODE_BAD_PARAMETER;
DDS_REPORT(result, "Topic parameter is NULL.");
}
if (result == DDS_RETCODE_OK) {
if (!pp_or_pub) {
result = dds_publisher_create(NULL, &publisher, qos, NULL);
ownPublisher = true;
} else {
if (DDS_Entity_get_kind(pp_or_pub) == DDS_ENTITY_KIND_DOMAINPARTICIPANT) {
result = dds_publisher_create(pp_or_pub, &publisher, qos, NULL);
ownPublisher = true;
} else {
publisher = pp_or_pub;
}
}
}
if (result == DDS_RETCODE_OK) {
info = dds_datawriter_info_new();
if (!info) {
result = DDS_RETCODE_ERROR;
DDS_REPORT(result, "Failed to create writer info.");
}
}
if (result == DDS_RETCODE_OK) {
*writer = NULL;
info->ownPublisher = ownPublisher;
if (listener) {
info->listener = os_malloc(sizeof(dds_writerlistener_t));
*info->listener = *listener;
lp = &dpl;
dds_datawriter_listener_init(&dpl, info);
}
if (qos) {
wQos = DDS_DataWriterQos__alloc();
result = DDS_Publisher_get_default_datawriter_qos(publisher, wQos);
if (result == DDS_RETCODE_OK) {
dds_qos_to_writer_qos(wQos, qos);
*writer = DDS_Publisher_create_datawriter(publisher, topic, wQos, lp, mask);
}
DDS_free(wQos);
} else {
*writer = DDS_Publisher_create_datawriter(publisher, topic, DDS_DATAWRITER_QOS_USE_TOPIC_QOS, lp, mask);
}
if (*writer) {
result = DDS_Entity_set_user_data(*writer, (DDS_EntityUserData)info);
} else {
result = dds_report_get_error_code();
}
DDS_Entity_release_user_data((DDS_EntityUserData)info);
}
DDS_REPORT_FLUSH(pp_or_pub, result != DDS_RETCODE_OK);
return DDS_ERRNO(result, DDS_MOD_WRITER, DDS_ERR_Mx);
}
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 (
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)
#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 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;
}
