MIDAS
Loading...
Searching...
No Matches
Classes | Macros | Functions | Variables
mcnaf.cxx File Reference
#include <stdio.h>
#include "midas.h"
#include "msystem.h"
#include "mcstd.h"
Include dependency graph for mcnaf.cxx:

Go to the source code of this file.

Classes

struct  CAMAC
 

Macros

#define D16   16
 
#define D24   24
 
#define LOOP   1
 
#define QUIT   2
 
#define HELP   3
 
#define SKIP   4
 
#define JOB   5
 
#define CHECK   6
 
#define READ   7
 
#define MCSTD   77
 
#define MAIN   78
 
#define CAM_OFF   100
 
#define CAMST   CAM_OFF+30
 
#define CAM16I   CAM_OFF+29
 
#define CAM24I   CAM_OFF+28
 
#define CAM16I_Q   CAM_OFF+27
 
#define CAM24I_Q   CAM_OFF+26
 
#define CAM16I_R   CAM_OFF+25
 
#define CAM24I_R   CAM_OFF+24
 
#define CAM16I_RQ   CAM_OFF+23
 
#define CAM24I_RQ   CAM_OFF+22
 
#define CAM16I_SA   CAM_OFF+21
 
#define CAM24I_SA   CAM_OFF+20
 
#define CAM16I_SN   CAM_OFF+19
 
#define CAM24I_SN   CAM_OFF+18
 
#define CAM16O   CAM_OFF+17
 
#define CAM24O   CAM_OFF+16
 
#define CAM16O_Q   CAM_OFF+15
 
#define CAM24O_Q   CAM_OFF+14
 
#define CAM16O_R   CAM_OFF+13
 
#define CAM24O_R   CAM_OFF+12
 
#define CAMC   CAM_OFF+11
 
#define CAMC_Q   CAM_OFF+10
 
#define CAMC_SA   CAM_OFF+9
 
#define CAMC_SN   CAM_OFF+8
 
#define CAM_LAM_ENABLE   CAM_OFF+7
 
#define CAM_LAM_READ   CAM_OFF+6
 
#define CAM_LAM_DISABLE   CAM_OFF+5
 
#define CAM_LAM_CLEAR   CAM_OFF+4
 
#define CAM_INHIBIT_CLEAR   CAM_OFF+3
 
#define CAM_INHIBIT_SET   CAM_OFF+2
 
#define CAM_CRATE_CLEAR   CAM_OFF+1
 
#define CAM_CRATE_ZINIT   CAM_OFF+0
 

Functions

INT cnafsub (BOOL, char *)
 
void help_page (INT which)
 
INT decode_line (CAMAC *p, char *str)
 
INT read_job_file (FILE *pF, INT action, CAMAC **job, char *name)
 
void make_display_string (int from, CAMAC *p, char *saddr)
 
void cc_services (CAMAC *p)
 
void mcstd_func (CAMAC *PP)
 
int main (int argc, char **argv)
 

Variables

char MCStd [32][32]
 
CAMAC Prompt [2]
 
char job_name [128] = "cnaf.cnf"
 
HNDLE hDB
 main ODB handle
 
HNDLE hKey
 
FILE * pF
 
BOOL jobflag
 
char addr [128]
 

Macro Definition Documentation

◆ CAM16I

#define CAM16I   CAM_OFF+29

Definition at line 31 of file mcnaf.cxx.

◆ CAM16I_Q

#define CAM16I_Q   CAM_OFF+27

Definition at line 33 of file mcnaf.cxx.

◆ CAM16I_R

#define CAM16I_R   CAM_OFF+25

Definition at line 35 of file mcnaf.cxx.

◆ CAM16I_RQ

#define CAM16I_RQ   CAM_OFF+23

Definition at line 37 of file mcnaf.cxx.

◆ CAM16I_SA

#define CAM16I_SA   CAM_OFF+21

Definition at line 39 of file mcnaf.cxx.

◆ CAM16I_SN

#define CAM16I_SN   CAM_OFF+19

Definition at line 41 of file mcnaf.cxx.

◆ CAM16O

#define CAM16O   CAM_OFF+17

Definition at line 44 of file mcnaf.cxx.

◆ CAM16O_Q

#define CAM16O_Q   CAM_OFF+15

Definition at line 46 of file mcnaf.cxx.

◆ CAM16O_R

#define CAM16O_R   CAM_OFF+13

Definition at line 48 of file mcnaf.cxx.

◆ CAM24I

#define CAM24I   CAM_OFF+28

Definition at line 32 of file mcnaf.cxx.

◆ CAM24I_Q

#define CAM24I_Q   CAM_OFF+26

Definition at line 34 of file mcnaf.cxx.

◆ CAM24I_R

#define CAM24I_R   CAM_OFF+24

Definition at line 36 of file mcnaf.cxx.

◆ CAM24I_RQ

#define CAM24I_RQ   CAM_OFF+22

Definition at line 38 of file mcnaf.cxx.

◆ CAM24I_SA

#define CAM24I_SA   CAM_OFF+20

Definition at line 40 of file mcnaf.cxx.

◆ CAM24I_SN

#define CAM24I_SN   CAM_OFF+18

Definition at line 42 of file mcnaf.cxx.

◆ CAM24O

#define CAM24O   CAM_OFF+16

Definition at line 45 of file mcnaf.cxx.

◆ CAM24O_Q

#define CAM24O_Q   CAM_OFF+14

Definition at line 47 of file mcnaf.cxx.

◆ CAM24O_R

#define CAM24O_R   CAM_OFF+12

Definition at line 49 of file mcnaf.cxx.

◆ CAM_CRATE_CLEAR

#define CAM_CRATE_CLEAR   CAM_OFF+1

Definition at line 62 of file mcnaf.cxx.

◆ CAM_CRATE_ZINIT

#define CAM_CRATE_ZINIT   CAM_OFF+0

Definition at line 63 of file mcnaf.cxx.

◆ CAM_INHIBIT_CLEAR

#define CAM_INHIBIT_CLEAR   CAM_OFF+3

Definition at line 60 of file mcnaf.cxx.

◆ CAM_INHIBIT_SET

#define CAM_INHIBIT_SET   CAM_OFF+2

Definition at line 61 of file mcnaf.cxx.

◆ CAM_LAM_CLEAR

#define CAM_LAM_CLEAR   CAM_OFF+4

Definition at line 59 of file mcnaf.cxx.

◆ CAM_LAM_DISABLE

#define CAM_LAM_DISABLE   CAM_OFF+5

Definition at line 58 of file mcnaf.cxx.

◆ CAM_LAM_ENABLE

#define CAM_LAM_ENABLE   CAM_OFF+7

Definition at line 56 of file mcnaf.cxx.

◆ CAM_LAM_READ

#define CAM_LAM_READ   CAM_OFF+6

Definition at line 57 of file mcnaf.cxx.

◆ CAM_OFF

#define CAM_OFF   100

