int
main (int argc, char **argv)
{
int trknum = 0;
printf
("HOMM2 CD music player\nEnter track number to play, 0 to stop playback, 1 to exit\n");
create_events ();
while (1)
{
int ret;
printf ("h2play> ");
ret = scanf ("%d", &trknum);
if (ret == EOF)
return 0;
if (!ret)
continue;
printf ("Event: %d\n", trknum);
fire_event (trknum);
if (trknum == 63)
{
printf ("Terminating\n");
return 0;
}
}
}
IODeviceProvider_TCPConnection::IODeviceProvider_TCPConnection(const SocketName &remote, const SocketName &local)
: timeout(15000)
{
socket.create_tcp();
create_events();
connect(remote, local);
}
static int
create_dialog( void )
{
int error;
GtkWidget *hbox, *vbox, *hbox2, *content_area;
GtkAccelGroup *accel_group;
gtkui_font font;
error = gtkui_get_monospaced_font( &font ); if( error ) return error;
dialog = gtkstock_dialog_new( "Fuse - Debugger",
G_CALLBACK( delete_dialog ) );
content_area = gtk_dialog_get_content_area( GTK_DIALOG( dialog ) );
/* The menu bar */
error = create_menu_bar( GTK_BOX( content_area ), &accel_group );
if( error ) return error;
/* Keyboard shortcuts */
gtk_window_add_accel_group( GTK_WINDOW( dialog ), accel_group );
/* Some boxes to contain the things we want to display */
hbox = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 );
gtk_box_pack_start( GTK_BOX( content_area ), hbox, TRUE, TRUE, 5 );
vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, 5 );
gtk_box_pack_start( GTK_BOX( hbox ), vbox, TRUE, TRUE, 5 );
hbox2 = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox2, TRUE, TRUE, 0 );
/* The main display areas */
error = create_register_display( GTK_BOX( hbox2 ), font );
if( error ) return error;
error = create_memory_map( GTK_BOX( hbox2 ) ); if( error ) return error;
create_breakpoints( GTK_BOX( vbox ) );
create_disassembly( GTK_BOX( hbox ), font );
create_stack_display( GTK_BOX( hbox ), font );
create_events( GTK_BOX( hbox ) );
error = create_command_entry( GTK_BOX( content_area ), accel_group );
if( error ) return error;
/* The action buttons */
error = create_buttons( GTK_DIALOG( dialog ), accel_group );
if( error ) return error;
gtkui_free_font( font );
dialog_created = 1;
return 0;
}
laundry create_laundry(double tf, double tr, int n, int s, int o, randgen rg){
laundry l;
l = (laundry)calloc(1, sizeof(struct slaundry));
l->events_list = create_events();
l->tfail = tf;
l->trepair = tr;
l->n = n;
l->s = s;
l->o = o;
l->rg = rg;
return l;
}
std::vector<epoll::event> epoll::await(std::uint32_t chunk_size) const {
std::vector<epoll_event> active_files;
active_files.resize(chunk_size);
auto events_number = epoll_wait(efd_, &active_files.front(), chunk_size, 1000);
if (-1 == events_number) {
active_files.resize(0);
if (errno != EINTR)
throw poll_error("Could not poll for events. errno = " + std::to_string(errno));
} else {
active_files.resize(events_number);
}
return create_events(active_files);
}
static GSource *
g_io_win32_create_watch (GIOChannel *channel,
GIOCondition condition,
unsigned (__stdcall *thread) (void *parameter))
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
GIOWin32Watch *watch;
GSource *source;
char send_buffer[] = "c";
source = g_source_new (&wp_g_io_watch_funcs, sizeof (GIOWin32Watch));
watch = (GIOWin32Watch *)source;
watch->channel = channel;
g_io_channel_ref (channel);
watch->condition = condition;
if (win32_channel->data_avail_event == NULL)
create_events (win32_channel);
watch->pollfd.fd = (gint) win32_channel->data_avail_event;
watch->pollfd.events = condition;
if (win32_channel->debug)
g_print ("g_io_win32_create_watch: fd:%d condition:%#x handle:%#x\n",
win32_channel->fd, condition, watch->pollfd.fd);
LOCK (win32_channel->mutex);
win32_channel->watches = g_slist_append (win32_channel->watches, watch);
if (win32_channel->thread_id == 0)
create_thread (win32_channel, condition, thread);
else
send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0);
g_source_add_poll (source, &watch->pollfd);
UNLOCK (win32_channel->mutex);
return source;
}
void
g_io_channel_win32_make_pollfd (GIOChannel *channel,
GIOCondition condition,
GPollFD *fd)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
if (win32_channel->data_avail_event == NULL)
create_events (win32_channel);
fd->fd = (gint) win32_channel->data_avail_event;
fd->events = condition;
if (win32_channel->thread_id == 0)
{
if ((condition & G_IO_IN) && win32_channel->type == G_IO_WIN32_FILE_DESC)
create_thread (win32_channel, condition, read_thread);
else if (win32_channel->type == G_IO_WIN32_SOCKET)
create_thread (win32_channel, condition, select_thread);
}
}
/**
* @brief
* calculate the run time of a resresv through simulation of
* future calendar events
*
* @param[in] name - the name of the resresv to find the start time of
* @param[in] sinfo - the pbs environment
* NOTE: sinfo will be modified, it should be a copy
* @param[in] flags - some flags to control the function
* SIM_RUN_JOB - simulate running the resresv
*
* @return int
* @retval time_t of when the job will run
* @retval 0 : can not determine when job will run
* @retval 1 : on error
*
*/
time_t
calc_run_time(char *name, server_info *sinfo, int flags)
{
time_t event_time = (time_t) 0; /* time of the simulated event */
event_list *calendar; /* calendar we are simulating in */
resource_resv *resresv; /* the resource resv to find star time for */
/* the value returned from simulate_events(). Init to TIMED_END_EVENT to
* force the initial check to see if the job can run
*/
unsigned int ret = TIMED_END_EVENT;
schd_error *err = NULL;
timed_event *te_start;
timed_event *te_end;
int desc;
nspec **ns = NULL;
if (name == NULL || sinfo == NULL)
return (time_t) -1;
event_time = sinfo->server_time;
calendar = sinfo->calendar;
resresv = find_resource_resv(sinfo->all_resresv, name);
if (!is_resource_resv_valid(resresv, NULL))
return (time_t) -1;
err = new_schd_error();
if(err == NULL)
return (time_t) 0;
do {
/* policy is used from sinfo instead of being passed into calc_run_time()
* because it's being simulated/updated in simulate_events()
*/
desc = describe_simret(ret);
if (desc > 0 || (desc == 0 && policy_change_info(sinfo, resresv))) {
clear_schd_error(err);
if (resresv->is_job)
ns = is_ok_to_run(sinfo->policy, -1, sinfo, resresv->job->queue, resresv, IGNORE_EQUIV_CLASS, err);
else
ns = is_ok_to_run(sinfo->policy, -1, sinfo, NULL, resresv, IGNORE_EQUIV_CLASS, err);
}
if (ns == NULL) /* event can not run */
ret = simulate_events(sinfo->policy, sinfo, SIM_NEXT_EVENT, &(sinfo->opt_backfill_fuzzy_time), &event_time);
#ifdef NAS /* localmod 030 */
if (check_for_cycle_interrupt(0)) {
break;
}
#endif /* localmod 030 */
} while (ns == NULL && !(ret & (TIMED_NOEVENT|TIMED_ERROR)));
#ifdef NAS /* localmod 030 */
if (check_for_cycle_interrupt(0) || (ret & TIMED_ERROR)) {
#else
if ((ret & TIMED_ERROR)) {
#endif /* localmod 030 */
free_schd_error(err);
if (ns != NULL)
free_nspecs(ns);
return -1;
}
/* we can't run the job, but there are no timed events left to process */
if (ns == NULL && (ret & TIMED_NOEVENT)) {
schdlogerr(PBSEVENT_SCHED, PBS_EVENTCLASS_SCHED, LOG_WARNING, resresv->name,
"Can't find start time estimate", err);
free_schd_error(err);
return 0;
}
/* err is no longer needed, we've reported it. */
free_schd_error(err);
err = NULL;
if (resresv->is_job)
resresv->job->est_start_time = event_time;
resresv->start = event_time;
resresv->end = event_time + resresv->duration;
te_start = create_event(TIMED_RUN_EVENT, resresv->start,
(event_ptr_t *) resresv, NULL, NULL);
if (te_start == NULL) {
if (ns != NULL)
free_nspecs(ns);
return -1;
}
te_end = create_event(TIMED_END_EVENT, resresv->end,
(event_ptr_t *) resresv, NULL, NULL);
if (te_end == NULL) {
if (ns != NULL)
free_nspecs(ns);
free_timed_event(te_start);
return -1;
}
add_event(calendar, te_start);
add_event(calendar, te_end);
if (flags & SIM_RUN_JOB)
sim_run_update_resresv(sinfo->policy, resresv, ns, RURR_NO_FLAGS);
else
free_nspecs(ns);
return event_time;
}
/**
* @brief
* create an event_list from running jobs and confirmed resvs
*
* @param[in] sinfo - server universe to act upon
*
* @return event_list
*/
event_list *
create_event_list(server_info *sinfo)
{
event_list *elist;
elist = new_event_list();
if (elist == NULL)
return NULL;
elist->events = create_events(sinfo);
elist->next_event = elist->events;
elist->current_time = &sinfo->server_time;
add_dedtime_events(elist, sinfo->policy);
return elist;
}
static espeak_ng_STATUS Synthesize(unsigned int unique_identifier, const void *text, int flags)
{
// Fill the buffer with output sound
int length;
int finished = 0;
int count_buffers = 0;
if ((outbuf == NULL) || (event_list == NULL))
return ENS_NOT_INITIALIZED;
option_ssml = flags & espeakSSML;
option_phoneme_input = flags & espeakPHONEMES;
option_endpause = flags & espeakENDPAUSE;
count_samples = 0;
espeak_ng_STATUS status;
if (translator == NULL) {
status = espeak_ng_SetVoiceByName("en");
if (status != ENS_OK)
return status;
}
if (p_decoder == NULL)
p_decoder = create_text_decoder();
status = text_decoder_decode_string_multibyte(p_decoder, text, translator->encoding, flags);
if (status != ENS_OK)
return status;
SpeakNextClause(0);
for (;;) {
out_ptr = outbuf;
out_end = &outbuf[outbuf_size];
event_list_ix = 0;
WavegenFill();
length = (out_ptr - outbuf)/2;
count_samples += length;
event_list[event_list_ix].type = espeakEVENT_LIST_TERMINATED; // indicates end of event list
event_list[event_list_ix].unique_identifier = unique_identifier;
event_list[event_list_ix].user_data = my_user_data;
count_buffers++;
if ((my_mode & ENOUTPUT_MODE_SPEAK_AUDIO) == ENOUTPUT_MODE_SPEAK_AUDIO) {
finished = create_events((short *)outbuf, length, event_list);
if (finished < 0)
return ENS_AUDIO_ERROR;
} else if (synth_callback)
finished = synth_callback((short *)outbuf, length, event_list);
if (finished) {
SpeakNextClause(2); // stop
return ENS_SPEECH_STOPPED;
}
if (Generate(phoneme_list, &n_phoneme_list, 1) == 0) {
if (WcmdqUsed() == 0) {
// don't process the next clause until the previous clause has finished generating speech.
// This ensures that <audio> tag (which causes end-of-clause) is at a sound buffer boundary
event_list[0].type = espeakEVENT_LIST_TERMINATED;
event_list[0].unique_identifier = my_unique_identifier;
event_list[0].user_data = my_user_data;
if (SpeakNextClause(1) == 0) {
finished = 0;
if ((my_mode & ENOUTPUT_MODE_SPEAK_AUDIO) == ENOUTPUT_MODE_SPEAK_AUDIO) {
if (dispatch_audio(NULL, 0, NULL) < 0)
return ENS_AUDIO_ERROR;
} else if (synth_callback)
finished = synth_callback(NULL, 0, event_list); // NULL buffer ptr indicates end of data
if (finished) {
SpeakNextClause(2); // stop
return ENS_SPEECH_STOPPED;
}
return ENS_OK;
}
}
}
}
}
static espeak_ERROR Synthesize(unsigned int unique_identifier, const void *text, int flags)
{//========================================================================================
// Fill the buffer with output sound
int length;
int finished = 0;
int count_buffers = 0;
#ifdef USE_ASYNC
uint32_t a_write_pos=0;
#endif
#ifdef DEBUG_ENABLED
ENTER("Synthesize");
if (text)
{
SHOW("Synthesize > uid=%d, flags=%d, >>>text=%s<<<\n", unique_identifier, flags, text);
}
#endif
if((outbuf==NULL) || (event_list==NULL))
return(EE_INTERNAL_ERROR); // espeak_Initialize() has not been called
option_multibyte = flags & 7;
option_ssml = flags & espeakSSML;
option_phoneme_input = flags & espeakPHONEMES;
option_endpause = flags & espeakENDPAUSE;
count_samples = 0;
#ifdef USE_ASYNC
if(my_mode == AUDIO_OUTPUT_PLAYBACK)
{
a_write_pos = wave_get_write_position(my_audio);
}
#endif
if(translator == NULL)
{
SetVoiceByName("default");
}
SpeakNextClause(NULL,text,0);
if(my_mode == AUDIO_OUTPUT_SYNCH_PLAYBACK)
{
for(;;)
{
#ifdef PLATFORM_WINDOWS
Sleep(300); // 0.3s
#else
#ifdef USE_NANOSLEEP
struct timespec period;
struct timespec remaining;
period.tv_sec = 0;
period.tv_nsec = 300000000; // 0.3 sec
nanosleep(&period,&remaining);
#else
sleep(1);
#endif
#endif
if(SynthOnTimer() != 0)
break;
}
return(EE_OK);
}
for(;;)
{
#ifdef DEBUG_ENABLED
SHOW("Synthesize > %s\n","for (next)");
#endif
out_ptr = outbuf;
out_end = &outbuf[outbuf_size];
event_list_ix = 0;
WavegenFill(0);
length = (out_ptr - outbuf)/2;
count_samples += length;
event_list[event_list_ix].type = espeakEVENT_LIST_TERMINATED; // indicates end of event list
event_list[event_list_ix].unique_identifier = my_unique_identifier;
event_list[event_list_ix].user_data = my_user_data;
count_buffers++;
if (my_mode==AUDIO_OUTPUT_PLAYBACK)
{
#ifdef USE_ASYNC
finished = create_events((short *)outbuf, length, event_list, a_write_pos);
if(finished < 0)
return EE_INTERNAL_ERROR;
length = 0; // the wave data are played once.
#endif
}
else
{
finished = synth_callback((short *)outbuf, length, event_list);
}
if(finished)
{
SpeakNextClause(NULL,0,2); // stop
break;
}
if(Generate(phoneme_list,&n_phoneme_list,1)==0)
{
if(WcmdqUsed() == 0)
{
// don't process the next clause until the previous clause has finished generating speech.
// This ensures that <audio> tag (which causes end-of-clause) is at a sound buffer boundary
event_list[0].type = espeakEVENT_LIST_TERMINATED;
event_list[0].unique_identifier = my_unique_identifier;
event_list[0].user_data = my_user_data;
if(SpeakNextClause(NULL,NULL,1)==0)
{
#ifdef USE_ASYNC
if (my_mode==AUDIO_OUTPUT_PLAYBACK)
{
if(dispatch_audio(NULL, 0, NULL) < 0) // TBD: test case
return err = EE_INTERNAL_ERROR;
}
else
{
synth_callback(NULL, 0, event_list); // NULL buffer ptr indicates end of data
}
#else
synth_callback(NULL, 0, event_list); // NULL buffer ptr indicates end of data
#endif
break;
}
}
}
}
return(EE_OK);
} // end of Synthesize
IODeviceProvider_TCPConnection::IODeviceProvider_TCPConnection(int handle, bool close_socket)
: timeout(15000)
{
socket.set_handle(handle, close_socket);
create_events();
}
IODeviceProvider_TCPConnection::IODeviceProvider_TCPConnection()
: timeout(15000)
{
socket.create_tcp();
create_events();
}
void iothub_client_sample_amqp_run(void)
{
TRANSPORT_HANDLE transport_handle;
IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle1;
IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle2;
EVENT_INSTANCE messages_device1[MESSAGE_COUNT];
EVENT_INSTANCE messages_device2[MESSAGE_COUNT];
g_continueRunning = true;
//callbackCounter = 0;
int receiveContext1 = 0;
int receiveContext2 = 0;
(void)printf("Starting the IoTHub client sample AMQP...\r\n");
if (platform_init() != 0)
{
printf("Failed to initialize the platform.\r\n");
}
else
{
if ((transport_handle = IoTHubTransport_Create(AMQP_Protocol, hubName, hubSuffix)) == NULL)
{
printf("Failed to creating the protocol handle.\r\n");
}
else
{
IOTHUB_CLIENT_DEVICE_CONFIG config1;
config1.deviceId = deviceId1;
config1.deviceKey = deviceKey1;
config1.deviceSasToken = NULL;
config1.protocol = AMQP_Protocol;
config1.transportHandle = IoTHubTransport_GetLLTransport(transport_handle);
IOTHUB_CLIENT_DEVICE_CONFIG config2;
config2.deviceId = deviceId2;
config2.deviceKey = deviceKey2;
config2.deviceSasToken = NULL;
config2.protocol = AMQP_Protocol;
config2.transportHandle = IoTHubTransport_GetLLTransport(transport_handle);
if ((iotHubClientHandle1 = IoTHubClient_LL_CreateWithTransport(&config1)) == NULL)
{
(void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n");
}
else if ((iotHubClientHandle2 = IoTHubClient_LL_CreateWithTransport(&config2)) == NULL)
{
(void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n");
}
else
{
bool traceOn = true;
IoTHubClient_LL_SetOption(iotHubClientHandle1, OPTION_LOG_TRACE, &traceOn);
#ifdef SET_TRUSTED_CERT_IN_SAMPLES
// For mbed add the certificate information
if (IoTHubClient_LL_SetOption(iotHubClientHandle1, OPTION_TRUSTED_CERT, certificates) != IOTHUB_CLIENT_OK)
{
printf("failure to set option \"TrustedCerts\"\r\n");
}
#endif // SET_TRUSTED_CERT_IN_SAMPLES
if (create_events(messages_device1, config1.deviceId) != 0 || create_events(messages_device2, config2.deviceId) != 0)
{
(void)printf("ERROR: failed creating events for the devices..........FAILED!\r\n");
}
/* Setting Message call back, so we can receive Commands. */
else if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle1, ReceiveMessageCallback, &receiveContext1) != IOTHUB_CLIENT_OK)
{
(void)printf("ERROR: IoTHubClient_SetMessageCallback for device 1..........FAILED!\r\n");
}
else if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle2, ReceiveMessageCallback, &receiveContext2) != IOTHUB_CLIENT_OK)
{
(void)printf("ERROR: IoTHubClient_SetMessageCallback for device 2..........FAILED!\r\n");
}
else
{
(void)printf("IoTHubClient_SetMessageCallback...successful.\r\n");
/* Now that we are ready to receive commands, let's send some messages */
size_t iterator = 0;
do
{
if (iterator < MESSAGE_COUNT)
{
if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle1, messages_device1[iterator].messageHandle, SendConfirmationCallback, &messages_device1[iterator]) != IOTHUB_CLIENT_OK)
{
(void)printf("ERROR: IoTHubClient_SendEventAsync for device 1..........FAILED!\r\n");
}
else if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle2, messages_device2[iterator].messageHandle, SendConfirmationCallback, &messages_device2[iterator]) != IOTHUB_CLIENT_OK)
{
(void)printf("ERROR: IoTHubClient_SendEventAsync for device 2..........FAILED!\r\n");
}
else
{
(void)printf("IoTHubClient_SendEventAsync accepted data for transmission to IoT Hub.\r\n");
}
IoTHubMessage_Destroy(messages_device1[iterator].messageHandle);
IoTHubMessage_Destroy(messages_device2[iterator].messageHandle);
}
IoTHubClient_LL_DoWork(iotHubClientHandle1);
IoTHubClient_LL_DoWork(iotHubClientHandle2);
ThreadAPI_Sleep(1);
iterator++;
} while (g_continueRunning);
(void)printf("iothub_client_sample_mqtt has gotten quit message, call DoWork %d more time to complete final sending...\r\n", DOWORK_LOOP_NUM);
for (size_t index = 0; index < DOWORK_LOOP_NUM; index++)
{
IoTHubClient_LL_DoWork(iotHubClientHandle1);
ThreadAPI_Sleep(1);
}
}
IoTHubClient_LL_Destroy(iotHubClientHandle1);
IoTHubClient_LL_Destroy(iotHubClientHandle2);
}
IoTHubTransport_Destroy(transport_handle);
}
platform_deinit();
}
}
int main(void)
{
TRANSPORT_HANDLE transport_handle;
IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol;
IOTHUB_DEVICE_CLIENT_LL_HANDLE device_ll_handle1;
IOTHUB_DEVICE_CLIENT_LL_HANDLE device_ll_handle2;
#ifdef SAMPLE_AMQP
protocol = AMQP_Protocol;
#endif // SAMPLE_AMQP
#ifdef SAMPLE_AMQP_OVER_WEBSOCKETS
protocol = AMQP_Protocol_over_WebSocketsTls;
#endif // SAMPLE_AMQP_OVER_WEBSOCKETS
#ifdef SAMPLE_HTTP
protocol = HTTP_Protocol;
#endif // SAMPLE_HTTP
g_continueRunning = true;
//callbackCounter = 0;
int receiveContext1 = 0;
int receiveContext2 = 0;
(void)printf("Starting the IoTHub client shared sample. Send `quit` message to either device to close...\r\n");
// Used to initialize IoTHub SDK subsystem
(void)IoTHub_Init();
if ((transport_handle = IoTHubTransport_Create(protocol, hubName, hubSuffix)) == NULL)
{
printf("Failed to creating the protocol handle.\r\n");
}
else
{
EVENT_INSTANCE device1_event;
EVENT_INSTANCE device2_event;
device1_event.deviceId = deviceId1;
IOTHUB_CLIENT_DEVICE_CONFIG config1 = { 0 };
config1.deviceId = deviceId1;
config1.deviceKey = deviceKey1;
config1.deviceSasToken = NULL;
config1.protocol = protocol;
config1.transportHandle = IoTHubTransport_GetLLTransport(transport_handle);
device2_event.deviceId = deviceId2;
IOTHUB_CLIENT_DEVICE_CONFIG config2 = { 0 };
config2.deviceId = deviceId2;
config2.deviceKey = deviceKey2;
config2.deviceSasToken = NULL;
config2.protocol = protocol;
config2.transportHandle = IoTHubTransport_GetLLTransport(transport_handle);
if ((device_ll_handle1 = IoTHubDeviceClient_LL_CreateWithTransport(&config1)) == NULL)
{
(void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n");
}
else if ((device_ll_handle2 = IoTHubDeviceClient_LL_CreateWithTransport(&config2)) == NULL)
{
(void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n");
}
else
{
// Set any option that are neccessary.
// For available options please see the iothub_sdk_options.md documentation
//bool traceOn = true;
//IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_LOG_TRACE, &traceOn);
//IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_LOG_TRACE, &traceOn);
#ifdef SET_TRUSTED_CERT_IN_SAMPLES
// Setting the Trusted Certificate. This is only necessary on system without
// built in certificate stores.
IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_TRUSTED_CERT, certificates);
IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_TRUSTED_CERT, certificates);
#endif // SET_TRUSTED_CERT_IN_SAMPLES
#ifdef SAMPLE_HTTP
unsigned int timeout = 241000;
// Because it can poll "after 9 seconds" polls will happen effectively // at ~10 seconds.
// Note that for scalabilty, the default value of minimumPollingTime
// is 25 minutes. For more information, see:
// https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging
unsigned int minimumPollingTime = 9;
IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_MIN_POLLING_TIME, &minimumPollingTime);
IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_HTTP_TIMEOUT, &timeout);
IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_MIN_POLLING_TIME, &minimumPollingTime);
IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_HTTP_TIMEOUT, &timeout);
#endif // SAMPLE_HTTP
/* Setting Message call back, so we can receive Commands. */
(void)IoTHubDeviceClient_LL_SetMessageCallback(device_ll_handle1, ReceiveMessageCallback, &receiveContext1);
(void)IoTHubDeviceClient_LL_SetMessageCallback(device_ll_handle2, ReceiveMessageCallback, &receiveContext2);
/* Now that we are ready to receive commands, let's send some messages */
size_t messages_sent = 0;
IOTHUB_MESSAGE_HANDLE message_handle;
do
{
if (messages_sent < MESSAGE_COUNT)
{
// Create the event hub message
message_handle = create_events(&device1_event);
(void)IoTHubDeviceClient_LL_SendEventAsync(device_ll_handle1, message_handle, SendConfirmationCallback, &device1_event);
// The message is copied to the sdk so the we can destroy it
IoTHubMessage_Destroy(message_handle);
message_handle = create_events(&device2_event);
(void)IoTHubDeviceClient_LL_SendEventAsync(device_ll_handle2, message_handle, SendConfirmationCallback, &device2_event);
// The message is copied to the sdk so the we can destroy it
IoTHubMessage_Destroy(message_handle);
messages_sent++;
}
IoTHubDeviceClient_LL_DoWork(device_ll_handle1);
IoTHubDeviceClient_LL_DoWork(device_ll_handle2);
ThreadAPI_Sleep(1);
} while (g_continueRunning);
(void)printf("client_amqp_shared_sample has gotten quit message, call DoWork %d more time to complete final sending...\r\n", DOWORK_LOOP_NUM);
for (size_t index = 0; index < DOWORK_LOOP_NUM; index++)
{
IoTHubDeviceClient_LL_DoWork(device_ll_handle1);
IoTHubDeviceClient_LL_DoWork(device_ll_handle2);
ThreadAPI_Sleep(1);
}
// Clean up the iothub sdk handle
IoTHubDeviceClient_LL_Destroy(device_ll_handle1);
IoTHubDeviceClient_LL_Destroy(device_ll_handle2);
}
IoTHubTransport_Destroy(transport_handle);
// Free all the sdk subsystem
IoTHub_Deinit();
}
return 0;
}
static int
create_dialog( void )
{
int error;
GtkWidget *hbox, *vbox, *hbox2;
GtkAccelGroup *accel_group;
debugger_pane i;
gtkui_font font;
error = gtkui_get_monospaced_font( &font ); if( error ) return error;
dialog = gtkstock_dialog_new( "Fuse - Debugger",
GTK_SIGNAL_FUNC( delete_dialog ) );
/* Keyboard shortcuts */
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group( GTK_WINDOW( dialog ), accel_group );
/* The menu bar */
error = create_menu_bar( GTK_BOX( GTK_DIALOG( dialog )->vbox ),
accel_group );
if( error ) return error;
/* Some boxes to contain the things we want to display */
hbox = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX( GTK_DIALOG( dialog )->vbox ), hbox,
TRUE, TRUE, 5 );
vbox = gtk_vbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( hbox ), vbox, TRUE, TRUE, 5 );
hbox2 = gtk_hbox_new( FALSE, 5 );
gtk_box_pack_start_defaults( GTK_BOX( vbox ), hbox2 );
/* The main display areas */
error = create_register_display( GTK_BOX( hbox2 ), font );
if( error ) return error;
error = create_memory_map( GTK_BOX( hbox2 ) ); if( error ) return error;
error = create_breakpoints( GTK_BOX( vbox ) ); if( error ) return error;
error = create_disassembly( GTK_BOX( hbox ), font );
if( error ) return error;
error = create_stack_display( GTK_BOX( hbox ), font );
if( error ) return error;
error = create_events( GTK_BOX( hbox ) ); if( error ) return error;
error = create_command_entry( GTK_BOX( GTK_DIALOG( dialog )->vbox ),
accel_group );
if( error ) return error;
/* The action buttons */
error = create_buttons( GTK_DIALOG( dialog ), accel_group );
if( error ) return error;
/* Initially, have all the panes visible */
for( i = DEBUGGER_PANE_BEGIN; i < DEBUGGER_PANE_END; i++ ) {
GtkCheckMenuItem *check_item;
check_item = get_pane_menu_item( i ); if( !check_item ) break;
gtk_check_menu_item_set_active( check_item, TRUE );
}
gtkui_free_font( font );
dialog_created = 1;
return 0;
}
