/***********************************************************************
*    TITLE        :SAMPLE.C    PX9301,PX9401送受信テスト メイン
*    VERSION      :V02.01
*    EQUIPMENT    :PX9301,PX9401  (ProXi)
***********************************************************************/
#include <stdio.h>  
#include <stdlib.h>
#include <dos.h>
#include <signal.h>
#include <conio.h>
#include <string.h> 
#include <math.h> 
#include "GPIBUSER.H"

/* ベースアドレス固定モード*/
#define        BASE_ADR_0           0x00c0      /* ch0 base address */
#define        BASE_ADR_S0          0x00c0      /* slave base address */
/* ベースアドレス非固定モード*/
/* #define        BASE_ADR_0        0x10D1  */  /* ch0 base address */
/* #define        BASE_ADR_S0       0x10D1  */  /* slave base address */

#define        INT_VEC_SW_0         0x01        /* int_vec_sw */
#define        INT_VEC_SW_1         0x01        /* int_vec_sw */
#define        MY_ADR_M0            1           /* master my_address */
#define        MY_ADR_S0            2           /* slave my_address  = talker address= lisner address */
#define        SLV                  0xffff      /* slave mode parameter */

#define        RX_BUF_LENGTH        100         /* receive data buffer size */
#define        MAX                  20          /* max count for loop */
#define        START_VALUE          1.23456789  /* 送受信基本データ  */
#define        CONSTANT_VALUE       40          /* 送受信データ乗数 */
#define        DIGITS_VALUE         20          /* 有効桁数 */

void     master_chk_process(unsigned int dma_enb) ;
void     slave_chk_process(unsigned int dma_enb) ;
void     tx(unsigned int addr,unsigned int dma_enb) ;
void     tx_asc(unsigned int addr,unsigned int dma_enb,unsigned int delimitter) ;
void     rx_chk(unsigned int addr,unsigned int dma_enb) ;
void     rx_asc(unsigned int addr,unsigned int dma_enb,unsigned int delimitter) ;
void     echo_back_chk(unsigned int addr,unsigned int dma_enb) ;
void     echo_back_chk_asc(unsigned int addr,unsigned int dma_enb,unsigned delimitter) ;
void     echo_back(unsigned int addr,unsigned int dma_enb) ;
void     echo_back_asc(unsigned int addr,unsigned int dma_enb,unsigned delimitter) ;
void     ctrl_c(void) ;

/**********************************************************************
*    TITLE        main    メイン（テストプログラム）
***********************************************************************/
union   u_tag{
            double  data ;
            unsigned char byte_data[8] ;
} txdat,rxdat ;    /* 送受信データ共用体 */