Definition at line 29 of file mcnaf.cxx.

◆ CAMC

#define CAMC   CAM_OFF+11

Definition at line 51 of file mcnaf.cxx.

◆ CAMC_Q

#define CAMC_Q   CAM_OFF+10

Definition at line 52 of file mcnaf.cxx.

◆ CAMC_SA

#define CAMC_SA   CAM_OFF+9

Definition at line 53 of file mcnaf.cxx.

◆ CAMC_SN

#define CAMC_SN   CAM_OFF+8

Definition at line 54 of file mcnaf.cxx.

◆ CAMST

#define CAMST   CAM_OFF+30

Definition at line 30 of file mcnaf.cxx.

◆ CHECK

#define CHECK   6

Definition at line 24 of file mcnaf.cxx.

◆ D16

#define D16   16

Definition at line 17 of file mcnaf.cxx.

◆ D24

#define D24   24

Definition at line 18 of file mcnaf.cxx.

◆ HELP

#define HELP   3

Definition at line 21 of file mcnaf.cxx.

◆ JOB

#define JOB   5

Definition at line 23 of file mcnaf.cxx.

◆ LOOP

#define LOOP   1

Definition at line 19 of file mcnaf.cxx.

◆ MAIN

#define MAIN   78

Definition at line 27 of file mcnaf.cxx.

◆ MCSTD

#define MCSTD   77

Definition at line 26 of file mcnaf.cxx.

◆ QUIT

#define QUIT   2

Definition at line 20 of file mcnaf.cxx.

◆ READ

#define READ   7

Definition at line 25 of file mcnaf.cxx.

◆ SKIP

#define SKIP   4

Definition at line 22 of file mcnaf.cxx.

Function Documentation

◆ cc_services()

void cc_services ( CAMAC *  p)

Definition at line 116 of file mcnaf.cxx.

117{
118 if (p->n == 30) {
119 if (p->a == 9 && p->f == 24)
120 cam_inhibit_clear(p->c);
121 else if (p->a == 9 && p->f == 26)
122 cam_inhibit_set(p->c);
123 else if (p->a >= 0 && p->a < 8 && p->f == 1)
124 cam_lam_read(p->c, &p->d24);
125 else if (p->a >= 13 && p->f == 17)
126 cam_lam_enable(p->c, p->d24);
127 else if (p->a >= 12 && p->f == 17)
128 cam_lam_disable(p->c, p->d24);
129 /* else if (p->a>=13 && p->f==1)
130 we don't support that function "read lam mask" */
131 } else if (p->n == 28 && (p->a == 8 || p->a == 9)) {
132 if (p->a == 8 && p->f == 26)
133 cam_crate_zinit(p->c);
134 else if (p->a == 9 && p->f == 26)
135 cam_crate_clear(p->c);
136 } else if (p->m == 24) /* Actual 24 bits CAMAC operation */
137 if (p->f < 16)
138 cam24i_q(p->c, p->n, p->a, p->f, &p->d24, &p->x, &p->q);
139 else
140 cam24o_q(p->c, p->n, p->a, p->f, p->d24, &p->x, &p->q);
141 else /* Actual 16 bits CAMAC operation */ if (p->f < 16)
142 cam16i_q(p->c, p->n, p->a, p->f, &p->d16, &p->x, &p->q);
143 else
144 cam16o_q(p->c, p->n, p->a, p->f, p->d16, &p->x, &p->q);
145}
cam24o_q
EXTERNAL void EXPRT cam24o_q(const int c, const int n, const int a, const int f, DWORD d, int *x, int *q)
cam16i_q
EXTERNAL void EXPRT cam16i_q(const int c, const int n, const int a, const int f, WORD *d, int *x, int *q)
cam_lam_enable
EXTERNAL void EXPRT cam_lam_enable(const int c, const int n)
cam_inhibit_set
EXTERNAL void EXPRT cam_inhibit_set(const int c)
cam24i_q
EXTERNAL void EXPRT cam24i_q(const int c, const int n, const int a, const int f, DWORD *d, int *x, int *q)
cam_inhibit_clear
EXTERNAL void EXPRT cam_inhibit_clear(const int c)
cam16o_q
EXTERNAL void EXPRT cam16o_q(const int c, const int n, const int a, const int f, WORD d, int *x, int *q)
cam_lam_read
EXTERNAL void cam_lam_read(const int c, DWORD *lam)
cam_lam_disable
EXTERNAL void EXPRT cam_lam_disable(const int c, const int n)
cam_crate_clear
EXTERNAL void EXPRT cam_crate_clear(const int c)
cam_crate_zinit
EXTERNAL void EXPRT cam_crate_zinit(const int c)
CAMAC::c
INT c
Definition mcnaf.cxx:80
CAMAC::m
INT m
Definition mcnaf.cxx:78
CAMAC::x
INT x
Definition mcnaf.cxx:89
CAMAC::d16
WORD d16
Definition mcnaf.cxx:84
CAMAC::q
INT q
Definition mcnaf.cxx:88
CAMAC::f
INT f
Definition mcnaf.cxx:83
CAMAC::a
INT a
Definition mcnaf.cxx:82
CAMAC::n
INT n
Definition mcnaf.cxx:81
CAMAC::d24
DWORD d24
Definition mcnaf.cxx:85
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cnafsub()

INT cnafsub ( BOOL  cmd_mode,
char *  cmd 
)

Definition at line 440 of file mcnaf.cxx.

