int main (int argc, char ** argv)
#endif
{
/* Generic DDS entities */
DDS_DomainParticipant participant;
DDS_Topic chatMessageTopic;
DDS_Topic nameServiceTopic;
DDS_Subscriber chatSubscriber;
DDS_QueryCondition singleUser;
DDS_ReadCondition newUser;
DDS_StatusCondition leftUser;
DDS_GuardCondition guard;
DDS_WaitSet userLoadWS;
DDS_LivelinessChangedStatus livChangStatus;
/* QosPolicy holders */
DDS_TopicQos *setting_topic_qos;
DDS_TopicQos *reliable_topic_qos;
DDS_SubscriberQos *sub_qos;
DDS_DataReaderQos *message_qos;
/* DDS Identifiers */
DDS_DomainId_t domain = NULL;
DDS_ReturnCode_t status;
DDS_ConditionSeq *guardList = NULL;
DDS_Duration_t timeout = DDS_DURATION_INFINITE;
/* Type-specific DDS entities */
Chat_ChatMessageTypeSupport chatMessageTS;
Chat_NameServiceTypeSupport nameServiceTS;
Chat_NameServiceDataReader nameServer;
Chat_ChatMessageDataReader loadAdmin;
DDS_sequence_Chat_ChatMessage msgList = { 0, 0, DDS_OBJECT_NIL, FALSE };
DDS_sequence_Chat_NameService nsList = { 0, 0, DDS_OBJECT_NIL, FALSE };
DDS_SampleInfoSeq infoSeq = { 0, 0, DDS_OBJECT_NIL, FALSE };
DDS_SampleInfoSeq infoSeq2 = { 0, 0, DDS_OBJECT_NIL, FALSE };
/* Others */
DDS_StringSeq args;
int closed = 0;
DDS_unsigned_long i, j;
DDS_long prevCount = 0;
char *partitionName;
char *chatMessageTypeName = NULL;
char *nameServiceTypeName = NULL;
pthread_t tid;
pthread_attr_t tattr;
printf("Starting UserLoad example.\n");
fflush(stdout);
/* Create a DomainParticipant (using the 'TheParticipantFactory' convenience macro). */
participant = DDS_DomainParticipantFactory_create_participant (
DDS_TheParticipantFactory,
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 SubscriberQos to read from the "ChatRoom" Partition. */
partitionName = "ChatRoom";
sub_qos = DDS_SubscriberQos__alloc();
checkHandle(sub_qos, "DDS_SubscriberQos__alloc");
status = DDS_DomainParticipant_get_default_subscriber_qos (participant, sub_qos);
checkStatus(status, "DDS_DomainParticipant_get_default_subscriber_qos");
sub_qos->partition.name._length = 1;
sub_qos->partition.name._maximum = 1;
sub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1);
checkHandle(sub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf");
sub_qos->partition.name._buffer[0] = DDS_string_alloc (strlen(partitionName) + 1);
checkHandle(sub_qos->partition.name._buffer[0], "DDS_string_alloc");
strcpy (sub_qos->partition.name._buffer[0], partitionName);
/* Create a Subscriber for the UserLoad application. */
chatSubscriber = DDS_DomainParticipant_create_subscriber(participant, sub_qos, NULL, DDS_STATUS_MASK_NONE);
checkHandle(chatSubscriber, "DDS_DomainParticipant_create_subscriber");
/* Create a DataReader for the NameService Topic (using the appropriate QoS). */
nameServer = DDS_Subscriber_create_datareader(
chatSubscriber,
nameServiceTopic,
DDS_DATAREADER_QOS_USE_TOPIC_QOS,
NULL,
DDS_STATUS_MASK_NONE);
checkHandle(nameServer, "DDS_Subscriber_create_datareader (NameService)");
/* Adapt the DataReaderQos for the ChatMessageDataReader to keep track of all messages. */
message_qos = DDS_DataReaderQos__alloc();
checkHandle(message_qos, "DDS_DataReaderQos__alloc");
status = DDS_Subscriber_get_default_datareader_qos(chatSubscriber, message_qos);
checkStatus(status, "DDS_Subscriber_get_default_datareader_qos");
status = DDS_Subscriber_copy_from_topic_qos(chatSubscriber, message_qos, reliable_topic_qos);
checkStatus(status, "DDS_Subscriber_copy_from_topic_qos");
message_qos->history.kind = DDS_KEEP_ALL_HISTORY_QOS;
/* Create a DataReader for the ChatMessage Topic (using the appropriate QoS). */
loadAdmin = DDS_Subscriber_create_datareader(
chatSubscriber,
chatMessageTopic,
message_qos,
NULL,
DDS_STATUS_MASK_NONE);
checkHandle(loadAdmin, "DDS_Subscriber_create_datareader (ChatMessage)");
/* Initialize the Query Arguments. */
args._length = 1;
args._maximum = 1;
args._buffer = DDS_StringSeq_allocbuf(1);
checkHandle(args._buffer, "DDS_StringSeq_allocbuf");
args._buffer[0] = DDS_string_alloc (12); /* Enough for maximum size numbers. */
checkHandle(args._buffer[0], "DDS_string_alloc");
sprintf(args._buffer[0], "%d", 0);
/* Create a QueryCondition that will contain all messages with userID=ownID */
singleUser = DDS_DataReader_create_querycondition(
loadAdmin,
DDS_ANY_SAMPLE_STATE,
DDS_ANY_VIEW_STATE,
DDS_ANY_INSTANCE_STATE,
"userID=%0",
&args);
checkHandle(singleUser, "DDS_DataReader_create_querycondition (singleUser Query)");
/* Create a ReadCondition that will contain new users only */
newUser = DDS_DataReader_create_readcondition(
nameServer,
DDS_NOT_READ_SAMPLE_STATE,
DDS_NEW_VIEW_STATE,
DDS_ALIVE_INSTANCE_STATE);
checkHandle(newUser, "DDS_DataReader_create_readcondition (newUser)");
/* Obtain a StatusCondition that triggers only when a Writer changes Liveliness */
leftUser = DDS_DataReader_get_statuscondition(loadAdmin);
checkHandle(leftUser, "DDS_DataReader_get_statuscondition");
status = DDS_StatusCondition_set_enabled_statuses(leftUser, DDS_LIVELINESS_CHANGED_STATUS);
checkStatus(status, "DDS_StatusCondition_set_enabled_statuses");
/* Create a bare guard which will be used to close the room */
escape = DDS_GuardCondition__alloc();
checkHandle(escape, "DDS_GuardCondition__alloc");
/* Create a waitset and add the ReadConditions */
userLoadWS = DDS_WaitSet__alloc();
checkHandle(userLoadWS, "DDS_WaitSet__alloc");
status = DDS_WaitSet_attach_condition(userLoadWS, newUser);
checkStatus(status, "DDS_WaitSet_attach_condition (newUser)");
status = DDS_WaitSet_attach_condition(userLoadWS, leftUser);
checkStatus(status, "DDS_WaitSet_attach_condition (leftUser)");
status = DDS_WaitSet_attach_condition(userLoadWS, escape);
checkStatus(status, "DDS_WaitSet_attach_condition (escape)");
/* Initialize and pre-allocate the GuardList used to obtain the triggered Conditions. */
guardList = DDS_ConditionSeq__alloc();
checkHandle(guardList, "DDS_ConditionSeq__alloc");
guardList->_maximum = 3;
guardList->_length = 0;
guardList->_buffer = DDS_ConditionSeq_allocbuf(3);
checkHandle(guardList->_buffer, "DDS_ConditionSeq_allocbuf");
/* Remove all known Users that are not currently active. */
status = Chat_NameServiceDataReader_take(
nameServer,
&nsList,
&infoSeq,
DDS_LENGTH_UNLIMITED,
DDS_ANY_SAMPLE_STATE,
DDS_ANY_VIEW_STATE,
DDS_NOT_ALIVE_INSTANCE_STATE);
checkStatus(status, "Chat_NameServiceDataReader_take");
status = Chat_NameServiceDataReader_return_loan(nameServer, &nsList, &infoSeq);
checkStatus(status, "Chat_NameServiceDataReader_return_loan");
/* Start the sleeper thread. */
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
pthread_create (&tid, &tattr, delayedEscape, NULL);
pthread_attr_destroy(&tattr);
while (!closed) {
/* Wait until at least one of the Conditions in the waitset triggers. */
status = DDS_WaitSet_wait(userLoadWS, guardList, &timeout);
checkStatus(status, "DDS_WaitSet_wait");
/* Walk over all guards to display information */
for (i = 0; i < guardList->_length; i++) {
guard = guardList->_buffer[i];
if (guard == newUser) {
/* The newUser ReadCondition contains data */
status = Chat_NameServiceDataReader_read_w_condition(
nameServer,
&nsList,
&infoSeq,
DDS_LENGTH_UNLIMITED,
newUser);
checkStatus(status, "Chat_NameServiceDataReader_read_w_condition");
for (j = 0; j < nsList._length; j++) {
printf ("New user: %s\n", nsList._buffer[j].name);
}
status = Chat_NameServiceDataReader_return_loan(nameServer, &nsList, &infoSeq);
checkStatus(status, "Chat_NameServiceDataReader_return_loan");
} else if (guard == leftUser) {
/* Some liveliness has changed (either a DataWriter joined or a DataWriter left) */
status = DDS_DataReader_get_liveliness_changed_status(loadAdmin, &livChangStatus);
checkStatus(status, "DDS_DataReader_get_liveliness_changed_status");
if (livChangStatus.alive_count < prevCount) {
/* A user has left the ChatRoom, since a DataWriter lost its liveliness */
/* Take the effected users so tey will not appear in the list later on. */
status = Chat_NameServiceDataReader_take(
nameServer,
&nsList,
&infoSeq,
DDS_LENGTH_UNLIMITED,
DDS_ANY_SAMPLE_STATE,
DDS_ANY_VIEW_STATE,
DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
checkStatus(status, "Chat_NameServiceDataReader_take");
for (j = 0; j < nsList._length; j++) {
/* re-apply query arguments */
sprintf(args._buffer[0], "%d", nsList._buffer[j].userID);
status = DDS_QueryCondition_set_query_parameters(singleUser, &args);
checkStatus(status, "DDS_QueryCondition_set_query_parameters");
/* Read this users history */
status = Chat_ChatMessageDataReader_take_w_condition(
loadAdmin,
&msgList,
&infoSeq2,
DDS_LENGTH_UNLIMITED,
singleUser);
checkStatus(status, "Chat_ChatMessageDataReader_take_w_condition");
/* Display the user and his history */
printf (
"Departed user %s has sent %d messages\n",
nsList._buffer[j].name,
msgList._length);
status = Chat_ChatMessageDataReader_return_loan(loadAdmin, &msgList, &infoSeq2);
checkStatus(status, "Chat_ChatMessageDataReader_return_loan");
}
status = Chat_NameServiceDataReader_return_loan(nameServer, &nsList, &infoSeq);
checkStatus(status, "Chat_NameServiceDataReader_return_loan");
}
prevCount = livChangStatus.alive_count;
} else if (guard == escape) {
printf ("UserLoad has terminated.\n");
closed = 1;
}
else
{
assert(0);
};
} /* for */
} /* while (!closed) */
/* Remove all Conditions from the WaitSet. */
status = DDS_WaitSet_detach_condition(userLoadWS, escape);
checkStatus(status, "DDS_WaitSet_detach_condition (escape)");
status = DDS_WaitSet_detach_condition(userLoadWS, leftUser);
checkStatus(status, "DDS_WaitSet_detach_condition (leftUser)");
status = DDS_WaitSet_detach_condition(userLoadWS, newUser);
checkStatus(status, "DDS_WaitSet_detach_condition (newUser)");
/* Free all resources */
DDS_free(guardList);
DDS_free(args._buffer);
DDS_free(userLoadWS);
DDS_free(escape);
DDS_free(setting_topic_qos);
DDS_free(reliable_topic_qos);
DDS_free(nameServiceTypeName);
DDS_free(chatMessageTypeName);
DDS_free(nameServiceTS);
DDS_free(chatMessageTS);
status = DDS_DomainParticipant_delete_contained_entities(participant);
checkStatus(status, "DDS_DomainParticipant_delete_contained_entities");
status = DDS_DomainParticipantFactory_delete_participant(
DDS_TheParticipantFactory,
participant);
checkStatus(status, "DDS_DomainParticipantFactory_delete_participant");
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);
}
int main (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_dos_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_dos_");
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_dos_");
topic = DDS_DomainParticipant_create_topic (part, "imu", "simple_msgs::dds_::Vector3_dos_", NULL, NULL, 0);
if (!topic) {
printf ("Can't register vector3 message type.\r\n");
exit (1);
}
if (verbose)
printf ("DDS Vector3_dos 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_dos 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_dos_type_free (ts);
if (verbose)
printf ("Vector3_dos Type deleted.\r\n");
error = DDS_DomainParticipantFactory_delete_participant (part);
if (verbose)
printf ("DDS Participant deleted (error = %u).\r\n", error);
#ifdef DDS_SECURITY
if (cert_path || key_path || engine_id)
cleanup_security ();
#endif
return (0);
}
static int subscriber_main(int domainId, int sample_count,
char *participant_auth, char *reader_auth)
{
DDS_DomainParticipant *participant = NULL;
DDS_Subscriber *subscriber = NULL;
DDS_Topic *topic = NULL;
struct DDS_DataReaderListener reader_listener =
DDS_DataReaderListener_INITIALIZER;
DDS_DataReader *reader = NULL;
DDS_ReturnCode_t retcode;
const char *type_name = NULL;
int count = 0;
struct DDS_Duration_t poll_period = {1,0};
struct DDS_DomainParticipantQos participant_qos = DDS_DomainParticipantQos_INITIALIZER;
struct DDS_DataReaderQos datareader_qos = DDS_DataReaderQos_INITIALIZER;
int len, max;
retcode = DDS_DomainParticipantFactory_get_default_participant_qos(DDS_TheParticipantFactory, &participant_qos);
if (retcode != DDS_RETCODE_OK) {
printf("get_default_participant_qos error\n");
return -1;
}
/* We include the subscriber credentials into de USER_DATA QoS. */
len = strlen(participant_auth) + 1;
max = participant_qos.resource_limits.participant_user_data_max_length;
if (len > max) {
printf("error, participant user_data exceeds resource limits\n");
} else {
/*
* DDS_Octet is defined to be 8 bits. If chars are not 8 bits
* on your system, this will not work.
*/
DDS_OctetSeq_from_array(&participant_qos.user_data.value,
(DDS_Octet*)(participant_auth), len);
}
/* To create participant with default QoS, use DDS_PARTICIPANT_QOS_DEFAULT
instead of participant_qos */
participant = DDS_DomainParticipantFactory_create_participant(
DDS_TheParticipantFactory, domainId, &participant_qos,
NULL /* listener */, DDS_STATUS_MASK_NONE);
if (participant == NULL) {
printf("create_participant error\n");
subscriber_shutdown(participant);
return -1;
}
/* Done! All the listeners are installed, so we can enable the participant now. */
if (DDS_Entity_enable((DDS_Entity*)participant) != DDS_RETCODE_OK) {
printf("***Error: Failed to Enable Participant\n");
return -1;
}
/* To customize subscriber QoS, use
DDS_DomainParticipant_get_default_subscriber_qos() */
subscriber = DDS_DomainParticipant_create_subscriber(
participant, &DDS_SUBSCRIBER_QOS_DEFAULT, NULL /* listener */,
DDS_STATUS_MASK_NONE);
if (subscriber == NULL) {
printf("create_subscriber error\n");
subscriber_shutdown(participant);
return -1;
}
/* Register type before creating topic */
type_name = msgTypeSupport_get_type_name();
retcode = msgTypeSupport_register_type(participant, type_name);
if (retcode != DDS_RETCODE_OK) {
printf("register_type error %d\n", retcode);
subscriber_shutdown(participant);
return -1;
}
/* To customize topic QoS, use
DDS_DomainParticipant_get_default_topic_qos() */
topic = DDS_DomainParticipant_create_topic(
participant, "Example msg",
type_name, &DDS_TOPIC_QOS_DEFAULT, NULL /* listener */,
DDS_STATUS_MASK_NONE);
if (topic == NULL) {
printf("create_topic error\n");
subscriber_shutdown(participant);
return -1;
}
/* Setup data reader listener */
reader_listener.on_requested_deadline_missed =
msgListener_on_requested_deadline_missed;
reader_listener.on_requested_incompatible_qos =
msgListener_on_requested_incompatible_qos;
reader_listener.on_sample_rejected =
msgListener_on_sample_rejected;
reader_listener.on_liveliness_changed =
msgListener_on_liveliness_changed;
reader_listener.on_sample_lost =
msgListener_on_sample_lost;
reader_listener.on_subscription_matched =
msgListener_on_subscription_matched;
reader_listener.on_data_available =
msgListener_on_data_available;
/*
* Start changes for Builtin_Topics
* Set user_data qos field for datareader
*/
/* Get default datareader QoS to customize */
retcode = DDS_Subscriber_get_default_datareader_qos(subscriber, &datareader_qos);
if (retcode != DDS_RETCODE_OK) {
printf("get_default_datareader_qos error\n");
return -1;
}
len = strlen(reader_auth) + 1;
max = participant_qos.resource_limits.reader_user_data_max_length;
if (len > max) {
printf("error, datareader user_data exceeds resource limits\n");
} else {
/*
* DDS_Octet is defined to be 8 bits. If chars are not 8 bits
on your system, this will not work.
*/
DDS_OctetSeq_from_array(&datareader_qos.user_data.value,
(DDS_Octet*)(reader_auth), len);
}
/* To create datareader with default QoS, use DDS_DATAREADER_QOS_DEFAULT
instead of datareader_qos */
reader = DDS_Subscriber_create_datareader(
subscriber, DDS_Topic_as_topicdescription(topic),
&datareader_qos, &reader_listener, DDS_STATUS_MASK_ALL);
if (reader == NULL) {
printf("create_datareader error\n");
subscriber_shutdown(participant);
return -1;
}
/* Main loop */
for (count=0; (sample_count == 0) || (count < sample_count); ++count) {
/*
printf("msg subscriber sleeping for %d sec...\n",
poll_period.sec);
*/
NDDS_Utility_sleep(&poll_period);
}
/* Cleanup and delete delete all entities */
return subscriber_shutdown(participant);
}
static void test_aux (void)
{
DDS_DomainParticipant np, p;
DDS_Subscriber sub;
DDS_Topic t;
DDS_TopicDescription td;
DDS_DataReader dr, dr0, dr1;
DDS_StatusCondition sc, sc2;
DDS_StatusMask sm;
DDS_InstanceHandle_t h, h2;
DDS_DataReaderQos drq;
DDS_ReturnCode_t r;
v_printf (" - Test auxiliary subscriber functions.\r\n");
p = DDS_DomainParticipantFactory_create_participant (1, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0);
fail_unless (p != NULL);
sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0);
fail_unless (sub != NULL);
sc = DDS_Subscriber_get_statuscondition (sub);
fail_unless (sc != NULL);
sc2 = DDS_Entity_get_statuscondition (sub);
fail_unless (sc2 != NULL);
sm = DDS_Subscriber_get_status_changes (sub);
fail_unless (sm == 0);
sm = DDS_Entity_get_status_changes (sub);
fail_unless (sm == 0);
/*dbg_printf ("(mask=%u)", sm);*/
h = DDS_Subscriber_get_instance_handle (sub);
fail_unless (h != 0);
h2 = DDS_Entity_get_instance_handle (sub);
fail_unless (h == h2);
np = DDS_Subscriber_get_participant (sub);
fail_unless (np == p);
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);
dr0 = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0);
fail_unless (dr0 != NULL);
dr = DDS_Subscriber_lookup_datareader (sub, "HelloWorld");
fail_unless (dr == dr0);
dr1 = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0);
fail_unless (dr1 != NULL);
delay ();
r = DDS_Subscriber_delete_contained_entities (sub);
fail_unless (r == DDS_RETCODE_OK);
v_printf (" - Test default child QoS of subscriber entities\r\n");
r = DDS_Subscriber_get_default_datareader_qos (sub, &drq);
fail_unless (r == DDS_RETCODE_OK);
drq.ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS;
r = DDS_Subscriber_set_default_datareader_qos (sub, &drq);
fail_unless (r == DDS_RETCODE_OK);
dr1 = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0);
fail_unless (dr1 != NULL);
delay ();
v_printf (" - Test coherency (not implemented).\r\n");
r = DDS_Subscriber_begin_access (sub);
fail_unless (r == DDS_RETCODE_UNSUPPORTED);
r = DDS_Subscriber_end_access (sub);
fail_unless (r == DDS_RETCODE_UNSUPPORTED);
r = DDS_Subscriber_copy_from_topic_qos (sub, &drq, NULL);
fail_unless (r == DDS_RETCODE_OK);
r = DDS_Subscriber_notify_datareaders (sub);
fail_unless (r == DDS_RETCODE_OK);
r = DDS_DomainParticipant_delete_subscriber (p, sub);
fail_unless (r == DDS_RETCODE_PRECONDITION_NOT_MET);
r = DDS_Subscriber_delete_datareader (sub, dr1);
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);
}
void start_reader (DDS_DomainParticipant part, Topic *tp)
{
Endpoint *wp;
DDS_DynamicTypeBuilder tb;
DDS_TypeObject tobj;
DDS_TopicDescription td;
DDS_DataReaderQos rqos;
static DDS_Subscriber sub = NULL;
wp = tp->writers;
if (!wp)
return;
printf ("* Monitor (%s/%s)\r\n", tp->topic_name, tp->type_name);
if (!tp->ts) {
tobj = DDS_TypeObject_create_from_key (part,
&wp->data.participant_key,
&wp->data.key);
if (!tobj) {
printf ("No type information available for %s!\r\n", tp->type_name);
return;
}
tb = DDS_DynamicTypeBuilderFactory_create_type_w_type_object (tobj);
if (!tb)
fatal ("Can't get Type from Type object for %s!", tp->type_name);
DDS_TypeObject_delete (tobj);
tp->dtype = DDS_DynamicTypeBuilder_build (tb);
if (!tp->dtype)
fatal ("Can't get build Type from Type builder for %s!", tp->type_name);
DDS_DynamicTypeBuilderFactory_delete_type (tb);
tp->ts = DDS_DynamicTypeSupport_create_type_support (tp->dtype);
if (!tp->ts)
fatal ("Can't get TypeSupport from Type for %s!", tp->type_name);
if (DDS_DynamicTypeSupport_register_type (tp->ts, part, tp->type_name))
fatal ("Can't register TypeSupport in domain for %s!", tp->topic_name);
}
if (!sub) {
sub = DDS_DomainParticipant_create_subscriber (part, NULL, NULL, 0);
if (!sub)
fatal ("Can't create subscriber!");
}
tp->topic = DDS_DomainParticipant_create_topic (part,
tp->topic_name,
tp->type_name,
NULL,
NULL,
0);
if (!tp->topic)
fatal ("Can't create topic!");
td = DDS_DomainParticipant_lookup_topicdescription (part, tp->topic_name);
if (!td)
fatal ("Can't create topic description!");
DDS_Subscriber_get_default_datareader_qos (sub, &rqos);
if (wp->data.durability.kind >= DDS_TRANSIENT_LOCAL_DURABILITY_QOS)
rqos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
rqos.reliability = wp->data.reliability;
listener.cookie = tp;
tp->sub = sub;
tp->reader = DDS_Subscriber_create_datareader (sub, td, &rqos,
&listener,
DDS_DATA_AVAILABLE_STATUS);
tp->active = 1;
}
int main(int argc, char* argv[])
{
int startTime = mstime();
DDS_PoolConstraints reqs;
DDS_DomainParticipant domainParticipant;
DDS_Publisher publisher;
DDS_Subscriber subscriber;
DDS_ReturnCode_t retCode;
char *configTopicName[nofConfigTopics];
DDS_Topic configTopic[nofConfigTopics];
DDS_Topic stateTopic[nofStateTopics];
DDS_Topic statisticTopic[nofStatisticTopics];
DDS_DataWriterQos dataWriterQos;
DDS_DataWriter configDataWriter[nofConfigTopics];
DDS_DataWriter stateDataWriter[nofStateTopics];
DDS_DataWriter statisticDataWriter[nofStatisticTopics];
DDS_DataReaderQos dataReaderQos;
DDS_DataReader configDataReader[nofConfigTopics];
acceptance_high_end_Config config;
acceptance_high_end_State state;
acceptance_high_end_Statistic statistic;
DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances];
DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances];
DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances];
int i = 0;
int j = 0;
int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0;
int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0;
int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0;
int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0;
printf("[0] Config topics start at %d...\r\n", firstConfigTopic);
printf("[0] State topics start at %d...\r\n", firstStateTopic);
printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic);
printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off");
if (stagedLoading) {
char file_name[24];
sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic);
struct stat buf;
if (stat(file_name, &buf)) {
printf ("[%d] Waiting for %s\r\n", mstime() - startTime, file_name);
do {
sleep(1);
}
while (stat(file_name, &buf));
printf ("[%d] Got %s!\r\n", mstime() - startTime, file_name);
}
}
DDS_program_name (&argc, argv);
DDS_entity_name ("Technicolor Limits Component");
DDS_get_default_pool_constraints(&reqs, ~0, 100);
#ifdef MINIMAL_POOLS
configure_minimal_pool_constraints (&reqs);
#else
configure_optimal_pool_constraints (&reqs);
#endif
DDS_set_pool_constraints(&reqs);
#ifdef DDS_DEBUG
DDS_Debug_start ();
#endif
/* Create domain participant... */
domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0);
if (!domainParticipant) {
fprintf(stderr, "Error creating domain participant.\r\n");
return -1;
}
printf("[%d] Created domain participant.\r\n", mstime() - startTime);
sleep(1);
/* Create publisher... */
publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0);
if (!publisher) {
fprintf(stderr, "Error creating publisher.\r\n");
return -1;
}
printf("[%d] Created publisher.\r\n", mstime() - startTime);
sleep(1);
/* Create subscriber... */
subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0);
if (!subscriber) {
fprintf(stderr, "Error creating subscriber.\r\n");
return -1;
}
printf("[%d] Created subscriber.\r\n", mstime() - startTime);
sleep(1);
/* Register types... */
retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode));
return -1;
}
printf("[%d] Registered config type.\r\n", mstime() - startTime);
retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode));
return -1;
}
printf("[%d] Registered state type.\r\n", mstime() - startTime);
retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode));
return -1;
}
printf("[%d] Registered statistic type.\r\n", mstime() - startTime);
sleep(1);
/* Create topics... */
for (i = 0; i < nofConfigTopics; i++) {
char topicName[32];
sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i);
configTopicName[i] = strdup (topicName);
configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0);
if (!configTopic[i]) {
fprintf(stderr, "Error creating topic.\r\n");
return -1;
}
}
printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics);
for (i = 0; i < nofStateTopics; i++) {
char topicName[32];
sprintf(topicName, "StateTopic%d", firstStateTopic + i);
stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0);
if (!stateTopic[i]) {
fprintf(stderr, "Error creating topic.\r\n");
return -1;
}
}
printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics);
for (i = 0; i < nofStatisticTopics; i++) {
char topicName[32];
sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i);
statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0);
if (!statisticTopic[i]) {
fprintf(stderr, "Error creating topic.\r\n");
return -1;
}
}
printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics);
sleep(1);
/* Create data writers... */
DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos);
dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
for (i = 0; i < nofConfigTopics; i++) {
configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0);
if (!configDataWriter[i]) {
fprintf(stderr, "Error creating data writer.\r\n");
return -1;
}
}
printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics);
DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos);
dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
for (i = 0; i < nofStateTopics; i++) {
stateDataWriter[i] = DDS_Publisher_create_datawriter(publisher, stateTopic[i], &dataWriterQos, NULL, 0);
if (!stateDataWriter[i]) {
fprintf(stderr, "Error creating data writer.\r\n");
return -1;
}
}
printf("[%d] Created %d state data writers.\r\n", mstime() - startTime, nofStateTopics);
DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos);
for (i = 0; i < nofStatisticTopics; i++) {
statisticDataWriter[i] = DDS_Publisher_create_datawriter(publisher, statisticTopic[i], &dataWriterQos, NULL, 0);
if (!statisticDataWriter[i]) {
fprintf(stderr, "Error creating data writer.\r\n");
return -1;
}
}
printf("[%d] Created %d statistic data writers.\r\n", mstime() - startTime, nofStatisticTopics);
sleep(1);
/* Create data readers... */
DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos);
dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
for (i = 0; i < nofConfigTopics; i++) {
configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, NULL, 0);
if (!configDataReader[i]) {
fprintf(stderr, "Error creating data reader.\r\n");
return -1;
}
}
printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics);
sleep(1);
/* Register instances... */
for (i = 0; i < nofConfigTopics; i++) {
for (j = 0; j < nofConfigInstances; j++) {
config.key = j;
configInstance[i][j] = DDS_DataWriter_register_instance(configDataWriter[i], &config);
if (!configInstance[i][j]) {
fprintf(stderr, "Error registering instance.\r\n");
break;
}
}
}
printf("[%d] Registered %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances);
for (i = 0; i < nofStateTopics; i++) {
for (j = 0; j < nofStateInstances; j++) {
state.key = j;
stateInstance[i][j] = DDS_DataWriter_register_instance(stateDataWriter[i], &state);
if (!stateInstance[i][j]) {
fprintf(stderr, "Error registering instance.\r\n");
break;
}
}
}
printf("[%d] Registered %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);
for (i = 0; i < nofStatisticTopics; i++) {
for (j = 0; j < nofStatisticInstances; j++) {
statistic.key = j;
statisticInstance[i][j] = DDS_DataWriter_register_instance(statisticDataWriter[i], &statistic);
if (!statisticInstance[i][j]) {
fprintf(stderr, "Error registering instance.\r\n");
break;
}
}
}
printf("[%d] Registered %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);
sleep(1);
/* Publish samples... */
for (i = 0; i < nofConfigTopics; i++) {
for (j = 0; j < nofConfigInstances; j++) {
config.key = j;
retCode = DDS_DataWriter_write(configDataWriter[i], &config, configInstance[i][j]);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode));
break;
}
}
}
printf("[%d] Published %d config samples.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances);
for (i = 0; i < nofStateTopics; i++) {
for (j = 0; j < nofStateInstances; j++) {
state.key = j;
retCode = DDS_DataWriter_write(stateDataWriter[i], &state, stateInstance[i][j]);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode));
break;
}
}
}
printf("[%d] Published %d state samples.\r\n", mstime() - startTime, nofStateTopics * nofStateInstances);
for (i = 0; i < nofStatisticTopics; i++) {
for (j = 0; j < nofStatisticInstances; j++) {
statistic.key = j;
retCode = DDS_DataWriter_write(statisticDataWriter[i], &statistic, statisticInstance[i][j]);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode));
break;
}
}
}
printf("[%d] Published %d statistic samples.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);
sleep(1);
if (stagedLoading) {
char file_name[24];
sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic + nofConfigTopics);
FILE *f = fopen(file_name, "w");
fclose(f);
}
// dbg_printf ("Zzzzzzz ... \r\n");
sleep(TEST_TIME);
// dbg_printf ("... o?\r\n");
/* Delete contained entities... */
// printf (" -- deleting contained entities.\r\n");
retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error deleting contained entities.\r\n");
return -1;
}
for (i = 0; i < nofConfigTopics; i++)
free (configTopicName[i]);
// printf (" -- contained entities deleted!\r\n");
// sleep(TEST_TIME);
/* Delete domain participants... */
retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error deleting domain participant.\r\n");
return -1;
}
printf ("[%d] comp completed successfully.\r\n", mstime() - startTime);
return 0;
}
int main(int argc, char* argv[])
{
int startTime = mstime();
DDS_PoolConstraints reqs;
DDS_DomainParticipant domainParticipant;
DDS_Publisher publisher;
DDS_Subscriber subscriber;
DDS_ReturnCode_t retCode;
char *configTopicName[nofConfigTopics];
char *stateTopicName[nofStateTopics];
char *statisticTopicName[nofStatisticTopics];
DDS_Topic configTopic[nofConfigTopics];
DDS_Topic stateTopic[nofStateTopics];
DDS_Topic statisticTopic[nofStatisticTopics];
DDS_DataWriterQos dataWriterQos;
DDS_DataWriter configDataWriter[nofConfigTopics];
DDS_DataReaderQos dataReaderQos;
DDS_DataReader configDataReader[nofConfigTopics];
DDS_DataReader stateDataReader[nofStateTopics];
DDS_DataReader statisticDataReader[nofStatisticTopics];
#if 0
acceptance_high_end_Config config;
acceptance_high_end_State state;
acceptance_high_end_Statistic statistic;
DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances];
DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances];
DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances];
#endif
int i = 0;
/*int j = 0;*/
int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0;
int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0;
int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0;
int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0;
printf("[0] Config topics start at %d...\r\n", firstConfigTopic);
printf("[0] State topics start at %d...\r\n", firstStateTopic);
printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic);
printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off");
DDS_program_name (&argc, argv);
DDS_entity_name ("Technicolor Limits Manager");
DDS_get_default_pool_constraints(&reqs, ~0, 100);
#ifdef MINIMAL_POOLS
configure_minimal_pool_constraints (&reqs);
#else
configure_optimal_pool_constraints (&reqs);
#endif
DDS_set_pool_constraints (&reqs);
#ifdef DDS_DEBUG
DDS_Debug_start ();
#endif
#ifdef TRACE_DATA
rtps_dtrace_set (DRTRC_TRACE_ALL);
#endif
/* Create domain participant... */
domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0);
if (!domainParticipant) {
fprintf(stderr, "Error creating domain participant.\r\n");
return -1;
}
printf("[%d] Created domain participant.\r\n", mstime() - startTime);
// sleep(1);
/* Create publisher... */
publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0);
if (!publisher) {
fprintf(stderr, "Error creating publisher.\r\n");
return -1;
}
printf("[%d] Created publisher.\r\n", mstime() - startTime);
// sleep(1);
/* Create subscriber... */
subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0);
if (!subscriber) {
fprintf(stderr, "Error creating subscriber.\r\n");
return -1;
}
printf("[%d] Created subscriber.\r\n", mstime() - startTime);
// sleep(1);
/* Register types... */
retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode));
return -1;
}
printf("[%d] Registered config type.\r\n", mstime() - startTime);
retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode));
return -1;
}
printf("[%d] Registered state type.\r\n", mstime() - startTime);
retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode));
return -1;
}
printf("[%d] Registered statistic type.\r\n", mstime() - startTime);
// sleep(1);
/* Create topics... */
for (i = 0; i < nofConfigTopics; i++) {
char topicName[32];
sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i);
configTopicName[i] = topicName;
configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0);
if (!configTopic[i]) {
fprintf(stderr, "Error creating topic.\r\n");
return -1;
}
}
printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics);
for (i = 0; i < nofStateTopics; i++) {
char topicName[32];
sprintf(topicName, "StateTopic%d", firstStateTopic + i);
stateTopicName[i] = topicName;
stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0);
if (!stateTopic[i]) {
fprintf(stderr, "Error creating topic.\r\n");
return -1;
}
}
printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics);
for (i = 0; i < nofStatisticTopics; i++) {
char topicName[32];
sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i);
statisticTopicName[i] = topicName;
statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0);
if (!statisticTopic[i]) {
fprintf(stderr, "Error creating topic.\r\n");
return -1;
}
}
printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics);
// sleep(1);
/* Create data writers... */
DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos);
dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
for (i = 0; i < nofConfigTopics; i++) {
configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0);
if (!configDataWriter[i]) {
fprintf(stderr, "Error creating data writer.\r\n");
return -1;
}
}
printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics);
// sleep(1);
/* Create data readers... */
DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos);
dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
for (i = 0; i < nofConfigTopics; i++) {
configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, &configDataReaderListener, DDS_DATA_AVAILABLE_STATUS);
if (!configDataReader[i]) {
fprintf(stderr, "Error creating data reader.\r\n");
return -1;
}
}
printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics);
DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos);
dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS;
for (i = 0; i < nofStateTopics; i++) {
stateDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, stateTopicName[i]), &dataReaderQos, &stateDataReaderListener, DDS_DATA_AVAILABLE_STATUS);
if (!stateDataReader[i]) {
fprintf(stderr, "Error creating data reader.\r\n");
return -1;
}
}
printf("[%d] Created %d state data readers.\r\n", mstime() - startTime, nofStateTopics);
DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos);
for (i = 0; i < nofStatisticTopics; i++) {
statisticDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, statisticTopicName[i]), &dataReaderQos, &statisticDataReaderListener, DDS_DATA_AVAILABLE_STATUS);
if (!statisticDataReader[i]) {
fprintf(stderr, "Error creating data reader.\r\n");
return -1;
}
}
printf("[%d] Created %d statistic data readers.\r\n", mstime() - startTime, nofStatisticTopics);
// sleep(1);
/* Lookup instances... */
/*for (i = 0; i < nofConfigTopics; i++) {
for (j = 0; j < nofConfigInstances; j++) {
config.key = j;
configInstance[i][j] = acceptance_high_end_ConfigDataReader_lookup_instance(configDataReader[i], &config);
if (!configInstance[i][j]) {
fprintf(stderr, "Error looking up instance.\r\n");
break;
}
}
}
printf("[%d] Looked up %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances);
for (i = 0; i < nofStateTopics; i++) {
for (j = 0; j < nofStateInstances; j++) {
state.key = j;
stateInstance[i][j] = acceptance_high_end_StateDataReader_lookup_instance(stateDataReader[i], &state);
if (!stateInstance[i][j]) {
fprintf(stderr, "Error looking up instance.\r\n");
break;
}
}
}
printf("[%d] Looked up %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);
for (i = 0; i < nofStatisticTopics; i++) {
for (j = 0; j < nofStatisticInstances; j++) {
statistic.key = j;
statisticInstance[i][j] = acceptance_high_end_StatisticDataReader_lookup_instance(statisticDataReader[i], &statistic);
if (!statisticInstance[i][j]) {
fprintf(stderr, "Error looking up instance.\r\n");
break;
}
}
}
printf("[%d] Looked up %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);*/
// sleep(1);
if (stagedLoading) {
char file_name[24];
sprintf(file_name, "/tmp/acceptStageLoad0");
FILE *f = fopen(file_name, "w");
fclose(f);
}
int waitTime = mstime();
int _nofConfigSamples = 0;
int _nofStateSamples = 0;
int _nofStatisticSamples = 0;
while ((mstime() - waitTime) < (TEST_TIME * 1000)) {
if ((nofConfigSamples > _nofConfigSamples) || (nofStateSamples > _nofStateSamples) || (nofStatisticSamples > _nofStatisticSamples)) {
printf("[%d] Received %d config samples.\r\n", mstime() - startTime, nofConfigSamples);
printf("[%d] Received %d state samples.\r\n", mstime() - startTime, nofStateSamples);
printf("[%d] Received %d statistic samples.\r\n", mstime() - startTime, nofStatisticSamples);
_nofConfigSamples = nofConfigSamples;
_nofStateSamples = nofStateSamples;
_nofStatisticSamples = nofStatisticSamples;
}
sleep(1);
}
/* Delete contained entities... */
// printf (" -- Deleting contained entities.\r\n");
retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error deleting contained entities.\r\n");
return -1;
}
// printf ("contained entities deleted!\r\n");
/* Delete domain participants... */
retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant);
if (retCode != DDS_RETCODE_OK) {
fprintf(stderr, "Error deleting domain participant.\r\n");
return -1;
}
printf ("[%d] mgmt completed successfully.\r\n", mstime() - startTime);
return 0;
}