void main(void)
{
    unsigned int i ;
    unsigned int m_s ;
    unsigned int sts ;
    unsigned int stb ;
    unsigned int ret ;
    unsigned int status_reg0,status_reg1 ;
    unsigned int dma_enb ;
    
    signal(SIGINT,ctrl_c) ;            /*  cntrl/c enable  */

    if( (BASE_ADR_0 & 0x00f0) == 0x00c0) {    
        /* ベースアドレス固定モード*/
        status_reg0 = 0x99 ;    /* ステータスレジスタ０　アドレス */
        status_reg1 = 0x9b ;    /* ステータスレジスタ１　アドレス */
    }
    else {
        /* ベースアドレス非固定モード*/
        status_reg0 = BASE_ADR_0 + 0x100 ;    /* ステータスレジスタ０　アドレス */
        status_reg1 = BASE_ADR_0 + 0x102 ;    /* ステータスレジスタ１　アドレス */
    }
    m_s=inp(status_reg0) ;                 /* dip switch read  */
    m_s &= 0x0020 ;                        /* get master/slave status */
    if(m_s == 0x20) {   /* 0x20:master  */
         /* マスタ側プログラム  */
        printf("  Master Test Start  \n") ;
        gpib_init(BASE_ADR_0,INT_VEC_SW_0,MY_ADR_M0)  ;  /* ボードの初期化  */

        if(gpib_board_type()== 3) dma_enb = 1 ; /* ＤＭＡ有効チェック */
        else dma_enb = 0 ;
        printf("dma_enb = %x\n",dma_enb) ;
        gpib_ifc() ;
        gpib_ren() ;
        gpib_delimit(0x80) ;
        gpib_errmsg_on() ;
        gpib_ppu() ;            /* paralell poll unconfigure */
        gpib_timeout(255) ;     /* タイムアウト時間設定なし。ctrl/cイネーブル  */
/*      gpib_timeout(2) ; */    /* タイムアウト時間設定　２Ｓｅｃ  */
        gpib_srq_on() ;
        while(!gpib_chk_srq()) {            /* srq receive check  */
            /* ＤＩポート状態表示 */
            i=inp(status_reg0) ;             /* status register0 read  */
            printf("REG0 = %x",i) ; 
            i=inp(status_reg1) ;             /* status register1 read  */
            printf("    REG1 = %x ",i) ; 
            i=gpib_chk_ifsts() ;
            printf("    STS = %x \n",i) ; 
        }
        printf(" srq receive \n") ;
        gpib_spoll(MY_ADR_S0,&sts)    ;          /* serial poll */
        printf(" srq status =  %x \n",sts) ;
        
        /* マスタ側チェックプログラム */
        master_chk_process(dma_enb) ;
    }
    else {
         /* スレーブ側プログラム  */
        printf("  Slave Test Start  \n") ;
        gpib_init(BASE_ADR_S0,INT_VEC_SW_0,MY_ADR_S0) ;  /* ボードの初期化  */

        if(gpib_board_type()== 3) dma_enb = 1 ; /* ＤＭＡ有効チェック */
        else dma_enb = 0 ;
        printf("dma_enb = %x\n",dma_enb) ;

        gpib_timeout(255) ;        /* タイムアウト時間設定なし。ctrl/cイネーブル  */
        gpib_delimit(0x80) ;
        gpib_ppr(1) ;
        do{
            /* ＤＩポート状態表示 */
            i=inp(status_reg0) ;        /* status register0 read  */
            printf("REG0 = %x",i) ; 
            i=inp(status_reg1) ;        /* status register1 read  */
            printf("    REG1= %x \n",i) ; 
            printf(" start if  space key push !! \n") ; 
        } while(getchar() != 0x20 ) ;       /* "space"_key_in check  */
        sts = 0x01 ;
        gpib_srq(sts) ;                      /* ＳＲＱ発行 */
        printf("send srq   status = %x \n",sts) ;
        
        /* シリアルポールの有無チェック */
        do {
            ret = gpib_srq_sts(&stb) ; 
            printf("stb = %x ,ret = %x\n",stb,ret) ;
            printf("serial poll waiting \n") ;
        }
        while( (stb & 0x40) != 0x00 ) ;
        printf("serial polled !! \n") ;
        
        /* スレーブ側チェックプログラム */
        slave_chk_process(dma_enb) ;
    }
}