441{
442 char str[128], line[128];
443 INT status, j;
444 CAMAC *P, *p = NULL, *job;
445
446 /* Loop return label */
447 if (jobflag) {
448 jobflag = FALSE;
449 }
450
451 /* Load default CAMAC */
452 P = Prompt;
453 while (1) {
454 if (!cmd_mode) {
455 make_display_string(MAIN, P, addr);
456 /* prompt */
457 printf("mCNAF> [%s] :", addr);
458 ss_gets(str, 128);
459 } else {
460 strcpy(str, cmd);
461 }
462
463 /* decode line */
464 status = decode_line(P, str);
465 if (status == QUIT)
466 return status;
467 else if (status == MCSTD) {
468 mcstd_func(P);
469 status = decode_line(P, str);
470 } else if (status == HELP)
471 help_page(MAIN);
472 else if (status == JOB) {
473 if (!cmd_mode) {
474 /* interactive session, display default job name */
475 printf("\nmCNAF> Job file name [%s]:", job_name);
476 ss_gets(line, 128);
477 if (strlen(line) == 0)
478 strcpy(line, job_name); // Use default
479 else {
480 strcpy(job_name, line);
481 }
482 } else {
483 /* from command line, skip @ */
484 strcpy(line, &str[1]);
485 }
486 /* Check if file exists */
487 status = read_job_file(pF, CHECK, &job, line);
488 if (status == JOB)
489 status = read_job_file(pF, READ, &job, line);
490 }
491
492 if (status == LOOP || status == JOB) {
493 for (j = 0; j < P->r; j++) {
494 if (status == LOOP)
495 p = P;
496 if (status == JOB)
497 p = job;
498 while (p->m) {
499 if (p->n == 28 || p->n == 29 || p->n == 30)
500 cc_services(p);
501 else if (p->m == 24) { /* Actual 24 bits CAMAC operation */
502 if (p->f < 8)
503 cam24i_q(p->c, p->n, p->a, p->f, &p->d24, &p->x, &p->q);
504 else if (p->f < 16)
505 camc_q(p->c, p->n, p->a, p->f, &p->q);
506 else if (p->f < 24)
507 cam24o_q(p->c, p->n, p->a, p->f, p->d24, &p->x, &p->q);
508 else
509 camc_q(p->c, p->n, p->a, p->f, &p->q);
510 }
511 else {
512 if (p->f < 16) /* Actual 16 bits CAMAC operation */
513 cam16i_q(p->c, p->n, p->a, p->f, &p->d16, &p->x, &p->q);
514 else if (p->f < 24)
515 cam16o_q(p->c, p->n, p->a, p->f, (WORD)p->d24, &p->x, &p->q);
516 else
517 camc_q(p->c, p->n, p->a, p->f, &p->q);
518 }
519 make_display_string(MAIN, p, addr);
520
521 /* Result display */
522 if (p->r > 1) {
523 /* repeat mode */
524 if (status == JOB) {
525 if (!cmd_mode)
526 printf("\nmCNAF> [%s]", addr);
527 if (p->w != 0)
528 ss_sleep(p->w);
529 } else {
530 if (!cmd_mode)
531 printf("mCNAF> [%s] <-%03i\n", addr, j + 1);
532 if (p->w != 0)
533 ss_sleep(p->w);
534 if (j > p->r - 1)
535 break;
536 }
537 } else {
538 /* single command */
539 if (status == JOB) {
540 if (!cmd_mode)
541 printf("mCNAF> [%s]\n", addr);
542 if (p->w != 0)
543 ss_sleep(p->w);
544 }
545 }
546 p++;
547 }
548 };
549 if (status == JOB) {
550 free(job);
551 if (!cmd_mode)
552 printf("\n");
553 }
554 }
555 if (cmd_mode)
556 break;
557 }
558 return status;
559}
FALSE
#define FALSE
Definition cfortran.h:309
camc_q
EXTERNAL void EXPRT camc_q(const int c, const int n, const int a, const int f, int *q)
WORD
unsigned short int WORD
Definition mcstd.h:49
ss_sleep
INT ss_sleep(INT millisec)
Definition system.cxx:3700
ss_gets
char * ss_gets(char *string, int size)
Definition system.cxx:7848
JOB
#define JOB
Definition mcnaf.cxx:23
Prompt
CAMAC Prompt[2]
Definition mcnaf.cxx:94
MAIN
#define MAIN
Definition mcnaf.cxx:27
help_page
void help_page(INT which)
Definition mcnaf.cxx:779
CHECK
#define CHECK
Definition mcnaf.cxx:24
cc_services
void cc_services(CAMAC *p)
Definition mcnaf.cxx:116
LOOP
#define LOOP
Definition mcnaf.cxx:19
job_name
char job_name[128]
Definition mcnaf.cxx:99
pF
FILE * pF
Definition mcnaf.cxx:102
read_job_file
INT read_job_file(FILE *pF, INT action, CAMAC **job, char *name)
Definition mcnaf.cxx:393
MCSTD
#define MCSTD
Definition mcnaf.cxx:26
decode_line
INT decode_line(CAMAC *p, char *str)
Definition mcnaf.cxx:562
QUIT
#define QUIT
Definition mcnaf.cxx:20
jobflag
BOOL jobflag
Definition mcnaf.cxx:103
READ
#define READ
Definition mcnaf.cxx:25
addr
char addr[128]
Definition mcnaf.cxx:104
HELP
#define HELP
Definition mcnaf.cxx:21
make_display_string
void make_display_string(int from, CAMAC *p, char *saddr)
Definition mcnaf.cxx:375
mcstd_func
void mcstd_func(CAMAC *PP)
Definition mcnaf.cxx:148
INT
int INT
Definition midas.h:129
cmd_mode
BOOL cmd_mode
Definition odbedit.cxx:25
j
INT j
Definition odbhist.cxx:40
str
char str[256]
Definition odbhist.cxx:33
status
DWORD status
Definition odbhist.cxx:39
P
#define P(a, b, c, d, e, f, g, h, x, K)
Definition sha256.cxx:174
CAMAC::w
INT w
Definition mcnaf.cxx:87
CAMAC::r
INT r
Definition mcnaf.cxx:86
Here is the call graph for this function:
Here is the caller graph for this function:

◆ decode_line()

INT decode_line ( CAMAC *  p,
char *  str 
)

Definition at line 562 of file mcnaf.cxx.

