Experimental Physics and
Industrial Control System

      extern "C" {

      int AsynBPM2DrvrConfigure(const char *portName, int index )

      {

            EWBAsynPortDrvr *drvr = (EWBAsynPortDrvr *)new asynBPMDrvr(portName, index);

            asynStatus status = drvr->setup();

            if(status==asynSuccess)

            {

                  return 0;

            }

            exit(1);

      }

      /* EPICS iocsh shell commands */

      static const iocshArg initArg0 = { "portName",iocshArgString};

      static const iocshArg initArg1 = { "index",iocshArgInt};

      static const iocshArg * const initArgs[] = {&initArg0, &initArg1};

      static const iocshFuncDef initFuncDef = {"AsynBPM2DrvrConfigure",2,initArgs};

      static void initCallFunc(const iocshArgBuf *args)

      {

            AsynBPM2DrvrConfigure(args[0].sval, args[1].ival);

      }

      void AsynBPM2DrvrRegister(void)

      {

            iocshRegister(&initFuncDef,initCallFunc);

      }

            epicsExportRegistrar(AsynBPM2DrvrRegister);

      }

#elif __BPM1__

      extern "C" {

      int AsynBPM1DrvrConfigure(const char *portName, int index )

      {

            EWBAsynPortDrvr *drvr = (EWBAsynPortDrvr *)new asynBPMDrvr(portName, index);

            asynStatus status = drvr->setup();

            if(status==asynSuccess)

            {

                  return 0;

            }

            exit(1);

      }

      /* EPICS iocsh shell commands */

      static const iocshArg initArg0 = { "portName",iocshArgString};

      static const iocshArg initArg1 = { "index",iocshArgInt};

      static const iocshArg * const initArgs[] = {&initArg0, &initArg1};

      static const iocshFuncDef initFuncDef = {"AsynBPM1DrvrConfigure",2,initArgs};

      static void initCallFunc(const iocshArgBuf *args)

      {

            AsynBPM1DrvrConfigure(args[0].sval, args[1].ival);

      }

      void AsynBPM1DrvrRegister(void)

      {

            iocshRegister(&initFuncDef,initCallFunc);

      }

            epicsExportRegistrar(AsynBPM1DrvrRegister);

      }

 * Constructor for the asynWBPortDrvr class.

 *

 * This class is an helper class:

 * must have a child class and call a parent class

 *

 * \param[in] portName The name of the asyn port driver to be created.

 * \param[in] max_nprm Maximum number of scope parameters

 *

 **/

EWBAsynPortDrvr::EWBAsynPortDrvr(const char *portName,int max_nprm)

