static void dump_ScanList(const ScanList *list, int level)
{
const TagInfo *info;
char tsString[50];
printf("Scanlist %g secs @ 0x%lX:\n",
list->period, (unsigned long)list);
printf(" Status : %s\n",
(list->enabled ? "enabled" : "DISABLED"));
epicsTimeToStrftime(tsString, sizeof(tsString),
"%Y/%m/%d %H:%M:%S.%04f", &list->scan_time);
printf(" Last scan : %s\n", tsString);
if (level > 4)
{
printf(" Errors : %u\n", (unsigned)list->list_errors);
printf(" Schedule Errs : %u\n", (unsigned)list->sched_errors);
epicsTimeToStrftime(tsString, sizeof(tsString),
"%Y/%m/%d %H:%M:%S.%04f", &list->scheduled_time);
printf(" Next scan : %s\n", tsString);
printf(" Min. scan time: %g secs\n",
list->min_scan_time);
printf(" Max. scan time: %g secs\n",
list->max_scan_time);
printf(" Last scan time: %g secs\n",
list->last_scan_time);
}
if (level > 5)
{
for (info=DLL_first(TagInfo, &list->taginfos); info;
info=DLL_next(TagInfo, info))
dump_TagInfo(info, level);
}
}
int ClockTime_Report(int level)
{
char timebuf[32];
if (onceId == EPICS_THREAD_ONCE_INIT) {
printf("OS Clock driver not %s.\n",
#ifdef CLOCK_REALTIME
"initialized"
#else
"available"
#endif /* CLOCK_REALTIME */
);
}
else if (ClockTimePvt.synchronize == CLOCKTIME_SYNC) {
int synchronized, syncFromPriority;
epicsTimeStamp startTime, syncTime;
epicsMutexMustLock(ClockTimePvt.lock);
synchronized = ClockTimePvt.synchronized;
syncFromPriority = ClockTimePvt.syncFromPriority;
startTime = ClockTimePvt.startTime;
syncTime = ClockTimePvt.syncTime;
epicsMutexUnlock(ClockTimePvt.lock);
if (synchronized) {
printf("OS Clock driver is synchronized to a priority=%d provider\n",
syncFromPriority);
if (level) {
epicsTimeToStrftime(timebuf, sizeof(timebuf),
"%Y-%m-%d %H:%M:%S.%06f", &startTime);
printf("Initial sync was at %s\n", timebuf);
epicsTimeToStrftime(timebuf, sizeof(timebuf),
"%Y-%m-%d %H:%M:%S.%06f", &syncTime);
printf("Last successful sync was at %s\n", timebuf);
}
printf("Syncronization interval = %.0f seconds\n",
ClockTimeSyncInterval);
}
else
printf("OS Clock driver is *not* synchronized\n");
}
else {
epicsTimeToStrftime(timebuf, sizeof(timebuf),
"%Y-%m-%d %H:%M:%S.%06f", &ClockTimePvt.startTime);
printf("Program started at %s\n", timebuf);
printf("OS Clock synchronization thread not running.\n");
}
return 0;
}
void MainWindow::readValue(int index)
{
//QWidget *pwidget = stackedWidget->widget(0);
if(CurrentPage() == 0)
{
if((size_t)index >= vecPage1Stamp.size()) index = vecPage1Stamp.size();
//page1index = index;
}
else
{
if((size_t)index >= vecPage2Stamp.size()) index = vecPage2Stamp.size();
//page2index = index;
};
PVandValue *pPVValue;
QHash<QString,CAColorTileButton *>::iterator tileiter;
char timebuf[30];
if(CurrentPage() == 0)
{
epicsTimeToStrftime(timebuf,28,"%m/%d/%Y %H:%M:%S", &(vecPage1Stamp.at(index)));
}
else
{
epicsTimeToStrftime(timebuf,28,"%m/%d/%Y %H:%M:%S", &(vecPage2Stamp.at(index)));
}
qDebug("Index(%d)-SliderValue(%d) --> %s", index,timeSlider->value(), timebuf);
currentTimeLabel->setText(timebuf);
for(int i = 0; i <= mloop; i++)
{
if (CurrentPage() == 0)
{
pPVValue = &(vecPage1Value.at((marraycount*i)+timeSlider->value()));
//qDebug("PVName[%d]:%s(%f),%s",i, pPVValue->pvname.c_str(), pPVValue->dvalue, mpage1names.at(i).c_str());
CAColorTileButton *pTileButton = hash_tilepage1[pPVValue->pvname.c_str()];
//qDebug("PVName:%s, Tile(%p)", pTileButton->getPvname().toStdString().c_str(), pTileButton);
pTileButton->changeValue(ECA_CONN,pPVValue->dvalue);
}
else
{
pPVValue = &(vecPage2Value.at((marraycount*i)+timeSlider->value()));
//qDebug("PVName[%d]:%s(%f),%s",i, pPVValue->pvname.c_str(), pPVValue->dvalue, mpage2names.at(i).c_str());
CAColorTileButton *pTileButton = hash_tilepage2[pPVValue->pvname.c_str()];
//qDebug("PVName:%s, Tile(%p)", pTileButton->getPvname().toStdString().c_str(), pTileButton);
pTileButton->changeValue(ECA_CONN,pPVValue->dvalue);
};
};
};
int NTPTime_Report(int level)
{
if (onceId == EPICS_THREAD_ONCE_INIT) {
printf("NTP driver not initialized\n");
} else if (NTPTimePvt.synchronize) {
printf("NTP driver %s synchronized with server\n",
NTPTimePvt.synchronized ? "is" : "is *not*");
if (NTPTimePvt.syncsFailed) {
printf("Last successful sync was %.1f minutes ago\n",
NTPTimePvt.syncsFailed * NTPTimeSyncInterval / 60.0);
}
if (level) {
char lastSync[32];
epicsTimeToStrftime(lastSync, sizeof(lastSync),
"%Y-%m-%d %H:%M:%S.%06f", &NTPTimePvt.syncTime);
printf("Syncronization interval = %.1f seconds\n",
NTPTimeSyncInterval);
printf("Last synchronized at %s\n",
lastSync);
printf("Current OS tick rate = %u Hz\n",
osdTickRateGet());
printf("Measured tick rate = %.3f Hz\n",
NTPTimePvt.tickRate);
osdNTPReport();
}
} else {
printf("NTP synchronization thread not running.\n");
}
return 0;
}
void epicsAssert (const char *pFile, const unsigned line,
const char *pExp, const char *pAuthorName)
{
epicsTimeStamp current;
errlogPrintf("\n\n\n"
"A call to 'assert(%s)'\n"
" by thread '%s' failed in %s line %u.\n",
pExp, epicsThreadGetNameSelf(), pFile, line);
errlogPrintf("EPICS Release %s.\n", epicsReleaseVersion);
if (epicsTimeGetCurrent(¤t) == 0) {
char date[64];
epicsTimeToStrftime(date, sizeof(date),
"%Y-%m-%d %H:%M:%S.%f %Z", ¤t);
errlogPrintf("Local time is %s\n", date);
}
if (!pAuthorName) {
pAuthorName = "the author";
}
errlogPrintf("Please E-mail this message to %s or to [email protected]\n",
pAuthorName);
errlogPrintf("Calling epicsThreadSuspendSelf()\n");
epicsThreadSuspendSelf ();
}
/* get date,time as yymmdd-HHMMSS */
int fGetDateStr( char datetime[])
{
epicsTimeStamp now;
epicsTimeGetCurrent(&now);
epicsTimeToStrftime(datetime, 28, "%y%m%d-%H%M%S", &now);
return(0);
}
int timeStampProcess(subRecord *precord)
{
epicsTimeStamp stamp;
long status;
char textBuffer[50];
status = dbCaGetTimeStamp(&precord->inpa,&stamp);
if(status) {
printf("timeStampProcess dbCaGetTimeStamp failed\n");
return(0);
}
epicsTimeToStrftime(textBuffer,sizeof(textBuffer),
"%a %b %d %Y %H:%M:%S",&stamp);
printf("timeStampProcess %s\n",textBuffer);
return(0);
}
/* ---------------------------------------------------------------------- */
static long dsetRead_devSiSyncTimestamp (struct stringinRecord *psi) {
CONTEXT *p_myContext;
char p_myDateFormat[BUFLEN];
int formattedStringLength;
char p_myWarmstartFilename[BUFLEN];
FILE *p_myFileHandle;
int myLogMark;
dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, psi->name);
p_myContext = (CONTEXT *)psi->dpvt;
strncpy(p_myDateFormat, p_myContext->p_dateFormat, BUFLEN);
myLogMark=p_myContext->logMark;
recGblGetTimeStamp(psi);
formattedStringLength=
epicsTimeToStrftime(psi->val, BUFLEN, p_myDateFormat, &psi->time);
if (formattedStringLength >= BUFLEN) {
psi->udf = 1;
recGblSetSevr(psi,UDF_ALARM,INVALID_ALARM);
dsetLog(3, __FILE__ "[%d] Error: String is too long!\n", __LINE__);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
psi->udf = 0;
sprintf(p_myWarmstartFilename, WARMSTART_FILE_PREFIX "/%s",psi->name);
p_myFileHandle=fopen(p_myWarmstartFilename, "w");
if (p_myFileHandle==NULL) {
dsetLog(1, __FILE__ "[%d] Error: %s\n", __LINE__);
dsetLog(1, __FILE__ "[%d] Error: Couldn't create/write %s\n",
__LINE__, p_myWarmstartFilename);
sleep(SLEEPTIME_ERROR);
return(ERROR);
}
fprintf(p_myFileHandle, "%s",psi->val);
fclose(p_myFileHandle);
if (myLogMark!=0) {
fprintf( stdout, "%s\n", psi->val);
}
dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__);
return(SUCCESS);
}
static bool viewer(void *arg, const char *name, size_t , size_t , const CtrlInfo &,
DbrType , DbrCount , const RawValue::Data *value)
{
MainWindow *pMain = (MainWindow*)arg;
if(pMain == 0) return false;
char timebuf[30];
epicsTimeToStrftime(timebuf,28,"%m/%d/%Y %H:%M:%S", &(value->stamp));
//qDebug("Time:%s, PVName(%s:%f)", timebuf, name, value->value);
//outstream << "Loop:" << pMain->mloop << ", Time: " << timebuf << ", PVName: ("<<name <<":" <<value->value<<")" << endl;
int curpage = pMain->CurrentPage();
if(pMain->mloop == 0)
{
pMain->AddEPICSTimeStamp(curpage, value->stamp);
};
pMain->AddPVAndValue(curpage, name, value->value);
return true;
}
static long process(struct timestampRecord *ptimestamp){
#if EPICS_VERSION >= 3 && EPICS_REVISION >= 14
#else
struct tsDetail time_s;
#endif
ptimestamp->udf = FALSE;
ptimestamp->pact = TRUE;
recGblGetTimeStamp(ptimestamp);
ptimestamp->sec = ptimestamp->time.secPastEpoch;
ptimestamp->nsec = ptimestamp->time.nsec;
#if EPICS_VERSION >= 3 && EPICS_REVISION >= 14
switch(ptimestamp->tst) {
case timestampTST_YY_MM_DD_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%y/%m/%d %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_MM_DD_YY_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%m/%d/%y %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_MM_DD_HH_MM_SS_YY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%b %d %H:%M:%S %y",&ptimestamp->time);
break;
case timestampTST_MM_DD_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%b %d %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%H:%M:%S",&ptimestamp->time);
break;
case timestampTST_HH_MM:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%H:%M",&ptimestamp->time);
break;
case timestampTST_DD_MM_YY_HH_MM_SS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%d/%m/%y %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_DD_MM_HH_MM_SS_YY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%d %b %H:%M:%S %y",&ptimestamp->time);
break;
case timestampTST_VMS:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%e-%b-%Y %H:%M:%S",&ptimestamp->time);
break;
case timestampTST_MM_DD_YYYY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%b %d, %Y %H:%M:%S.%04f",&ptimestamp->time);
break;
case timestampTST_MM_DD_YY:
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%m/%d/%y %H:%M:%S.%04f",&ptimestamp->time);
break;
default : /* YY/MM/DD HH:MM:SS */
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),
"%y/%m/%D %H:%M:%S",&ptimestamp->time);
break;
}
#else
tsStampToLocal(ptimestamp->time, &time_s);
switch(ptimestamp->tst) {
case timestampTST_YY_MM_DD_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.year,time_s.monthNum+1,time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_YY_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.monthNum+1,time_s.dayMonth+1,time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_HH_MM_SS_YY:
sprintf(ptimestamp->val,"%s %.2d %.2d:%.2d:%.2d %.2d"
,MONTH[time_s.monthNum],time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds,time_s.year);
break;
case timestampTST_MM_DD_HH_MM_SS:
sprintf(ptimestamp->val,"%s %.2d %.2d:%.2d:%.2d"
,MONTH[time_s.monthNum],time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d:%.2d:%.2d"
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_HH_MM:
sprintf(ptimestamp->val,"%.2d:%.2d"
,time_s.hours,time_s.minutes);
break;
case timestampTST_DD_MM_YY_HH_MM_SS:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.dayMonth+1,time_s.monthNum+1,time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_DD_MM_HH_MM_SS_YY:
sprintf(ptimestamp->val,"%.2d %s %.2d:%.2d:%.2d %.2d"
,time_s.dayMonth+1,MONTH[time_s.monthNum]
,time_s.hours,time_s.minutes,time_s.seconds,time_s.year);
break;
case timestampTST_VMS:
sprintf(ptimestamp->val,"%.2d-%s-%.4d %.2d:%.2d:%.2d"
,time_s.dayMonth+1,MONTH[time_s.monthNum],time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_YYYY:
sprintf(ptimestamp->val,"%s %.2d, %.4d %.2d:%.2d:%.2d"
,MONTH[time_s.monthNum],time_s.dayMonth+1
,time_s.year,time_s.hours,time_s.minutes,time_s.seconds);
break;
case timestampTST_MM_DD_YY:
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.monthNum+1,time_s.dayMonth+1,time_s.year
,time_s.hours,time_s.minutes,time_s.seconds);
break;
default : /* YY/MM/DD HH:MM:SS */
sprintf(ptimestamp->val,"%.2d/%.2d/%.2d %.2d:%.2d:%.2d"
,time_s.year,time_s.monthNum+1,time_s.dayMonth+1
,time_s.hours,time_s.minutes,time_s.seconds);
break;
}
#endif
/* check event list */
monitor(ptimestamp);
/* process the forward scan link record */
recGblFwdLink(ptimestamp);
ptimestamp->pact=FALSE;
return(0);
}
static void printBuffer(
long status, short dbr_type, void *pbuffer, long reqOptions,
long retOptions, long no_elements, TAB_BUFFER *pMsgBuff, int tab_size)
{
epicsInt32 val_i32;
epicsUInt32 val_u32;
char *pmsg = pMsgBuff->message;
int i, len;
if (reqOptions & DBR_STATUS) {
if (retOptions & DBR_STATUS) {
struct dbr_status *pdbr_status = (void *)pbuffer;
printf("status = %u, severity = %u\n",
pdbr_status->status,
pdbr_status->severity);
}
else {
printf("status and severity not returned\n");
}
pbuffer = (char *)pbuffer + dbr_status_size;
}
if (reqOptions & DBR_UNITS) {
if (retOptions & DBR_UNITS) {
struct dbr_units *pdbr_units = (void *)pbuffer;
printf("units = \"%s\"\n",
pdbr_units->units);
}
else {
printf("units not returned\n");
}
pbuffer = (char *)pbuffer + dbr_units_size;
}
if (reqOptions & DBR_PRECISION) {
if (retOptions & DBR_PRECISION){
struct dbr_precision *pdbr_precision = (void *)pbuffer;
printf("precision = %ld\n",
pdbr_precision->precision.dp);
}
else {
printf("precision not returned\n");
}
pbuffer = (char *)pbuffer + dbr_precision_size;
}
if (reqOptions & DBR_TIME) {
if (retOptions & DBR_TIME) {
struct dbr_time *pdbr_time = (void *)pbuffer;
char time_buf[40];
epicsTimeToStrftime(time_buf, 40, "%Y-%m-%d %H:%M:%S.%09f",
&pdbr_time->time);
printf("time = %s\n", time_buf);
}
else {
printf("time not returned\n");
}
pbuffer = (char *)pbuffer + dbr_time_size;
}
if (reqOptions & DBR_ENUM_STRS) {
if (retOptions & DBR_ENUM_STRS) {
struct dbr_enumStrs *pdbr_enumStrs = (void *)pbuffer;
printf("no_strs = %u:\n",
pdbr_enumStrs->no_str);
for (i = 0; i < pdbr_enumStrs->no_str; i++)
printf("\t\"%s\"\n", pdbr_enumStrs->strs[i]);
}
else {
printf("enum strings not returned\n");
}
pbuffer = (char *)pbuffer + dbr_enumStrs_size;
}
if (reqOptions & DBR_GR_LONG) {
if (retOptions & DBR_GR_LONG) {
struct dbr_grLong *pdbr_grLong = (void *)pbuffer;
printf("grLong: %d .. %d\n",
pdbr_grLong->lower_disp_limit,
pdbr_grLong->upper_disp_limit);
}
else {
printf("DBRgrLong not returned\n");
}
pbuffer = (char *)pbuffer + dbr_grLong_size;
}
if (reqOptions & DBR_GR_DOUBLE) {
if (retOptions & DBR_GR_DOUBLE) {
struct dbr_grDouble *pdbr_grDouble = (void *)pbuffer;
printf("grDouble: %g .. %g\n",
pdbr_grDouble->lower_disp_limit,
pdbr_grDouble->upper_disp_limit);
}
else {
printf("DBRgrDouble not returned\n");
}
pbuffer = (char *)pbuffer + dbr_grDouble_size;
}
if (reqOptions & DBR_CTRL_LONG) {
if (retOptions & DBR_CTRL_LONG){
struct dbr_ctrlLong *pdbr_ctrlLong = (void *)pbuffer;
printf("ctrlLong: %d .. %d\n",
pdbr_ctrlLong->lower_ctrl_limit,
pdbr_ctrlLong->upper_ctrl_limit);
}
else {
printf("DBRctrlLong not returned\n");
}
pbuffer = (char *)pbuffer + dbr_ctrlLong_size;
}
if (reqOptions & DBR_CTRL_DOUBLE) {
if (retOptions & DBR_CTRL_DOUBLE) {
struct dbr_ctrlDouble *pdbr_ctrlDouble = (void *)pbuffer;
printf("ctrlDouble: %g .. %g\n",
pdbr_ctrlDouble->lower_ctrl_limit,
pdbr_ctrlDouble->upper_ctrl_limit);
}
else {
printf("DBRctrlDouble not returned\n");
}
pbuffer = (char *)pbuffer + dbr_ctrlDouble_size;
}
if (reqOptions & DBR_AL_LONG) {
if (retOptions & DBR_AL_LONG) {
struct dbr_alLong *pdbr_alLong = (void *)pbuffer;
printf("alLong: %d < %d .. %d < %d\n",
pdbr_alLong->lower_alarm_limit,
pdbr_alLong->lower_warning_limit,
pdbr_alLong->upper_warning_limit,
pdbr_alLong->upper_alarm_limit);
}
else {
printf("DBRalLong not returned\n");
}
pbuffer = (char *)pbuffer + dbr_alLong_size;
}
if (reqOptions & DBR_AL_DOUBLE) {
if (retOptions & DBR_AL_DOUBLE) {
struct dbr_alDouble *pdbr_alDouble = (void *)pbuffer;
printf("alDouble: %g < %g .. %g < %g\n",
pdbr_alDouble->lower_alarm_limit,
pdbr_alDouble->lower_warning_limit,
pdbr_alDouble->upper_warning_limit,
pdbr_alDouble->upper_alarm_limit);
}
else {
printf("DBRalDouble not returned\n");
}
pbuffer = (char *)pbuffer + dbr_alDouble_size;
}
/* Now print values */
if (no_elements == 0)
return;
switch (dbr_type) {
case (DBR_STRING):
if (no_elements == 1)
sprintf(pmsg, "DBR_STRING: ");
else
sprintf(pmsg, "DBR_STRING[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, "DBR_STRING: failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for(i=0; i<no_elements; i++) {
len = strlen(pbuffer);
if (len > 0) {
sprintf(pmsg, " \"%s\"", (char *)pbuffer);
dbpr_msgOut(pMsgBuff, tab_size);
}
pbuffer = (char *)pbuffer + MAX_STRING_SIZE;
}
break;
case (DBR_CHAR):
if (no_elements == 1)
sprintf(pmsg, "DBR_CHAR: ");
else
sprintf(pmsg, "DBR_CHAR[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
if (no_elements == 1) {
val_i32 = *(epicsInt8 *) pbuffer;
sprintf(pmsg, "%-9d 0x%-9x", val_i32, val_i32);
dbpr_msgOut(pMsgBuff, tab_size);
}
else {
for (i = 0; i < no_elements; i+= MAXLINE - 5) {
int width = no_elements - i;
if (width > MAXLINE - 5) width = MAXLINE - 5;
sprintf(pmsg, " \"%.*s\"", width, (char *)pbuffer + i);
if (i + MAXLINE - 5 < no_elements) strcat(pmsg, " +");
dbpr_msgOut(pMsgBuff, tab_size);
}
}
break;
case (DBR_UCHAR):
if (no_elements == 1)
sprintf(pmsg, "DBR_UCHAR: ");
else
sprintf(pmsg, "DBR_UCHAR[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
val_u32 = *(epicsUInt8 *) pbuffer;
sprintf(pmsg, "%-9u 0x%-9x", val_u32, val_u32);
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsUInt8);
}
break;
case (DBR_SHORT):
if (no_elements == 1)
sprintf(pmsg, "DBR_SHORT: ");
else
sprintf(pmsg, "DBR_SHORT[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
val_i32 = *(epicsInt16 *) pbuffer;
sprintf(pmsg, "%-9d 0x%-9x", val_i32, val_i32);
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsInt16);
}
break;
case (DBR_USHORT):
if (no_elements == 1)
sprintf(pmsg, "DBR_USHORT: ");
else
sprintf(pmsg, "DBR_USHORT[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
val_u32 = *(epicsUInt16 *) pbuffer;
sprintf(pmsg, "%-9u 0x%-9x", val_u32, val_u32);
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsUInt16);
}
break;
case (DBR_LONG):
if (no_elements == 1)
sprintf(pmsg, "DBR_LONG: ");
else
sprintf(pmsg, "DBR_LONG[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
val_i32 = *(epicsInt32 *) pbuffer;
sprintf(pmsg, "%-9d 0x%-9x", val_i32, val_i32);
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsInt32);
}
break;
case (DBR_ULONG):
if (no_elements == 1)
sprintf(pmsg, "DBR_ULONG: ");
else
sprintf(pmsg, "DBR_ULONG[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
val_u32 = *(epicsUInt32 *) pbuffer;
sprintf(pmsg, "%-9u 0x%-9x", val_u32, val_u32);
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsUInt32);
}
break;
case (DBR_FLOAT):
if (no_elements == 1)
sprintf(pmsg, "DBR_FLOAT: ");
else
sprintf(pmsg, "DBR_FLOAT[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
sprintf(pmsg, "%-13.6g", *((epicsFloat32 *) pbuffer));
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsFloat32);
}
break;
case (DBR_DOUBLE):
if (no_elements == 1)
sprintf(pmsg, "DBR_DOUBLE: ");
else
sprintf(pmsg, "DBR_DOUBLE[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
sprintf(pmsg, "%-13.6g", *((epicsFloat64 *) pbuffer));
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsFloat64);
}
break;
case (DBR_ENUM):
if (no_elements == 1)
sprintf(pmsg, "DBR_ENUM: ");
else
sprintf(pmsg, "DBR_ENUM[%ld]: ", no_elements);
dbpr_msgOut(pMsgBuff, tab_size);
if (status != 0) {
sprintf(pmsg, " failed.");
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
for (i = 0; i < no_elements; i++) {
sprintf(pmsg, "%-9u", *((epicsEnum16 *) pbuffer));
dbpr_msgOut(pMsgBuff, tab_size);
pbuffer = (char *)pbuffer + sizeof(epicsEnum16);
}
break;
default:
printf(" illegal request type.");
break;
}
dbpr_msg_flush(pMsgBuff, tab_size);
return;
}
static int dbpr_report(
const char *pname, DBADDR *paddr, int interest_level,
TAB_BUFFER *pMsgBuff, int tab_size)
{
char *pmsg;
dbFldDes *pdbFldDes = paddr->pfldDes;
dbRecordType *pdbRecordType = pdbFldDes->pdbRecordType;
short n2;
void *pfield;
char *pfield_name;
char *pfield_value;
DBENTRY dbentry;
DBENTRY *pdbentry = &dbentry;
long status;
dbInitEntry(pdbbase,pdbentry);
status = dbFindRecord(pdbentry,pname);
if (status) {
errMessage(status,pname);
return -1;
}
pmsg = pMsgBuff->message;
for (n2 = 0; n2 <= pdbRecordType->no_fields - 1; n2++) {
pdbFldDes = pdbRecordType->papFldDes[pdbRecordType->sortFldInd[n2]];
pfield_name = pdbFldDes->name;
pfield = ((char *)paddr->precord) + pdbFldDes->offset;
if (pdbFldDes->interest > interest_level )
continue;
switch (pdbFldDes->field_type) {
case DBF_STRING:
case DBF_USHORT:
case DBF_ENUM:
case DBF_FLOAT:
case DBF_CHAR:
case DBF_UCHAR:
case DBF_SHORT:
case DBF_LONG:
case DBF_ULONG:
case DBF_DOUBLE:
case DBF_MENU:
case DBF_DEVICE:
status = dbFindField(pdbentry,pfield_name);
pfield_value = dbGetString(pdbentry);
sprintf(pmsg, "%s: %s", pfield_name,
(pfield_value ? pfield_value : "<nil>"));
dbpr_msgOut(pMsgBuff, tab_size);
break;
case DBF_INLINK:
case DBF_OUTLINK:
case DBF_FWDLINK: {
DBLINK *plink = (DBLINK *)pfield;
int ind;
status = dbFindField(pdbentry,pfield_name);
for (ind=0; ind<LINK_NTYPES; ind++) {
if (pamaplinkType[ind].value == plink->type)
break;
}
if (ind>=LINK_NTYPES) {
sprintf(pmsg,"%s: Illegal Link Type", pfield_name);
}
else {
sprintf(pmsg,"%s:%s %s", pfield_name,
pamaplinkType[ind].strvalue,dbGetString(pdbentry));
}
dbpr_msgOut(pMsgBuff, tab_size);
}
break;
case DBF_NOACCESS:
if (pfield == (void *)&paddr->precord->time) {
/* Special for the TIME field, make it human-readable */
char time_buf[40];
epicsTimeToStrftime(time_buf, 40, "%Y-%m-%d %H:%M:%S.%09f",
&paddr->precord->time);
sprintf(pmsg, "%s: %s", pfield_name, time_buf);
dbpr_msgOut(pMsgBuff, tab_size);
}
else if (pdbFldDes->size == sizeof(void *) &&
strchr(pdbFldDes->extra, '*')) {
/* Special for pointers, needed on little-endian CPUs */
sprintf(pmsg, "%s: %p", pfield_name, *(void **)pfield);
dbpr_msgOut(pMsgBuff, tab_size);
}
else { /* just print field as hex bytes */
unsigned char *pchar = (unsigned char *)pfield;
char temp_buf[61];
char *ptemp_buf = &temp_buf[0];
short n = pdbFldDes->size;
short i;
unsigned int value;
if (n > sizeof(temp_buf)/3) n = sizeof(temp_buf)/3;
for (i=0; i<n; i++, ptemp_buf += 3, pchar++) {
value = (unsigned int)*pchar;
sprintf(ptemp_buf, "%02x ", value);
}
sprintf(pmsg, "%s: %s", pfield_name,temp_buf);
dbpr_msgOut(pMsgBuff, tab_size);
}
break;
default:
sprintf(pmsg, "%s: dbpr: Unknown field_type", pfield_name);
dbpr_msgOut(pMsgBuff, tab_size);
break;
}
}
pmsg[0] = '\0';
dbpr_msgOut(pMsgBuff, tab_size);
dbFinishEntry(pdbentry);
return (0);
}
void NDPluginOverlay::doOverlayT(NDArray *pArray, NDOverlay_t *pOverlay)
{
size_t xmin, xmax, ymin, ymax, ix, iy, ii, jj, ib;
size_t xwide, ywide, xwidemax_line, xwidemin_line;
epicsType *pRow;
char textOutStr[512]; // our string, maybe with a time stamp, to place into the image array
char *cp; // character pointer to current character being rendered
int bmc; // current byte in the font bitmap
int mask; // selects the bit in bmc to look at
char tstr[64]; // Used to build the time string
NDPluginOverlayTextFontBitmapType *bmp; // pointer to our font information (bitmap pointer, perhaps misnamed)
int bpc; // bytes per char, ie, 1 for 6x13 font, 2 for 9x15 font
int sbc; // "sub" byte counter to keep track of which byte we are looking at for multi byte fonts
asynPrint(pasynUserSelf, ASYN_TRACEIO_DRIVER,
"NDPluginOverlay::DoOverlayT, shape=%d, Xpos=%ld, Ypos=%ld, Xsize=%ld, Ysize=%ld\n",
pOverlay->shape, (long)pOverlay->PositionX, (long)pOverlay->PositionY,
(long)pOverlay->SizeX, (long)pOverlay->SizeY);
switch(pOverlay->shape) {
case NDOverlayCross:
xmin = 0;
if (pOverlay->PositionX > pOverlay->SizeX)
xmin = pOverlay->PositionX - pOverlay->SizeX;
xmax = pOverlay->PositionX + pOverlay->SizeX;
xmax = MIN(xmax, this->arrayInfo.xSize-1);
ymin = 0;
if (pOverlay->PositionY > pOverlay->SizeY)
ymin = pOverlay->PositionY - pOverlay->SizeY;
ymax = pOverlay->PositionY + pOverlay->SizeY;
ymax = MIN(ymax, this->arrayInfo.ySize-1);
xwide = (pOverlay->WidthX == 1) ? 0 : pOverlay->WidthX / 2;
ywide = (pOverlay->WidthY == 1) ? 0 : pOverlay->WidthY / 2;
xwide = MIN(xwide, pOverlay->SizeX-1);
ywide = MIN(ywide, pOverlay->SizeY);
for (iy=ymin; iy<ymax; iy++) {
pRow = (epicsType *)pArray->pData + iy*this->arrayInfo.yStride;
if ((iy >= (pOverlay->PositionY - ywide)) && (iy <= (pOverlay->PositionY + ywide))) {
for (ix=xmin; ix<xmax; ++ix) {
setPixel(&pRow[ix*this->arrayInfo.xStride], pOverlay);
}
} else {
xwidemin_line = pOverlay->PositionX - xwide;
xwidemax_line = pOverlay->PositionX + xwide;
for (size_t line=xwidemin_line; line<=xwidemax_line; ++line) {
setPixel(&pRow[line*this->arrayInfo.xStride], pOverlay);
}
}
}
break;
case NDOverlayRectangle:
xmin = pOverlay->PositionX;
xmin = MAX(xmin, 0);
xmax = pOverlay->PositionX + pOverlay->SizeX;
xmax = MIN(xmax, this->arrayInfo.xSize);
ymin = pOverlay->PositionY;
ymin = MAX(ymin, 0);
ymax = pOverlay->PositionY + pOverlay->SizeY;
ymax = MIN(ymax, this->arrayInfo.ySize);
xwide = (pOverlay->WidthX == 1) ? 0 : pOverlay->WidthX / 2;
ywide = (pOverlay->WidthY == 1) ? 0 : pOverlay->WidthY / 2;
xwide = MIN(xwide, pOverlay->SizeX-1);
ywide = MIN(ywide, pOverlay->SizeY);
//For non-zero width, grow the rectangle towards the center.
for (iy=ymin; iy<ymax; iy++) {
pRow = (epicsType *)pArray->pData + iy*arrayInfo.yStride;
if ((iy >= ymin) && (iy <= (ymin + ywide))) {
for (ix=xmin; ix<xmax; ix++) setPixel(&pRow[ix*this->arrayInfo.xStride], pOverlay);
} else if ((iy >= (ymax-1 - ywide)) && (iy <= ymax-1)) {
for (ix=xmin; ix<xmax; ix++) setPixel(&pRow[ix*this->arrayInfo.xStride], pOverlay);
} else {
for (size_t line=xmin; line<=xmin+xwide; ++line) {
setPixel(&pRow[line*this->arrayInfo.xStride], pOverlay);
}
for (size_t line=(xmax-xwide); line<=xmax; ++line) {
setPixel(&pRow[(line-1)*this->arrayInfo.xStride], pOverlay);
}
}
}
break;
case NDOverlayText:
if ((pOverlay->Font >= 0) && (pOverlay->Font < NDPluginOverlayTextFontBitmapTypeN)) {
bmp = &NDPluginOverlayTextFontBitmaps[pOverlay->Font];
} else {
// Really, no reason to go on if the font is ill defined
return;
}
bpc = bmp->width / 8 + 1;
if (strlen(pOverlay->TimeStampFormat) > 0) {
epicsTimeToStrftime(tstr, sizeof(tstr)-1, pOverlay->TimeStampFormat, &pArray->epicsTS);
epicsSnprintf(textOutStr, sizeof(textOutStr)-1, "%s%s", pOverlay->DisplayText, tstr);
} else {
epicsSnprintf(textOutStr, sizeof(textOutStr)-1, "%s", pOverlay->DisplayText);
}
textOutStr[sizeof(textOutStr)-1] = 0;
cp = textOutStr;
xmin = pOverlay->PositionX;
xmin = MAX(xmin, 0);
xmax = pOverlay->PositionX + pOverlay->SizeX;
xmax = MAX(xmax, this->arrayInfo.xSize);
ymin = pOverlay->PositionY;
ymin = MAX(ymin, 0);
ymax = pOverlay->PositionY + pOverlay->SizeY;
ymax = MIN(ymax, pOverlay->PositionY + bmp->height);
ymax = MIN(ymax, this->arrayInfo.ySize);
// Loop over vertical lines
for (jj=0, iy=ymin; iy<ymax; jj++, iy++) {
pRow = (epicsType *)pArray->pData + iy*arrayInfo.yStride;
// Loop over characters
for (ii=0; cp[ii]!=0; ii++) {
if( cp[ii] < 32)
continue;
if (xmin+ii * bmp->width >= xmax)
// None of this character can be written
break;
sbc = 0;
bmc = bmp->bitmap[(bmp->height*(cp[ii] - 32) + jj)*bpc];
mask = 0x80;
for (ib=0; ib<bmp->width; ib++) {
ix = xmin + ii * bmp->width + ib;
if (ix >= xmax)
break;
if (mask & bmc) {
setPixel( &pRow[ix*this->arrayInfo.xStride], pOverlay);
}
mask >>= 1;
if (!mask) {
mask = 0x80;
sbc++;
bmc = bmp->bitmap[(bmp->height*(cp[ii] - 32) + jj)*bpc + sbc];
}
}
}
}
break;
}
}
/* Scan task, one per PLC */
static void PLC_scan_task(PLC *plc)
{
ScanList *list;
epicsTimeStamp next_schedule, start_time, end_time;
double timeout, delay, quantum;
eip_bool transfer_ok, reset_next_schedule;
quantum = epicsThreadSleepQuantum();
timeout = (double)ETHERIP_TIMEOUT/1000.0;
scan_loop: /* --------- The Scan Loop for one PLC -------- */
if (epicsMutexLock(plc->lock) != epicsMutexLockOK)
{
EIP_printf_time(1, "drvEtherIP scan task for PLC '%s'"
" cannot take plc->lock\n", plc->name);
return;
}
if (!assert_PLC_connect(plc))
{ /* don't rush since connection takes network bandwidth */
epicsMutexUnlock(plc->lock);
EIP_printf_time(2, "drvEtherIP: PLC '%s' is disconnected\n", plc->name);
epicsThreadSleep(timeout);
goto scan_loop;
}
EIP_printf_time(10, "drvEtherIP scan PLC '%s'\n", plc->name);
reset_next_schedule = true;
epicsTimeGetCurrent(&start_time);
for (list = DLL_first(ScanList,&plc->scanlists);
list; list = DLL_next(ScanList,list))
{
if (! list->enabled)
continue;
if (epicsTimeLessThanEqual(&list->scheduled_time, &start_time))
{
epicsTimeGetCurrent(&list->scan_time);
transfer_ok = process_ScanList(plc->connection, list);
epicsTimeGetCurrent(&end_time);
list->last_scan_time =
epicsTimeDiffInSeconds(&end_time, &list->scan_time);
/* update statistics */
if (list->last_scan_time > list->max_scan_time)
list->max_scan_time = list->last_scan_time;
if (list->last_scan_time < list->min_scan_time ||
list->min_scan_time == 0.0)
list->min_scan_time = list->last_scan_time;
if (transfer_ok) /* re-schedule exactly */
{
list->scheduled_time = list->scan_time;
epicsTimeAddSeconds(&list->scheduled_time, list->period);
}
else
{ /* end_time+fixed delay, ignore extra due to error */
list->scheduled_time = end_time;
epicsTimeAddSeconds(&list->scheduled_time, timeout);
++list->list_errors;
++plc->plc_errors;
disconnect_PLC(plc);
epicsMutexUnlock(plc->lock);
goto scan_loop;
}
}
/* Update time for list that's due next */
if (reset_next_schedule ||
epicsTimeLessThan(&list->scheduled_time, &next_schedule))
{
reset_next_schedule = false;
next_schedule = list->scheduled_time;
}
}
epicsMutexUnlock(plc->lock);
/* fallback for empty/degenerate scan list */
if (reset_next_schedule)
delay = EIP_MIN_TIMEOUT;
else
{
epicsTimeGetCurrent(&start_time);
delay = epicsTimeDiffInSeconds(&next_schedule, &start_time);
if (delay > 60.0)
{
char tsString[50];
printf("Scanlist %g secs has scheduling problem, delay = %g sec\n",
list->period, delay);
epicsTimeToStrftime(tsString, sizeof(tsString),
"%Y/%m/%d %H:%M:%S.%04f", &list->scan_time);
printf(" 'Scan time' : %s\n", tsString);
epicsTimeToStrftime(tsString, sizeof(tsString),
"%Y/%m/%d %H:%M:%S.%04f", &start_time);
printf(" 'Current time' : %s\n", tsString);
epicsTimeToStrftime(tsString, sizeof(tsString),
"%Y/%m/%d %H:%M:%S.%04f", &next_schedule);
printf(" 'Next time' : %s\n", tsString);
/* Attempt to hack around this by waiting a minute,
* hoping that the clock looks better by then.
* Also resetting the scheduled time to 'now'.
*/
delay = 60.0;
list->scheduled_time = start_time;
++list->sched_errors;
}
}
/* Sleep until next turn. */
if (delay > 0.0)
epicsThreadSleep(delay);
else if (delay <= -quantum)
{
EIP_printf(8, "drvEtherIP scan task slow, %g sec delay\n", delay);
++plc->slow_scans; /* hmm, "plc" not locked... */
}
goto scan_loop;
}
/* Public, also driver's report routine */
long drvEtherIP_report(int level)
{
PLC *plc;
EIPIdentityInfo *ident;
ScanList *list;
epicsTimeStamp now;
char tsString[50];
if (level <= 0)
{
printf("drvEtherIP V%d.%d - ControlLogix 5000 PLC via EtherNet/IP\n",
ETHERIP_MAYOR, ETHERIP_MINOR);
return 0;
}
printf("drvEtherIP V%d.%d report, -*- outline -*-\n",
ETHERIP_MAYOR, ETHERIP_MINOR);
if (drvEtherIP_private.lock == 0)
{
printf(" drvEtherIP lock is 0, did you call drvEtherIP_init?\n");
return 0;
}
if (level > 1)
printf(" Mutex lock: 0x%lX\n",
(unsigned long) drvEtherIP_private.lock);
for (plc = DLL_first(PLC,&drvEtherIP_private.PLCs);
plc; plc = DLL_next(PLC,plc))
{
printf ("* PLC '%s', IP '%s'\n", plc->name, plc->ip_addr);
if (level > 1)
{
ident = &plc->connection->info;
printf(" Interface name : %s\n", ident->name);
printf(" Interface vendor : 0x%X\n", ident->vendor);
printf(" Interface type : 0x%X\n", ident->device_type);
printf(" Interface revision : 0x%X\n", ident->revision);
printf(" Interface serial : 0x%X\n",
(unsigned)ident->serial_number);
printf(" scan thread slow count: %u\n", (unsigned)plc->slow_scans);
printf(" connection errors : %u\n", (unsigned)plc->plc_errors);
}
if (level > 2)
{
printf(" Mutex lock : 0x%lX\n",
(unsigned long)plc->lock);
printf(" scan task ID : 0x%lX (%s)\n",
(unsigned long) plc->scan_task_id,
(plc->scan_task_id==0 ? "-dead-" :
epicsThreadIsSuspended(plc->scan_task_id)!=0 ? "suspended":
"running"));
epicsTimeGetCurrent(&now);
epicsTimeToStrftime(tsString, sizeof(tsString),
"%Y/%m/%d %H:%M:%S.%04f", &now);
printf(" Now : %s\n", tsString);
if (level > 3)
{
printf("** ");
EIP_dump_connection(plc->connection);
}
if (level > 4)
{
for (list=DLL_first(ScanList, &plc->scanlists); list;
list=DLL_next(ScanList, list))
{
printf("** ");
dump_ScanList(list, level);
}
}
}
}
printf("\n");
return 0;
}
long generalTimeReport(int level)
{
int items;
if (onceId == EPICS_THREAD_ONCE_INIT) {
printf("General time framework not yet initialized.\n");
return epicsTimeOK;
}
printf("Backwards time errors prevented %u times.\n\n",
generalTimeGetErrorCounts());
/* Use an output buffer to avoid holding mutexes during printing */
printf("Current Time Providers:\n");
epicsMutexMustLock(gtPvt.timeListLock);
if ((items = ellCount(>Pvt.timeProviders))) {
gtProvider *ptp;
char *message; /* Temporary output buffer */
char *pout;
message = calloc(items, 80 * 2); /* Each provider needs 2 lines */
if (!message) {
epicsMutexUnlock(gtPvt.timeListLock);
printf("Out of memory\n");
return epicsTimeERROR;
}
pout = message;
for (ptp = (gtProvider *)ellFirst(>Pvt.timeProviders);
ptp; ptp = (gtProvider *)ellNext(&ptp->node)) {
pout += sprintf(pout, " \"%s\", priority = %d\n",
ptp->name, ptp->priority);
if (level) {
epicsTimeStamp tempTS;
if (ptp->get.Time(&tempTS) != epicsTimeERROR) {
char tempTSText[40];
epicsTimeToStrftime(tempTSText, sizeof(tempTSText),
"%Y-%m-%d %H:%M:%S.%06f", &tempTS);
pout += sprintf(pout, "\tCurrent Time is %s.\n",
tempTSText);
} else {
pout += sprintf(pout, "\tCurrent Time not available\n");
}
}
}
epicsMutexUnlock(gtPvt.timeListLock);
puts(message);
free(message);
} else {
epicsMutexUnlock(gtPvt.timeListLock);
printf("\tNo Providers registered.\n");
}
printf("Event Time Providers:\n");
epicsMutexMustLock(gtPvt.eventListLock);
if ((items = ellCount(>Pvt.eventProviders)))
{
gtProvider *ptp;
char *message; /* Temporary output buffer */
char *pout;
message = calloc(items, 80); /* Each provider needs 1 line, */
if (!message) {
epicsMutexUnlock(gtPvt.eventListLock);
printf("Out of memory\n");
return epicsTimeERROR;
}
pout = message;
for (ptp = (gtProvider *)ellFirst(>Pvt.eventProviders);
ptp; ptp = (gtProvider *)ellNext(&ptp->node)) {
pout += sprintf(pout, " \"%s\", priority = %d\n",
ptp->name, ptp->priority);
}
epicsMutexUnlock(gtPvt.eventListLock);
puts(message);
free(message);
}
else
{
epicsMutexUnlock(gtPvt.eventListLock);
printf("\tNo Providers registered.\n");
}
return epicsTimeOK;
}
static long process(struct timestampRecord *ptimestamp){
const char * format=NULL;
ptimestamp->udf = FALSE;
ptimestamp->pact = TRUE;
/* Device time here is the OS time appart from any epics
* time stamp system */
if (ptimestamp->tse==epicsTimeEventDeviceTime)
epicsTimeFromTime_t(&ptimestamp->time,time(0));
else
recGblGetTimeStamp(ptimestamp);
ptimestamp->rval=ptimestamp->time.secPastEpoch;
if (ptimestamp->time.secPastEpoch==0)
{
sprintf(ptimestamp->val,"-NULL-");
}
else switch(ptimestamp->tst)
{
case timestampTST_YY_MM_DD_HH_MM_SS:
format="%y/%m/%d %H:%M:%S";
break;
case timestampTST_MM_DD_YY_HH_MM_SS:
format="%m/%d/%y %H:%M:%S";
break;
case timestampTST_MM_DD_HH_MM_SS_YY:
format="%b %d %H:%M:%S %y" ;
break;
case timestampTST_MM_DD_HH_MM_SS:
format="%b %d %H:%M:%S";
break;
case timestampTST_HH_MM_SS:
format="%H:%M:%S";
break;
case timestampTST_HH_MM:
format="%H:%M";
break;
case timestampTST_DD_MM_YY_HH_MM_SS:
format="%d/%m/%y %H:%M:%S";
break;
case timestampTST_DD_MM_HH_MM_SS_YY:
format="%d %b %H:%M:%S %y";
break;
case timestampTST_VMS:
format="%d-%b-%Y %H:%M:%S";
break;
case timestampTST_MM_DD_YYYY:
format="%b %d %Y %H:%M:%S.%03f";
break;
case timestampTST_MM_DD_YY:
format="%m/%d/%y %H:%M:%S.%03f";
break;
default : /* YY/MM/DD HH:MM:SS */
format="%y/%m/%d %H:%M:%S";
break;
}
if (format)
epicsTimeToStrftime(ptimestamp->val,sizeof(ptimestamp->val),format,
&ptimestamp->time);
/* check event list */
monitor(ptimestamp);
/* process the forward scan link record */
recGblFwdLink(ptimestamp);
ptimestamp->pact=FALSE;
return(0);
}
void PvaPyLogger::prepareTimeStamp(char* timeStamp, int timeStampLength, const char* timeStampFormat)
{
epicsTimeStamp now;
epicsTimeGetCurrent(&now);
epicsTimeToStrftime(timeStamp, timeStampLength, timeStampFormat, &now);
}