563{
564 char empty[17] = { " " };
565 char *c, *cmd;
566 char pp[128], *p, *s, *ps;
567 DWORD tmp, i;
568 BOOL ok = FALSE;
569
570 p = pp;
571 s = ss;
572 memset(pp, 0, 128);
573
574 /* convert to uppercase */
575 c = ss;
576 while (*c) {
577 *c = toupper(*c);
578 c++;
579 }
580
581 while (*s) {
582 if (*s == 'G') {
583 while (*s)
584 *p++ = *s++;
585 break;
586 }
587 if ((*s == 'B') || (*s == 'C') ||
588 (*s == 'N') || (*s == 'A') ||
589 (*s == 'F') || (*s == 'C') ||
590 (*s == 'R') || (*s == 'W') ||
591 (*s == 'G') || (*s == 'H') || (*s == 'E') || (*s == 'Q'))
592 *p++ = ' ';
593 else if ((*s == 'X') || (*s == 'D') || (*s == 'O')) {
594 *p++ = ' ';
595 *p++ = *s++;
596 while (*s)
597 *p++ = *s++;
598 break;
599 };
600 *p++ = *s++;
601 }
602 *p++ = ' ';
603
604 p = pp;
605
606 if ((cmd = strpbrk(p, "P")))
607 return MCSTD;
608 if ((cmd = strpbrk(p, "G"))) {
609 for (i = 0;; i++) {
610 if (MCStd[i][0] == 0)
611 break;
612 if (strstr(p + 2, MCStd[i]) != NULL)
613 return CAM_OFF + i;
614 }
615 return LOOP;
616 }
617 if ((cmd = strpbrk(p, "H")))
618 return HELP;
619 if ((cmd = strpbrk(p, "J@")))
620 return JOB;
621 if ((cmd = strpbrk(p, "X"))) {
622 ps = strchr(cmd, ' ');
623 *ps = 0;
624 if (P->m == D24) {
625 tmp = strtoul((cmd + 1), NULL, 16);
626 if (tmp <= 0xffffff) {
627 P->d24 = tmp;
628 ok = TRUE;
629 } else
630 printf("mcnaf-E- Data out of range 0x0:0xffffff\n");
631 } else {
632 tmp = strtoul((cmd + 1), NULL, 16);
633 if (tmp <= 0xffff) {
634 P->d16 = (WORD) tmp;
635 ok = TRUE;
636 } else
637 printf("mcnaf-E- Data out of range 0x0:0xffff\n");
638 }
639 strncpy(cmd, empty, strlen(cmd));
640 *ps = ' ';
641 }
642 if ((cmd = strpbrk(p, "O"))) {
643 ps = strchr(cmd, ' ');
644 *ps = 0;
645 if (P->m == D24) {
646 tmp = strtoul((cmd + 1), NULL, 8);
647 if (tmp <= 077777777) {
648 P->d24 = tmp;
649 ok = TRUE;
650 } else
651 printf("mcnaf-E- Data out of range O0:O77777777\n");
652 } else {
653 tmp = strtoul((cmd + 1), NULL, 8);
654 if (tmp <= 0177777) {
655 P->d16 = (WORD) tmp;
656 ok = TRUE;
657 } else
658 printf("mcnaf-E- Data out of range O0:O177777\n");
659 }
660 strncpy(cmd, empty, strlen(cmd));
661 *ps = ' ';
662 }
663 if ((cmd = strpbrk(p, "D"))) {
664 ps = strchr(cmd, ' ');
665 *ps = 0;
666 if (P->m == D24) {
667 tmp = strtoul((cmd + 1), NULL, 10);
668 if (tmp <= 0xffffff) {
669 P->d24 = tmp;
670 ok = TRUE;
671 } else
672 printf("mcnaf-E- Data out of range 0:16777215\n");
673 } else {
674 tmp = strtoul((cmd + 1), NULL, 10);
675 if (tmp <= 0xffff) {
676 P->d16 = (WORD) tmp;
677 ok = TRUE;
678 } else
679 printf("mcnaf-E- Data out of range 0:65535\n");
680 }
681 strncpy(cmd, empty, strlen(cmd));
682 *ps = ' ';
683 }
684 if ((cmd = strchr(p, 'B'))) {
685 ps = strchr(cmd, ' ');
686 *ps = 0;
687 tmp = atoi((cmd + 1));
688 if (tmp < 8) {
689 P->b = tmp;
690 ok = TRUE;
691 } else
692 printf("mcnaf-E- B out of range 0:7\n");
693 *ps = ' ';
694 }
695 if ((cmd = strchr(p, 'C'))) {
696 ps = strchr(cmd, ' ');
697 *ps = 0;
698 tmp = atoi((cmd + 1));
699 if (tmp < 8) {
700 P->c = tmp;
701 ok = TRUE;
702 } else
703 printf("mcnaf-E- C out of range 0:7\n");
704 *ps = ' ';
705 }
706 if ((cmd = strchr(p, 'N'))) {
707 ps = strchr(cmd, ' ');
708 *ps = 0;
709 tmp = atoi((cmd + 1));
710 if (tmp < 32) {
711 P->n = tmp;
712 ok = TRUE;
713 } else
714 printf("mcnaf-E- N out of range 0:31\n");
715 *ps = ' ';
716 }
717 if ((cmd = strchr(p, 'A'))) {
718 ps = strchr(cmd, ' ');
719 *ps = 0;
720 tmp = atoi((cmd + 1));
721 if (tmp < 16) {
722 P->a = tmp;
723 ok = TRUE;
724 } else
725 printf("mcnaf-E- A out of range 0:15\n");
726 *ps = ' ';
727 }
728 if ((cmd = strchr(p, 'F'))) {
729 ps = strchr(cmd, ' ');
730 *ps = 0;
731 tmp = atoi((cmd + 1));
732 if (tmp < 32) {
733 P->f = tmp;
734 ok = TRUE;
735 } else
736 printf("mcnaf-E- F out of range 0:31\n");
737 *ps = ' ';
738 }
739 if ((cmd = strchr(p, 'R'))) {
740 ps = strchr(cmd, ' ');
741 *ps = 0;
742 tmp = atoi((cmd + 1));
743 if (tmp < 1000) {
744 if (tmp == 0)
745 tmp = 1;
746 P->r = tmp;
747 } else
748 printf("mcnaf-E- R out of range 1:1000\n");
749 *ps = ' ';
750 }
751 if ((cmd = strchr(p, 'W'))) {
752 ps = strchr(cmd, ' ');
753 *ps = 0;
754 tmp = atoi((cmd + 1));
755 if (tmp < 10001)
756 P->w = tmp;
757 else
758 printf("mcnaf-E- W out of range 0:10000\n");
759 *ps = ' ';
760 }
761 if ((cmd = strchr(p, 'M'))) {
762 ps = strchr(cmd, ' ');
763 *ps = 0;
764 tmp = atoi((cmd + 1));
765 if (tmp == D16 || tmp == D24)
766 P->m = tmp;
767 else
768 printf("mcnaf-E- M out of range 16,24\n");
769 *ps = ' ';
770 }
771 if (ok)
772 return LOOP;
773 if ((cmd = strpbrk(p, "QE")))
774 return QUIT;
775 return SKIP;
776}
DWORD
unsigned int DWORD
Definition mcstd.h:51
SKIP
#define SKIP
Definition mcnaf.cxx:22
D16
#define D16
Definition mcnaf.cxx:17
CAM_OFF
#define CAM_OFF
Definition mcnaf.cxx:29
MCStd
char MCStd[32][32]
Definition mcnaf.cxx:66
D24
#define D24
Definition mcnaf.cxx:18
i
INT i
Definition mdump.cxx:32
BOOL
DWORD BOOL
Definition midas.h:105
TRUE
#define TRUE
Definition midas.h:182
c
char c
Definition system.cxx:1312
Here is the caller graph for this function:

◆ help_page()

void help_page ( INT  which)

Definition at line 779 of file mcnaf.cxx.

