Return to q.c CVS log

Up to [Research Unix] / researchv10dc / cmd / qsnap

Annotation of researchv10dc/cmd/qsnap/q.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: 
                      3: int flag = 0;
                      4: int Errors=0;
                      5: 
                      6: static
                      7: srq()
                      8: {      signal(2, srq);
                      9:        flag = 1 - flag;
                     10:        printf("<SRQ>");
                     11:        fflush(stdout);
                     12: }
                     13: 
                     14: qreset()
                     15: {      register i;
                     16: 
                     17:        printf("waiting for reset.."); fflush(stdout);
                     18:        signal(2, srq);
                     19:        if ((i = gpib(4)) < 0)
                     20:                iberr(i, "Gpib Clear");
                     21:        if ((i = gpib(5)) < 0)
                     22:                iberr(i, "Gpib Remote");
                     23:        sleep(12);
                     24:        printf("done\n"); fflush(stdout);
                     25:        Errors=0;
                     26: }
                     27: 
                     28: qcmd(cmd, len)
                     29:        char *cmd;
                     30: {
                     31:        register i;
                     32:        if (Errors) return;
                     33:        /* unlisten, untalk, interface talk, qcr listen */
                     34:        if ((i = gpib(0, "\077\137\043\125", 4)) < 0)
                     35:        {       iberr(i, "cmd setup");
                     36:                Errors++;
                     37:                return;
                     38:        }
                     39:        if ((i = gpib(1, cmd, len, 2)) < 0)
                     40:        {       iberr(i, "cmd send");
                     41:                Errors++;
                     42:                return;
                     43:        }
                     44: }
                     45: 
                     46: qwrite(cmd, len)
                     47:        char *cmd;
                     48: {
                     49:        register i;
                     50: 
                     51:        if (Errors) return;
                     52:        /* unlisten, untalk, interface talk, qcr listen */
                     53:        if ((i = gpib(0, "\077\137\042\125", 4)) < 0)
                     54:        {       iberr(i, "write setup");
                     55:                Errors++;
                     56:                return 0;
                     57:        }
                     58:        if ((i = gpib(1, cmd, len, 2)) < 0)
                     59:        {       iberr(i, "write cmd");
                     60:                Errors++;
                     61:                return 0;
                     62:        }
                     63:        return i;
                     64: }
                     65: 
                     66: qread(cmd, len)
                     67:        char *cmd;
                     68: {
                     69:        register i;
                     70: 
                     71:        if (Errors) return;
                     72:        /* unlisten, untalk, interface talk, qcr listen */
                     73:        if ((i = gpib(0, "\077\137\102\065", 3)) < 0)
                     74:        {       iberr(i, "read setup");
                     75:                Errors++;
                     76:                return 0;
                     77:        }
                     78:        if ((i = gpib(2, cmd, len, 0)) < 0)
                     79:        {       iberr(i, "read cmd");
                     80:                Errors++;
                     81:                return 0;
                     82:        }
                     83:        return i;
                     84: }
                     85: 
                     86: qpause()
                     87: {      int i;
                     88: 
                     89:        for (i=1000*500; i>0; i--)      /* was 1000*200 */
                     90:                ;
                     91: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.