ISIS Logo
ISISBEAM
ISIS Beam Information
isisbeamDriver.cpp
Go to the documentation of this file.
1 #include <stdlib.h>
2 #include <string.h>
3 #include <stdio.h>
4 #include <errno.h>
5 #include <math.h>
6 #include <exception>
7 #include <iostream>
8 #include <map>
9 #include <string>
10 
11 #include <epicsTypes.h>
12 #include <epicsTime.h>
13 #include <epicsThread.h>
14 #include <epicsString.h>
15 #include <epicsTimer.h>
16 #include <epicsMutex.h>
17 #include <epicsEvent.h>
18 #include <iocsh.h>
19 
20 #include "isisbeamDriver.h"
21 
22 #include <macLib.h>
23 #include <epicsGuard.h>
24 
25 #include <epicsExport.h>
26 
27 #include "1st_nd_post.h"
28 
29 static epicsThreadOnceId onceId = EPICS_THREAD_ONCE_INIT;
30 
32 
33 //Copied from relay_server.c to format the shutter status info
34 static char* ts2_shutter_status(int stat)
35 {
36  switch( stat & 0xff )
37  {
38  case 0:
39  /* return "DEACTIVE"; */
40  return "DEACT";
41  break;
42  case 1:
43  return "OPEN";
44  break;
45  case 2:
46  return "CLOSED";
47  break;
48  case 3:
49  return "MOVING";
50  break;
51  case 4:
52  return "FAULT";
53  break;
54  default:
55  return "INVALID";
56  break;
57  }
58  return "INVALID"; /*NOTREACHED*/
59 }
60 
61 static char* ts2_shutter_mode(int stat)
62 {
63  switch( (stat >> 8) & 0xff )
64  {
65  case 0:
66  return "DEACT";; // De-Activated
67  break;
68  case 1:
69  return "MANUAL"; // Manual (Control Room HMI)
70  break;
71  case 2:
72  return "REM-MANUAL"; // Remote Manual (used for shutter scanning)
73  break;
74  case 3:
75  return "STC"; // Shield Top Control (used for maintenance)
76  break;
77  case 4:
78  return "OPENING-BLR"; // Opening (beam line request)
79  break;
80  case 5:
81  return "CLOSING-BLR"; // Closing (beam line request)
82  break;
83  case 6:
84  return "POS-CORR"; // Position Correction
85  break;
86  case 7:
87  return "OPENING-CR"; // Opening (control Room HMI request)
88  break;
89  case 8:
90  return "CLOSING-CR"; // Closing (control Room HMI request)
91  break;
92  case 9:
93  return "EMG-CLOSE"; // Emergency Close (control Room HMI request)
94  break;
95  case 98:
96  return "BLC"; // Beam Line Control (no auto correction)
97  break;
98  case 99:
99  return "BLC"; // Beam Line Control (with auto correction)
100  break;
101  default:
102  return "INVALID";
103  break;
104 
105  }
106  return "INVALID"; /*NOTREACHED*/
107 }
108 
109 static char* ts2_vat_status(int stat)
110 {
111  switch(stat)
112  {
113  case 0:
114  /* return "DEACTIVE"; */
115  return "DEACT";
116  break;
117  case 1:
118  return "OPEN";
119  break;
120  case 2:
121  return "MOVING";
122  break;
123  case 3:
124  return "CLOSED";
125  break;
126  case 4:
127  return "FAULT";
128  break;
129  default:
130  return "INVALID";
131  break;
132  }
133  return "INVALID"; /*NOTREACHED*/
134 }
135 
136 static char* ts1_shutter_status(int stat, int beamline)
137 {
138  switch( stat & (1 << (beamline - 1)) )
139  {
140  case 0:
141  return "CLOSED";
142  break;
143  default:
144  return "OPEN";
145  break;
146  }
147  return "INVALID"; /*NOTREACHED*/
148 }
149 
150 static void initCOM(void*)
151 {
152 // CoInitializeEx(NULL, COINIT_MULTITHREADED);
153 }
154 
155 static const char *driverName="isisbeamDriver";
156 
157 #define MAX_ASYN_BL_PARAMS 300
158 
159 isisbeamDriver::isisbeamDriver(const char *portName)
163  : asynPortDriver(portName,
164  0, /* maxAddr */
165  MAX_ASYN_BL_PARAMS,
166  asynInt32Mask | asynFloat64Mask | asynOctetMask | asynDrvUserMask, /* Interface mask */
167  asynInt32Mask | asynFloat64Mask | asynOctetMask, /* Interrupt mask */
168  ASYN_CANBLOCK, /* asynFlags. This driver can block but it is not multi-device */
169  1, /* Autoconnect */
170  0, /* Default priority */
171  0) /* Default stack size*/
172 {
173  epicsThreadOnce(&onceId, initCOM, NULL);
174 
175  const char *functionName = "isisbeamDriver";
176 
177  createParam(P_BeamTS1String, asynParamFloat64, &P_BeamTS1);
178  createParam(P_BeamTS2String, asynParamFloat64, &P_BeamTS2);
179  createParam(P_BeamEPB1String, asynParamFloat64, &P_BeamEPB1);
180  createParam(P_MethaneTS1String, asynParamFloat64, &P_MethaneTS1);
181  createParam(P_HydrogenTS1String, asynParamFloat64, &P_HydrogenTS1);
182  createParam(P_BeamSynchString, asynParamFloat64, &P_BeamSynch);
183  createParam(P_FreqSynchString, asynParamFloat64, &P_FreqSynch);
184  createParam(P_TotalTS1String, asynParamFloat64, &P_TotalTS1);
185  createParam(P_FreqTS2String, asynParamFloat64, &P_FreqTS2);
186  createParam(P_TotalTS2String, asynParamFloat64, &P_TotalTS2);
187  createParam(P_DeMethaneTS2String, asynParamFloat64, &P_DeMethaneTS2);
188  createParam(P_MethaneTS2String, asynParamFloat64, &P_MethaneTS2);
189  createParam(P_HydrogenTS2String, asynParamFloat64, &P_HydrogenTS2);
190  createParam(P_MuonKickString, asynParamFloat64, &P_MuonKick);
191  createParam(P_DmodRunTS2String, asynParamFloat64, &P_DmodRunTS2);
192  createParam(P_DmodRunLimTS2String, asynParamFloat64, &P_DmodRunLimTS2);
193  createParam(P_BeamDmodTS2String, asynParamFloat64, &P_BeamDmodTS2);
194  createParam(P_DmodAnnLowTS2String, asynParamFloat64, &P_DmodAnnLowTS2);
195  createParam(P_OnTS1String, asynParamOctet, &P_OnTS1);
196  createParam(P_OffTS1String, asynParamOctet, &P_OffTS1);
197  createParam(P_OnTS2String, asynParamOctet, &P_OnTS2);
198  createParam(P_OffTS2String, asynParamOctet, &P_OffTS2);
199  createParam(P_InstTS1String, asynParamOctet, &P_InstTS1);
200  createParam(P_InstTS2String, asynParamOctet, &P_InstTS2);
201  createParam(P_OsirisCryomagString, asynParamInt32, &P_OsirisCryomag);
202  createParam(P_UpdateTimeString, asynParamOctet, &P_UpdateTime);
203  createParam(P_UpdateTimeTString, asynParamInt32, &P_UpdateTimeT);
204  // create beamline specific parameters (shutter status, shutter mode, VAT valve)
205  // assigns a default "unavailable" value to each as not all are available on every beamline
206  // make sure MAX_ASYN_BL_PARAMS is big enough
207  const char* axes = "NSWE";
208  char buff[32];
209  int id;
210  for(int i=1; i<=9; ++i)
211  {
212  for(int j=0; j<4; ++j)
213  {
214  sprintf(buff, "SHUT_%c%d", axes[j], i);
215  createParam(buff, asynParamOctet, &id);
216  setStringParam(id, "N/A");
217  m_blparams[buff] = id;
218  sprintf(buff, "VAT_%c%d", axes[j], i);
219  createParam(buff, asynParamOctet, &id);
220  setStringParam(id, "N/A");
221  m_blparams[buff] = id;
222  sprintf(buff, "SMODE_%c%d", axes[j], i);
223  createParam(buff, asynParamOctet, &id);
224  setStringParam(id, "N/A");
225  m_blparams[buff] = id;
226  }
227  }
228  // Create the thread for background tasks (not used at present, could be used for I/O intr scanning)
229  if (epicsThreadCreate("isisbeamPoller",
230  epicsThreadPriorityMedium,
231  epicsThreadGetStackSize(epicsThreadStackMedium),
232  (EPICSTHREADFUNC)pollerThreadC, this) == 0)
233  {
234  printf("%s:%s: epicsThreadCreate failure\n", driverName, functionName);
235  return;
236  }
237 }
238 
239 asynStatus isisbeamDriver::readFloat64(asynUser *pasynUser, epicsFloat64 *value)
240 {
241 // pasynUser->timeStamp = m_timestamp;
242  return asynPortDriver::readFloat64(pasynUser, value);
243 }
244 
245 
246 void isisbeamDriver::pollerThreadC(void* arg)
247 {
248  isisbeamDriver* driver = (isisbeamDriver*)arg;
249  driver->pollerThread();
250 }
251 
252 #define LEN_BUFFER 10024
253 
254 void isisbeamDriver::pollerThread()
255 {
256  static const char* functionName = "isisbeamPoller";
257  static char buffer[LEN_BUFFER+1];
258  SOCKET sd = setup_udp_socket(ND_BROADCAST_PORT1, 0);
259  int n,v;
260  char* tmp;
261  struct tm* pstm;
262  time_t timer;
263  double beamts1, beamts2, beamepb1, mtempts1, htempts1, beamsynch, freqsynch, totalts1, freqts2, totalts2, demethanets2, methanets2, hydrogents2, dmodrunts2, dmodrunlimts2, beamdmodts2, muonkick, dmodannlowts2;
264  char *onts1, *offts1, *onts2, *offts2, *e1, *e2, *e3, *e4, *e5, *e6, *e7, *e8, *e9, *w1, *w2, *w3, *w4, *w5, *w6, *w7, *w8, *w9, *n1, *n2, *n3, *n4, *n5, *n6, *n7, *n8, *n9, *s1, *s2, *s3, *s4, *s5, *s6, *s7, *s8, *s9, *em1, *em2, *em3, *em4, *em5, *em6, *em7, *em8, *em9, *wm1, *wm2, *wm3, *wm4, *wm5, *wm6, *wm7, *wm8, *wm9;
265  static char time_buffer[128];
266  int c1, c2, c3, c4, c5, c6, c7, c8, c9;
267 
268  while(true)
269  {
270  n = receive_data_udp(sd, buffer, LEN_BUFFER);
271  if (n > 0)
272  {
273  buffer[n] = '\0';
274  buffer[LEN_BUFFER] = '\0';
275  tmp = xml_parse(buffer, "ISISBEAM");
276  if (tmp == NULL)
277  {
278  tmp = xml_parse(buffer, "ISISBEAM2");
279  if (tmp == NULL)
280  {
281  continue; // ignore anything other than ISISBEAM and ISISBEAM2 packets for moment
282  }
283  free(tmp);
284  tmp = xml_parse(buffer, "TIME");
285  if (tmp == NULL)
286  {
287  continue;
288  }
289  timer = atol(tmp);
290  pstm = localtime(&timer);
291  free(tmp);
292  strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S+0100", pstm);
293  tmp = xml_parse(buffer, "DMOD_RUNTIME"); dmodrunts2 = atof(tmp); free(tmp);
294  tmp = xml_parse(buffer, "DMOD_RUNTIME_LIM"); dmodrunlimts2 = atof(tmp); free(tmp);
295  tmp = xml_parse(buffer, "DMOD_UABEAM"); beamdmodts2 = atof(tmp); free(tmp);
296  tmp = xml_parse(buffer, "DMOD_ANNLOW1"); dmodannlowts2 = atof(tmp); free(tmp);
297  tmp = xml_parse(buffer, "VATE");
298  sscanf(tmp, "%lu %lu %lu %lu %lu %lu %lu %lu %lu", &c1, &c2, &c3, &c4, &c5, &c6, &c7, &c8, &c9);
299  e1 = ts2_vat_status(c1);
300  e2 = ts2_vat_status(c2);
301  e3 = ts2_vat_status(c3);
302  e4 = ts2_vat_status(c4);
303  e5 = ts2_vat_status(c5);
304  e6 = ts2_vat_status(c6);
305  e7 = ts2_vat_status(c7);
306  e8 = ts2_vat_status(c8);
307  e9 = ts2_vat_status(c9);
308  free(tmp);
309  tmp = xml_parse(buffer, "VATW");
310  sscanf(tmp, "%lu %lu %lu %lu %lu %lu %lu %lu %lu", &c1, &c2, &c3, &c4, &c5, &c6, &c7, &c8, &c9);
311  w1 = ts2_vat_status(c1);
312  w2 = ts2_vat_status(c2);
313  w3 = ts2_vat_status(c3);
314  w4 = ts2_vat_status(c4);
315  w5 = ts2_vat_status(c5);
316  w6 = ts2_vat_status(c6);
317  w7 = ts2_vat_status(c7);
318  w8 = ts2_vat_status(c8);
319  w9 = ts2_vat_status(c9);
320  free(tmp);
321  lock();
322  setDoubleParam(P_DmodRunTS2, dmodrunts2);
323  setDoubleParam(P_DmodRunLimTS2, dmodrunlimts2);
324  setDoubleParam(P_BeamDmodTS2, beamdmodts2);
325  setDoubleParam(P_DmodAnnLowTS2, dmodannlowts2);
326  setStringParam(m_blparams["VAT_E1"], e1);
327  setStringParam(m_blparams["VAT_E2"], e2);
328  setStringParam(m_blparams["VAT_E3"], e3);
329  setStringParam(m_blparams["VAT_E4"], e4);
330  setStringParam(m_blparams["VAT_E5"], e5);
331  setStringParam(m_blparams["VAT_E6"], e6);
332  setStringParam(m_blparams["VAT_E7"], e7);
333  setStringParam(m_blparams["VAT_E8"], e8);
334  setStringParam(m_blparams["VAT_E9"], e9);
335  setStringParam(m_blparams["VAT_W1"], w1);
336  setStringParam(m_blparams["VAT_W2"], w2);
337  setStringParam(m_blparams["VAT_W3"], w3);
338  setStringParam(m_blparams["VAT_W4"], w4);
339  setStringParam(m_blparams["VAT_W5"], w5);
340  setStringParam(m_blparams["VAT_W6"], w6);
341  setStringParam(m_blparams["VAT_W7"], w7);
342  setStringParam(m_blparams["VAT_W8"], w8);
343  setStringParam(m_blparams["VAT_W9"], w9);
344  setStringParam(P_UpdateTime, time_buffer);
345  setIntegerParam(P_UpdateTimeT, timer);
346  setStringParam(P_InstTS1, "ALF,ARGUS,CHRONUS,CRISP,EMMA,EMU,ENGINX,EVS,GEM,HIFI,HRPD,INES,IRIS,LOQ,MAPS,MARI,MERLIN,MUSR,OSIRIS,PEARL,POLARIS,"
347  "PRISMA,ROTAX,SANDALS,SURF,SXD,TOSCA,VESUVIO");
348 
349  setStringParam(P_InstTS2, "CHIPIR,IMAT,INTER,LARMOR,LET,NIMROD,OFFSPEC,POLREF,SANS2D,WISH,ZOOM");
350  setIntegerParam(P_OsirisCryomag, 0);
351  callParamCallbacks();
352  unlock();
353  }
354  else
355  {
356  free(tmp);
357  tmp = xml_parse(buffer, "TIME");
358  if (tmp == NULL)
359  {
360  continue;
361  }
362  timer = atol(tmp);
363  pstm = localtime(&timer);
364  free(tmp);
365  strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S+0100", pstm);
366  tmp = xml_parse(buffer, "BEAMT"); beamts1 = atof(tmp); free(tmp);
367  tmp = xml_parse(buffer, "BEAMT2"); beamts2 = atof(tmp); free(tmp);
368  tmp = xml_parse(buffer, "BEAME1"); beamepb1 = atof(tmp); free(tmp);
369  tmp = xml_parse(buffer, "MTEMP"); mtempts1 = atof(tmp); free(tmp);
370  tmp = xml_parse(buffer, "HTEMP"); htempts1 = atof(tmp); free(tmp);
371  tmp = xml_parse(buffer, "BEAMS"); beamsynch = atof(tmp); free(tmp);
372  tmp = xml_parse(buffer, "REPR"); freqsynch = atof(tmp); free(tmp);
373  tmp = xml_parse(buffer, "TS1_TOTAL"); totalts1 = atof(tmp); free(tmp);
374  tmp = xml_parse(buffer, "REPR2"); freqts2 = atof(tmp); free(tmp);
375  tmp = xml_parse(buffer, "TS2_TOTAL"); totalts2 = atof(tmp); free(tmp);
376  tmp = xml_parse(buffer, "T2MTEMP1"); demethanets2 = atof(tmp); free(tmp);
377  tmp = xml_parse(buffer, "T2MTEMP2"); methanets2 = atof(tmp); free(tmp);
378  tmp = xml_parse(buffer, "T2HTEMP1"); hydrogents2 = atof(tmp); free(tmp);
379  tmp = xml_parse(buffer, "MUONKICKER"); muonkick = atof(tmp); free(tmp);
380  onts1 = xml_parse(buffer, "TS1ON");
381  offts1 = xml_parse(buffer, "TS1OFF");
382  onts2 = xml_parse(buffer, "TS2ON");
383  offts2 = xml_parse(buffer, "TS2OFF");
384  tmp = xml_parse(buffer, "SHUTE");
385  sscanf(tmp, "%lu %lu %lu %lu %lu %lu %lu %lu %lu", &c1, &c2, &c3, &c4, &c5, &c6, &c7, &c8, &c9);
386  e1 = ts2_shutter_status(c1);
387  e2 = ts2_shutter_status(c2);
388  e3 = ts2_shutter_status(c3);
389  e4 = ts2_shutter_status(c4);
390  e5 = ts2_shutter_status(c5);
391  e6 = ts2_shutter_status(c6);
392  e7 = ts2_shutter_status(c7);
393  e8 = ts2_shutter_status(c8);
394  e9 = ts2_shutter_status(c9);
395  em1 = ts2_shutter_mode(c1);
396  em2 = ts2_shutter_mode(c2);
397  em3 = ts2_shutter_mode(c3);
398  em4 = ts2_shutter_mode(c4);
399  em5 = ts2_shutter_mode(c5);
400  em6 = ts2_shutter_mode(c6);
401  em7 = ts2_shutter_mode(c7);
402  em8 = ts2_shutter_mode(c8);
403  em9 = ts2_shutter_mode(c9);
404  free(tmp);
405  tmp = xml_parse(buffer, "SHUTW");
406  sscanf(tmp, "%lu %lu %lu %lu %lu %lu %lu %lu %lu", &c1, &c2, &c3, &c4, &c5, &c6, &c7, &c8, &c9);
407  w1 = ts2_shutter_status(c1);
408  w2 = ts2_shutter_status(c2);
409  w3 = ts2_shutter_status(c3);
410  w4 = ts2_shutter_status(c4);
411  w5 = ts2_shutter_status(c5);
412  w6 = ts2_shutter_status(c6);
413  w7 = ts2_shutter_status(c7);
414  w8 = ts2_shutter_status(c8);
415  w9 = ts2_shutter_status(c9);
416  wm1 = ts2_shutter_mode(c1);
417  wm2 = ts2_shutter_mode(c2);
418  wm3 = ts2_shutter_mode(c3);
419  wm4 = ts2_shutter_mode(c4);
420  wm5 = ts2_shutter_mode(c5);
421  wm6 = ts2_shutter_mode(c6);
422  wm7 = ts2_shutter_mode(c7);
423  wm8 = ts2_shutter_mode(c8);
424  wm9 = ts2_shutter_mode(c9);
425  free(tmp);
426  tmp = xml_parse(buffer, "SHUTN");
427  v = atoi((const char *)tmp);
428  n1 = ts1_shutter_status(v, 1);
429  n2 = ts1_shutter_status(v, 2);
430  n3 = ts1_shutter_status(v, 3);
431  n4 = ts1_shutter_status(v, 4);
432  n5 = ts1_shutter_status(v, 5);
433  n6 = ts1_shutter_status(v, 6);
434  n7 = ts1_shutter_status(v, 7);
435  n8 = ts1_shutter_status(v, 8);
436  n9 = ts1_shutter_status(v, 9);
437  free(tmp);
438  tmp = xml_parse(buffer, "SHUTS");
439  v = atoi((const char *)tmp);
440  s1 = ts1_shutter_status(v, 1);
441  s2 = ts1_shutter_status(v, 2);
442  s3 = ts1_shutter_status(v, 3);
443  s4 = ts1_shutter_status(v, 4);
444  s5 = ts1_shutter_status(v, 5);
445  s6 = ts1_shutter_status(v, 6);
446  s7 = ts1_shutter_status(v, 7);
447  s8 = ts1_shutter_status(v, 8);
448  s9 = ts1_shutter_status(v, 9);
449  free(tmp);
450  lock();
451  epicsTimeFromTime_t(&m_timestamp, timer);
452  setDoubleParam(P_BeamTS1, beamts1);
453  setDoubleParam(P_BeamTS2, beamts2);
454  setDoubleParam(P_BeamEPB1, beamepb1);
455  setDoubleParam(P_MethaneTS1, mtempts1);
456  setDoubleParam(P_HydrogenTS1, htempts1);
457  setDoubleParam(P_BeamSynch, beamsynch);
458  setDoubleParam(P_FreqSynch, freqsynch);
459  setDoubleParam(P_TotalTS1, totalts1);
460  setDoubleParam(P_FreqTS2, freqts2);
461  setDoubleParam(P_TotalTS2, totalts2);
462  setDoubleParam(P_DeMethaneTS2, demethanets2);
463  setDoubleParam(P_MethaneTS2, methanets2);
464  setDoubleParam(P_HydrogenTS2, hydrogents2);
465  setDoubleParam(P_MuonKick, muonkick);
466  setStringParam(P_OnTS1, onts1);
467  setStringParam(P_OffTS1, offts1);
468  setStringParam(P_OnTS2, onts2);
469  setStringParam(P_OffTS2, offts2);
470  free(onts1);
471  free(offts1);
472  free(onts2);
473  free(offts2);
474  setStringParam(m_blparams["SHUT_N1"], n1);
475  setStringParam(m_blparams["SHUT_N2"], n2);
476  setStringParam(m_blparams["SHUT_N3"], n3);
477  setStringParam(m_blparams["SHUT_N4"], n4);
478  setStringParam(m_blparams["SHUT_N5"], n5);
479  setStringParam(m_blparams["SHUT_N6"], n6);
480  setStringParam(m_blparams["SHUT_N7"], n7);
481  setStringParam(m_blparams["SHUT_N8"], n8);
482  setStringParam(m_blparams["SHUT_N9"], n9);
483  setStringParam(m_blparams["SHUT_S1"], s1);
484  setStringParam(m_blparams["SHUT_S2"], s2);
485  setStringParam(m_blparams["SHUT_S3"], s3);
486  setStringParam(m_blparams["SHUT_S4"], s4);
487  setStringParam(m_blparams["SHUT_S5"], s5);
488  setStringParam(m_blparams["SHUT_S6"], s6);
489  setStringParam(m_blparams["SHUT_S7"], s7);
490  setStringParam(m_blparams["SHUT_S8"], s8);
491  setStringParam(m_blparams["SHUT_S9"], s9);
492  setStringParam(m_blparams["SHUT_E1"], e1);
493  setStringParam(m_blparams["SHUT_E2"], e2);
494  setStringParam(m_blparams["SHUT_E3"], e3);
495  setStringParam(m_blparams["SHUT_E4"], e4);
496  setStringParam(m_blparams["SHUT_E5"], e5);
497  setStringParam(m_blparams["SHUT_E6"], e6);
498  setStringParam(m_blparams["SHUT_E7"], e7);
499  setStringParam(m_blparams["SHUT_E8"], e8);
500  setStringParam(m_blparams["SHUT_E9"], e9);
501  setStringParam(m_blparams["SHUT_W1"], w1);
502  setStringParam(m_blparams["SHUT_W2"], w2);
503  setStringParam(m_blparams["SHUT_W3"], w3);
504  setStringParam(m_blparams["SHUT_W4"], w4);
505  setStringParam(m_blparams["SHUT_W5"], w5);
506  setStringParam(m_blparams["SHUT_W6"], w6);
507  setStringParam(m_blparams["SHUT_W7"], w7);
508  setStringParam(m_blparams["SHUT_W8"], w8);
509  setStringParam(m_blparams["SHUT_W9"], w9);
510  setStringParam(m_blparams["SMODE_E1"], em1);
511  setStringParam(m_blparams["SMODE_E2"], em2);
512  setStringParam(m_blparams["SMODE_E3"], em3);
513  setStringParam(m_blparams["SMODE_E4"], em4);
514  setStringParam(m_blparams["SMODE_E5"], em5);
515  setStringParam(m_blparams["SMODE_E6"], em6);
516  setStringParam(m_blparams["SMODE_E7"], em7);
517  setStringParam(m_blparams["SMODE_E8"], em8);
518  setStringParam(m_blparams["SMODE_E9"], em9);
519  setStringParam(m_blparams["SMODE_W1"], wm1);
520  setStringParam(m_blparams["SMODE_W2"], wm2);
521  setStringParam(m_blparams["SMODE_W3"], wm3);
522  setStringParam(m_blparams["SMODE_W4"], wm4);
523  setStringParam(m_blparams["SMODE_W5"], wm5);
524  setStringParam(m_blparams["SMODE_W6"], wm6);
525  setStringParam(m_blparams["SMODE_W7"], wm7);
526  setStringParam(m_blparams["SMODE_W8"], wm8);
527  setStringParam(m_blparams["SMODE_W9"], wm9);
528  setStringParam(P_UpdateTime, time_buffer);
529  setIntegerParam(P_UpdateTimeT, timer);
530  callParamCallbacks();
531  unlock();
532  }
533  }
534  else
535  {
536  epicsThreadSleep(3.0);
537  }
538  }
539 }
540 
541 extern "C" {
542 
545 int isisbeamConfigure(const char *portName)
546 {
547  try
548  {
549  new isisbeamDriver(portName);
550  return(asynSuccess);
551  }
552  catch(const std::exception& ex)
553  {
554  std::cerr << "isisbeamDriver failed: " << ex.what() << std::endl;
555  return(asynError);
556  }
557 }
558 
559 // EPICS iocsh shell commands
560 
561 static const iocshArg initArg0 = { "portName", iocshArgString};
562 
563 static const iocshArg * const initArgs[] = { &initArg0 };
564 
565 static const iocshFuncDef initFuncDef = {"isisbeamConfigure", sizeof(initArgs) / sizeof(iocshArg*), initArgs};
566 
567 static void initCallFunc(const iocshArgBuf *args)
568 {
569  isisbeamConfigure(args[0].sval);
570 }
571 
572 static void isisbeamRegister(void)
573 {
574  iocshRegister(&initFuncDef, initCallFunc);
575 }
576 
577 epicsExportRegistrar(isisbeamRegister);
578 
579 }
580 
xml_parse
char * xml_parse(const char *input_string, const char *token)
Definition: 1st_nd_lib.c:467
P_MethaneTS1String
#define P_MethaneTS1String
Definition: isisbeamDriver.h:72
SOCKET
#define SOCKET
Definition: 1st_nd_lib.c:16
ts2_vat_status
static char * ts2_vat_status(int stat)
Definition: isisbeamDriver.cpp:109
P_BeamTS2String
#define P_BeamTS2String
Definition: isisbeamDriver.h:71
ND_BROADCAST_PORT1
#define ND_BROADCAST_PORT1
Definition: 1st_nd_post.h:37
P_BeamEPB1String
#define P_BeamEPB1String
Definition: isisbeamDriver.h:74
P_BeamTS1String
#define P_BeamTS1String
ASYN driver parameter name for TS1 beam current.
Definition: isisbeamDriver.h:70
isisbeamConfigure
int isisbeamConfigure(const char *portName)
EPICS iocsh callable function to call constructor of isisbeamDriver().
Definition: isisbeamDriver.cpp:545
P_UpdateTimeString
#define P_UpdateTimeString
Definition: isisbeamDriver.h:95
epicsExportRegistrar
epicsExportRegistrar(isisbeamRegister)
P_MethaneTS2String
#define P_MethaneTS2String
Definition: isisbeamDriver.h:81
isisbeamDriver::isisbeamDriver
isisbeamDriver(const char *portName)
Constructor for the isisbeamDriver class.
Definition: isisbeamDriver.cpp:162
isisbeamDriver::m_blparams
std::map< std::string, int > m_blparams
ASYN diver parameters for beamline specific information (shutter etc.)
Definition: isisbeamDriver.h:64
P_MuonKickString
#define P_MuonKickString
Definition: isisbeamDriver.h:83
isisbeamDriver::pollerThreadC
static void pollerThreadC(void *arg)
Definition: isisbeamDriver.cpp:246
ts2_shutter_status
static char * ts2_shutter_status(int stat)
Definition: isisbeamDriver.cpp:34
onceId
static epicsThreadOnceId onceId
Definition: isisbeamDriver.cpp:29
P_TotalTS2String
#define P_TotalTS2String
Definition: isisbeamDriver.h:79
P_FreqTS2String
#define P_FreqTS2String
Definition: isisbeamDriver.h:78
receive_data_udp
int receive_data_udp(SOCKET sd, char *dp, int n)
Definition: 1st_nd_lib.c:304
P_OffTS2String
#define P_OffTS2String
Definition: isisbeamDriver.h:91
P_TotalTS1String
#define P_TotalTS1String
Definition: isisbeamDriver.h:77
initFuncDef
static const iocshFuncDef initFuncDef
Definition: isisbeamDriver.cpp:565
P_InstTS2String
#define P_InstTS2String
Definition: isisbeamDriver.h:93
P_HydrogenTS2String
#define P_HydrogenTS2String
Definition: isisbeamDriver.h:82
P_BeamSynchString
#define P_BeamSynchString
Definition: isisbeamDriver.h:75
isisbeamDriver::readFloat64
virtual asynStatus readFloat64(asynUser *pasynUser, epicsFloat64 *value)
Definition: isisbeamDriver.cpp:239
driverName
static const char * driverName
Definition: isisbeamDriver.cpp:155
isisbeamDriver::P_BeamTS1
int P_BeamTS1
ASYN driver parameter index for TS1 beam current (double)
Definition: isisbeamDriver.h:36
P_BeamDmodTS2String
#define P_BeamDmodTS2String
Definition: isisbeamDriver.h:86
P_DmodRunTS2String
#define P_DmodRunTS2String
Definition: isisbeamDriver.h:84
P_OnTS2String
#define P_OnTS2String
Definition: isisbeamDriver.h:90
P_FreqSynchString
#define P_FreqSynchString
Definition: isisbeamDriver.h:76
initArg0
static const iocshArg initArg0
The name of the asyn driver port we will create.
Definition: isisbeamDriver.cpp:561
ts2_shutter_mode
static char * ts2_shutter_mode(int stat)
Definition: isisbeamDriver.cpp:61
P_OnTS1String
#define P_OnTS1String
Definition: isisbeamDriver.h:88
P_DmodAnnLowTS2String
#define P_DmodAnnLowTS2String
Definition: isisbeamDriver.h:87
isisbeamDriver::m_timestamp
epicsTimeStamp m_timestamp
Definition: isisbeamDriver.h:67
initCOM
static void initCOM(void *)
Definition: isisbeamDriver.cpp:150
P_DeMethaneTS2String
#define P_DeMethaneTS2String
Definition: isisbeamDriver.h:80
1st_nd_post.h
P_HydrogenTS1String
#define P_HydrogenTS1String
Definition: isisbeamDriver.h:73
isisbeamDriver.h
Header for ISIS beam driver.
P_UpdateTimeTString
#define P_UpdateTimeTString
Definition: isisbeamDriver.h:96
isisbeamRegister
static void isisbeamRegister(void)
Definition: isisbeamDriver.cpp:572
MAX_ASYN_BL_PARAMS
#define MAX_ASYN_BL_PARAMS
needs to be large enough to cover beamline parameters created dynamically in isisbeamDriver() ...
Definition: isisbeamDriver.cpp:157
LEN_BUFFER
#define LEN_BUFFER
Definition: isisbeamDriver.cpp:252
P_OffTS1String
#define P_OffTS1String
Definition: isisbeamDriver.h:89
isisbeamDriver
Driver for ISIS beam.
Definition: isisbeamDriver.h:28
initArgs
static const iocshArg *const initArgs[]
Definition: isisbeamDriver.cpp:563
initCallFunc
static void initCallFunc(const iocshArgBuf *args)
Definition: isisbeamDriver.cpp:567
setup_udp_socket
SOCKET setup_udp_socket(unsigned short port, int multicast)
Definition: 1st_nd_lib.c:353
P_OsirisCryomagString
#define P_OsirisCryomagString
Definition: isisbeamDriver.h:94
ts1_shutter_status
static char * ts1_shutter_status(int stat, int beamline)
Definition: isisbeamDriver.cpp:136
P_DmodRunLimTS2String
#define P_DmodRunLimTS2String
Definition: isisbeamDriver.h:85
P_InstTS1String
#define P_InstTS1String
Definition: isisbeamDriver.h:92
Copyright © 2013 Science and Technology Facilities Council | Generated by   doxygen 1.8.5