780{
781 if (which == MAIN) {
782 printf("\n*-v%s----------- H E L P C N A F -------------------*\n", cm_get_revision());
783 printf(" Interactive Midas CAMAC command\n");
784 printf(" ===============================\n");
785 printf(" Output : Data [dec/hex X=0/1 - Q=0/1 ]\n");
786 printf(" Inputs : Bx : Branch [0 - 7] Cx : Crate [0 - 7]\n");
787 printf(" Nx : Slot [1 - 31] Ax : SubAdd. [0 - 15]\n");
788 printf(" Fx : Function [0 - 31] Mx : Access mode [16,24]\n");
789 printf(" H : HELP on CNAF E/Q: Exit/Quit from CNAF\n");
790 printf(" Rx : Repetition counter [1 - 999]\n");
791 printf(" Wx : Delay between command (ms) [0 - 10000]\n");
792 printf(" P : Switch to MCStd CAMAC operation\n");
793 printf(" J : Perform JOB (command list from file )\n");
794 printf(" Same syntax as in interactive session\n");
795 printf(" G : PERFORM ACTION of predefine set-up\n");
796 printf(" D : Decimal Data [0 - max data_size]\n");
797 printf(" O : Octal Data [0 - max data_size]\n");
798 printf(" X : Hexadecimal Data [0 - max data_size]\n");
799 printf("\n");
800 printf(">>>>>>>>>> Data has to be given LAST if needed in the command string <<<<<\n");
801 printf("\n");
802 printf(" The commands below are following the ESONE standard for a A2 controller\n");
803 printf(" N30A9F24 : Crate clear inhibit N30A9F26 : Crate set inhibit\n");
804 printf(" N28A8F26 : Z crate N28A9F26 : C crate\n");
805 printf(" N30A13F17: CC Lam enable N30A12F17: CC Lam disable\n");
806 printf(" N30A0-7F1: CC read Lam\n");
807 printf("\n");
808 printf(" examples: ");
809 printf(">mcnaf -cl\"triggerFE\" -h local -e myexpt\n");
810 printf(" CNAF> [B0C1N30A00F00 [0/0x000000 Q0X0] R1W0M24] :n30a9f24\n");
811 printf(" CNAF> [B0C1N06A00F24 [0/0x000000 Q1X1] R1W0M24] :n6f9a0\n");
812 } else {
813 printf("\n*-v%s----------- H E L P C N A F -------------------*\n", cm_get_revision());
814 printf(" Interactive MCStd CAMAC command\n");
815 printf("The action taken is dependent on the driver implementation\n");
816 printf("[Q/E] : Exit this level\n");
817 printf("[G] <function> : Issue the given function on preset CAMAC address\n");
818 printf("Possible functions are:\n");
819 printf("cam16/24i : 16/24bit input\n");
820 printf("cam16/24i_q : 16/24bit input with Q response\n");
821 printf("cam16/24i_r : 16/24bit input repeat until R reached (max 100)\n");
822 printf("cam16/24i_rq : 16/24bit input repeat until NoQ or R reached (max 100)\n");
823 printf("cam16/24i_sa : 16/24bit input scan R times over A\n");
824 printf("cam16/24i_sn : 16/24bit input scan R times over N\n");
825 printf("cam16/24o : 16/24bit output\n");
826 printf("cam16/24o_q : 16/24bit output with Q response\n");
827 printf("cam16/24o_r : 16/24bit output repeat R times\n");
828 printf("camc : 16bit command \n");
829 printf("camc_q : 16bit command with Q response\n");
830 printf("camc_sa : 16bit command scan R times over A\n");
831 printf("camc_sn : 16bit command scan R times over N\n");
832 printf("cam_lam_enable : Enable lam in Crate controller ONLY\n");
833 printf("cam_lam_disable : Disable lam in Crate controlled ONLY\n");
834 printf("cam_lam_read : Read lam from Crate controller\n");
835 printf("cam_inhibit_clear: Reset Inhibit line in crate\n");
836 printf("cam_inhibit_set : Set Inhibit line in crate\n");
837 printf("cam_crate_clear : Generate a Clear cycle to the crate\n");
838 printf("cam_crate_zinit : Generate a Z cycle to the crate\n");
839 }
840}
cm_get_revision
const char * cm_get_revision()
Definition midas.cxx:1500
Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 844 of file mcnaf.cxx.

845{
846 char host_name[HOST_NAME_LENGTH], exp_name[NAME_LENGTH], fe_name[256], rpc_server[256];
847 char cmd[256];
848 INT i, status;
849 BOOL debug, cmd_mode = FALSE;
850
851 /* set default */
852 host_name[0] = '\0';
853 exp_name[0] = '\0';
854 fe_name[0] = '\0';
855 rpc_server[0] = '\0';
856 debug = FALSE;
857
858 /* get parameters */
859 cm_get_environment(host_name, sizeof(host_name), exp_name, sizeof(exp_name));
860
861 /* parse command line parameters */
862 for (i = 1; i < argc; i++) {
863 if (argv[i][0] == '-' && argv[i][1] == 'd')
864 debug = TRUE;
865 else if (argv[i][0] == '-') {
866 if (i + 1 >= argc || argv[i + 1][0] == '-')
867 goto usage;
868 if (strncmp(argv[i], "-e", 3) == 0)
869 strcpy(exp_name, argv[++i]);
870 else if (strncmp(argv[i], "-h", 3) == 0)
871 strcpy(host_name, argv[++i]);
872 else if (strncmp(argv[i], "-f", 3) == 0)
873 strcpy(fe_name, argv[++i]);
874 else if (strncmp(argv[i], "-s", 3) == 0)
875 strcpy(rpc_server, argv[++i]);
876 else if (argv[i][1] == 'c') {
877 if (strlen(argv[i]) >= 256) {
878 printf("error: command line too long (>256).\n");
879 return 0;
880 }
881 strcpy(cmd, argv[++i]);
882 cmd_mode = TRUE;
883 } else {
884 usage:
885 printf("usage: mcnaf [-f Frontend] [-h Hostname] [-e Experiment] [-s RPC server]\n");
886 printf(" [-c Command] [-c @CommandFile] \n\n");
887 return 0;
888 }
889 }
890 }
891
892 if (debug)
893 status = SUCCESS;
894
895 if (rpc_server[0])
896 status = cam_init_rpc("", "", "", "mcnaf", rpc_server);
897 else
898 status = cam_init_rpc(host_name, exp_name, fe_name, "mcnaf", "");
899 if (status == SUCCESS) {
900 status = cam_init();
901 if (status == SUCCESS)
902 status = cnafsub(cmd_mode, cmd);
903 }
904 cam_exit();
905// printf("status:%d\n", status);
906 return status;
907}
usage
static void usage()
Definition fetest_tmfe.cxx:98
cm_get_environment
INT cm_get_environment(char *host_name, int host_name_size, char *exp_name, int exp_name_size)
Definition midas.cxx:2150
cam_init
EXTERNAL int EXPRT cam_init(void)
cam_init_rpc
EXTERNAL int EXPRT cam_init_rpc(const char *host_name, const char *exp_name, const char *fe_name, const char *client_name, const char *rpc_server)
cam_exit
EXTERNAL void EXPRT cam_exit(void)
SUCCESS
#define SUCCESS
Definition mcstd.h:54
exp_name
char exp_name[NAME_LENGTH]
Definition mana.cxx:243
debug
BOOL debug
debug printouts
Definition mana.cxx:254
host_name
char host_name[HOST_NAME_LENGTH]
Definition mana.cxx:242
cnafsub
INT cnafsub(BOOL, char *)
Definition mcnaf.cxx:440
HOST_NAME_LENGTH
#define HOST_NAME_LENGTH
Definition midas.h:273
NAME_LENGTH
#define NAME_LENGTH
Definition midas.h:272
Here is the call graph for this function:

◆ make_display_string()