/**********************************************************************
*    TITLE        master_chk_process()    マスタ側チェックルーチン
***********************************************************************/
void     master_chk_process(unsigned int dma_enb)
{
    unsigned int i,cyc,cycx ;
    unsigned int sts,expected_sts,ppr,expected_ppr ;

    cyc = 0 ;
    while(1) {
        tx(MY_ADR_S0,dma_enb) ;
        rx_chk(MY_ADR_S0,dma_enb) ;
        echo_back_chk(MY_ADR_S0,dma_enb) ;
        echo_back(MY_ADR_S0,dma_enb) ;

        while(!gpib_chk_srq()) {                /* srq receive check  */
            printf("waiting srq .......\n")  ;
            for(i=0;i<30000;i++) i=i;    /*  ウェイト　ループ　*/
        }
        cycx = cyc % 8 ;
        switch(cycx) {
            case 0:
                gpib_ppe(MY_ADR_S0,0x0068) ;    /* paralell poll answer dio1 by "1" */
                expected_sts = 0x41 ;
                expected_ppr = 0x01 ;
                break ;
            case 1:
                gpib_ppe(MY_ADR_S0,0x0069) ;    /* paralell poll answer dio2 by "1" */
                expected_sts = 0x42 ;
                expected_ppr = 0x02 ;
                break ;
            case 2:
                gpib_ppe(MY_ADR_S0,0x006a) ;  /* paralell poll answer dio3 by "1" */
                expected_sts = 0x44 ;
                expected_ppr = 0x04 ;
                break ;
            case 3:
                gpib_ppe(MY_ADR_S0,0x006b) ;  /* paralell poll answer dio4 by "1" */
                expected_sts = 0x48 ;
                expected_ppr = 0x08 ;
                break ;
            case 4:
                gpib_ppe(MY_ADR_S0,0x006c) ;  /* paralell poll answer dio5 by "1" */
                expected_sts = 0x50 ;
                expected_ppr = 0x10 ;
                break ;
            case 5:
                gpib_ppe(MY_ADR_S0,0x006d) ;  /* paralell poll answer dio6 by "1" */
                expected_sts = 0x60 ;
                expected_ppr = 0x20 ;
                break ;
            case 6:
                gpib_ppe(MY_ADR_S0,0x006e) ;  /* paralell poll answer dio7 by "1" */
                expected_sts = 0xc0 ;
                expected_ppr = 0x40 ;
                break ;
            case 7:
                gpib_ppe(MY_ADR_S0,0x006f) ;  /* paralell poll answer dio8 by "1" */
                expected_sts = 0xff ;
                expected_ppr = 0x80 ;
                break ;
            default :
                break ;
        }
        gpib_ppoll(&ppr) ;                  /* excute paralell poll */
        printf("\n ppr = %x\n",ppr) ;
        if(expected_ppr != ppr) {
            printf("parallel poll error !! (expected ppr = %x\n",expected_ppr) ;
            gpib_end() ;       /* ＧＰＩＢ終了 */
            exit(0) ;
        }
        gpib_spoll(MY_ADR_S0,&sts) ;        /* serial poll */
        printf(" srq status = %x \n",sts) ;
        if(expected_sts != sts) {
            printf("serial poll error !! (expected sts = %x\n",expected_sts) ;
            gpib_end() ;       /* ＧＰＩＢ終了 */
            exit(0) ;
        }
        printf("\n***** %d cycle end*****\n\n",cyc++) ;
    }
}

/**********************************************************************
*    TITLE        slave_chk_process()    スレーブ側チェックルーチン
***********************************************************************/
void     slave_chk_process(unsigned int dma_enb)
{
    unsigned int cyc,cycx ;
    unsigned int sts,ret ;
    unsigned int stb ;

    cyc = 0 ;
    while(1){
        rx_chk(SLV,dma_enb) ;
        tx(SLV,dma_enb) ;
        echo_back(SLV,dma_enb) ;
        echo_back_chk(SLV,dma_enb) ;
        
        cycx = cyc % 8 ;
        switch(cycx) {
            case 0:
                sts = 0x01 ;
                break ;
            case 1:
                sts = 0x02 ;
                break ;
            case 2:
                sts = 0x04 ;
                break ;
            case 3:
                sts = 0x08 ;
                break ;
            case 4:
                sts = 0x10 ;
                break ;
            case 5:
                sts = 0x20 ;
                break ;
            case 6:
                sts = 0x80 ;
                break ;
            case 7:
                sts = 0xbf ;
                break ;
            default :
                break ;
        }
        gpib_srq(sts) ;  /* ＳＲＱ発行 */
        printf("send srq   status = %x \n",sts) ;
        /* シリアルポールの有無チェック */
        do{
            ret = gpib_srq_sts(&stb) ; 
            printf("stb = %x ,ret = %x\n",stb,ret) ;
            printf("serial poll waiting\n") ;
        }
        while( (stb & 0x40) != 0x00 ) ;
        printf("serial polled !! \n") ;
        
        printf("\n***** %d cycle end*****\n\n",cyc++) ;
    }
}

