void SessionSummaryThr::run() { if ( mysqlpp::get_library_version() != MYSQLPP_HEADER_VERSION ) { cerr<< "Library/header version number mismatch" << endl; return; }; MyNode mynode(mpSession); //mynode.prevshotnum = startshot; SEVCHK(ca_context_create(ca_disable_preemptive_callback),"ca_context_create"); SEVCHK(ca_add_exception_event(exceptionCallback,NULL), "ca_add_exception_event"); //string pvnames[]={"CCS_SHOT_NUMBER","CCS_PERFORM_SHOT_SUMMARY"}; //Test.. //SEVCHK(ca_create_channel("DDS2_getState",connectionCallback, // &mynode,10,(oldChannelNotify**)&mynode.summary_chid), "ca_create_channel"); SEVCHK(ca_create_channel("CCS_PERFORM_SHOT_SUMMARY",connectionCallback, &mynode,10,(oldChannelNotify**)&mynode.summary_chid), "ca_create_channel"); SEVCHK(ca_replace_access_rights_event(mynode.summary_chid, accessRightsCallback), "ca_replace_access_rights_event"); ca_create_subscription (DBR_TIME_LONG, 0, mynode.summary_chid, DBE_VALUE|DBE_ALARM, eventCallback, (void*)&mynode, NULL); /*Should never return from following call*/ SEVCHK(ca_pend_event(0.0),"ca_pend_event"); }
static gboolean osk_audio_init_canberra(OskAudio* audio) { GdkScreen* screen; ca_proplist* props; const char* name; int nr; if (ca_context_create(&audio->ca) != CA_SUCCESS) return FALSE; screen = gdk_screen_get_default(); nr = gdk_screen_get_number(screen); name = gdk_display_get_name(gdk_screen_get_display(screen)); /* Set default application properties */ ca_proplist_create(&props); ca_proplist_sets(props, CA_PROP_APPLICATION_NAME, "Onboard"); ca_proplist_sets(props, CA_PROP_APPLICATION_ID, "org.onboard.Onboard"); ca_proplist_sets(props, CA_PROP_APPLICATION_ICON_NAME, "onboard"); ca_proplist_sets(props, CA_PROP_WINDOW_X11_DISPLAY, name); ca_proplist_setf(props, CA_PROP_WINDOW_X11_SCREEN, "%i", nr); ca_context_change_props_full(audio->ca, props); ca_proplist_destroy(props); return TRUE; }
static ca_context* connect_canberra_context(char* device, char* driver) { ca_context* ca = NULL; if (ca_context_create(&ca) != 0) { g_warning("Create canberra context failed"); return NULL; } // set backend driver if (strlen(driver) > 0) { if (ca_context_set_driver(ca, driver) != 0 ) { g_warning("Set '%s' as backend driver failed", driver); ca_context_destroy(ca); return NULL; } } if (strlen(device) > 0) { if (ca_context_change_device(ca, device) != 0) { g_warning("Set '%s' as backend device failed", device); ca_context_destroy(ca); return NULL; } } if (ca_context_open(ca) != 0) { g_warning("Connect the context to sound system failed"); ca_context_destroy(ca); return NULL; } return ca; }
int main(int argc,char **argv) { FILE *fp=NULL, *ftmp=NULL; char s[BUF_SIZE], filename[PATH_SIZE], restoreFileName[PATH_SIZE]; char *tempname; int n; int numDifferences; int status; int verbose=0, debug=0, write_restore_file=0; /* Parse args */ if (argc == 1) { printUsage(); exit(1); } if (*argv[1] == '-') { for (n=1; n<strlen(argv[1]); n++) { if (argv[1][n] == 'v') verbose = 1; if (argv[1][n] == 'r') write_restore_file = 1; if (argv[1][n] == 'd') printf("debug=%d\n", ++debug); if (argv[1][n] == 'h') {printUsage(); exit(1);} } strcpy(filename, argv[2]); } else { strcpy(filename, argv[1]); } status = ca_context_create(ca_disable_preemptive_callback); if (!(status & CA_M_SUCCESS)) { printf("Can't create CA context. I quit.\n"); return(-1); } /* * Copy to temporary file. * The .sav file is likely to be overwritten while we're using it. */ fp = fopen(filename,"r"); if (fp == NULL) {printf("Can't open %s\n", filename); return(-1);} tempname = tmpnam(NULL); ftmp = fopen(tempname,"w"); if (ftmp == NULL) {printf("Can't open temp file.\n"); return(-1);} while (!feof(fp) && (n=fread(s,1,BUF_SIZE,fp))) { fwrite(s,1,n,ftmp); } fclose(fp); fp = NULL; fclose(ftmp); ftmp = NULL; if (write_restore_file) { strcpy(restoreFileName, filename); strcat(restoreFileName, ".asVerify"); } else { strcpy(restoreFileName, ""); } numDifferences = asVerify(tempname, verbose, debug, write_restore_file, restoreFileName); remove(tempname); ca_context_destroy(); return(numDifferences); }
/*! * Default Constructor. * \param app_name for example "An example" * \param app_id for example "org.freedesktop.libcanberra.Test" * \param app_icon_name for example "libcanberra-test" */ Canberra(const char* app_name = NULL, const char* app_id = NULL, const char* app_icon_name = NULL) { ca_context_create(&m_ctx); /* Set a few application-global properties */ if (app_name) { ca_context_change_props(m_ctx, CA_PROP_APPLICATION_NAME, app_name, NULL); } if (app_id) { ca_context_change_props(m_ctx, CA_PROP_APPLICATION_ID, app_id, NULL); } if (app_icon_name) { ca_context_change_props(m_ctx, CA_PROP_APPLICATION_ICON_NAME, app_icon_name, NULL); } }
ChannelAccessThr::ChannelAccessThr(VecChacc &vecchacc, AttachChannelAccess *pattach, QObject *parent):QThread(parent),m_pattach(pattach) { register_chacc = vecchacc; ca_context_create(ca_disable_preemptive_callback); ca_add_exception_event(exceptionCallback,NULL); start(); mstop = false; mbclearev = false; mbaddev = false; }
static int canberra_connect () { int error; if (c_context) return TRUE; ca_context_create (&c_context); error = ca_context_open (c_context); if (error) { N_WARNING (LOG_CAT "can't connect to canberra! %s", ca_strerror (error)); ca_context_destroy (c_context); c_context = 0; return FALSE; } return TRUE; }
static void play_music() { static ca_context *notification = NULL; const char *file = "/usr/share/sounds/login.wav"; if (!notification) { ca_context_create(¬ification); ca_context_change_props( notification, CA_PROP_APPLICATION_NAME, "Dawati Alarm Notify", NULL); } ca_context_play(notification, 0, CA_PROP_MEDIA_FILENAME, file, NULL); }
/* * start channel access */ static int init_CA_common(int flag) { int stat; struct ca_client_context *context; stat = ca_context_create(flag?ca_enable_preemptive_callback:ca_disable_preemptive_callback); /* ECA_NOTTHREADED indicates that this thread is recognized as * part of an existing context, and the application will have to * trust the callbacks being made. */ if( stat != ECA_NORMAL && stat != ECA_NOTTHREADED) { printf("Can't start channel access (%d)\n", stat); return -1; } if( processFlag == 0) processFlag = epicsMutexCreate(); context = ca_current_context(); epicsConnectAddContext( context, flag); return 0; }
static EventdPluginContext * _eventd_libcanberra_init(EventdCoreContext *core, EventdCoreInterface *interface) { EventdPluginContext *context; libeventd_regex_init(); context = g_new0(EventdPluginContext, 1); int error; error = ca_context_create(&context->context); if ( error < 0 ) { g_warning("Couldn't create libcanberra context: %s", ca_strerror(error)); g_free(context); return NULL; } context->events = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, _eventd_canberra_event_free); return context; }
static gboolean gsound_context_real_init(GInitable *initable, GCancellable *cancellable, GError **error) { GSoundContext *self = GSOUND_CONTEXT(initable); if (self->priv->ca) return TRUE; int success = ca_context_create(&self->priv->ca); if (!test_return(success, error)) return FALSE; /* Set a couple of attributes here if we can */ ca_proplist *pl; ca_proplist_create(&pl); ca_proplist_sets(pl, CA_PROP_APPLICATION_NAME, g_get_application_name()); if (g_application_get_default()) { GApplication *app = g_application_get_default (); ca_proplist_sets(pl, CA_PROP_APPLICATION_ID, g_application_get_application_id(app)); } success = ca_context_change_props_full(self->priv->ca, pl); ca_proplist_destroy(pl); if (!test_return(success, error)) { ca_context_destroy(self->priv->ca); self->priv->ca = NULL; } return TRUE; }
static void dbCaTask(void *arg) { taskwdInsert(0, NULL, NULL); SEVCHK(ca_context_create(ca_enable_preemptive_callback), "dbCaTask calling ca_context_create"); dbCaClientContext = ca_current_context (); SEVCHK(ca_add_exception_event(exceptionCallback,NULL), "ca_add_exception_event"); epicsEventSignal(startStopEvent); /* channel access event loop */ while (TRUE){ do { epicsEventMustWait(workListEvent); } while (dbCaCtl == ctlPause); while (TRUE) { /* process all requests in workList*/ caLink *pca; short link_action; int status; epicsMutexMustLock(workListLock); if (!(pca = (caLink *)ellGet(&workList))){ /* Take off list head */ epicsMutexUnlock(workListLock); if (dbCaCtl == ctlExit) goto shutdown; break; /* workList is empty */ } link_action = pca->link_action; pca->link_action = 0; if (link_action & CA_CLEAR_CHANNEL) --removesOutstanding; epicsMutexUnlock(workListLock); /* Give back immediately */ if (link_action & CA_CLEAR_CHANNEL) { /* This must be first */ dbCaLinkFree(pca); /* No alarm is raised. Since link is changing so what? */ continue; /* No other link_action makes sense */ } if (link_action & CA_CONNECT) { status = ca_create_channel( pca->pvname,connectionCallback,(void *)pca, CA_PRIORITY_DB_LINKS, &(pca->chid)); if (status != ECA_NORMAL) { errlogPrintf("dbCaTask ca_create_channel %s\n", ca_message(status)); printLinks(pca); continue; } dbca_chan_count++; status = ca_replace_access_rights_event(pca->chid, accessRightsCallback); if (status != ECA_NORMAL) { errlogPrintf("dbCaTask replace_access_rights_event %s\n", ca_message(status)); printLinks(pca); } continue; /*Other options must wait until connect*/ } if (ca_state(pca->chid) != cs_conn) continue; if (link_action & CA_WRITE_NATIVE) { assert(pca->pputNative); if (pca->putType == CA_PUT) { status = ca_array_put( pca->dbrType, pca->nelements, pca->chid, pca->pputNative); } else if (pca->putType==CA_PUT_CALLBACK) { status = ca_array_put_callback( pca->dbrType, pca->nelements, pca->chid, pca->pputNative, putCallback, pca); } else { status = ECA_PUTFAIL; } if (status != ECA_NORMAL) { errlogPrintf("dbCaTask ca_array_put %s\n", ca_message(status)); printLinks(pca); } epicsMutexMustLock(pca->lock); if (status == ECA_NORMAL) pca->newOutNative = FALSE; epicsMutexUnlock(pca->lock); } if (link_action & CA_WRITE_STRING) { assert(pca->pputString); if (pca->putType == CA_PUT) { status = ca_array_put( DBR_STRING, 1, pca->chid, pca->pputString); } else if (pca->putType==CA_PUT_CALLBACK) { status = ca_array_put_callback( DBR_STRING, 1, pca->chid, pca->pputString, putCallback, pca); } else { status = ECA_PUTFAIL; } if (status != ECA_NORMAL) { errlogPrintf("dbCaTask ca_array_put %s\n", ca_message(status)); printLinks(pca); } epicsMutexMustLock(pca->lock); if (status == ECA_NORMAL) pca->newOutString = FALSE; epicsMutexUnlock(pca->lock); } /*CA_GET_ATTRIBUTES before CA_MONITOR so that attributes available * before the first monitor callback */ if (link_action & CA_GET_ATTRIBUTES) { status = ca_get_callback(DBR_CTRL_DOUBLE, pca->chid, getAttribEventCallback, pca); if (status != ECA_NORMAL) { errlogPrintf("dbCaTask ca_get_callback %s\n", ca_message(status)); printLinks(pca); } } if (link_action & CA_MONITOR_NATIVE) { size_t element_size; element_size = dbr_value_size[ca_field_type(pca->chid)]; epicsMutexMustLock(pca->lock); pca->pgetNative = dbCalloc(pca->nelements, element_size); epicsMutexUnlock(pca->lock); status = ca_add_array_event( ca_field_type(pca->chid)+DBR_TIME_STRING, ca_element_count(pca->chid), pca->chid, eventCallback, pca, 0.0, 0.0, 0.0, 0); if (status != ECA_NORMAL) { errlogPrintf("dbCaTask ca_add_array_event %s\n", ca_message(status)); printLinks(pca); } } if (link_action & CA_MONITOR_STRING) { epicsMutexMustLock(pca->lock); pca->pgetString = dbCalloc(1, MAX_STRING_SIZE); epicsMutexUnlock(pca->lock); status = ca_add_array_event(DBR_TIME_STRING, 1, pca->chid, eventCallback, pca, 0.0, 0.0, 0.0, 0); if (status != ECA_NORMAL) { errlogPrintf("dbCaTask ca_add_array_event %s\n", ca_message(status)); printLinks(pca); } } } SEVCHK(ca_flush_io(), "dbCaTask"); } shutdown: taskwdRemove(0); if (dbca_chan_count == 0) ca_context_destroy(); else fprintf(stderr, "dbCa: chan_count = %d at shutdown\n", dbca_chan_count); epicsEventSignal(startStopEvent); }
int main (int argc, char *argv[]) { int returncode = 0; int n = 0; int result; /* CA result */ int opt; /* getopt() current option */ int digits = 0; /* getopt() no. of float digits */ int nPvs; /* Number of PVs */ pv* pvs = 0; /* Array of PV structures */ setvbuf(stdout,NULL,_IOLBF,BUFSIZ); /* Set stdout to line buffering */ while ((opt = getopt(argc, argv, ":nhm:se:f:g:#:d:0:w:t:")) != -1) { switch (opt) { case 'h': /* Print usage */ usage(); return 0; case 'n': /* Print ENUM as index numbers */ enumAsNr=1; break; case 't': /* Select timestamp source(s) and type */ tsSrcServer = 0; tsSrcClient = 0; { int i = 0; char c; while ((c = optarg[i++])) switch (c) { case 's': tsSrcServer = 1; break; case 'c': tsSrcClient = 1; break; case 'n': break; case 'r': tsType = relative; break; case 'i': tsType = incremental; break; case 'I': tsType = incrementalByChan; break; default : fprintf(stderr, "Invalid argument '%c' " "for option '-t' - ignored.\n", c); } } break; case 'w': /* Set CA timeout value */ if(epicsScanDouble(optarg, &caTimeout) != 1) { fprintf(stderr, "'%s' is not a valid timeout value " "- ignored. ('caget -h' for help.)\n", optarg); caTimeout = DEFAULT_TIMEOUT; } break; case '#': /* Array count */ if (sscanf(optarg,"%ld", &reqElems) != 1) { fprintf(stderr, "'%s' is not a valid array element count " "- ignored. ('caget -h' for help.)\n", optarg); reqElems = 0; } break; case 'm': /* Select CA event mask */ eventMask = 0; { int i = 0; char c, err = 0; while ((c = optarg[i++]) && !err) switch (c) { case 'v': eventMask |= DBE_VALUE; break; case 'a': eventMask |= DBE_ALARM; break; case 'l': eventMask |= DBE_LOG; break; default : fprintf(stderr, "Invalid argument '%s' " "for option '-m' - ignored.\n", optarg); eventMask = DBE_VALUE | DBE_ALARM; err = 1; } } break; case 's': /* Select string dbr for floating type data */ floatAsString = 1; break; case 'e': /* Select %e/%f/%g format, using <arg> digits */ case 'f': case 'g': if (sscanf(optarg, "%d", &digits) != 1) fprintf(stderr, "Invalid precision argument '%s' " "for option '-%c' - ignored.\n", optarg, opt); else { if (digits>=0 && digits<=VALID_DOUBLE_DIGITS) sprintf(dblFormatStr, "%%-.%d%c", digits, opt); else fprintf(stderr, "Precision %d for option '-%c' " "out of range - ignored.\n", digits, opt); } break; case '0': /* Select integer format */ switch ((char) *optarg) { case 'x': outType = hex; break; /* 0x print Hex */ case 'b': outType = bin; break; /* 0b print Binary */ case 'o': outType = oct; break; /* 0o print Octal */ default : fprintf(stderr, "Invalid argument '%s' " "for option '-0' - ignored.\n", optarg); } break; case '?': fprintf(stderr, "Unrecognized option: '-%c'. ('caget -h' for help.)\n", optopt); return 1; case ':': fprintf(stderr, "Option '-%c' requires an argument. ('caget -h' for help.)\n", optopt); return 1; default : usage(); return 1; } } nPvs = argc - optind; /* Remaining arg list are PV names */ if (nPvs < 1) { fprintf(stderr, "No pv name specified. ('camonitor -h' for help.)\n"); return 1; } /* Start up Channel Access */ result = ca_context_create(ca_disable_preemptive_callback); if (result != ECA_NORMAL) { fprintf(stderr, "CA error %s occurred while trying " "to start channel access '%s'.\n", ca_message(result), pvs[n].name); return 1; } /* Allocate PV structure array */ pvs = calloc (nPvs, sizeof(pv)); if (!pvs) { fprintf(stderr, "Memory allocation for channel structures failed.\n"); return 1; } /* Connect channels */ /* Copy PV names from command line */ for (n = 0; optind < argc; n++, optind++) { pvs[n].name = argv[optind]; } /* Create CA connections */ returncode = create_pvs(pvs, nPvs, connection_handler); if ( returncode ) { return returncode; } /* Check for channels that didn't connect */ ca_pend_event(caTimeout); for (n = 0; n < nPvs; n++) { if (!pvs[n].onceConnected) print_time_val_sts(&pvs[n], pvs[n].reqElems); } /* Read and print data forever */ ca_pend_event(0); /* Shut down Channel Access */ ca_context_destroy(); return result; }
// extern "C" int epicsShareAPI ca_task_initialize ( void ) { return ca_context_create ( ca_disable_preemptive_callback ); }
int main (int argc, char *argv[]) { GError *error_parsearg = NULL; GOptionContext *context; GtkWidget *window, *vbox, *hbox2; GtkAdjustment *sadj, *madj, *hadj; #ifdef ENABLE_NLS bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif gtk_init (&argc, &argv); notify_init ("Gtimer"); ca_context_create (&sound); context = g_option_context_new (_("- a simple countdown timer")); g_option_context_add_main_entries (context, entries, NULL); #ifdef ENABLE_NLS g_option_context_set_translation_domain (context, GETTEXT_PACKAGE); #endif if (!g_option_context_parse (context, &argc, &argv, &error_parsearg)) { g_fprintf (stderr, "%s\n", error_parsearg->message); exit(1); } vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_spacing (GTK_BOX (hbox2), 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); timer_display = gtk_label_new (NULL); reset_display(); sadj = gtk_adjustment_new (0, 0, 60, 1, 1, 0); madj = gtk_adjustment_new (0, 0, 60, 1, 1, 0); hadj = gtk_adjustment_new (0, 0, 24, 1, 1, 0); spin_seconds = gtk_spin_button_new (sadj, 1, 0); spin_minutes = gtk_spin_button_new (madj, 1, 0); spin_hours = gtk_spin_button_new (hadj, 1, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin_seconds), TRUE); gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_seconds), seconds); g_object_set (spin_seconds, "shadow-type", GTK_SHADOW_IN, NULL); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin_minutes), TRUE); gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_minutes), minutes); g_object_set (spin_minutes, "shadow-type", GTK_SHADOW_IN, NULL); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin_hours), TRUE); gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_hours), hours); g_object_set (spin_hours, "shadow-type", GTK_SHADOW_IN, NULL); entry = gtk_entry_new(); gtk_entry_set_text (GTK_ENTRY (entry), entry_text); button_timer = gtk_button_new(); gtk_button_set_label (GTK_BUTTON (button_timer), _("Start")); button_reset = gtk_button_new_with_label (_("Reset")); gtk_widget_set_sensitive (button_reset, FALSE); gtk_box_pack_start (GTK_BOX (hbox1), spin_hours, TRUE, FALSE, 5); gtk_box_pack_start (GTK_BOX (hbox1), spin_minutes, TRUE, FALSE, 5); gtk_box_pack_start (GTK_BOX (hbox1), spin_seconds, TRUE, FALSE, 5); gtk_box_pack_start (GTK_BOX (vbox), timer_display, FALSE, TRUE, 5); gtk_box_pack_start (GTK_BOX (hbox2), button_timer, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox2), button_reset, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (vbox), hbox1); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, TRUE, 5); gtk_container_add (GTK_CONTAINER (vbox), hbox2); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Gtimer"); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show_all (window); g_timeout_add_seconds (1, (GSourceFunc) timer_function, NULL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (button_timer, "clicked", G_CALLBACK (on_timer_button_clicked), NULL); g_signal_connect (button_reset, "clicked", G_CALLBACK (on_reset_button_clicked), NULL); gtk_main(); notify_uninit(); ca_context_destroy (sound); g_option_context_free (context); return 0; }
int cagetFuZE(char *pvName, char *pvValue) { RequestT request = get; OutputT format = plain; chtype dbrType = -1; unsigned long reqElems = 0; int n, result; pv* pvs; int i; unsigned long nElems; result = ca_context_create(ca_disable_preemptive_callback); pvs = calloc(1, sizeof(pv)); pvs[0].name = pvName; connect_pvs(pvs, 1); for (n = 0; n < 1; n++) { /* Set up pvs structure */ /* -------------------- */ /* Get natural type and array count */ nElems = ca_element_count(pvs[n].chid); pvs[n].dbfType = ca_field_type(pvs[n].chid); pvs[n].dbrType = dbrType; /* Set up value structures */ if (format != specifiedDbr) { pvs[n].dbrType = dbf_type_to_DBR_TIME(pvs[n].dbfType); /* Use native type */ if (dbr_type_is_ENUM(pvs[n].dbrType)) /* Enums honour -n option */ { if (enumAsNr) pvs[n].dbrType = DBR_TIME_INT; else pvs[n].dbrType = DBR_TIME_STRING; } else if (floatAsString && (dbr_type_is_FLOAT(pvs[n].dbrType) || dbr_type_is_DOUBLE(pvs[n].dbrType))) { pvs[n].dbrType = DBR_TIME_STRING; } } /* Issue CA request */ /* ---------------- */ if (ca_state(pvs[n].chid) == cs_conn) { nConn++; pvs[n].onceConnected = 1; if (request == callback) { /* Event handler will allocate value and set nElems */ pvs[n].reqElems = reqElems > nElems ? nElems : reqElems; result = ca_array_get_callback(pvs[n].dbrType, pvs[n].reqElems, pvs[n].chid, event_handler, (void*)&pvs[n]); } else { /* We allocate value structure and set nElems */ pvs[n].nElems = reqElems && reqElems < nElems ? reqElems : nElems; pvs[n].value = calloc(1, dbr_size_n(pvs[n].dbrType, pvs[n].nElems)); if (!pvs[n].value) { fprintf(stderr,"Memory allocation failed\n"); return -1; } result = ca_array_get(pvs[n].dbrType, pvs[n].nElems, pvs[n].chid, pvs[n].value); } pvs[n].status = result; } else { pvs[n].status = ECA_DISCONN; } } if (!nConn) return -1; /* No connection? We're done. */ /* Wait for completion */ /* ------------------- */ result = ca_pend_io(caTimeout); if (result == ECA_TIMEOUT) { fprintf(stderr, "Read operation timed out: some PV data was not read.\n"); return -1; } if (request == callback) /* Also wait for callbacks */ { if (caTimeout != 0) { double slice = caTimeout / PEND_EVENT_SLICES; for (n = 0; n < PEND_EVENT_SLICES; n++) { ca_pend_event(slice); if (nRead >= nConn) break; } if (nRead < nConn) { fprintf(stderr, "Read operation timed out: some PV data was not read.\n"); return -1; } } else { /* For 0 timeout keep waiting until all are done */ while (nRead < nConn) { ca_pend_event(1.0); } } } // Does this kill the connection?? ca_context_destroy(); sprintf(pvValue, "%s\n", val2str(pvs[0].value, pvs[0].dbrType, 0)); return 1; }
int main(int argc,char **argv) { char *pval; double sleepSecs = 0.0; int clearEvery = 0; int indValue = 1; int indNumberCallback = 1; while((argc>1) && (argv[1][0] == '-')) { int i; char option; int narg; option = toupper((argv[1])[1]); pval = argv[2]; argc -= 1; narg = 1; if(option=='S') { sscanf(pval,"%lf",&sleepSecs); argc -= 1; ++narg; } else if(option=='C') { sscanf(pval,"%d",&clearEvery); argc -= 1; ++narg; } else if(option=='V') { verbose = 1; } else { usageExit(); } for(i=1; i<argc; i++) argv[i] = argv[i + narg]; } if(argc != 4) usageExit(); pvname = argv[1]; pvalue1 = argv[2]; pvalue2 = argv[3]; pevent = epicsEventCreate(epicsEventEmpty); SEVCHK(ca_context_create(ca_enable_preemptive_callback), "ca_task_initialize"); while(1) { SEVCHK(ca_search(pvname,&mychid),"ca_search_and_connect"); if(ca_pend_io(3.0)!=ECA_NORMAL) { epicsThreadSleep(5.0); continue; } while(1) { epicsEventWaitStatus status; if(indValue==0) { indValue = 1; pvalue = pvalue2; } else { indValue = 0; pvalue=pvalue1; } if(++indNumberCallback >= MAXnumberCallback) indNumberCallback=0; numberCallback[indNumberCallback] = ++expectedCallback; status = ca_array_put_callback(DBR_STRING,1,mychid, pvalue,putCallback,&numberCallback[indNumberCallback]); if(status!=ECA_NORMAL) { printf("ca_array_put_callback %s\n",ca_message(status)); epicsThreadSleep(2.0); continue; } if((clearEvery>0) && ((expectedCallback % clearEvery)==0)) { ca_flush_io(); epicsThreadSleep(sleepSecs); SEVCHK(ca_clear_channel(mychid),"ca_clear_channel"); ca_flush_io(); expectedCallback = 0; epicsThreadSleep(sleepSecs); if(verbose) { printTime(); printf("Issued ca_clear_channel expectedCallback %d\n", expectedCallback); } break; } ca_flush_io(); if(verbose) { printTime(); printf("Issued ca_put_callback expectedCallback %d\n", expectedCallback); } while(1) { status = epicsEventWaitWithTimeout(pevent,10.0); if(status==epicsEventWaitTimeout) { if(verbose) { printTime(); printf("timeout after 10 seconds\n"); } continue; } break; } if(status!=epicsEventWaitOK) { int i; printTime(); printf("eventWait status %d\n",status); for(i=0; i<MAXnumberCallback; i++) numberCallback[i]=0; } epicsThreadSleep(sleepSecs); } } ca_task_exit(); return(0); }
int main (int argc, char *argv[]) { int i; int result; /* CA result */ OutputT format = plain; /* User specified format */ RequestT request = get; /* User specified request type */ int isArray = 0; /* Flag for array operation */ int enumAsString = 0; /* Force ENUM values to be strings */ int count = 1; int opt; /* getopt() current option */ chtype dbrType = DBR_STRING; char *pend; EpicsStr *sbuf; double *dbuf; char *cbuf = 0; char *ebuf = 0; void *pbuf; int len = 0; int waitStatus; struct dbr_gr_enum bufGrEnum; int nPvs; /* Number of PVs */ pv* pvs; /* Array of PV structures */ LINE_BUFFER(stdout); /* Configure stdout buffering */ putenv("POSIXLY_CORRECT="); /* Behave correct on GNU getopt systems */ while ((opt = getopt(argc, argv, ":cnlhatsS#:w:p:F:")) != -1) { switch (opt) { case 'h': /* Print usage */ usage(); return 0; case 'n': /* Force interpret ENUM as index number */ enumAsNr = 1; enumAsString = 0; break; case 's': /* Force interpret ENUM as menu string */ enumAsString = 1; enumAsNr = 0; break; case 'S': /* Treat char array as (long) string */ charArrAsStr = 1; isArray = 0; break; case 't': /* Select terse output format */ format = terse; break; case 'l': /* Select long output format */ format = all; break; case 'a': /* Select array mode */ isArray = 1; charArrAsStr = 0; break; case 'c': /* Select put_callback mode */ request = callback; break; case 'w': /* Set CA timeout value */ if(epicsScanDouble(optarg, &caTimeout) != 1) { fprintf(stderr, "'%s' is not a valid timeout value " "- ignored. ('caput -h' for help.)\n", optarg); caTimeout = DEFAULT_TIMEOUT; } break; case '#': /* Array count */ if (sscanf(optarg,"%d", &count) != 1) { fprintf(stderr, "'%s' is not a valid array element count " "- ignored. ('caput -h' for help.)\n", optarg); count = 0; } break; case 'p': /* CA priority */ if (sscanf(optarg,"%u", &caPriority) != 1) { fprintf(stderr, "'%s' is not a valid CA priority " "- ignored. ('caget -h' for help.)\n", optarg); caPriority = DEFAULT_CA_PRIORITY; } if (caPriority > CA_PRIORITY_MAX) caPriority = CA_PRIORITY_MAX; break; case 'F': /* Store this for output and tool_lib formatting */ fieldSeparator = (char) *optarg; break; case '?': fprintf(stderr, "Unrecognized option: '-%c'. ('caput -h' for help.)\n", optopt); return 1; case ':': fprintf(stderr, "Option '-%c' requires an argument. ('caput -h' for help.)\n", optopt); return 1; default : usage(); return 1; } } nPvs = argc - optind; /* Remaining arg list are PV names and values */ if (nPvs < 1) { fprintf(stderr, "No pv name specified. ('caput -h' for help.)\n"); return 1; } if (nPvs == 1) { fprintf(stderr, "No value specified. ('caput -h' for help.)\n"); return 1; } nPvs = 1; /* One PV - the rest is value(s) */ epId = epicsEventCreate(epicsEventEmpty); /* Create empty EPICS event (semaphore) */ /* Start up Channel Access */ result = ca_context_create(ca_enable_preemptive_callback); if (result != ECA_NORMAL) { fprintf(stderr, "CA error %s occurred while trying " "to start channel access.\n", ca_message(result)); return 1; } /* Allocate PV structure array */ pvs = calloc (nPvs, sizeof(pv)); if (!pvs) { fprintf(stderr, "Memory allocation for channel structure failed.\n"); return 1; } /* Connect channels */ pvs[0].name = argv[optind] ; /* Copy PV name from command line */ result = connect_pvs(pvs, nPvs); /* If the connection fails, we're done */ if (result) { ca_context_destroy(); return result; } /* Get values from command line */ optind++; if (isArray) { optind++; /* In case of array skip first value (nr * of elements) - actual number of values is used */ count = argc - optind; } else { /* Concatenate the remaining line to one string * (sucks but is compatible to the former version) */ for (i = optind; i < argc; i++) { len += strlen(argv[i]); len++; } cbuf = calloc(len, sizeof(char)); if (!cbuf) { fprintf(stderr, "Memory allocation failed.\n"); return 1; } strcpy(cbuf, argv[optind]); if (argc > optind+1) { for (i = optind + 1; i < argc; i++) { strcat(cbuf, " "); strcat(cbuf, argv[i]); } } if ((argc - optind) >= 1) count = 1; argv[optind] = cbuf; } sbuf = calloc (count, sizeof(EpicsStr)); dbuf = calloc (count, sizeof(double)); if(!sbuf || !dbuf) { fprintf(stderr, "Memory allocation failed\n"); return 1; } /* ENUM? Special treatment */ if (ca_field_type(pvs[0].chid) == DBR_ENUM) { /* Get the ENUM strings */ result = ca_array_get (DBR_GR_ENUM, 1, pvs[0].chid, &bufGrEnum); result = ca_pend_io(caTimeout); if (result == ECA_TIMEOUT) { fprintf(stderr, "Read operation timed out: ENUM data was not read.\n"); return 1; } if (enumAsNr) { /* Interpret values as numbers */ for (i = 0; i < count; ++i) { dbuf[i] = epicsStrtod(*(argv+optind+i), &pend); if (*(argv+optind+i) == pend) { /* Conversion didn't work */ fprintf(stderr, "Enum index value '%s' is not a number.\n", *(argv+optind+i)); return 1; } if (dbuf[i] >= bufGrEnum.no_str) { fprintf(stderr, "Warning: enum index value '%s' may be too large.\n", *(argv+optind+i)); } } dbrType = DBR_DOUBLE; } else { /* Interpret values as strings */ for (i = 0; i < count; ++i) { epicsStrnRawFromEscaped(sbuf[i], sizeof(EpicsStr), *(argv+optind+i), sizeof(EpicsStr)); *( sbuf[i]+sizeof(EpicsStr)-1 ) = '\0'; dbrType = DBR_STRING; /* Compare to ENUM strings */ for (len = 0; len < bufGrEnum.no_str; len++) if (!strcmp(sbuf[i], bufGrEnum.strs[len])) break; if (len >= bufGrEnum.no_str) { /* Not a string? Try as number */ dbuf[i] = epicsStrtod(sbuf[i], &pend); if (sbuf[i] == pend || enumAsString) { fprintf(stderr, "Enum string value '%s' invalid.\n", sbuf[i]); return 1; } if (dbuf[i] >= bufGrEnum.no_str) { fprintf(stderr, "Warning: enum index value '%s' may be too large.\n", sbuf[i]); } dbrType = DBR_DOUBLE; } } } } else { /* Not an ENUM */ if (charArrAsStr) { dbrType = DBR_CHAR; ebuf = calloc(len, sizeof(char)); if(!ebuf) { fprintf(stderr, "Memory allocation failed\n"); return 1; } count = epicsStrnRawFromEscaped(ebuf, len, cbuf, len-1) + 1; } else { for (i = 0; i < count; ++i) { epicsStrnRawFromEscaped(sbuf[i], sizeof(EpicsStr), *(argv+optind+i), sizeof(EpicsStr)); *( sbuf[i]+sizeof(EpicsStr)-1 ) = '\0'; } dbrType = DBR_STRING; } } /* Read and print old data */ if (format != terse) { printf("Old : "); result = caget(pvs, nPvs, format, 0, 0); } /* Write new data */ if (dbrType == DBR_STRING) pbuf = sbuf; else if (dbrType == DBR_CHAR) pbuf = ebuf; else pbuf = dbuf; if (request == callback) { /* Use callback version of put */ pvs[0].status = ECA_NORMAL; /* All ok at the moment */ result = ca_array_put_callback ( dbrType, count, pvs[0].chid, pbuf, put_event_handler, (void *) pvs); } else { /* Use standard put with defined timeout */ result = ca_array_put (dbrType, count, pvs[0].chid, pbuf); } result = ca_pend_io(caTimeout); if (result == ECA_TIMEOUT) { fprintf(stderr, "Write operation timed out: Data was not written.\n"); return 1; } if (request == callback) { /* Also wait for callbacks */ waitStatus = epicsEventWaitWithTimeout( epId, caTimeout ); if (waitStatus) fprintf(stderr, "Write callback operation timed out\n"); /* retrieve status from callback */ result = pvs[0].status; } if (result != ECA_NORMAL) { fprintf(stderr, "Error occured writing data.\n"); return 1; } /* Read and print new data */ if (format != terse) printf("New : "); result = caget(pvs, nPvs, format, 0, 0); /* Shut down Channel Access */ ca_context_destroy(); return result; }