void make_display_string ( int  from,
CAMAC *  p,
char *  saddr 
)

Definition at line 375 of file mcnaf.cxx.

376{
377 if (from == MAIN) {
378 if (p->m == D24)
379 sprintf(saddr, "B%01dC%01dN%02dA%02dF%02d [%d/0x%06x Q%01dX%01d] R%dW%dM%2d",
380 p->b, p->c, p->n, p->a, p->f, p->d24, p->d24, p->q, p->x, p->r, p->w,
381 p->m);
382 else
383 sprintf(saddr, "B%01dC%01dN%02dA%02dF%02d [%d/0x%04x Q%01dX%01d] R%dW%dM%2d",
384 p->b, p->c, p->n, p->a, p->f, p->d16, p->d16, p->q, p->x, p->r, p->w,
385 p->m);
386 } else {
387 sprintf(saddr, "B%01dC%01dN%02dA%02dF%02d [%d/0x%06x] R%d", p->b, p->c, p->n,
388 p->a, p->f, p->d24, p->d24, p->r);
389 }
390}
CAMAC::b
INT b
Definition mcnaf.cxx:79
Here is the caller graph for this function:

◆ mcstd_func()

void mcstd_func ( CAMAC *  PP)

Definition at line 148 of file mcnaf.cxx.

