• EPICS asyn诊断帮助

    iocsh命令

    1. asynReport(level,portName) 
    2. asynInterposeFlushConfig(portName,addr,timeout)
    3. asynInterposeEosConfig(portName,addr,processIn,processOut)
    4. asynSetTraceMask(portName,addr,mask)
    5. asynSetTraceIOMask(portName,addr,mask)
    6. asynSetTraceInfoMask(portName,addr,mask)
    7. asynSetTraceFile(portName,addr,filename)
    8. asynSetTraceIOTruncateSize(portName,addr,size)
    9. asynSetOption(portName,addr,key,val)
    10. asynShowOption(portName,addr,key)
    11. asynAutoConnect(portName,addr,yesNo)
    12. asynSetAutoConnectTimeout(timeout)
    13. asynWaitConnect(portName, timeout)
    14. asynEnable(portName,addr,yesNo)
    15. asynOctetConnect(entry,portName,addr,timeout,buffer_len,drvInfo)
    16. asynOctetRead(entry,nread)
    17. asynOctetWrite(entry,output)
    18. asynOctetWriteRead(entry,output,nread)
    19. asynOctetFlush(entry)
    20. asynOctetSetInputEos(portName,addr,eos,drvInfo)
    21. asynOctetGetInputEos(portName,addr,drvInfo)
    22. asynOctetSetOutputEos(portName,addr,eos,drvInfo)
    23. asynOctetGetOutputEos(portName,addr,drvInfo)
    24. asynRegisterTimeStampSource(portName,functionName);
    25. asynUnregisterTimeStampSource(portName)

    asynReport：如果指定了portName，asynReport为指定端口调用asynCommon:report，如果没有指定portName, 为所有注册的驱动程序和InterposeInterface调用asynCommon:report。

    asynInterposeFlushConfig：是一个通用的interposeInterface，它为没有实现flush的底层驱动程序实现了flush。它仅发出读取请求，直到没有剩下要读的字节。timeout是用于读取请求。

    asynInterposeEosConfig：是一个通用interposeInterface，它为没有实现字符串末尾处理的底层驱动程序，实现了它。

    asynSetTraceMask：为指定端口和地址调用asynTrace:setTraceMask。如果portName是0长度，则全局跟踪掩码被设置。

    一个掩码确定能被显示的信息类型。各种选项可是被ORed到一起。当创建一个端口时，这个掩码的默认值是：ASYN_TRACE_ERRROR。

    1. ASYN_TRACE_ERROR：报告运行时错误，例如，超时。
    2. ASYN_TRACEIO_DEVICE：设备支持报告I/O活动。
    3. ASYN_TRACEIO_FILTER：在设备支持和底层驱动之间的任何层报告它对I/O进行的任何过滤。
    4. ASYN_TRACEIO_DRIVER：底层驱动报告I/O活动。
    5. ASYN_TRACE_FLOW：报告逻辑流。设备支持应该报告所有队列请求，进入的回调以及对驱动的所有调用。在设备支持和底层驱动之间的层应该报告它们对更低层驱动的所有调用。底层驱动报告它们对其它支持的调用。
    6. ASYN_TRACE_WARNING：报告警告，即，在ASYN_TRACE_ERROR和ASYN_TRACE_FLOW之间的情况。

    asynSetTraceIOMask：为指定端口和地址调用asynTrace:setTraceIOMask。如果portName是0长度，则全局跟踪掩码被设置。另一个掩码，它决定打印多少消息缓存。各种选项能够被ORed到一起。创建这个端口时，这个掩码的默认值是ASYN_TRACEIO_NODATA。

    1. ASYN_TRACEIO_NODATA：不打印来自消息缓存的任何数据。
    2. ASYN_TRACEIO_ASCII：用"%s"格式打印。
    3. ASYN_TRACEIO_ESCAPE： 调用epicsStrPrintEscaped.
    4. ASYN_TRACEIO_HEX ：用%2.2x打印每个字节。

    asynSetTraceInfoMask：为指定端口和地址调用asynTrace:setTraceInfoMask。如果portName是0长度，则全局跟踪掩码被设置。一个掩码确定了在每条消息开头打印数目信息。不同选项可以被ORed在一起。创建一个端口时，这个掩码的默认值是ASYN_TRACEINFO_TIME。

    1. ASYN_TRACEINFO_TIME：打印这条消息的日期和时间。
    2. ASYN_TRACEINFO_PORT：打印[port, addr, reason]，此处port是端口名，addr是asyn地址，而reason是pasynUser->reason。这些是asyn中3段"地址"信息。
    3. ASYN_TRACEINFO_SOURCE：打印文件名和行号，即[__FILE__, __LINE__]，此处asynPrint或asynPrintIO状态发生的位置。
    4. ASYN_TRACEINFO_THREAD：打印线程名称，线程ID和线程优先级，即[epicsThreadGetNameSelf(), epicsThreadGetIdSelf(), epicsThreadGetPrioritySelf()]。

    从asyn R4-35开始，可以用以+或|连接的整数或者符号名称指定asynSetTraceMask, asynSetTraceIOMask和asynSetTraceInfoMask。空白是被允许的，但需要引号。符号名称是像在asynDriver.h中定义的宏名称，但不是区分大小写的，并且前缀ASYN_, TRACE_, TRACEIO_和TRACEINFO_是可选的。示例：

    1. asynSetTraceMask port,0,ASYN_TRACE_ERROR 
    2. asynSetTraceIOMask port,0,ascii+escape
    3. asynSetTraceInfoMask port,0,1+port+TRACEINFO_SOURCE|ASYN_TRACEINFO_THREAD

    asynSetTraceFile：asynSetTraceFile调用asynTrace:setTraceFile。按如下处理文件名：

    1. 未指定。一个NULL指针被传递给setTraceFile。后续消息被发送给errlog。
    2. 一个空字符串("")或"stderr"：stderr被传递给setTraceFile。
    3. "stdout"：stdout被传递给setTraceFile。
    4. 任何其它字符串：用选项"w"打开这个指定的文件，并且文件指针被传递给setTraceFile。

    asynSetTraceIOTruncateSize：asynSetTraceIOTruncateSize调用asynTrace:setTraceIOTruncateSize。

    asynSetOption：asynSetOption调用asynCommon:setOption。

    asynShowOptin：asynShowOption调用asynCommon:getOption。

    asynOctetXXX命令：提供了对asynOctetSyncIO方法的shell访问。entry是标识端口，地址的字符串常量。

    此处：

    • filename：一个指定文件名的ascii字符串。如果null或null字符串，则输出被发送到stdout。
    • level：汇报级别。
    • portName：一个指定驱动的portName的ascii字符串。
    • addr：指定设备地址的整数。用于多设备端口，-1值标识端口自身。对于支持单设备的端口，忽略addr。
    • mask：要设置的掩码。
    • key：对应所需选项的键。
    • val：对应这个选项的值。
    • yesNo：值(0,1)表示(no, yes)。
    • entry：一个字符串，标识asynOctetConnect请求。
    • timeout：用毫秒整数指定timeout。默认是1。
    • buffer_len：对应I/O的缓存长度。默认为160。注意：传递给asynOctetWrite的输出字符串可以有转义字符。buffer_len必须足够大来处理转义字符。例如，如果\x02出现在输出字符串中，它算作4个字符。
    • drvInfo：通过接口asynDrvUser传递给驱动的字符串。
    • nread：要读取最大数目的字节。默认=buffer_len。
    • flush：(0,1)表示在读取前(不要，要)flush。默认0。
    • output：输出字符串。

    命令asynOctetConnect, asynOctetDisconnect, asynOctetRead, asynOctetWrite, asynOctetWriteRead, asynOctet允许从ioc shell对设备进行I/O。示例是：

    以下示例展示了使用https://blog.csdn.net/yuyuyuliang00/article/details/132668739中的asyn驱动模块创建了一个端口驱动程序来测试以上列出的部分asyn诊断命令。

    以下这个驱动程序的源代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include "cantProceed.h"
    8. #include "epicsStdio.h"
    9. #include "epicsThread.h"
    10. #include "iocsh.h"
    11.  
    12. #include "asynDriver.h"
    13. #include "asynOctet.h"
    14. #include "asynInt32.h"
    15.  
    16. #include 
    17. #define BUFFERSIZE 4096
    18.  
    19. static int VALUE = 0;
    20.  
    21. typedef struct deviceBuffer{
    22. 	char	buffer[BUFFERSIZE];
    23. 	size_t	nchars;
    24. 	int	value;
    25. 	int	low;
    26. 	int	high;
    27. }deviceBuffer;
    28.  
    29. typedef struct deviceInfo{
    30. 	deviceBuffer	buffer;
    31. 	int 		connected;
    32. }deviceInfo;
    33.  
    34. typedef struct infoPvt{
    35. 	deviceInfo 	device;
    36. 	const char 	* portName;
    37. 	int 		connected;
    38. 	double 		delay;
    39. 	asynInterface 	common;
    40. 	asynInterface 	octet;
    41. 	asynInterface	int32;
    42. 	char 		eos[2];
    43. 	int		eoslen;
    44. 	void		* pasynPvt;
    45. 	void		* pasynInt32Pvt;
    46. }infoPvt;
    47.  
    48. static int infoDriverInit(const char * portName, double delay, int noAutoConnect, int low, int high);
    49.  
    50.  
    51. /* asynCommon  */
    52. static void report(void *drvPvt, FILE * fp, int details);
    53. static asynStatus connect(void * drvPvt, asynUser *pasynUser);
    54. static asynStatus disconnect(void *drvPvt, asynUser * pasynUser);
    55. static asynCommon asynC = {report, connect, disconnect};
    56.  
    57. /* asynOctet */
    58. static asynStatus infoWrite(void *drvPvt, asynUser *pasynUser,
    59. 		const char *data, size_t numchars, size_t *nbytesTransfered);
    60. static asynStatus infoRead(void *drvPvt, asynUser *pasynUser,
    61. 		char *data, size_t maxchars, size_t *nbytesTransfered, int *eomReason);
    62. static asynStatus infoFlush(void *drvPvt, asynUser *pasynUser);
    63. static asynStatus setEos(void *drvPvt, asynUser *pasynUser, const char *eos, int eoslen);
    64. static asynStatus getEos(void *drvPvt, asynUser *pasynUser, char *eos, int eossize, int *eoslen);
    65. static asynOctet asynO;
    66.  
    67. /* asynInt32*/
    68. static asynStatus intWrite(void *drvPvt, asynUser * pasynUser, epicsInt32 value);
    69. static asynStatus intRead(void *drvPvt, asynUser * pasynUser, epicsInt32 *value);
    70. static asynStatus getIntBounds(void *drvPvt, asynUser * pasynUser, epicsInt32 *low, epicsInt32 *high);
    71. static asynInt32 asynI32;
    72.  
    73.  
    74. static int infoDriverInit(const char * pn, double delay, int noAutoConnect, int low, int high)
    75. {
    76. 	infoPvt		*pinfoPvt;
    77. 	char		*portName;
    78. 	asynStatus	status;
    79. 	size_t		nbytes;
    80. 	int		attributes;
    81. 	
    82. 	nbytes = sizeof(infoPvt) + strlen(pn) + 1;
    83. 	pinfoPvt = (infoPvt *)callocMustSucceed(nbytes, sizeof(char), "infoPvt");
    84. 	portName = (char *)(pinfoPvt + 1);
    85. 	strcpy(portName, pn);
    86.  
    87. 	pinfoPvt->device.buffer.low = low;
    88. 	pinfoPvt->device.buffer.high = high;
    89. 	pinfoPvt->device.buffer.value = (low + high) / 2;
    90.  
    91. 	pinfoPvt->portName = portName;
    92. 	pinfoPvt->delay = delay;
    93. 	pinfoPvt->common.interfaceType = asynCommonType;
    94. 	pinfoPvt->common.pinterface = (void *)&asynC;
    95. 	pinfoPvt->common.drvPvt = pinfoPvt;
    96.  
    97. 	attributes = 0;
    98. 	if (delay > 0.0){
    99. 		attributes |= ASYN_CANBLOCK;
    100. 	}
    101.  
    102. 	status = pasynManager->registerPort(portName, attributes, !noAutoConnect, 0, 0);
    103.  
    104. 	if (status != asynSuccess){
    105. 		printf("infoDriverInit registerDriver failed\n");
    106. 		return 0;
    107. 	}
    108.  
    109. 	status = pasynManager->registerInterface(portName, &pinfoPvt->common);
    110. 	if (status != asynSuccess){
    111. 		printf("infoDriverInit registerInterface failed");
    112. 		return 0;
    113. 	}
    114.  
    115.  
    116. 	asynO.write = infoWrite;
    117. 	asynO.read = infoRead;
    118. 	asynO.flush = infoFlush;
    119. 	asynO.setInputEos = setEos;
    120. 	asynO.getInputEos = getEos;
    121. 	pinfoPvt->octet.interfaceType = asynOctetType;
    122. 	pinfoPvt->octet.pinterface = (void *)&asynO;
    123. 	pinfoPvt->octet.drvPvt = pinfoPvt;
    124. 	
    125. 	status = pasynOctetBase->initialize(portName, &pinfoPvt->octet, 1, 1, 0);
    126.  
    127. 	if (status == asynSuccess){
    128. 		status = pasynManager->registerInterruptSource(
    129. 				portName, &pinfoPvt->octet, &pinfoPvt->pasynPvt);
    130. 	}
    131.  
    132. 	if (status != asynSuccess){
    133. 		printf("infoDriverInit registerInterface asynOctet failed\n");
    134. 		return 0;
    135. 	}
    136.  
    137.  
    138. 	asynI32.write = intWrite;
    139. 	asynI32.read  = intRead;
    140. 	asynI32.getBounds = getIntBounds;
    141. 	pinfoPvt->int32.interfaceType = asynInt32Type;
    142. 	pinfoPvt->int32.pinterface = (void *)&asynI32;
    143. 	pinfoPvt->int32.drvPvt = pinfoPvt;
    144.  
    145. 	status =  pasynInt32Base->initialize(portName, &pinfoPvt->int32);
    146.  
    147. 	if (status == asynSuccess){
    148. 		status = pasynManager->registerInterruptSource(
    149. 				portName, &pinfoPvt->int32, &pinfoPvt->pasynInt32Pvt);
    150. 	}
    151.  
    152. 	if (status != asynSuccess){
    153. 		printf("infoDriverInit registerInterface asynInt32 failed\n");
    154. 		return 0;
    155. 	}
    156.  
    157. 	return 0;
    158. }
    159.  
    160. static void report(void *drvPvt, FILE *fp, int details)
    161. {
    162. 	infoPvt * pinfoPvt = (infoPvt *)drvPvt;
    163. 	int i,n;
    164.  
    165. 	fprintf(fp, "infoDriver connected:%s delay = %f\n", 
    166. 			pinfoPvt->connected ? "Yes": "NO",
    167. 			pinfoPvt->delay);
    168. }
    169.  
    170. 	
    171. static asynStatus connect(void *drvPvt, asynUser * pasynUser)
    172. {
    173. 	infoPvt		*pinfoPvt = (infoPvt *)drvPvt;
    174. 	deviceInfo	*pdeviceInfo;
    175. 	int		addr;
    176. 	asynStatus	status;
    177.  
    178. 	status = pasynManager->getAddr(pasynUser, &addr);
    179. 	if (status != asynSuccess) return status;
    180.  
    181. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s infoDriver: connect addr %d\n",
    182. 			pinfoPvt->portName, addr);
    183.  
    184. 	if (pinfoPvt->connected){
    185. 		asynPrint(pasynUser, ASYN_TRACE_ERROR,
    186. 				"%s infoDriver: connect port already connected\n",
    187. 				pinfoPvt->portName);
    188. 		return asynError;
    189. 	}
    190.  
    191. 	if (pinfoPvt->delay > 0.0){
    192. 		epicsThreadSleep(pinfoPvt->delay * 10.);
    193. 	}
    194. 	pinfoPvt->connected = 1;
    195. 	pinfoPvt->device.connected = 1;
    196. 	pasynManager->exceptionConnect(pasynUser);
    197.  
    198. 	return asynSuccess;
    199. }
    200.  
    201. static asynStatus disconnect(void *drvPvt, asynUser *pasynUser)
    202. {
    203. 	infoPvt		*pinfoPvt = (infoPvt *)drvPvt;
    204. 	deviceInfo 	*pdeviceInfo;
    205. 	int		addr;
    206. 	asynStatus	status;
    207.  
    208. 	status = pasynManager->getAddr(pasynUser, &addr);
    209. 	if (status != asynSuccess) return status;
    210. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s infoDriver: disconnect addr %d\n",
    211. 			pinfoPvt->portName, addr);
    212. 	
    213. 	if (!pinfoPvt->connected){
    214. 		asynPrint(pasynUser, ASYN_TRACE_ERROR,
    215. 				"%s infoDriver: disconnect port not connected\n",
    216. 				pinfoPvt->portName);
    217. 		return asynError;
    218. 	}
    219.  
    220. 	pinfoPvt->connected = 0;
    221. 	pinfoPvt->device.connected = 0;
    222. 	pasynManager->exceptionDisconnect(pasynUser);
    223.  
    224. 	return asynSuccess;
    225. }
    226.  
    227. static asynStatus infoWrite(void *drvPvt, asynUser *pasynUser, 
    228. 		const char *data, size_t nchars, size_t *nbytesTransfered)
    229. {
    230. 	infoPvt		*pinfoPvt = (infoPvt *)drvPvt;
    231. 	deviceInfo	*pdeviceInfo;
    232. 	deviceBuffer	*pdeviceBuffer;
    233. 	int		addr;
    234. 	asynStatus	status;
    235.  
    236. 	//printf("infoWrite: %s\n", data);
    237. 	status = pasynManager->getAddr(pasynUser, &addr);
    238. 	if(status != asynSuccess)	return status;
    239. 	addr = 0;
    240. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: write addr %d\n",
    241. 			pinfoPvt->portName, addr);
    242.  
    243. 	pdeviceInfo = &pinfoPvt->device;
    244. 	if (!pdeviceInfo->connected){
    245. 		asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: write %d not connected\n", pinfoPvt->portName, addr);
    246. 		epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    247. 				"%s infoDriver:write device %d not connected",
    248. 				pinfoPvt->portName, addr);
    249. 		return asynError;
    250. 	}
    251.  
    252. 	if (pinfoPvt->delay > pasynUser->timeout){
    253. 		if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
    254. 		asynPrint(pasynUser, ASYN_TRACE_ERROR, 
    255. 				"%s initDriver write timeout\n", pinfoPvt->portName);
    256. 		epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    257. 				"%s infoDriver write timeout", pinfoPvt->portName);
    258.  
    259. 		return asynTimeout;
    260. 	}
    261.  
    262. 	pdeviceBuffer = &pdeviceInfo->buffer;
    263. 	if(nchars > BUFFERSIZE) nchars = BUFFERSIZE;
    264. 	if(nchars > 0){
    265. 		memcpy(pdeviceBuffer, data, nchars);
    266. 	}
    267. 	asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, data, nchars,
    268. 				"infoWrite nchars %lu\n", (unsigned long)nchars);	
    269. 	pdeviceBuffer->nchars = nchars;
    270. 	if (pinfoPvt->delay > 0.0) {
    271. 		epicsThreadSleep(pinfoPvt->delay);
    272. 	}
    273. 	*nbytesTransfered = nchars;
    274. 	return status;
    275. }
    276.  
    277. static asynStatus infoRead(void *drvPvt, asynUser *pasynUser, char *data,
    278. 		size_t maxchars, size_t *nbytesTransfered,int *eomReason)
    279. {
    280. 	infoPvt		*pinfoPvt = (infoPvt *)drvPvt;
    281. 	deviceInfo	*pdeviceInfo;
    282. 	deviceBuffer	*pdeviceBuffer;
    283. 	char		*pfrom, *pto;
    284. 	char		thisChar;
    285. 	size_t		nremaining;
    286. 	size_t		nout = 0;
    287. 	int		addr;
    288. 	asynStatus	status;
    289.  
    290. 	if (eomReason) *eomReason = 0;
    291. 	if (nbytesTransfered) *nbytesTransfered = 0;
    292. 	status = pasynManager->getAddr(pasynUser, &addr);
    293. 	addr = 0;
    294.  
    295. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, 
    296. 			"%s infoDriver: read addr %d\n", pinfoPvt->portName, addr);
    297. 	pdeviceInfo = &pinfoPvt->device;
    298. 	if (!pdeviceInfo->connected){
    299. 		asynPrint(pasynUser, ASYN_TRACE_ERROR, 
    300. 				"%s infoDriver: read device %d not connected\n",
    301. 				pinfoPvt->portName, addr);
    302. 		epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    303. 				"%s infoDriver:read device %d not connected",
    304. 				pinfoPvt->portName, addr);
    305.  
    306. 		return asynError;
    307. 	}
    308.  
    309. 	if (pinfoPvt->delay > pasynUser->timeout){
    310. 		if (pinfoPvt->delay > 0.0){
    311. 			epicsThreadSleep(pasynUser->timeout);
    312. 		}
    313. 		asynPrint(pasynUser, ASYN_TRACE_ERROR, 
    314. 				"%s infoDriver read timeout\n", pinfoPvt->portName);
    315. 		epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    316. 				"%s infoDriver read timeout", pinfoPvt->portName);
    317. 		return asynTimeout;
    318. 	}
    319.  
    320. 	if (pinfoPvt->delay > 0.0){
    321. 		epicsThreadSleep(pinfoPvt->delay);
    322. 	}
    323.  
    324. 	pdeviceBuffer = &pdeviceInfo->buffer;
    325. 	nremaining = pdeviceBuffer->nchars;
    326. 	pdeviceBuffer->nchars = 0;
    327. 	pfrom = pdeviceBuffer->buffer;
    328. 	pto = data;
    329.  
    330. 	while (nremaining >0 && nout < maxchars){
    331. 		thisChar = *pto++ = *pfrom++;
    332. 		nremaining--;
    333. 		nout++;
    334.  
    335. 		if (pinfoPvt->eoslen > 0){
    336. 			if (thisChar == pinfoPvt->eos[0]){
    337. 				if (pinfoPvt->eoslen == 1){
    338. 					if (eomReason) * eomReason |= ASYN_EOM_EOS;
    339. 					break;
    340. 				}
    341. 			}
    342. 			if (nremaining == 0){
    343. 				if (eomReason) *eomReason |= ASYN_EOM_CNT;
    344. 				break;	
    345. 			}
    346.  
    347. 			if (* pfrom == pinfoPvt->eos[1]){
    348. 				*pto++ = *pfrom++;
    349. 				nremaining--;
    350. 				nout++;
    351.  
    352. 				if (eomReason){
    353. 					*eomReason |= ASYN_EOM_EOS;
    354. 					if(nremaining == 0){
    355. 						*eomReason |= ASYN_EOM_CNT;
    356. 						break;
    357. 					}
    358. 				}
    359. 			}
    360. 		}
    361. 	}
    362.  
    363. 	if (nbytesTransfered) *nbytesTransfered = nout;
    364. 	if (eomReason){
    365. 		if (*nbytesTransfered >= maxchars) *eomReason |= ASYN_EOM_CNT;
    366. 		if (nremaining == 0) * eomReason |= ASYN_EOM_END;
    367. 	}
    368.  
    369. 	pasynOctetBase->callInterruptUsers(pasynUser, pinfoPvt->pasynPvt, data,
    370. 			nbytesTransfered, eomReason);
    371. 	asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, data, nout,
    372. 			"infoRead nbytesTransfered %lu\n", (unsigned long)*nbytesTransfered);
    373. 	return status;
    374. }
    375.  
    376. static asynStatus infoFlush(void *drvPvt, asynUser * pasynUser)
    377. {
    378. 	infoPvt *pinfoPvt = (infoPvt *)drvPvt;
    379. 	deviceInfo *pdeviceInfo;
    380. 	deviceBuffer * pdeviceBuffer;
    381. 	int addr;
    382. 	asynStatus status;
    383.  
    384. 	status = pasynManager->getAddr(pasynUser, &addr);
    385. 	if (status != asynSuccess) return status;
    386.  
    387. 	addr = 0;
    388.  
    389. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, 
    390. 			"%s initDriver: flush addr %d\n",
    391. 			pinfoPvt->portName, addr);
    392.  
    393. 	pdeviceInfo = &pinfoPvt->device;
    394. 	if (!pdeviceInfo->connected){
    395. 		asynPrint(pasynUser, ASYN_TRACE_ERROR, 
    396. 				"%s initDriver:flush device %d not connected\n",
    397. 				pinfoPvt->portName, addr);
    398. 		return -1;
    399. 	}
    400.  
    401. 	pdeviceBuffer = &pdeviceInfo->buffer;
    402. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s infoDriver\n", pinfoPvt->portName);
    403. 	pdeviceBuffer->nchars = 0;
    404.  
    405. 	return asynSuccess;
    406. }
    407.  
    408. static asynStatus setEos(void *drvPvt, asynUser * pasynUser, const char *eos, int eoslen)
    409. {
    410. 	infoPvt * pinfoPvt = (infoPvt *)drvPvt;
    411. 	int i;
    412.  
    413. 	if (eoslen > 2 || eoslen < 0){
    414. 		epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    415. 				"setEos illegal eoslen %d", eoslen);
    416. 		return asynError;
    417. 	}
    418.  
    419. 	pinfoPvt->eoslen = eoslen;
    420. 	for (i = 0; i < eoslen; i++){
    421. 		pinfoPvt->eos[i] = eos[i];
    422. 	}
    423.  
    424. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s setEos\n", pinfoPvt->portName);
    425. 	return asynSuccess;
    426. }
    427.  
    428. static asynStatus getEos(void *drvPvt, asynUser * pasynUser,char *eos, int eossize, int *eoslen)
    429. {
    430. 	infoPvt * pinfoPvt = (infoPvt *)drvPvt;
    431. 	int i;
    432.  
    433. 	* eoslen = pinfoPvt->eoslen;
    434. 	
    435. 	for (i = 0; i < *eoslen; i++){
    436. 		eos[i] = pinfoPvt->eos[i];
    437. 	}
    438.  
    439. 	asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s setEos\n", 
    440. 			pinfoPvt->portName);
    441.  
    442. 	return asynSuccess;
    443. }
    444.  
    445. static asynStatus intWrite(void *drvPvt, asynUser * pasynUser, epicsInt32 value)
    446. {
    447. 	 infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
    448.          deviceInfo      *pdeviceInfo;
    449.          deviceBuffer    *pdeviceBuffer;
    450.          int             addr;
    451.          asynStatus      status;
    452.  
    453.          //printf("infoWrite: %s\n", data);
    454.          status = pasynManager->getAddr(pasynUser, &addr);
    455.          if(status != asynSuccess)       return status;
    456.          addr = 0;
    457.          asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: intWrite addr %d\n",
    458.                          pinfoPvt->portName, addr);
    459.          pdeviceInfo = &pinfoPvt->device;
    460.          if (!pdeviceInfo->connected){
    461.                 asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: intWrite %d not connected\n", pinfoPvt->portName, addr);
    462.                 epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    463.                                  "%s infoDriver:intWrite device %d not connected",
    464.                                  pinfoPvt->portName, addr);
    465.                  return asynError;
    466.          }
    467.  
    468.          if (pinfoPvt->delay > pasynUser->timeout){
    469.                  if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
    470.                  asynPrint(pasynUser, ASYN_TRACE_ERROR,
    471.                                  "%s initDriver intWrite timeout\n", pinfoPvt->portName);
    472.                  epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    473.                                  "%s infoDriver intWrite timeout", pinfoPvt->portName);
    474.  
    475.                  return asynTimeout;
    476.          }
    477.  
    478.          pdeviceBuffer = &pdeviceInfo->buffer;
    479. 	 if (value < pdeviceBuffer->low){
    480. 		pdeviceBuffer->value = pdeviceBuffer->low;
    481. 	 }
    482. 	 else if (value > pdeviceBuffer->high){
    483. 	 	pdeviceBuffer->value = pdeviceBuffer->high;
    484. 	 }
    485. 	 else{
    486. 	 	pdeviceBuffer->value = value;
    487. 	 }
    488.  
    489.          asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, "Write to device", strlen("Write to device"),
    490.                                  "intWrite value = %d\n", pdeviceBuffer->value);
    491.          if (pinfoPvt->delay > 0.0) {
    492.                  epicsThreadSleep(pinfoPvt->delay);
    493.          }
    494.          return status;
    495. }
    496.  
    497. static asynStatus intRead(void *drvPvt, asynUser * pasynUser, epicsInt32 *value)
    498. {
    499. 	 infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
    500.          deviceInfo      *pdeviceInfo;
    501.          deviceBuffer    *pdeviceBuffer;
    502.          int             addr;
    503.          asynStatus      status;
    504.  
    505.          //printf("infoRead: %s\n", data);
    506.          status = pasynManager->getAddr(pasynUser, &addr);
    507.          if(status != asynSuccess)       return status;
    508.          addr = 0;
    509.          asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: intRead addr %d\n",
    510.                          pinfoPvt->portName, addr);
    511.          pdeviceInfo = &pinfoPvt->device;
    512.          if (!pdeviceInfo->connected){
    513.                 asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: intRead %d not connected\n", pinfoPvt->portName, addr);
    514.                 epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    515.                                  "%s infoDriver:intRead device %d not connected",
    516.                                  pinfoPvt->portName, addr);
    517.                  return asynError;
    518.          }
    519.  
    520.          if (pinfoPvt->delay > pasynUser->timeout){
    521.                  if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
    522.                  asynPrint(pasynUser, ASYN_TRACE_ERROR,
    523.                                  "%s initDriver intRead timeout\n", pinfoPvt->portName);
    524.                  epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    525.                                  "%s infoDriver intRead timeout", pinfoPvt->portName);
    526.  
    527.                  return asynTimeout;
    528.          }
    529.  
    530.          pdeviceBuffer = &pdeviceInfo->buffer;
    531. 	 * value = pdeviceBuffer->value;
    532.  
    533.          asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, "Read from device", strlen("Read from device"),
    534.                                  "intRead value = %d\n", pdeviceBuffer->value);
    535.          if (pinfoPvt->delay > 0.0) {
    536.                  epicsThreadSleep(pinfoPvt->delay);
    537.          }
    538.          return status;
    539. }
    540.  
    541.  
    542. static asynStatus getIntBounds(void *drvPvt, asynUser * pasynUser, epicsInt32 *low, epicsInt32 *high)
    543. {
    544. 	 infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
    545.          deviceInfo      *pdeviceInfo;
    546.          deviceBuffer    *pdeviceBuffer;
    547.          int             addr;
    548.          asynStatus      status;
    549.  
    550.          //printf("getIntBounds: %s\n", data);
    551.          status = pasynManager->getAddr(pasynUser, &addr);
    552.          if(status != asynSuccess)       return status;
    553.          addr = 0;
    554.          asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: getIntBounds addr %d\n",
    555.                          pinfoPvt->portName, addr);
    556.          pdeviceInfo = &pinfoPvt->device;
    557.          if (!pdeviceInfo->connected){
    558.                 asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: getIntBounds %d not connected\n", pinfoPvt->portName, addr);
    559.                 epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    560.                                  "%s infoDriver:getIntBounds device %d not connected",
    561.                                  pinfoPvt->portName, addr);
    562.                  return asynError;
    563.          }
    564.  
    565.          if (pinfoPvt->delay > pasynUser->timeout){
    566.                  if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
    567.                  asynPrint(pasynUser, ASYN_TRACE_ERROR,
    568.                                  "%s initDriver getIntBounds timeout\n", pinfoPvt->portName);
    569.                  epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
    570.                                  "%s infoDriver getIntBounds timeout", pinfoPvt->portName);
    571.  
    572.                  return asynTimeout;
    573.          }
    574.  
    575.          pdeviceBuffer = &pdeviceInfo->buffer;
    576. 	 * low = pdeviceBuffer->low;
    577. 	 * high = pdeviceBuffer->high;
    578.  
    579.          asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, "get limits from device", strlen("get limits from device"),
    580.                                  "getIntBounds low = %d, high = %d\n", pdeviceBuffer->low, pdeviceBuffer->high);
    581.          return status;
    582. }
    583.  
    584. // static int infoDriverInit(const char * portName, double delay, int noAutoConnect, int low, int high);
    585. static const iocshArg infoDriverInitArg0 = { "portName", iocshArgString };
    586. static const iocshArg infoDriverInitArg1 = { "delay", iocshArgDouble };
    587. static const iocshArg infoDriverInitArg2 = { "noautoconnect", iocshArgInt };
    588. static const iocshArg infoDriverInitArg3 = { "low", iocshArgInt };
    589. static const iocshArg infoDriverInitArg4 = { "high", iocshArgInt };
    590.  
    591. static const iocshArg *infoDriverInitArgs[] = {
    592.     &infoDriverInitArg0,&infoDriverInitArg1,
    593.     &infoDriverInitArg2,&infoDriverInitArg3, &infoDriverInitArg4};
    594.  
    595. static const iocshFuncDef infoDriverInitFuncDef = {
    596.     "infoDriverInit", 5, infoDriverInitArgs};
    597.  
    598. static void infoDriverInitCallFunc(const iocshArgBuf *args)
    599. {
    600.     infoDriverInit(args[0].sval,args[1].dval,args[2].ival,args[3].ival, args[4].ival);
    601. }
    602.  
    603. static void infoDriverRegister(void)
    604. {
    605.     static int firstTime = 1;
    606.     if (firstTime) {
    607.         firstTime = 0;
    608.         iocshRegister(&infoDriverInitFuncDef, infoDriverInitCallFunc);
    609.     }
    610. }
    611.  
    612. epicsExportRegistrar(infoDriverRegister);

    将以上程序添加到应用程序的dbd文件如下：device.dbd

    registrar(infoDriverRegister)

     将以上device.c和device.dbd文件添加到相同目录下Makefile中，并且添加所需的其它库文件：

    1. ...
    2. # dbd文件
    3. infoDriver_DBD += asyn.dbd
    4. infoDriver_DBD += device.dbd
    5. # 库文件
    6. infoDriver_LIBS += asyn
    7. # 源文件
    8. infoDriver_SRCS += device.c
    9.  
    10. ...

    回到这个IOC的顶层目录，执行make命令，进行编译。

    进入这个点IOC程序的启动目录中，在st.cmd脚本中按定义的格式调用infoDriverInit：

    1. #!../../bin/linux-aarch64/infoDriver
    2.  
    3. #- You may have to change infoDriver to something else
    4. #- everywhere it appears in this file
    5.  
    6. < envPaths
    7.  
    8. cd "${TOP}"
    9.  
    10. ## Register all support components
    11. dbLoadDatabase "dbd/infoDriver.dbd"
    12. infoDriver_registerRecordDeviceDriver pdbbase
    13.  
    14. infoDriverInit("MyPort", 0.5, 0, 0, 1000)
    15. dbLoadRecords("$(ASYN)/db/asynRecord.db","P=Asyn:,R=AsynRecord,PORT=MyPort,ADDR=0,OMAX=0,IMAX=0")
    16.  
    17. cd "${TOP}/iocBoot/${IOC}"
    18. iocInit

    启动这个IOC程序：

    1. root@orangepi5:/usr/local/EPICS/program/infoDriver/iocBoot/iocinfoDriver# ../../bin/linux-aarch64/infoDriver st.cmd
    2. #!../../bin/linux-aarch64/infoDriver
    3. < envPaths
    4. epicsEnvSet("IOC","iocinfoDriver")
    5. epicsEnvSet("TOP","/usr/local/EPICS/program/infoDriver")
    6. epicsEnvSet("SUPPORT","/usr/local/EPICS/synApps/support")
    7. epicsEnvSet("ASYN","/usr/local/EPICS/synApps/support/asyn")
    8. epicsEnvSet("EPICS_BASE","/usr/local/EPICS/base")
    9. cd "/usr/local/EPICS/program/infoDriver"
    10. ## Register all support components
    11. dbLoadDatabase "dbd/infoDriver.dbd"
    12. infoDriver_registerRecordDeviceDriver pdbbase
    13. infoDriverInit("MyPort", 0.5, 0, 0, 1000)
    14. cd "/usr/local/EPICS/program/infoDriver/iocBoot/iocinfoDriver"
    15. iocInit
    16. Starting iocInit
    17. ############################################################################
    18. ## EPICS R7.0.7
    19. ## Rev. 2023-05-26T09:07+0000
    20. ## Rev. Date build date/time:
    21. ############################################################################
    22. iocRun: All initialization complete
    23. epics>

    在epics命令提示环境中测试以上部分asyn诊断命令： 

    1. epics> asynOctetConnect("myid","MyPort",0,1,20)
    2. epics> asynOctetWrite("myid","HelloWorld")
    3. epics> asynOctetRead("myid")
    4. eomReason 0x4
    5. HelloWorld
    6. epics> asynOctetWriteRead("myid","This is a test")
    7. eomReason 0x4
    8. This is a test
    9. epics> asynOctetDisconnect("myid")
    10. epics> asynReport(1,"MyPort")
    11. MyPort multiDevice:No canBlock:Yes autoConnect:Yes
    12.     enabled:Yes connected:Yes numberConnects 1
    13.     nDevices 0 nQueued 0 blocked:No
    14.     asynManagerLock:No synchronousLock:No
    15.     exceptionActive:No exceptionUsers 1 exceptionNotifys 0
    16.     traceMask:0x1 traceIOMask:0x0 traceInfoMask:0x1
    17. infoDriver connected:Yes delay = 0.500000
    1. epics>  asynSetTraceMask("MyPort",-1, ASYN_TRACE_ERROR|ASYN_TRACE_FLOW)
    2. epics> asynOctetWrite("myid","HelloWorld")
    3. 2023/09/05 12:55:25.521 MyPort asynManager::queueLockPort locking port
    4. 2023/09/05 12:55:25.522 MyPort asynManager::queueLockPort taking mutex 0x55702ab790
    5. 2023/09/05 12:55:25.522 MyPort asynManager::queueLockPort queueing request
    6. 2023/09/05 12:55:25.523 MyPort addr -1 queueRequest priority 0 not lockHolder
    7. 2023/09/05 12:55:25.524 MyPort schedule queueRequest timeout in 2.000000 seconds
    8. 2023/09/05 12:55:25.525 MyPort asynManager::queueLockPort waiting for event
    9. 2023/09/05 12:55:25.526 asynManager::portThread port=MyPort callback
    10. 2023/09/05 12:55:25.526 MyPort asynManager::queueLockPortCallback signaling begin event
    11. 2023/09/05 12:55:25.526 MyPort asynManager::queueLockPortCallback waiting for mutex from queueUnlockPort
    12. 2023/09/05 12:55:25.526 MyPort asynManager::queueLockPort got event from callback
    13. 2023/09/05 12:55:25.528 MyPort initDriver: write addr 0
    14. 2023/09/05 12:55:26.028 MyPort queueUnlockPort
    15. 2023/09/05 12:55:26.030 MyPort asynManager::queueUnlockPort waiting for event
    16. 2023/09/05 12:55:26.031 MyPort queueUnlockPort unlock mutex 0x55702ab790 complete.
    17. epics>  asynOctetRead("myid")
    18. 2023/09/05 12:56:12.292 MyPort asynManager::queueLockPort locking port
    19. 2023/09/05 12:56:12.293 MyPort asynManager::queueLockPort taking mutex 0x55702ab790
    20. 2023/09/05 12:56:12.293 MyPort asynManager::queueLockPort queueing request
    21. 2023/09/05 12:56:12.293 MyPort addr -1 queueRequest priority 0 not lockHolder
    22. 2023/09/05 12:56:12.294 MyPort schedule queueRequest timeout in 2.000000 seconds
    23. 2023/09/05 12:56:12.295 MyPort asynManager::queueLockPort waiting for event
    24. 2023/09/05 12:56:12.296 asynManager::portThread port=MyPort callback
    25. 2023/09/05 12:56:12.296 MyPort asynManager::queueLockPortCallback signaling begin event
    26. 2023/09/05 12:56:12.296 MyPort asynManager::queueLockPortCallback waiting for mutex from queueUnlockPort
    27. 2023/09/05 12:56:12.296 MyPort asynManager::queueLockPort got event from callback
    28. 2023/09/05 12:56:12.296 MyPort infoDriver: read addr 0
    29. 2023/09/05 12:56:12.797 MyPort queueUnlockPort
    30. 2023/09/05 12:56:12.797 MyPort asynManager::queueUnlockPort waiting for event
    31. 2023/09/05 12:56:12.798 MyPort queueUnlockPort unlock mutex 0x55702ab790 complete.
    32. eomReason 0x4
    33. HelloWorld

    使用asyRecord.adl进行测试：

    medm -x -macro "P=Asyn:,R=AsynRecord" asynRecord.adl

    出现以下窗口：

    选择More...菜单的asynOctet Interface I/O：

     弹出以下窗口，在Out的ASCII文本框中输入一个字符串，这里为HelloWord，按回车，可以看到Input的ASCII文本框中显示读回的HelloWorld，并且EOM reason中显示字符串结束的原因。

    选择More...菜单的Register Interface I/O，弹出以下窗口，将Interface下的菜单选中asynInt32，在Output文本框中输入一个数值68，按回车后，在Input文本框中回读到这个数值：

    补充一个记录实例文件：

    1. record(calc,"$(P)$(R)_P$(PORT)_A$(A)_calc") {
    2.     field(DESC, "Counter")
    3.     field(SCAN,"Passive")
    4.     field(CALC, "(A<99)?(A+1):0")
    5.     field(INPA,"$(P)$(R)_P$(PORT)_A$(A)_calc NPP NMS")
    6.     field(FLNK,"$(P)$(R)_P$(PORT)_A$(A)_so")
    7.     field(EGU, "Counts")
    8.     field(HOPR, "10")
    9.     field(FLNK,"$(P)$(R)_P$(PORT)_A$(A)_so")
    10. }
    11.  
    12. record(stringout,"$(P)$(R)_P$(PORT)_A$(A)_so") {
    13.     field(DOL,"$(P)$(R)_P$(PORT)_A$(A)_calc NPP NMS")
    14.     field(OMSL,"closed_loop")
    15.     field(FLNK,"$(P)$(R)_P$(PORT)_A$(A)_si")
    16. }
    17.  
    18. record(stringin,"$(P)$(R)_P$(PORT)_A$(A)_si") {
    19.     field(DTYP,"asynOctetWriteRead")
    20.     field(INP,"@asyn($(PORT),$(A)) $(P)$(R)_P$(PORT)_A$(A)_so")
    21. }

    以上实例文件运行过程为：当calc记录运行时，其从自己的VAL读取一个值，如果这个数值小于99就VAL增加1，否则VAL变为0，在运行结束前，通过FLNK使stringout记录运行，stringout从calc记录的VAL字段读取一个值，将其转换成字符串表示形式，存入到自己的VAL字段，并且在运行结束前，通过FLNK使得stringin记录运行，当stringin运行时，通过接口asynOctetWriteRead设备支持，将从stringout读取的字符串写入到端口驱动程序中，然后从端口驱动中回读字符串，写入到自己的VAL字段中。 

     将以下记录加载命令，添加到st.cmd启动脚本文件的iocInit前：

    dbLoadRecords("db/test.db", "P=Test:,R=Client,PORT=MyPort,A=0")

     重启这个IOC，用dbl命令查看加载的记录：

    1. epics>dbl
    2. Asyn:AsynRecord
    3. Test:Client_PMyPort_A0_calc
    4. Test:Client_PMyPort_A0_si
    5. Test:Client_PMyPort_A0_so

     用CSS进行以上记录运行的显示：

    asynRegisterTimeStampSource：为指定端口调用pasynManager->registerTimeStampSource。时间戳源函数必须在这个程序的dbd文件中被定义为"函数"。

    asynReisgerTimeStampSource：为指定端口调用pasynManager->unregisterTimeStampSource。这恢复成asynManager中默认的时间戳源函数。

  • 相关阅读:
    如何利用大模型蒸馏出小模型实现降本
    DICOM图像像素值、灰度值与CT值的解释及关系
    外贸软件助力国际贸易企业业财共享数字化转型升级
    【webrtc】PC ： BaseChannel 及子类VideoChannel 和 VoiceChannel ：关联source、sink，关联MediaEngine子类，实现RTP包收发
    企业如何利用APS排程软件建立起精益供应链与生产体系
    C++一行代码实现任意系统函数Hook
    基于车路协同功能的路侧及车载智能设备研究
    pycharm中出现这个的原因是什么，如何解决？
    基于Nodejs的知识信息分享平台的设计和实现
    设计模式-工厂方法模式
  • 原文地址：https://blog.csdn.net/yuyuyuliang00/article/details/132670336