: asynPortDriver(portName,

            1,

             max_nprm,

            (asynInt32Mask | asynFloat64Mask | asynOctetMask | asynInt32ArrayMask | asynFloat32ArrayMask | asynDrvUserMask), /* Interface mask */

            (asynInt32Mask | asynFloat64Mask | asynOctetMask | asynInt32ArrayMask | asynFloat32ArrayMask ), /* Interrupt mask */

            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*/

            pRoot(NULL), driverName(portName)

{

      EWBAsynPrm afld;

      afld.pPrm=NULL;

      afld.syncflags=AWB_SYNC_DERIVED; //when not define we derive

      fldPrms = std::vector<EWBAsynPrm>( max_nprm,afld);

      syncNow=EWBSync::EWB_AM_RW;

 * Create a asyn parameter and link it to a WB field

 *

 * With this method: the name given to the process variable will be auto-generated in the format

 *          \<reg_name\>_\<field_name\>

 * \note If there is only one field named 'value' the generated name will only have the reg_name

 *

 * \param[in] fld  A WBField that is going to be link with the parameter

 * \param[in] pIndex PV index

 * \param[in] syncflags Select in which mode we want to sync between PV and device/library.

 * \return Returns a asynSuccess if everything is okay. Otherwise asynParamAlreadyExists if the parameter already exists, or asynBadParamIndex if

 * adding this parameter would exceed the size of the parameter list and asynError is the WBField is not valid.

 * \see AsynWBSync for the type of synchronization

 */

asynStatus EWBAsynPortDrvr::createParam(EWBField* fld,int *pIndex, uint32_t syncflags)

{

      std::stringstream ss;

      if(pIndex) *pIndex=-1;

      TRACE_CHECK_PTR(fld,asynError);

      TRACE_CHECK_PTR(fld->getReg(),asynError);

      if(fld->getName()==fld->getReg()->getName() || (fld->getName()=="value" && fld->getReg()->getFields().size()==1))

            ss << fld->getReg()->getName();

      else

            ss << fld->getReg()->getName() << "_" << fld->getName();

      return this->createParam(ss.str().c_str(),fld, pIndex, syncflags);

}

/**

 * Create a asyn parameter and link it to a WB field

 *

 * \param[in] name The name of this parameter

 * \param[in] pPrm  A WBField that is going to be link with the parameter

 * \param[in] pIndex PV index.

 * \param[in] syncflags Select in which mode we want to sync between PV and device/library.

 * \return Returns a asynSuccess if everything is okay. Otherwise asynParamAlreadyExists if the parameter already exists, or asynBadParamIndex if

 * adding this parameter would exceed the size of the parameter list and asynError is the WBField is not valid.

 * \see AsynWBSync for the type of synchronization

 */

asynStatus EWBAsynPortDrvr::createParam(const char* name, EWBParam* pPrm,int *pIndex, uint32_t syncflags)

{

      int tmp;

      asynStatus status=asynError;

      asynParamType atype;

      if(pIndex) *pIndex=-1;

      if(pPrm && pPrm->isValid())

      {

            pIndex=(pIndex)?pIndex:&tmp;

            if(pPrm->getType() == EWBParam::EWBF_STRING)

            {

                  atype=asynParamOctet;

            }

            else if(pPrm->getType() & EWBParam::EWBF_TM_TYPE_FIELD)

            {

                  if(pPrm->getType() & EWBParam::EWBF_TM_FIXED_POINT){

                        atype=asynParamFloat64;

                  }

                  else{

                        atype=asynParamInt32;

                  }

            }

            else

            {

                  TRACE_P_WARNING("Unknown type 0x%x for Param %s (pv:%s)",pPrm->getType(), pPrm->getCName(), name);

                  return asynError;

            }

            //if(list==1) list=0;

            status = asynPortDriver::createParam(name,atype,pIndex);

            if(status==asynSuccess)

            {

                  fldPrms[*pIndex].pPrm=pPrm;

                  fldPrms[*pIndex].syncflags=syncflags;

                  fldPrms[*pIndex].atype=atype;         

                  switch(atype)

                  {

                        case asynParamOctet:

                              setStringParam(*pIndex, pPrm->getString().c_str()); break; //TODO:CHECK this

                        case asynParamInt32:  

                              setIntegerParam(*pIndex,pPrm->getU32()); break;

                        case asynParamFloat64:

                              setDoubleParam(*pIndex,pPrm->getFloat()); break;

                        default:

                              TRACE_P_WARNING("Type 0x%x not handled",atype);

                  }

            }

            EWBField *pFld=pPrm->castField();

            if(pFld)

            {

                  TRACE_P_DEBUG("#%03d:%-15s ; val:%s (flgsync=x%03x, %s) => %s.%s.%s (0x%08X) ",

                              *pIndex,name,pPrm->getString().c_str(),

                              syncflags,(atype==asynParamInt32)?"I32":"U64",

                              pFld->getReg()->getPrtNode()->getCName(),pFld->getReg()->getCName(),pFld->getCName(),

                              pFld->getReg()->getOffset(true));

            }

            EWBParamStr *pPrmStr=pPrm->castParamStr();

            if(pPrmStr)

            {

                  TRACE_P_DEBUG("#%03d:%-15s ; val:%s (flgsync=x%03x, %s) => key:%s ",

                              *pIndex,name,pPrm->getString().c_str(),syncflags,

                              (atype==asynParamOctet)?"Oct":((atype==asynParamInt32)?"I32":"U64"),

                              pPrmStr->getCName());

            }

      }

      return status;

}

/**

 * Create parameters for internal use of the IOC

 *

 * This parameters will not be synchronized with our device. This function override the standard

 * asynPortDriver::createParam(), and only add the syncflags to AWB_SYNC_PRMLIST or AWB_SYNC_DERIVED

 *

 * \param[in] name The name of this parameter

 * \param[in] atype  The type of parameters A WBField that is going to be link with the parameter

 * \param[in] pIndex PV index.

 * \param[in] syncflags Select in which mode we want to sync. As we don't communicate with the device we can not set AWB_SYNC_DEVICE or AWB_SYNC_WBSTRUCT

 * \return Returns a asynSuccess if everything is okay. Otherwise asynParamAlreadyExists if the parameter already exists, or asynBadParamIndex if

 * adding this parameter would exceed the size of the parameter list and asynError is the syncflags is not valid.

 * \see AsynWBSync for the type of synchronization

 */

asynStatus EWBAsynPortDrvr::createParam(const char* name, asynParamType atype,int *pIndex,uint32_t syncflags)

{

      int tmp;

      asynStatus status=asynError;

      if(pIndex) *pIndex=-1;

      TRACE_CHECK_VA(!(syncflags & EWB_SYNC_FLG_DEV),status,"Bad sync mode :%d",syncflags);

      pIndex=(pIndex)?pIndex:&tmp;

      status=asynPortDriver::createParam(name,atype,pIndex);

      if( status==asynSuccess )

      {

            fldPrms[*pIndex].pPrm=NULL;

            fldPrms[*pIndex].syncflags=syncflags;

            fldPrms[*pIndex].atype=atype;               

            TRACE_P_DEBUG("#%03d:%-15s (flgsync=x%03x, %s:%d)",*pIndex,name,syncflags,paramVal::typeNames[atype], atype);

            switch(atype)

            {

                  case asynParamOctet:   setStringParam(*pIndex,""); break;

                  case asynParamInt32:   setIntegerParam(*pIndex,0); break;

                  case asynParamFloat64: setDoubleParam(*pIndex,0); break;

                  default: TRACE_P_WARNING("Type 0x%x not handled",atype);

            }

      }

      return status;

#!../../bin/linux-arm/AsynDrvr

< envPaths

Can't open envPaths: No such file or directory

##Set the DATADIR (store autosave, datalog, etc.)

epicsEnvSet( "TOP","/root/topBPM")

epicsEnvSet( "DATADIR","." )

epicsEnvSet( "IOCPATH","/root" )

epicsEnvSet( "EPICS_CA_MAX_ARRAY_BYTES","45000")

epicsEnvSet( "BPM","BPM1")

epicsEnvSet( "CHANNEL", "Cha")

##Set the host EPICS name

epicsEnvSet("EPICS_HOST_1",SL-SCL-CM3:DIA-BPM-3)

cd "/root/topBPM"

## Register all support components

dbLoadDatabase ("dbd/AsynDrvr1.dbd")

AsynDrvr_registerRecordDeviceDriver(pdbbase)

## Configure the IOCs

AsynDrvrConfigure( "BPM1", 0, "./datalog" )

**************************************END OF setupEWBPeriphCtl()********************************************

## Load record instances for BPM-1

# CTL

dbLoadRecords( "db/7s_ctl.db",             "user=SL-SCL-CM3:DIA-BPM-3, PORT=BPM1, ADDR=0, TIMEOUT=0" )

dbLoadRecords( "db/7s_bpm_time.db",        "user=SL-SCL-CM3:DIA-BPM-3, PORT=BPM1, ADDR=0, TIMEOUT=1, MACROTIME=SL-SCL-CM3:TIM-EVR-3" )

# dbLoadRecords( "db/7s_pm_slw_idx.db",      "user=${EPICS_HOST_1}, PORT=${BPM}, ADDR=0, TIMEOUT=1" )

## Set this to see messages from mySub

#var mySubDebug 1

## Run this to trace the stages of iocInit

#traceIocInit

## setup autosave files and directories

set_savefile_path("/home/epics-user/data/autosave")

set_requestfile_path("/root/topBPM/iocBoot/iocAsynBPM1")

set_pass1_restoreFile("auto_settings_BPM1.sav")

# Number of sequenced backup files (e.g., 'auto_settings.sav0') to write

save_restoreSet_NumSeqFiles(0)

save_restoreSet_DatedBackupFiles(0)

#cd "${TOP}/iocBoot/${IOC}"

iocInit()

Starting iocInit

############################################################################

## EPICS R3.15.5

## EPICS Base built Jul  1 2022

############################################################################

2022/07/11 10:54:15.414 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Ctrl_PosMesEna

SL-SCL-CM3:DIA-BPM-3:PosMesEnaStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.414 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Ctrl_Alarm

SL-SCL-CM3:DIA-BPM-3:AlarmStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.414 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Ctrl_Acqst

SL-SCL-CM3:DIA-BPM-3:AcqstStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.414 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Ctrl_SelfClbEna

SL-SCL-CM3:DIA-BPM-3:SelfClbStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.414 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Ctrl_CableClbEna

SL-SCL-CM3:DIA-BPM-3:CableClbStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.415 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Ctrl_get_idle

SL-SCL-CM3:DIA-BPM-3:IdleEnaStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.415 asynPortDriver:drvUserCreate: addr=0, cannot find parameter Cavity_present

SL-SCL-CM3:DIA-BPM-3:CavityPresentStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.415 asynPortDriver:drvUserCreate: addr=0, cannot find parameter disable_calibration

SL-SCL-CM3:DIA-BPM-3:DisableCalibrationStat devAsynInt32::initCommon drvUserCreate

2022/07/11 10:54:15.415 asynPortDriver:drvUserCreate: addr=0, cannot find parameter ctl_pps_utc_sw

SL-SCL-CM3:DIA-BPM-3:PpsUtcSoftRb devAsynInt32::initCommon drvUserCreate

reboot_restore: entry for file 'auto_settings_BPM1.sav'

reboot_restore: Found filename 'auto_settings_BPM1.sav' in restoreFileList.

*** restoring from '/home/epics-user/data/autosave/auto_settings_BPM1.sav' at initHookState 7 (after record/device init) ***

37 PVs had no saved value.

reboot_restore: done with file 'auto_settings_BPM1.sav'

iocRun: All initialization complete

date

2022/07/11 10:54:15.945194  --> DATE AFTER IOCINIT

##Start the save task

create_monitor_set("auto_settings_BPM1.req", 1, "id=SL-SCL-CM3:DIA-BPM-3")

## Create info_x.req file in current directory (Use req_info2auto.sh to obtain auto_x.req)

makeAutosaveFiles

asynPortDriver.h:    virtual asynStatus createParam(int list, const char *name, asynParamType type, int *index);

However, here you are calling it with 2 arguments

createParam( "ntp_status", asynParamInt32 );

Hello Mark, 

That is the driver code:

asynDrvr::asynDrvr( const char *portName, int index )

}

asynStatus asynDrvr::setupEWBPeriphCtl()

}

De: Mark Rivers <rivers at cars.uchicago.edu>
Enviado: jueves, 7 de julio de 2022 16:05
Para: Adrian Martinez <adrian.martinez at orolia.com>
Cc: tech-talk <tech-talk at aps.anl.gov>
Asunto: RE: EPICS compilation errors