149{
150 char paddr[128], pstr[128];
151 int i, status, pstatus = 0;
152 WORD dd16[100];
153 WORD *pdd16;
154 DWORD dd24[100];
155 DWORD *pdd24;
156 DWORD lam;
157 CAMAC *p;
158
159 /* Load default CAMAC */
160 // PP = &Prompt[1];
161 while (1) {
162 make_display_string(MCSTD, PP, paddr);
163 /* prompt */
164 printf("MCStd> [%s] :", paddr);
165 ss_gets(pstr, 128);
166
167 /* decode line */
168 status = decode_line(PP, pstr);
169 p = PP;
170 if (status == LOOP)
171 status = pstatus;
172 if (status != SKIP && status != HELP)
173 pstatus = status;
174 i = 0;
175 pdd16 = dd16;
176 pdd24 = dd24;
177 switch (status) {
178 /* system */
179 case CAMST:
180 printf("cam_op\n");
181 cam_op();
182 break;
183 case CAM_LAM_ENABLE:
184 cam_lam_enable(p->c, p->n);
185 printf("cam_lam_enable:C%i-N%i\n", p->c, p->n);
186 break;
187 case CAM_LAM_DISABLE:
188 cam_lam_disable(p->c, p->n);
189 printf("cam_lam_disable:C%i-N%i\n", p->c, p->n);
190 break;
191 case CAM_LAM_READ:
192 cam_lam_read(p->c, &lam);
193 printf("cam_lam_read:C%i-> 0x%x\n", p->c, lam);
194 break;
195 case CAM_LAM_CLEAR:
196 cam_lam_clear(p->c, p->n);
197 printf("cam_lam_clear:C%i \n", p->c);
198 break;
199 case CAM_INHIBIT_SET:
200 cam_inhibit_set(p->c);
201 printf("cam_inhibit_set:C%i\n", p->c);
202 break;
203 case CAM_INHIBIT_CLEAR:
204 cam_inhibit_clear(p->c);
205 printf("cam_inhibit_clear:C%i\n", p->c);
206 break;
207 case CAM_CRATE_CLEAR:
208 cam_crate_clear(p->c);
209 printf("cam_crate_clear:C%i\n", p->c);
210 break;
211 case CAM_CRATE_ZINIT:
212 cam_crate_zinit(p->c);
213 printf("cam_crate_zinit:C%i\n", p->c);
214 break;
215 /* command */
216 case CAMC:
217 do {
218 camc(p->c, p->n, p->a, p->f);
219 printf("camc:[R%i]-C%i-N%i-A%i-F%i\n", ++i, p->c, p->n, p->a, p->f);
220 } while (i < p->r);
221 break;
222 case CAMC_Q:
223 do {
224 camc_q(p->c, p->n, p->a, p->f, &p->q);
225 printf("camc_q:[R%i]-C%i-N%i-A%i-F%i -Q:%i\n", ++i, p->c, p->n, p->a, p->f,
226 p->q);
227 } while (i < p->r);
228 break;
229 case CAMC_SA:
230 camc(p->c, p->n, p->a, p->f);
231 printf("camc_sa:C%i-N%i-A%i-F%i\n", p->c, p->n, p->a, p->f);
232 break;
233 case CAMC_SN:
234 camc(p->c, p->n, p->a, p->f);
235 printf("camc_sn:C%i-N%i-A%i-F%i\n", p->c, p->n, p->a, p->f);
236 break;
237 /* output */
238 case CAM16O:
239 do {
240 cam16o(p->c, p->n, p->a, p->f, p->d16);
241 printf("cam16o:[R%i]-C%i-N%i-A%i-F%i <- 0x%x\n", ++i, p->c, p->n, p->a, p->f,
242 p->d16);
243 } while (i < p->r);
244 break;
245 case CAM24O:
246 do {
247 cam24o(p->c, p->n, p->a, p->f, p->d24);
248 printf("cam24o:[R%i]-C%i-N%i-A%i-F%i <- 0x%x\n", ++i, p->c, p->n, p->a, p->f,
249 p->d24);
250 } while (i < p->r);
251 break;
252 case CAM16O_Q:
253 do {
254 cam16o_q(p->c, p->n, p->a, p->f, p->d16, &p->x, &p->q);
255 printf("cam16o_q:[R%i]-C%i-N%i-A%i-F%i <- 0x%x X:%i-Q:%i\n", ++i, p->c, p->n,
256 p->a, p->f, p->d16, p->x, p->q);
257 } while (i < p->r);
258 break;
259 case CAM24O_Q:
260 do {
261 cam24o_q(p->c, p->n, p->a, p->f, p->d24, &p->x, &p->q);
262 printf("cam24o_q:[R%i]-C%i-N%i-A%i-F%i <- 0x%x X:%i-Q:%i\n", ++i, p->c, p->n,
263 p->a, p->f, p->d24, p->x, p->q);
264 } while (i < p->r);
265 break;
266 case CAM16O_R:
267 cam16o_r(p->c, p->n, p->a, p->f, pdd16, p->r);
268 printf("cam16o_r:C%i-N%i-A%i-F%i <- 0x%x\n", p->c, p->n, p->a, p->f, p->d16);
269 break;
270 case CAM24O_R:
271 cam24o_r(p->c, p->n, p->a, p->f, pdd24, p->r);
272 printf("cam24o_r:C%i-N%i-A%i-F%i <- 0x%x\n", p->c, p->n, p->a, p->f, p->d24);
273 break;
274 /* inputs */
275 case CAM16I:
276 do {
277 cam16i(p->c, p->n, p->a, p->f, &p->d16);
278 printf("cam16i:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", ++i, p->c, p->n, p->a,
279 p->f, p->d16);
280 } while (i < p->r);
281 break;
282 case CAM24I:
283 do {
284 cam24i(p->c, p->n, p->a, p->f, &p->d24);
285 printf("cam24i:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", ++i, p->c, p->n, p->a,
286 p->f, p->d24);
287 } while (i < p->r);
288 break;
289 case CAM16I_Q:
290 do {
291 cam16i_q(p->c, p->n, p->a, p->f, &p->d16, &p->x, &p->q);
292 printf("cam16i_q:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x X:%i-Q:%i\n", ++i, p->c,
293 p->n, p->a, p->f, p->d16, p->x, p->q);
294 } while (i < p->r);
295 break;
296 case CAM24I_Q:
297 do {
298 cam24i_q(p->c, p->n, p->a, p->f, &p->d24, &p->x, &p->q);
299 printf("cam24i_q:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x X:%i-Q:%i\n", ++i, p->c,
300 p->n, p->a, p->f, p->d24, p->x, p->q);
301 } while (i < p->r);
302 break;
303 case CAM16I_R:
304 memset(pdd16, 0, sizeof(dd16));
305 cam16i_r(p->c, p->n, p->a, p->f, &pdd16, p->r);
306 for (i = 0; i < p->r; i++)
307 printf("cam16i_r:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", i + 1, p->c, p->n, p->a,
308 p->f, dd16[i]);
309 break;
310 case CAM24I_R:
311 memset(pdd24, 0, sizeof(dd24));
312 cam24i_r(p->c, p->n, p->a, p->f, &pdd24, p->r);
313 for (i = 0; i < p->r; i++)
314 printf("cam24i_r:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", i + 1, p->c, p->n, p->a,
315 p->f, dd24[i]);
316 break;
317 case CAM16I_RQ:
318 memset(pdd16, 0, sizeof(dd16));
319 cam16i_rq(p->c, p->n, p->a, p->f, &pdd16, p->r);
320 for (i = 0; i < p->r; i++)
321 printf("cam16i_rq:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", i + 1, p->c, p->n, p->a,
322 p->f, dd16[i]);
323 break;
324 case CAM24I_RQ:
325 memset(pdd24, 0, sizeof(dd24));
326 cam24i_rq(p->c, p->n, p->a, p->f, &pdd24, p->r);
327 for (i = 0; i < p->r; i++)
328 printf("cam24i_rq:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", i + 1, p->c, p->n,
329 p->a, p->f, dd24[i]);
330 break;
331 case CAM16I_SA:
332 memset(pdd16, 0, sizeof(dd16));
333 cam16i_sa(p->c, p->n, p->a, p->f, &pdd16, p->r);
334 for (i = 0; i < p->r; i++)
335 printf("cam16i_sa:[R%i]-C%i-N%i-A%i-F%i-> 0x%4.4x\n", i + 1, p->c, p->n,
336 p->a + i, p->f, dd16[i]);
337 break;
338 case CAM24I_SA:
339 memset(pdd24, 0, sizeof(dd24));
340 cam24i_sa(p->c, p->n, p->a, p->f, &pdd24, p->r);
341 for (i = 0; i < p->r; i++)
342 printf("cam24i_sa:[R%i]-C%i-N%i-A%i-F%i-> 0x%6.6x\n", i + 1, p->c, p->n,
343 p->a + i, p->f, dd24[i]);
344 break;
345 case CAM16I_SN:
346 memset(pdd16, 0, sizeof(dd16));
347 cam16i_sa(p->c, p->n, p->a, p->f, &pdd16, p->r);
348 for (i = 0; i < p->r; i++)
349 printf("cam16i_sn:[R%i]-C%i-N%i-A%i-F%i-> 0x%x\n", i + 1, p->c, p->n + i,
350 p->a, p->f, dd16[i]);
351 break;
352 case CAM24I_SN:
353 memset(pdd24, 0, sizeof(dd24));
354 cam24i_sn(p->c, p->n, p->a, p->f, &pdd24, p->r);
355 for (i = 0; i < p->r; i++)
356 printf("cam24i_sn:[R%i]-C%i-N%i-A%i-F%i-> 0x%x\n", i + 1, p->c, p->n + i,
357 p->a, p->f, dd24[i]);
358 break;
359 case QUIT:
360 p->r = 1;
361 return;
362 case HELP:
363 help_page(MCSTD);
364 break;
365 case SKIP:
366 break;
367 default:
368 status = SKIP;
369 break;
370 }
371 }
372}
cam16i
EXTERNAL void EXPRT cam16i(const int c, const int n, const int a, const int f, WORD *d)
cam_lam_clear
EXTERNAL void EXPRT cam_lam_clear(const int c, const int n)
cam24i_sa
EXTERNAL void EXPRT cam24i_sa(const int c, const int n, const int a, const int f, DWORD **d, const int r)
cam24i
EXTERNAL void EXPRT cam24i(const int c, const int n, const int a, const int f, DWORD *d)
cam16o_r
EXTERNAL void EXPRT cam16o_r(const int c, const int n, const int a, const int f, WORD *d, const int r)
cam_op
EXTERNAL void EXPRT cam_op()
cam16o
EXTERNAL void EXPRT cam16o(const int c, const int n, const int a, const int f, WORD d)
cam24o_r
EXTERNAL void EXPRT cam24o_r(const int c, const int n, const int a, const int f, DWORD *d, const int r)
cam24i_r
EXTERNAL void EXPRT cam24i_r(const int c, const int n, const int a, const int f, DWORD **d, const int r)
cam16i_sa
EXTERNAL void EXPRT cam16i_sa(const int c, const int n, const int a, const int f, WORD **d, const int r)
cam24i_sn
EXTERNAL void EXPRT cam24i_sn(const int c, const int n, const int a, const int f, DWORD **d, const int r)
cam24o
EXTERNAL void EXPRT cam24o(const int c, const int n, const int a, const int f, DWORD d)
cam16i_rq
EXTERNAL void EXPRT cam16i_rq(const int c, const int n, const int a, const int f, WORD **d, const int r)
camc
EXTERNAL void EXPRT camc(const int c, const int n, const int a, const int f)
cam24i_rq
EXTERNAL void EXPRT cam24i_rq(const int c, const int n, const int a, const int f, DWORD **d, const int r)
cam16i_r
EXTERNAL void EXPRT cam16i_r(const int c, const int n, const int a, const int f, WORD **d, const int r)
CAM16I_SA
#define CAM16I_SA
Definition mcnaf.cxx:39
CAMC_SA
#define CAMC_SA
Definition mcnaf.cxx:53
CAM_LAM_DISABLE
#define CAM_LAM_DISABLE
Definition mcnaf.cxx:58
CAM24I
#define CAM24I
Definition mcnaf.cxx:32
CAMC_SN
#define CAMC_SN
Definition mcnaf.cxx:54
CAMC_Q
#define CAMC_Q
Definition mcnaf.cxx:52
CAMST
#define CAMST
Definition mcnaf.cxx:30
CAM16O
#define CAM16O
Definition mcnaf.cxx:44
CAM_LAM_CLEAR
#define CAM_LAM_CLEAR
Definition mcnaf.cxx:59
CAM16I_RQ
#define CAM16I_RQ
Definition mcnaf.cxx:37
CAMC
#define CAMC
Definition mcnaf.cxx:51
CAM24I_R
#define CAM24I_R
Definition mcnaf.cxx:36
CAM16I_Q
#define CAM16I_Q
Definition mcnaf.cxx:33
CAM24O
#define CAM24O
Definition mcnaf.cxx:45
CAM24I_Q
#define CAM24I_Q
Definition mcnaf.cxx:34
CAM_INHIBIT_SET
#define CAM_INHIBIT_SET
Definition mcnaf.cxx:61
CAM24I_SA
#define CAM24I_SA
Definition mcnaf.cxx:40
CAM_LAM_READ
#define CAM_LAM_READ
Definition mcnaf.cxx:57
CAM24O_Q
#define CAM24O_Q
Definition mcnaf.cxx:47
CAM16I
#define CAM16I
Definition mcnaf.cxx:31
CAM24I_RQ
#define CAM24I_RQ
Definition mcnaf.cxx:38
CAM24I_SN
#define CAM24I_SN
Definition mcnaf.cxx:42
CAM_CRATE_CLEAR
#define CAM_CRATE_CLEAR
Definition mcnaf.cxx:62
CAM_INHIBIT_CLEAR
#define CAM_INHIBIT_CLEAR
Definition mcnaf.cxx:60
CAM16O_R
#define CAM16O_R
Definition mcnaf.cxx:48
CAM24O_R
#define CAM24O_R
Definition mcnaf.cxx:49
CAM16I_R
#define CAM16I_R
Definition mcnaf.cxx:35
CAM_CRATE_ZINIT
#define CAM_CRATE_ZINIT
Definition mcnaf.cxx:63
CAM16O_Q
#define CAM16O_Q
Definition mcnaf.cxx:46
CAM_LAM_ENABLE
#define CAM_LAM_ENABLE
Definition mcnaf.cxx:56
CAM16I_SN
#define CAM16I_SN
Definition mcnaf.cxx:41
Here is the call graph for this function:
Here is the caller graph for this function:

