Return to q.c CVS log

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

Annotation of researchv10no/cmd/qsnap/q.c, revision 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.