int drvRFCTRL_Configure(int start, char *ip, int port)
{
int i;
epicsPrintf("*** RF CTRL START ***\n");
sprintf(lhcd_rfctrl.ip, "%s", ip);
lhcd_rfctrl.sock = set_up_tcp( ip, RFCTRL_PORT);
if(lhcd_rfctrl.sock >= 0) lhcd_rfctrl.con_stat = 1;
epicsPrintf("*** RF CTRL Connection OK ***\n");
lhcd_rfctrl.mds_status = 0;
lhcd_rfctrl.t0 = 0.0;
epicsThreadCreate("RFCTRL",
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC)GetRFCTRL_Data_Thread, &lhcd_rfctrl);
epicsThreadCreate("RFCTRL",
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC)PutRFCTRL_MDS_Thread, &lhcd_rfctrl);
return 0;
}
int
Run_mode(acqMaster_t *master)
{
acqEvent_t *ev;
acqScan_t *sc;
char threadName[50];
master->acqRuns = 1;
master->globalShutdown = 0;
master->globalPause = 0;
for( ev = first_acqEvent(master); ev ; ev = next_acqEvent(ev) )
{
snprintf(threadName, sizeof threadName, "event_%s", ev->eventName);
ev->outputCount = 0;
ev->state = AS_STARTUP;
ev->threadID = epicsThreadCreate(threadName, epicsThreadPriorityMedium, epicsThreadGetStackSize(epicsThreadStackMedium), (EPICSTHREADFUNC)runEvent, ev);
}
for( sc = first_acqScan(master) ; sc ; sc = next_acqScan(sc) )
{
snprintf(threadName, sizeof threadName, "scan_%s", sc->scanName);
sc->state = AS_STARTUP;
sc->threadID = epicsThreadCreate(threadName, epicsThreadPriorityMedium, epicsThreadGetStackSize(epicsThreadStackMedium), (EPICSTHREADFUNC)runAcqScan, sc);
}
master->putMode(master, AS_RUNUP);
master->messageAdd(master, "Run Mode");
return 0;
}
static void errlogInitPvt(void *arg)
{
struct initArgs *pconfig = (struct initArgs *) arg;
epicsThreadId tid;
pvtData.errlogInitFailed = TRUE;
pvtData.buffersize = pconfig->bufsize;
pvtData.maxMsgSize = pconfig->maxMsgSize;
pvtData.msgNeeded = adjustToWorstCaseAlignment(pvtData.maxMsgSize +
sizeof(msgNode));
ellInit(&pvtData.listenerList);
ellInit(&pvtData.msgQueue);
pvtData.toConsole = TRUE;
pvtData.console = stderr;
pvtData.waitForWork = epicsEventMustCreate(epicsEventEmpty);
pvtData.listenerLock = epicsMutexMustCreate();
pvtData.msgQueueLock = epicsMutexMustCreate();
pvtData.waitForFlush = epicsEventMustCreate(epicsEventEmpty);
pvtData.flush = epicsEventMustCreate(epicsEventEmpty);
pvtData.flushLock = epicsMutexMustCreate();
pvtData.waitForExit = epicsEventMustCreate(epicsEventEmpty);
pvtData.pbuffer = callocMustSucceed(1, pvtData.buffersize,
"errlogInitPvt");
errSymBld(); /* Better not to do this lazily... */
tid = epicsThreadCreate("errlog", epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC)errlogThread, 0);
if (tid) {
pvtData.errlogInitFailed = FALSE;
}
}
long dbtpn(char *pname, char *pvalue)
{
struct dbChannel *chan;
tpnInfo *ptpnInfo;
processNotify *ppn=NULL;
chan = dbChannelCreate(pname);
if (!chan) {
printf("dbtpn: No such channel");
return -1;
}
ppn = dbCalloc(1, sizeof(processNotify));
ppn->requestType = pvalue ? putProcessRequest : processGetRequest;
ppn->chan = chan;
ppn->putCallback = putCallback;
ppn->getCallback = getCallback;
ppn->doneCallback = doneCallback;
ptpnInfo = dbCalloc(1, sizeof(tpnInfo));
ptpnInfo->ppn = ppn;
ptpnInfo->callbackDone = epicsEventCreate(epicsEventEmpty);
strncpy(ptpnInfo->buffer, pvalue, 80);
ptpnInfo->buffer[79] = 0;
ppn->usrPvt = ptpnInfo;
epicsThreadCreate("dbtpn", epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackMedium), tpnThread, ptpnInfo);
return 0;
}
/// Constructor for the #NetShrVarDriver class.
/// Calls constructor for the asynPortDriver base class and sets up driver parameters.
///
/// @param[in] netvarint interface pointer created by NetShrVarConfigure()
/// @param[in] poll_ms @copydoc initArg0
/// @param[in] portName @copydoc initArg3
NetShrVarDriver::NetShrVarDriver(NetShrVarInterface* netvarint, int poll_ms, const char *portName)
: asynPortDriver(portName,
0, /* maxAddr */
static_cast<int>(netvarint->nParams()),
asynInt32Mask | asynInt32ArrayMask | asynFloat64Mask | asynFloat64ArrayMask | asynOctetMask | asynDrvUserMask, /* Interface mask */
asynInt32Mask | asynInt32ArrayMask | asynFloat64Mask | asynFloat64ArrayMask | asynOctetMask, /* Interrupt mask */
ASYN_CANBLOCK, /* asynFlags. This driver can block but it is not multi-device */
1, /* Autoconnect */
0, /* Default priority */
0), /* Default stack size*/
m_netvarint(netvarint), m_poll_ms(poll_ms), m_shutting_down(false)
{
const char *functionName = "NetShrVarDriver";
m_netvarint->createParams(this);
if (poll_ms == 0)
{
std::cerr << "Warning: driver is not polling for buffered reads, only subscribers will see changes" << std::endl;
}
epicsAtExit(epicsExitFunc, this);
// Create the thread for background tasks (not used at present, could be used for I/O intr scanning)
if (epicsThreadCreate("NetShrVarDriverTask",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)NetShrVarTask, this) == 0)
{
printf("%s:%s: epicsThreadCreate failure\n", driverName, functionName);
return;
}
}
/// Constructor for the isisdaeDriver class.
/// Calls constructor for the asynPortDriver base class.
/// \param[in] dcomint DCOM interface pointer created by lvDCOMConfigure()
/// \param[in] portName @copydoc initArg0
daedataDriver::daedataDriver(const char *portName, const char* host)
: asynPortDriver(portName,
0, /* maxAddr */
NUM_ISISDAE_PARAMS,
asynInt32Mask | asynInt32ArrayMask | asynDrvUserMask, /* Interface mask */
asynInt32Mask | asynInt32ArrayMask, /* Interrupt mask */
ASYN_CANBLOCK , /* asynFlags. This driver can block but it is not multi-device */
1, /* Autoconnect */
0, /* Default priority */
0) /* Default stack size*/
{
const char *functionName = "daedataDriver";
// epicsThreadOnce(&onceId, initCOM, NULL);
m_udp = new DAEDataUDP(host);
createParam(P_SVN_VERSIONString, asynParamInt32, &P_SVN_VERSION);
createParam(P_FIRMWARE_VERSIONString, asynParamInt32, &P_FIRMWARE_VERSION);
createParam(P_CHANNEL_POSITIONString, asynParamInt32Array, &P_CHANNEL_POSITION);
// Create the thread for background tasks (not used at present, could be used for I/O intr scanning)
if (epicsThreadCreate("isisdaePoller",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)pollerThreadC, this) == 0)
{
printf("%s:%s: epicsThreadCreate failure\n", driverName, functionName);
return;
}
}
/* epicsShareFunc int drvSNMPConnInit(const char *version, const char *hostaddr, const char *username, const char *authpass, const char*privpass) */
epicsShareFunc int drvSNMPConnInit(char *version, char *hostaddr, char *username, char *authpass, char*privpass)
{
printf("------------------------------------------------\n");
printf("degug line\n");
printf("------------------------------------------------\n");
printf("version: %s, hostaddr: %s, username: %s, authpass: %s, privpass: %s\n",
version, hostaddr, username, authpass, privpass);
printf("------------------------------------------------\n");
snmpinfo = (SNMP_INFO *)malloc(sizeof(SNMP_INFO));
strcpy(&snmpinfo->version, version);
strcpy(&snmpinfo->hostaddr, hostaddr);
strcpy(&snmpinfo->username, username);
strcpy(&snmpinfo->authpass, authpass);
strcpy(&snmpinfo->privpass, privpass);
strcpy(&snmpinfo->msg,"Test Message");
gsnmpInfo = snmpinfo;
memcpy(gsnmpInfo, snmpinfo, sizeof(SNMP_INFO));
printf("version: %s, hostaddr: %s, username: %s, authpass: %s, privpass: %s\n",
snmpinfo->version, snmpinfo->hostaddr, snmpinfo->username, snmpinfo->authpass, snmpinfo->privpass);
ellInit(&devSNMPList);
epicsThreadCreate("drvSNMPConnInit", epicsThreadPriorityHigh, epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC)devSNMPScanThread,NULL);
return 0;
};
/**
* @ingroup asub_functions
* @param[in] prec Pointer to aSub record
*/
static long iocExit(aSubRecord *prec)
{
long stat = *(long*)prec->a;
epicsThreadCreate("iocExit", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium), exitFunc, (void*)stat);
return 0; /* process output links */
}
int epicsShareAPI asInitAsyn(ASDBCALLBACK *pcallback)
{
if(!pacf) return(0);
if(asInitTheadId) {
errMessage(-1,"asInit: asInitTask already active");
if(pcallback) {
pcallback->status = S_asLib_InitFailed;
callbackRequest(&pcallback->callback);
}
return(-1);
}
asInitTheadId = epicsThreadCreate("asInitTask",
(epicsThreadPriorityCAServerHigh + 1),
epicsThreadGetStackSize(epicsThreadStackBig),
(EPICSTHREADFUNC)asInitTask,(void *)pcallback);
if(asInitTheadId==0) {
errMessage(0,"asInit: epicsThreadCreate Error");
if(pcallback) {
pcallback->status = S_asLib_InitFailed;
callbackRequest(&pcallback->callback);
}
asInitTheadId = 0;
}
return(0);
}
/*
static void print_channelConfig(drvM6802_taskConfig *ptaskConfig, int level)
{
drvM6802_channelConfig *pchannelConfig;
pchannelConfig = (drvM6802_channelConfig*) ellFirst(ptaskConfig->pchannelConfig);
while(pchannelConfig) {
epicsPrintf(" %s", pchannelConfig->chanName);
if(level>2) {
epicsPrintf("\tChannel, status: 0x%x, index: %d, gain: %f",
pchannelConfig->channelStatus,
pchannelConfig->chanIndex,
pchannelConfig->gain );
if(level>3) {
epicsPrintf(", conv.T: %f usec", pchannelConfig->conversionTime_usec);
}
}
epicsPrintf("\n");
pchannelConfig = (drvM6802_channelConfig*) ellNext(&pchannelConfig->node);
}
return;
}
*/
static drvM6802_controlThreadConfig* make_controlThreadConfig(drvM6802_taskConfig *ptaskConfig)
{
drvM6802_controlThreadConfig *pcontrolThreadConfig = NULL;
pcontrolThreadConfig = (drvM6802_controlThreadConfig*)malloc(sizeof(drvM6802_controlThreadConfig));
if(!pcontrolThreadConfig) return pcontrolThreadConfig;
sprintf(pcontrolThreadConfig->threadName, "%s_ctrl", ptaskConfig->taskName);
pcontrolThreadConfig->threadPriority = epicsThreadPriorityLow;
pcontrolThreadConfig->threadStackSize = epicsThreadGetStackSize(epicsThreadStackSmall);
pcontrolThreadConfig->threadFunc = (EPICSTHREADFUNC) controlThreadFunc;
pcontrolThreadConfig->threadParam = (void*) ptaskConfig;
pcontrolThreadConfig->threadQueueId = epicsMessageQueueCreate(100,sizeof(controlThreadQueueData));
epicsThreadCreate(pcontrolThreadConfig->threadName,
pcontrolThreadConfig->threadPriority,
pcontrolThreadConfig->threadStackSize,
(EPICSTHREADFUNC) pcontrolThreadConfig->threadFunc,
(void*) pcontrolThreadConfig->threadParam);
return pcontrolThreadConfig;
}
static drvM6802_controlThreadConfig* make_fpdpThreadConfig(drvM6802_taskConfig *ptaskConfig)
{
drvM6802_controlThreadConfig *pfpdpThreadConfig = NULL;
pfpdpThreadConfig = (drvM6802_controlThreadConfig*)malloc(sizeof(drvM6802_controlThreadConfig));
if(!pfpdpThreadConfig) return pfpdpThreadConfig;
sprintf(pfpdpThreadConfig->threadName, "FPDP_ctrl");
pfpdpThreadConfig->threadPriority = epicsThreadPriorityHigh;
pfpdpThreadConfig->threadStackSize = epicsThreadGetStackSize(epicsThreadStackBig);
pfpdpThreadConfig->threadFunc = (EPICSTHREADFUNC) FPDPthreadFunc;
pfpdpThreadConfig->threadParam = (void*) ptaskConfig;
pfpdpThreadConfig->threadQueueId = epicsMessageQueueCreate(100,sizeof(bufferingThreadQueueData));
bufferingQueueID = pfpdpThreadConfig->threadQueueId;
/* pfpdpThreadConfig->threadQueueId = 0; */
/* if(pfpdpThreadConfig->threadQueueId) ptaskConfig->taskStatus |= TASK_CONTQUEUE; */
epicsThreadCreate(pfpdpThreadConfig->threadName,
pfpdpThreadConfig->threadPriority,
pfpdpThreadConfig->threadStackSize,
(EPICSTHREADFUNC) pfpdpThreadConfig->threadFunc,
(void*) pfpdpThreadConfig->threadParam);
return pfpdpThreadConfig;
}
motorSimController::motorSimController(const char *portName, int numAxes, int priority, int stackSize)
: asynMotorController(portName, numAxes, NUM_SIM_CONTROLLER_PARAMS,
asynInt32Mask | asynFloat64Mask,
asynInt32Mask | asynFloat64Mask,
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
priority, stackSize)
{
int axis;
motorSimControllerNode *pNode;
if (!motorSimControllerListInitialized) {
motorSimControllerListInitialized = 1;
ellInit(&motorSimControllerList);
}
// We should make sure this portName is not already in the list */
pNode = (motorSimControllerNode*) calloc(1, sizeof(motorSimControllerNode));
pNode->portName = epicsStrDup(portName);
pNode->pController = this;
ellAdd(&motorSimControllerList, (ELLNODE *)pNode);
if (numAxes < 1 ) numAxes = 1;
numAxes_ = numAxes;
this->movesDeferred_ = 0;
for (axis=0; axis<numAxes; axis++) {
new motorSimAxis(this, axis, DEFAULT_LOW_LIMIT, DEFAULT_HI_LIMIT, DEFAULT_HOME, DEFAULT_START);
setDoubleParam(axis, this->motorPosition_, DEFAULT_START);
}
this->motorThread_ = epicsThreadCreate("motorSimThread",
epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC) motorSimTaskC, (void *) this);
}
long epicsShareAPI dbtpn(char *pname,char *pvalue)
{
long status;
tpnInfo *ptpnInfo;
DBADDR *pdbaddr=NULL;
putNotify *ppn=NULL;
char *psavevalue;
int len;
len = strlen(pvalue);
/*allocate space for value immediately following DBADDR*/
pdbaddr = dbCalloc(1,sizeof(DBADDR) + len+1);
psavevalue = (char *)(pdbaddr + 1);
strcpy(psavevalue,pvalue);
status = dbNameToAddr(pname,pdbaddr);
if(status) {
errMessage(status, "dbtpn: dbNameToAddr");
free((void *)pdbaddr);
return(-1);
}
ppn = dbCalloc(1,sizeof(putNotify));
ppn->paddr = pdbaddr;
ppn->pbuffer = psavevalue;
ppn->nRequest = 1;
ppn->dbrType = DBR_STRING;
ppn->userCallback = dbtpnCallback;
ptpnInfo = dbCalloc(1,sizeof(tpnInfo));
ptpnInfo->ppn = ppn;
ptpnInfo->callbackDone = epicsEventCreate(epicsEventEmpty);
ppn->usrPvt = ptpnInfo;
epicsThreadCreate("dbtpn",epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackMedium),
tpnThread,ptpnInfo);
return(0);
}
static drvM6802_controlThreadConfig* make_ringThreadConfig(drvM6802_taskConfig *ptaskConfig)
{
drvM6802_controlThreadConfig *pringThreadConfig = NULL;
pringThreadConfig = (drvM6802_controlThreadConfig*)malloc(sizeof(drvM6802_controlThreadConfig));
if(!pringThreadConfig) return pringThreadConfig;
sprintf(pringThreadConfig->threadName, "RING_ctrl");
pringThreadConfig->threadPriority = epicsThreadPriorityLow;
pringThreadConfig->threadStackSize = epicsThreadGetStackSize(epicsThreadStackBig);
pringThreadConfig->threadFunc = (EPICSTHREADFUNC) RingThreadFunc;
pringThreadConfig->threadParam = (void*) ptaskConfig;
/* pringThreadConfig->threadQueueId = epicsMessageQueueCreate(100,sizeof(controlThreadQueueData)); */
pringThreadConfig->threadQueueId = 0; /* we don't need this */
/* if(pringThreadConfig->threadQueueId) ptaskConfig->taskStatus |= TASK_CONTQUEUE; */
epicsThreadCreate(pringThreadConfig->threadName,
pringThreadConfig->threadPriority,
pringThreadConfig->threadStackSize,
(EPICSTHREADFUNC) pringThreadConfig->threadFunc,
(void*) pringThreadConfig->threadParam);
return pringThreadConfig;
}
long mdsPlusPut( genSubRecord *pgsub )
{
/*char *buf = (char *)calloc(40, sizeof(char));*/
int i;
int nextPos = 0;
/* if notified new pulse set taskPos = 0 and notify next access will not be new */
if(notifyNewPulse) {
taskPos = 0;
notifyNewPulse = 0;
}
/* if startMdsPut is active, do nothing */
if(startMdsPut) {
return(0);
}
nextPos = taskPos;
pmdsPutData[nextPos].plinkout = pgsub->outa;
/*buf = (char *)pgsub->a;
sscanf(buf,"%s %s",pmdsPutData[nextPos].serverID, pmdsPutData[nextPos].treeID);
buf = (char *)pgsub->g;
sscanf(buf,"%s",pmdsPutData[nextPos].tagName);*/
sscanf(pgsub->a,"%s %s",pmdsPutData[nextPos].serverID, pmdsPutData[nextPos].treeID);
sscanf(pgsub->g,"%s",pmdsPutData[nextPos].tagName);
/* check shot number */
pmdsPutData[nextPos].shotID = *((unsigned long *)pgsub->b);
pmdsPutData[nextPos].noRd = *((unsigned long *)pgsub->c);
/* check dT and offT */
pmdsPutData[nextPos].dT = *((float *)pgsub->d);
pmdsPutData[nextPos].offT = *((float *)pgsub->e);
/* check the node is valid */
pmdsPutData[nextPos].putFlag = *((unsigned long *)pgsub->h);
if(genSubDebug > 0)
printf("genSub: Ready mdsPlusPut() shotID=%lu,treeID=%s,serverID=%s,tagName=%s, noRd=%lu\n",
pmdsPutData[nextPos].shotID, pmdsPutData[nextPos].treeID, pmdsPutData[nextPos].serverID,
pmdsPutData[nextPos].tagName, pmdsPutData[nextPos].noRd);
/* alocate data memory by noRd */
/*pmdsPutData[nextPos].dataArray = (float *)calloc(pmdsPutData[nextPos].noRd, sizeofTypes[pgsub->ftf]);*/
pmdsPutData[nextPos].dataArray = (float *)realloc(pmdsPutData[nextPos].dataArray,
pmdsPutData[nextPos].noRd * sizeofTypes[pgsub->ftf]);
/* put data */
memcpy(pmdsPutData[nextPos].dataArray, pgsub->f, pmdsPutData[nextPos].noRd*sizeof(sizeofTypes[pgsub->ftf]));
/* if taskPos is equal to the numNode-1, start mdsput and notify new pulse for next access.*/
if(taskPos == numNode - 1 ) {
notifyNewPulse = 1;
startMdsPut = 1;
epicsThreadCreate("mdsPlusPutTask",
epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC) mdsPlusPut_Task,
0);
} else {
taskPos = (taskPos+1)&0xf;
}
/*free(buf);*/
return(pmdsPutData[nextPos].noRd);
}
void ClockTime_Init(int synchronize)
{
int firstTime = 0;
epicsThreadOnce(&onceId, ClockTime_InitOnce, &firstTime);
if (synchronize == CLOCKTIME_SYNC) {
if (ClockTimePvt.synchronize == CLOCKTIME_NOSYNC) {
/* Start synchronizing */
ClockTimePvt.synchronize = synchronize;
epicsThreadCreate("ClockTimeSync", epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackSmall),
ClockTimeSync, NULL);
}
else {
/* No change, sync thread should already be running */
}
}
else {
if (ClockTimePvt.synchronize == CLOCKTIME_SYNC) {
/* Turn off synchronization thread */
ClockTime_Shutdown(NULL);
}
else {
/* No synchronization thread */
if (firstTime)
ClockTimeGetCurrent(&ClockTimePvt.startTime);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////
// //
// void CLeyboldSimPortDriver::octetConnectionCallback( //
// void *drvPvt, asynUser *pasynUser, char *portName, size_t len, int eomReason) //
// //
// Description: //
// static method, callback is invoked when a client connects. //
// NB, one thread for each simulated pump connection. //
// //
//////////////////////////////////////////////////////////////////////////////////////////////////
void CLeyboldSimPortDriver::octetConnectionCallback(void *drvPvt, asynUser *pasynUser, char *portName,
size_t len, int eomReason)
{
CLeyboldSimPortDriver* This = reinterpret_cast<CLeyboldSimPortDriver*>(drvPvt);
// Create a new thread to communicate with this port
This->m_Threads.push_back(new epicsThread(*This->m_ThreadRunable, portName, epicsThreadGetStackSize(epicsThreadStackSmall)));
(*This->m_Threads.rbegin())->start();
}
/** Constructor for the testErrors class.
* Calls constructor for the asynPortDriver base class.
* \param[in] portName The name of the asyn port driver to be created. */
testErrors::testErrors(const char *portName)
: asynPortDriver(portName,
1, /* maxAddr */
(int)NUM_PARAMS,
/* Interface mask */
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask | asynOctetMask |
asynInt8ArrayMask | asynInt16ArrayMask | asynInt32ArrayMask | asynFloat32ArrayMask | asynFloat64ArrayMask |
asynOptionMask | asynEnumMask | asynDrvUserMask,
/* Interrupt mask */
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask | asynOctetMask |
asynInt8ArrayMask | asynInt16ArrayMask | asynInt32ArrayMask | asynFloat32ArrayMask | asynFloat64ArrayMask |
asynEnumMask,
0, /* asynFlags. This driver does not block and it is not multi-device, so flag is 0 */
1, /* Autoconnect */
0, /* Default priority */
0) /* Default stack size*/
{
asynStatus status;
int i;
const char *functionName = "testErrors";
createParam(P_StatusReturnString, asynParamInt32, &P_StatusReturn);
createParam(P_EnumOrderString, asynParamInt32, &P_EnumOrder);
createParam(P_Int32ValueString, asynParamInt32, &P_Int32Value);
createParam(P_Float64ValueString, asynParamFloat64, &P_Float64Value);
createParam(P_UInt32DigitalValueString, asynParamUInt32Digital, &P_UInt32DigitalValue);
createParam(P_OctetValueString, asynParamOctet, &P_OctetValue);
createParam(P_Int8ArrayValueString, asynParamInt8Array, &P_Int8ArrayValue);
createParam(P_Int16ArrayValueString, asynParamInt16Array, &P_Int16ArrayValue);
createParam(P_Int32ArrayValueString, asynParamInt32Array, &P_Int32ArrayValue);
createParam(P_Float32ArrayValueString, asynParamFloat32Array, &P_Float32ArrayValue);
createParam(P_Float64ArrayValueString, asynParamFloat64Array, &P_Float64ArrayValue);
for (i=0; i<MAX_INT32_ENUMS; i++) {
int32EnumStrings_[i] = (char*)calloc(MAX_ENUM_STRING_SIZE, sizeof(char));
}
for (i=0; i<MAX_UINT32_ENUMS; i++) {
uint32EnumStrings_[i] = (char*)calloc(MAX_ENUM_STRING_SIZE, sizeof(char));
}
setIntegerParam(P_StatusReturn, asynSuccess);
setIntegerParam(P_Int32Value, 0);
setDoubleParam(P_Float64Value, 0.0);
setIntegerParam(P_EnumOrder, 0);
setEnums();
// Need to force callbacks with the interruptMask once
setUIntDigitalParam(P_UInt32DigitalValue, (epicsUInt32)0x0, 0xFFFFFFFF, 0xFFFFFFFF);
/* Create the thread that computes the waveforms in the background */
status = (asynStatus)(epicsThreadCreate("testErrorsTask",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)::callbackTask,
this) == NULL);
if (status) {
printf("%s:%s: epicsThreadCreate failure\n", driverName, functionName);
return;
}
}
/* (Re-)connect to IOC,
* (Re-)start scan tasks, one per PLC.
* Returns number of tasks spawned.
*/
int drvEtherIP_restart()
{
PLC *plc;
char taskname[20];
int tasks = 0;
size_t len;
if (drvEtherIP_private.lock == 0) return 0;
epicsMutexLock(drvEtherIP_private.lock);
if (!databaseIsReady) {
epicsMutexUnlock(drvEtherIP_private.lock);
for (plc = DLL_first(PLC,&drvEtherIP_private.PLCs);
plc; plc = DLL_next(PLC,plc))
{
if (plc->name)
{
EIP_printf(4, "drvEtherIP: Delaying launch of scan task for PLC '%s' until database ready\n",
plc->name);
}
}
return 0;
}
for (plc = DLL_first(PLC,&drvEtherIP_private.PLCs);
plc; plc = DLL_next(PLC,plc))
{
/* block scan task (if running): */
epicsMutexLock(plc->lock);
/* restart the connection:
* disconnect, PLC_scan_task will reconnect */
disconnect_PLC(plc);
/* check the scan task */
if (plc->scan_task_id==0)
{
len = strlen(plc->name);
if (len > 16)
len = 16;
taskname[0] = 'E';
taskname[1] = 'I';
taskname[2] = 'P';
memcpy(&taskname[3], plc->name, len);
taskname[len+3] = '\0';
plc->scan_task_id = epicsThreadCreate(
taskname,
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)PLC_scan_task,
(void *)plc);
EIP_printf(5, "drvEtherIP: launch scan task for PLC '%s'\n",
plc->name);
++tasks;
}
epicsMutexUnlock(plc->lock);
}
epicsMutexUnlock(drvEtherIP_private.lock);
return tasks;
}
ipAddrToAsciiEnginePrivate::ipAddrToAsciiEnginePrivate () :
thread ( *this, "ipToAsciiProxy",
epicsThreadGetStackSize(epicsThreadStackBig),
epicsThreadPriorityLow ),
pCurrent ( 0 ), cancelPendingCount ( 0u ), exitFlag ( false ),
callbackInProgress ( false )
{
this->thread.start (); // start the thread
}
static void exitLaterOnceFunc(void *raw)
{
int *status = raw;
exitLaterStatus = *status;
epicsThreadMustCreate("exitLater",
epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackSmall),
&exitNow, NULL);
}
timerQueueActive ::
timerQueueActive ( RefMgr & refMgr,
bool okToShareIn, unsigned priority ) :
_refMgr ( refMgr ), queue ( *this ), thread ( *this, "timerQueue",
epicsThreadGetStackSize ( epicsThreadStackMedium ), priority ),
sleepQuantum ( epicsThreadSleepQuantum() ), okToShare ( okToShareIn ),
exitFlag ( false ), terminateFlag ( false )
{
}
int createControllerHandler (ST_STD_device *pSTDdev)
{
epicsThreadCreate ("ctrl_recv",
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC) ctrl_comm_handler,
(void*)pSTDdev);
return WR_OK;
}
int createRfmHandler (ST_STD_device *pSTDdev)
{
epicsThreadCreate ("rfm_recv",
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC) kstar_rfm_handler,
(void*)pSTDdev);
return WR_OK;
}
void epicsThreadPoolConfigDefaults(epicsThreadPoolConfig *opts)
{
memset(opts, 0, sizeof(*opts));
opts->maxThreads = epicsThreadGetCPUs();
opts->workerStack = epicsThreadGetStackSize(epicsThreadStackSmall);
if (epicsThreadLowestPriorityLevelAbove(epicsThreadPriorityCAServerHigh, &opts->workerPriority)
!= epicsThreadBooleanStatusSuccess)
opts->workerPriority = epicsThreadPriorityMedium;
}
static int testInit(const char *port,int addr,
cmdInfo **ppcmdInfo, threadInfo **ppthreadInfo,int ind,FILE *file)
{
cmdInfo *pcmdInfo;
threadInfo *pthreadInfo;
asynUser *pasynUser;
asynStatus status;
asynInterface *pasynInterface;
size_t size;
pcmdInfo = (cmdInfo *)pasynManager->memMalloc(sizeof(cmdInfo));
memset(pcmdInfo,0,sizeof(cmdInfo));
*ppcmdInfo = pcmdInfo;
size = sizeof(threadInfo) + (strlen(port)+ 1) + (strlen(thread) + 2);
pthreadInfo = (threadInfo *)pasynManager->memMalloc(size);
memset(pthreadInfo,0,sizeof(threadInfo));
pthreadInfo->size = size;
*ppthreadInfo = pthreadInfo;
pthreadInfo->portName = (char *)(pthreadInfo +1);
strcpy(pthreadInfo->portName,port);
pthreadInfo->threadName = pthreadInfo->portName
+ strlen(pthreadInfo->portName) + 1;
sprintf(pthreadInfo->threadName,"%s%1.1d",thread,ind);
pcmdInfo->callbackDone = epicsEventMustCreate(epicsEventEmpty);
pthreadInfo->work = epicsEventMustCreate(epicsEventEmpty);
pthreadInfo->done = epicsEventMustCreate(epicsEventEmpty);
pthreadInfo->tid = epicsThreadCreate(pthreadInfo->threadName,
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)workThread,pthreadInfo);
if(!pthreadInfo->tid) {
fprintf(pcmdInfo->file,"epicsThreadCreate failed\n");
return -1;
}
pcmdInfo->pasynUser = pasynManager->createAsynUser(
workCallback,timeoutCallback);
pasynUser = pcmdInfo->pasynUser;
pasynUser->userPvt = pcmdInfo;
status = pasynManager->connectDevice(pasynUser,port,addr);
if(status!=asynSuccess) {
fprintf(pcmdInfo->file,"connectDevice failed %s\n",pasynUser->errorMessage);
return -1;
}
pasynInterface = pasynManager->findInterface(pasynUser, asynCommonType, 1);
if(!pasynInterface) {
fprintf(pcmdInfo->file,"can't find asynCommon\n");
return -1;
}
pcmdInfo->pasynCommon = (asynCommon *) pasynInterface->pinterface;
pcmdInfo->asynCommonPvt = pasynInterface->drvPvt;
pcmdInfo->file = file;
pcmdInfo->pthreadInfo = pthreadInfo;
pthreadInfo->pcmdInfo = pcmdInfo;
return 0;
}
IRQPoller::IRQPoller(pollerFN fn, void *arg, double period)
:done(false)
,period(0.1)
,fn(fn)
,arg(arg)
,runner(*this, "IRQPoller",
epicsThreadGetStackSize(epicsThreadStackBig),
epicsThreadPriorityHigh)
{
runner.start();
}
void RpcServer::startListener()
{
if (destroyed) {
throw InvalidState("Invalid state: server has been shutdown and cannot be restarted.");
}
// One must call PyEval_InitThreads() in the main thread
// to initialize thread state, which is needed for proper functioning
// of PyGILState_Ensure()/PyGILState_Release().
PyGilManager::evalInitThreads();
epicsThreadCreate("RpcServerListenerThread", epicsThreadPriorityLow, epicsThreadGetStackSize(epicsThreadStackSmall), (EPICSTHREADFUNC)listenerThread, this);
}
void dbCaLinkInit(void)
{
dbServiceIOInit();
dbCaLinkInitIsolated();
startStopEvent = epicsEventMustCreate(epicsEventEmpty);
dbCaCtl = ctlPause;
epicsThreadCreate("dbCaLink", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackBig),
dbCaTask, NULL);
epicsEventMustWait(startStopEvent);
}
static void initOnce(void)
{
if ((onceQ = epicsRingPointerCreate(onceQueueSize)) == NULL) {
cantProceed("initOnce: Ring buffer create failed\n");
}
onceSem = epicsEventMustCreate(epicsEventEmpty);
onceTaskId = epicsThreadCreate("scanOnce",
epicsThreadPriorityScanLow + nPeriodic,
epicsThreadGetStackSize(epicsThreadStackBig), onceTask, 0);
epicsEventWait(startStopEvent);
}