/**********************************************************************
*    TITLE        tx()    データ送信
***********************************************************************/
void     tx(unsigned int addr,unsigned int dma_enb)
{
    unsigned int i ;
    unsigned int ret ;

    /* バイナリデータ送信 */
    printf("\n send binary, delimitter = 0x80\n") ;
    gpib_delimit(0x80) ;
    txdat.data = START_VALUE ;
    for(i=0;i<MAX;i++) {
        txdat.data *= CONSTANT_VALUE ;
        ret = gpib_print(addr,txdat.byte_data,sizeof(txdat)) ;              /* データの送信 */
        printf("gpib_print_ret = %x, tx_data = %e\n",ret,txdat.data) ;
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            txdat.data *= CONSTANT_VALUE ;
            ret = gpib_print(addr,txdat.byte_data,sizeof(txdat)) ;              /*  データの送信  */    
            printf("gpib_print_ret = %x, tx_data = %e\n",ret,txdat.data) ;
        }
    }
    else {   /* ＤＭＡ使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            txdat.data *= CONSTANT_VALUE ;
            ret = gpib_print_dma(addr,txdat.byte_data,sizeof(txdat)) ;              /*  データの送信  */    
            printf("gpib_print_dma_ret = %x, tx_data = %e\n",ret,txdat.data) ;
        }
    }
    
    /* アスキーデータ送信 */
    tx_asc(addr,dma_enb,0x02) ;
    tx_asc(addr,dma_enb,0x03) ;
    tx_asc(addr,dma_enb,0x01) ;
    tx_asc(addr,dma_enb,0x82) ;
    tx_asc(addr,dma_enb,0x83) ;
    tx_asc(addr,dma_enb,0x81) ;
}