◆ read_job_file()

INT read_job_file ( FILE *  pF,
INT  action,
CAMAC **  job,
char *  name 
)

Definition at line 393 of file mcnaf.cxx.

394{
395 DWORD n;
396 char line[128];
397 CAMAC *pjob;
398
399 if (action == CHECK) {
400 if (*name == 0)
401 sprintf(name, "%s", job_name);
402 pF = fopen(name, "r");
403 if (pF) {
404 fclose(pF);
405 return JOB;
406 }
407 printf("CNAF-I- File not found :%s\n", name);
408 return SKIP;
409 } else if (action == READ) {
410 pF = fopen(name, "r");
411 if (pF) {
412 n = 0;
413 /* count the total number of line */
414 while (fgets(line, 128, pF))
415 n++;
416 /* allocate memory for full job */
417 *job = (CAMAC*)malloc((n + 1) * sizeof(CAMAC));
418 pjob = *job;
419 /* preset the full job with 0 */
420 memset((char *) pjob, 0, (n + 1) * sizeof(CAMAC));
421 /* preset the first entry with the predefined CAMAC access */
422 memcpy((char *) pjob, (char *) Prompt, sizeof(CAMAC));
423 rewind(pF);
424 while (fgets(line, 128, pF)) {
425 if (pjob->m == 0) {
426 /* load previous command before overwriting */
427 memcpy((char *) pjob, (char *) (pjob - 1), sizeof(CAMAC));
428 }
429 decode_line(pjob++, line);
430 }
431 fclose(pF);
432 return JOB;
433 }
434 } else
435 printf("CNAF-I- Cmd not found :%s\n", name);
436 return SKIP;
437}
n
DWORD n[4]
Definition mana.cxx:247
name
#define name(x)
Definition midas_macro.h:24
Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ addr

char addr[128]

Definition at line 104 of file mcnaf.cxx.

◆ hDB

HNDLE hDB

main ODB handle

Definition at line 101 of file mcnaf.cxx.

◆ hKey

HNDLE hKey

Definition at line 101 of file mcnaf.cxx.

◆ job_name

char job_name[128] = "cnaf.cnf"

Definition at line 99 of file mcnaf.cxx.

◆ jobflag

BOOL jobflag

Definition at line 103 of file mcnaf.cxx.

◆ MCStd

char MCStd[32][32]
Initial value:
= {
"CAM_CRATE_ZINIT", "CAM_CRATE_CLEAR", "CAM_INHIBIT_SET", "CAM_INHIBIT_CLEAR",
"CAM_LAM_CLEAR", "CAM_LAM_DISABLE", "CAM_LAM_READ", "CAM_LAM_ENABLE",
"CAMC_SN", "CAMC_SA", "CAMC_Q", "CAMC",
"CAM24O_R", "CAM16O_R", "CAM24O_Q", "CAM16O_Q", "CAM24O", "CAM16O",
"CAM24I_SN", "CAM16I_SN", "CAM24I_SA", "CAM16I_SA",
"CAM24I_RQ", "CAM16I_RQ", "CAM24I_R", "CAM16I_R",
"CAM24I_Q", "CAM16I_Q", "CAM24I", "CAM16I", "CAMST", ""
}

Definition at line 66 of file mcnaf.cxx.

66 {
67 "CAM_CRATE_ZINIT", "CAM_CRATE_CLEAR", "CAM_INHIBIT_SET", "CAM_INHIBIT_CLEAR",
68 "CAM_LAM_CLEAR", "CAM_LAM_DISABLE", "CAM_LAM_READ", "CAM_LAM_ENABLE",
69 "CAMC_SN", "CAMC_SA", "CAMC_Q", "CAMC",
70 "CAM24O_R", "CAM16O_R", "CAM24O_Q", "CAM16O_Q", "CAM24O", "CAM16O",
71 "CAM24I_SN", "CAM16I_SN", "CAM24I_SA", "CAM16I_SA",
72 "CAM24I_RQ", "CAM16I_RQ", "CAM24I_R", "CAM16I_R",
73 "CAM24I_Q", "CAM16I_Q", "CAM24I", "CAM16I", "CAMST", ""
74};

◆ pF

FILE* pF

Definition at line 102 of file mcnaf.cxx.

◆ Prompt

CAMAC Prompt[2]
Initial value:
= { {24, 0, 0, 1, 2, 0, 0, 0, 1, 0, 0, 0},
{0}
}

Definition at line 94 of file mcnaf.cxx.

94 { {24, 0, 0, 1, 2, 0, 0, 0, 1, 0, 0, 0},
95{0}
96};