/**********************************************************************
*    TITLE        tx_asc()    アスキーデータ送信
***********************************************************************/
void     tx_asc(unsigned int addr,unsigned int dma_enb,unsigned int delimitter)
{
    unsigned int i ;
    unsigned int ret ;
    char buffer[100] ;

    gpib_delimit(delimitter) ;
    printf("\n send ascii, delimitter = %x\n",delimitter) ;
    txdat.data = START_VALUE ;
    for(i=0;i<MAX;i++) {
        txdat.data *= CONSTANT_VALUE ;
        gcvt(txdat.data,DIGITS_VALUE,buffer); /* 浮動小数点数値をアスキー文字列に変換 */
        ret = gpib_print(addr,buffer,strlen(buffer))  ;   /*  データ送信  */    
        printf("gpib_print_ret = %x, tx_length = %d, tx_data = %e\n",
                    ret,strlen(buffer),txdat.data) ;
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        printf("\n send ascii, delimitter = %x\n",delimitter) ;
        for(i=MAX;i<MAX*2;i++) {
            txdat.data *= CONSTANT_VALUE ;
            gcvt(txdat.data,DIGITS_VALUE,buffer); /* 浮動小数点数値をアスキー文字列に変換 */
            ret = gpib_print(addr,buffer,strlen(buffer)) ;  /* データ送信 */
            printf("gpib_print_ret = %x, tx_length = %d, tx_data = %e\n",
                        ret,strlen(buffer),txdat.data) ;
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        printf("\n send ascii (DMA), delimitter = %x\n",delimitter) ;
        for(i=MAX;i<MAX*2;i++) {
            txdat.data *= CONSTANT_VALUE ;
            gcvt(txdat.data,DIGITS_VALUE,buffer); /* 浮動小数点数値をアスキー文字列に変換 */
            ret = gpib_print_dma(addr,buffer,strlen(buffer)) ;  /*  データ送信  */    
            printf("gpib_print_dma_ret = %x, tx_length = %d, tx_data = %e\n",
                        ret,strlen(buffer),txdat.data) ;
        }
    }
}

/**********************************************************************
*    TITLE        rx_chk()    データ受信 ＆ チェック
***********************************************************************/
void     rx_chk(unsigned int addr,unsigned int dma_enb)
{
    unsigned int i,j ;
    unsigned int ret ;
    unsigned int rx_str_length ;     /* 実際の受信データ数 */
    unsigned char rx_str[RX_BUF_LENGTH] ;
    double  expected_data ;

    /* バイナリデータ受信 */
    printf("\n receive binary, delimitter = 0x80\n") ;
    gpib_delimit(0x80) ;
    expected_data = START_VALUE ;
    for(i=0;i<MAX;i++) {
        expected_data *= CONSTANT_VALUE ;
        ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
        for(j=0;j<rx_str_length;j++) rxdat.byte_data[j] = rx_str[j] ;
        printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                    ret,rx_str_length,rxdat.data) ;
        if(rxdat.data != expected_data) {     /* データが一致しなければエラー   */
            printf("rx binary data error !! (expected_data = %e\n",expected_data) ;
            printf("end test \n") ;
            gpib_end() ;       /* ＧＰＩＢ終了 */
            exit(0) ;
        }
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            expected_data *= CONSTANT_VALUE ;
            ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            for(j=0;j<rx_str_length;j++) rxdat.byte_data[j] = rx_str[j] ;
            printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                        ret,rx_str_length,rxdat.data) ;
            if(rxdat.data != expected_data) {     /* データが一致しなければエラー   */
                printf("rx binary data error !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            expected_data *= CONSTANT_VALUE ;
            ret = gpib_input_dma(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            for(j=0;j<rx_str_length;j++) rxdat.byte_data[j] = rx_str[j] ;
            printf("gpib_input_dma_ret = %x, rx_length = %d, rx_data = %e\n",
                        ret,rx_str_length,rxdat.data) ;
            if(rxdat.data != expected_data) {     /* データが一致しなければエラー   */
                printf("rx binary data error (DMA) !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
    /* アスキーデータ受信 */
    rx_asc(addr,dma_enb,0x02) ;
    rx_asc(addr,dma_enb,0x03) ;
    rx_asc(addr,dma_enb,0x01) ;
    rx_asc(addr,dma_enb,0x82) ;
    rx_asc(addr,dma_enb,0x83) ;
    rx_asc(addr,dma_enb,0x81) ;
}


/**********************************************************************
*    TITLE        rx_asc()    アスキーデータ受信 ＆ チェック
***********************************************************************/
void     rx_asc(unsigned int addr,unsigned int dma_enb,unsigned int delimitter)
{
    unsigned int i ;
    unsigned int ret ;
    unsigned int rx_str_length ;     /* 実際の受信データ数 */
    unsigned char rx_str[RX_BUF_LENGTH] ;
    double   rx_data,tmp_data,expected_data ;
    char buffer[50] ;

    gpib_delimit(delimitter) ;

    tmp_data = START_VALUE ;
    printf("\n receive ascii, delimitter = %x\n",delimitter) ;
    for(i=0;i<MAX;i++) {
        tmp_data *= CONSTANT_VALUE ;
        gcvt(tmp_data,DIGITS_VALUE,buffer); /* 浮動小数点数値をアスキー文字列に変換 */
        expected_data = atof(buffer) ; /* 有効数字の桁合わせ */
        ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
        rx_str[rx_str_length] = '\0' ;
        rx_data = atof(rx_str) ;
        printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                   ret,rx_str_length,rx_data) ;

        if(rx_data != expected_data) {     /* データが一致しなければエラー   */
            printf("rx ascii data error !! (expected_data = %e\n",expected_data) ;
            printf("end test \n") ;
            gpib_end() ;       /* ＧＰＩＢ終了 */
            exit(0) ;
        }
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        printf("\n receive ascii, delimitter = %x\n",delimitter) ;
        for(i=MAX;i<MAX*2;i++) {
            tmp_data *= CONSTANT_VALUE ;
            gcvt(tmp_data,DIGITS_VALUE,buffer); /* 浮動小数点数値をアスキー文字列に変換 */
            expected_data = atof(buffer) ; /* 有効数字の桁合わせ */
            ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            rx_str[rx_str_length] = '\0' ;
            rx_data = atof(rx_str) ;
            printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                       ret,rx_str_length,rx_data) ;
            if(rx_data != expected_data) {     /* データが一致しなければエラー   */
                printf("rx ascii data error !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        printf("\n receive ascii (DMA), delimitter = %x\n",delimitter) ;
        for(i=MAX;i<MAX*2;i++) {
            tmp_data *= CONSTANT_VALUE ;
            gcvt(tmp_data,DIGITS_VALUE,buffer); /* 浮動小数点数値をアスキー文字列に変換 */
            expected_data = atof(buffer) ; /* 有効数字の桁合わせ */
            ret = gpib_input_dma(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            rx_str[rx_str_length] = '\0' ;
            rx_data = atof(rx_str) ;
            printf("gpib_input_dma_ret = %x, rx_length = %d, rx_data = %e\n",
                       ret,rx_str_length,rx_data) ;
            if(rx_data != expected_data) {     /* データが一致しなければエラー   */
                printf("rx ascii data error (DMA) !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
}

/**********************************************************************
*    TITLE        echo_back_chk()    エコーバックテスト
***********************************************************************/
void     echo_back_chk(unsigned int addr,unsigned int dma_enb)
{
    unsigned int i,j ;
    unsigned int ret ;
    unsigned int rx_str_length ;     /* 実際の受信データ数 */
    unsigned char rx_str[RX_BUF_LENGTH] ;
    double  expected_data ;

    /* バイナリデータ エコーバックチェック  */
    printf("\nbinary echo_back check , delimitter = 0x80\n") ;
    gpib_delimit(0x80) ;
    txdat.data = START_VALUE ;
    expected_data = START_VALUE ;
    for(i=0;i<MAX;i++) {
        txdat.data *= CONSTANT_VALUE ;
        expected_data *= CONSTANT_VALUE ;

        ret = gpib_print(addr,txdat.byte_data,sizeof(txdat))  ;   /* データ送信 */    
        printf("gpib_print_ret = %x, tx_data = %e\n",ret,txdat.data) ;
        ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
        for(j=0;j<rx_str_length;j++) rxdat.byte_data[j] = rx_str[j] ;
        printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                    ret,rx_str_length,rxdat.data) ;
        if(rxdat.data != expected_data) {     /* データが一致しなければエラー   */
            printf("binary echo_back data error !! (expected_data = %e\n",expected_data) ;
            printf("end test \n") ;
            gpib_end() ;       /* ＧＰＩＢ終了 */
            exit(0) ;
        }
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        printf("\n binary echo_back check, delimitter = 0x80\n") ;
        for(i=MAX;i<MAX*2;i++) {
            txdat.data *= CONSTANT_VALUE ;
            expected_data *= CONSTANT_VALUE ;
            ret = gpib_print(addr,txdat.byte_data,sizeof(txdat)) ;   /* データ送信 */
            printf("gpib_print_ret = %x, tx_data = %e\n",ret,txdat.data) ;
            ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /* データ受信 */
            for(j=0;j<rx_str_length;j++) rxdat.byte_data[j] = rx_str[j] ;
            printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                        ret,rx_str_length,rxdat.data) ;
            if(rxdat.data != expected_data) {     /* データが一致しなければエラー   */
                printf("binary echo_back data error !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        printf("\n binary echo_back check (DMA), delimitter = 0x80\n") ;
        for(i=MAX;i<MAX*2;i++) {
            txdat.data *= CONSTANT_VALUE ;
            expected_data *= CONSTANT_VALUE ;
            ret = gpib_print_dma(addr,txdat.byte_data,sizeof(txdat)) ;   /* データ送信 */
            printf("gpib_print_dma_ret = %x, tx_data = %e\n",ret,txdat.data) ;
            ret = gpib_input_dma(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /* データ受信 */
            for(j=0;j<rx_str_length;j++) rxdat.byte_data[j] = rx_str[j] ;
            printf("gpib_input_dma_ret = %x, rx_length = %d, rx_data = %e\n",
                        ret,rx_str_length,rxdat.data) ;
            if(rxdat.data != expected_data) {     /* データが一致しなければエラー   */
                printf("binary echo_back data error (DMA)!! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }

    /* アスキーデータ エコーバックチェック */
    echo_back_chk_asc(addr,dma_enb,0x02) ;
    echo_back_chk_asc(addr,dma_enb,0x03) ;
    echo_back_chk_asc(addr,dma_enb,0x01) ;
    echo_back_chk_asc(addr,dma_enb,0x82) ;
    echo_back_chk_asc(addr,dma_enb,0x83) ;
    echo_back_chk_asc(addr,dma_enb,0x81) ;
}

/**********************************************************************
*    TITLE        echo_back_chk_asc()    アスキーエコーバックチェック
***********************************************************************/
void    echo_back_chk_asc(unsigned int addr,unsigned int dma_enb,unsigned delimitter)
{
    unsigned int i ;
    unsigned int ret ;
    unsigned int rx_str_length ;     /* 実際の受信データ数   */
    unsigned char rx_str[RX_BUF_LENGTH] ;
    double   rx_data,tmp_data,expected_data ;
    char buffer0[50],buffer1[50] ;

    gpib_delimit(delimitter) ;
    txdat.data = START_VALUE ;
    tmp_data = START_VALUE ;
    printf("\n ascii echo_back check , delimitter = %x\n",delimitter) ;
    for(i=0;i<MAX;i++) {
        tmp_data *= CONSTANT_VALUE ;
        gcvt(tmp_data,DIGITS_VALUE,buffer1);  /* 浮動小数点数値をアスキー文字列に変換 */
        expected_data = atof(buffer1) ; /* 有効数字の桁合わせ */

        txdat.data *= CONSTANT_VALUE ;
        gcvt(txdat.data,DIGITS_VALUE,buffer0); /* 浮動小数点数値をアスキー文字列に変換 */
        ret = gpib_print(addr,buffer0,strlen(buffer0))  ;   /* データ送信 */    
        printf("gpib_print_ret = %x, tx_length = %d, tx_data = %e\n",
                    ret,strlen(buffer0),txdat.data) ;
        ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /* データ受信 */
        rx_str[rx_str_length] = '\0' ;
        rx_data = atof(rx_str) ;
        printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                   ret,rx_str_length,rx_data) ;

        if(rx_data != expected_data) {     /* データが一致しなければエラー */
            printf("ascii echo_back data error !! (expected_data = %e\n",expected_data) ;
            printf("end test \n") ;
            gpib_end() ;       /* ＧＰＩＢ終了 */
            exit(0) ;
        }
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        printf("\n ascii echo_back check, delimitter = %x\n",delimitter) ;
        for(i=MAX;i<MAX*2;i++) {
            tmp_data *= CONSTANT_VALUE ;
            gcvt(tmp_data,DIGITS_VALUE,buffer1);  /* 浮動小数点数値をアスキー文字列に変換 */
            expected_data = atof(buffer1) ; /* 有効数字の桁合わせ */

            txdat.data *= CONSTANT_VALUE ;
            gcvt(txdat.data,DIGITS_VALUE,buffer0); /* 浮動小数点数値をアスキー文字列に変換 */
            ret = gpib_print(addr,buffer0,strlen(buffer0))  ;   /* データ送信 */    
            printf("gpib_print_ret = %x, tx_length = %d, tx_data = %e\n",
                        ret,strlen(buffer0),txdat.data) ;
            ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /* データ受信 */
            rx_str[rx_str_length] = '\0' ;
            rx_data = atof(rx_str) ;
            printf("gpib_input_ret = %x, rx_length = %d, rx_data = %e\n",
                       ret,rx_str_length,rx_data) ;

            if(rx_data != expected_data) {   /* データが一致しなければエラー */
                printf("ascii echo_back data error !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        printf("\n ascii echo_back check (DMA), delimitter = %x\n",delimitter) ;
        for(i=MAX;i<MAX*2;i++) {
            tmp_data *= CONSTANT_VALUE ;
            gcvt(tmp_data,DIGITS_VALUE,buffer1);  /* 浮動小数点数値をアスキー文字列に変換 */
            expected_data = atof(buffer1) ; /* 有効数字の桁合わせ */

            txdat.data *= CONSTANT_VALUE ;
            gcvt(txdat.data,DIGITS_VALUE,buffer0); /* 浮動小数点数値をアスキー文字列に変換 */
            ret = gpib_print_dma(addr,buffer0,strlen(buffer0))  ;   /* データ送信 */    
            printf("gpib_print_dma_ret = %x, tx_length = %d, tx_data = %e\n",
                        ret,strlen(buffer0),txdat.data) ;
            ret = gpib_input_dma(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /* データ受信 */
            rx_str[rx_str_length] = '\0' ;
            rx_data = atof(rx_str) ;
            printf("gpib_input_dma_ret = %x, rx_length = %d, rx_data = %e\n",
                       ret,rx_str_length,rx_data) ;

            if(rx_data != expected_data) {     /* データが一致しなければエラー */
                printf("ascii echo_back data error (DMA) !! (expected_data = %e\n",expected_data) ;
                printf("end test \n") ;
                gpib_end() ;       /* ＧＰＩＢ終了 */
                exit(0) ;
            }
        }
    }
}

/**********************************************************************
*    TITLE        echo_back()    データエコーバック
***********************************************************************/
void     echo_back(unsigned int addr,unsigned int dma_enb)
{
    unsigned int i ;
    unsigned int ret ;
    unsigned int delimitter ;
    unsigned int rx_str_length ;     /* 実際の受信データ数   */
    unsigned char rx_str[RX_BUF_LENGTH] ;

    printf("\n") ;
    /* バイナリデータ エコーバック */
    delimitter = 0x80;
    gpib_delimit(delimitter)  ; 
    for(i=0;i<MAX;i++) {
        ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
        ret = gpib_print(addr,rx_str,rx_str_length) ;  /* データ送信 */    
        printf("ascii data echo back, delimitter = %x\n",delimitter) ;
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            ret = gpib_print(addr,rx_str,rx_str_length) ;  /* データ送信 */    
            printf("ascii data echo back, delimitter = %x\n",delimitter) ;
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            ret = gpib_input_dma(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            ret = gpib_print_dma(addr,rx_str,rx_str_length) ;  /* データ送信 */    
            printf("ascii data echo back (DMA), delimitter = %x\n",delimitter) ;
        }
    }
    /* アスキーデータ エコーバック */
    echo_back_asc(addr,dma_enb,0x02) ;
    echo_back_asc(addr,dma_enb,0x03) ;
    echo_back_asc(addr,dma_enb,0x01) ;
    echo_back_asc(addr,dma_enb,0x82) ;
    echo_back_asc(addr,dma_enb,0x83) ;
    echo_back_asc(addr,dma_enb,0x81) ;
}

/**********************************************************************
*    TITLE        echo_back_asc()     アスキーデータエコーバック
***********************************************************************/
void  echo_back_asc(unsigned int addr,unsigned int dma_enb,unsigned delimitter)
{
    unsigned int i ;
    unsigned int ret ;
    unsigned int rx_str_length ;     /* 実際の受信データ数 */
    unsigned char rx_str[RX_BUF_LENGTH] ;

    /* アスキーデータ エコーバック */
    printf("\n") ;
    gpib_delimit(delimitter)  ; 
    for(i=0;i<MAX;i++) {
        ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
        ret = gpib_print(addr,rx_str,rx_str_length) ;  /* データ送信 */    
        printf("ascii data echo back, delimitter = %x\n",delimitter) ;
    }
    if(dma_enb == 0) {   /* ＤＭＡ不使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            ret = gpib_input(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            ret = gpib_print(addr,rx_str,rx_str_length) ;  /* データ送信 */    
            printf("ascii data echo back, delimitter = %x\n",delimitter) ;
        }
    }
    else {  /* ＤＭＡ使用の場合 */
        for(i=MAX;i<MAX*2;i++) {
            ret = gpib_input_dma(addr,rx_str,RX_BUF_LENGTH,&rx_str_length) ; /*  データ受信  */
            ret = gpib_print_dma(addr,rx_str,rx_str_length) ;  /* データ送信 */    
            printf("ascii data echo back (DMA), delimitter = %x\n",delimitter) ;
        }
    }
}

/******************************************/
/*    control/c process                   */
/******************************************/
void    ctrl_c()
{
    printf("\n cntrl_c & gpib_end \n") ;
    gpib_end() ;
    exit(0) ;
}