gpib.c

Go to the documentation of this file.

 
#include "user_config.h"
#include "hal.h"
#include "gpib_hal.h"
 
#include "defines.h"
#include "gpib.h"
#include "gpib_task.h"
#include "amigo.h"
#include "ss80.h"
 
#include "fatfs.h"
#include "posix.h"
#include "debug.h"
 
 
extern void gpib_user_task();
 
uint8_t gpib_iobuff[GPIB_IOBUFF_LEN];
 
uint8_t gpib_unread_f = 0;                        // saved character flag
uint16_t gpib_unread_data;                        // saved character and status
 
uint8_t talking;
uint8_t talking_last;
 
uint8_t listening;
uint8_t listening_last;
 
uint8_t spoll;
uint16_t lastcmd,current;
 
uint8_t secondary;
 
typedef struct
{
    int cmd;
    char *name;
} gpib_token_t;
 
gpib_token_t gpib_tokens[] =
{
    {0x01,"GTL" },
    {0x04,"SDC" },
    {0x05,"PPC" },
    {0x08,"GET" },
    {0x09,"TCT" },
    {0x11,"LLO" },
    {0x14,"DCL" },
    {0x15,"PPU" },
    {0x18,"SPE" },
    {0x19,"SPD" },
    {0x3F,"UNL" },
    {0x5F,"UNT" },
    {-1,NULL }
};
 
 
void gpib_timer_elapsed_begin( void )
{
 
#ifdef SYSTEM_ELAPSED_TIMER
    clock_elapsed_begin();
#else
    cli();
    gpib_timer.elapsed = 0;
    sei();
#endif
}
 
 
 
void gpib_timer_reset( void )
{
    cli();
    gpib_timer.elapsed = 0;
    gpib_timer.down_counter = 0;
    gpib_timer.down_counter_done = 1;
    sei();
}
 
 
void gpib_timer_elapsed_end( char *msg)
{
#ifdef SYSTEM_ELAPSED_TIMER
    clock_elapsed_end( msg );
#else
    uint32_t val;
    uint32_t seconds;
    uint32_t useconds;
 
    cli();
    val  = gpib_timer.elapsed;
    sei();
 
    seconds = val * GPIB_TASK_TIC_US / 1000000L;
    useconds = (val * GPIB_TASK_TIC_US ) % 1000000L;
 
    printf("[%s: %ld.%06ld]\n", msg, seconds,useconds);
#endif
}
 
 
void gpib_timer_task()
{
    cli();
#ifndef SYSTEM_ELAPSED_TIMER
    gpib_timer.elapsed++;
#endif
    if(gpib_timer.down_counter)
        gpib_timer.down_counter--;
    else
        gpib_timer.down_counter_done = 1;
    sei();
}
 
 
void gpib_timeout_set(uint32_t time)
{
// printf("\n%8ld\n", (long)time);
    cli();
    gpib_timer.down_counter = time;
    gpib_timer.down_counter_done = 0;
    sei();
}
 
 
uint8_t gpib_timeout_test()
{
// printf("%8ld,%d\r", (long)gpib_timer.down_counter, (int)gpib_timer.down_counter_done);
    return(gpib_timer.down_counter_done);
}
 
void gpib_bus_init( )
{
 
    uint8_t sreg = SREG;
    cli();
    gpib_unread_f = 0;
 
    GPIB_BUS_IN();                                // CPU data direction IN
    GPIB_BUS_LATCH_WR(0xff);                      // Float them HIGH
 
    // ============
    // Handshake lines
    // TX, TE = 1, DAV = T, NDAC = R, NRFD = R
    // RX, TE = 0, DAV = R, NDAC = T, NRFD = T
    GPIB_PIN_FLOAT_UP(DAV);                       // DAV FLOAT PULLUP
    GPIB_PIN_FLOAT_UP(NRFD);                      // SRQ FLOAT PULLUP
    GPIB_PIN_FLOAT_UP(NDAC);                      // NDAC FLOAT PULLUP
    // ============
 
    // ============
    // DC = 1
    // Always Inputs
    // We will NEVER write to ATN,IFC,REN,SRQ after BUS init
    GPIB_PIN_FLOAT_UP(ATN);                       // ATN FLOAT PULLUP
    GPIB_PIN_FLOAT_UP(IFC);                       // IFC FLOAT PULLUP
    GPIB_PIN_FLOAT_UP(REN);                       // REN FLOAT PULLUP
    // Always OC output
    GPIB_PIN_FLOAT_UP(SRQ);                       // SRQ FLOAT PULLUP
    // ============
 
    // ============
    // EOI
    // TX if TE = 1, ATN = 1
    // RX if TE = 1, ATN = 0
    // RX if TE = 0, ATN = 1
    GPIB_PIN_FLOAT_UP(EOI);                       // EOI FLOAT PULLUP
    // ============
 
#if BOARD == 2
    // ALWAYS in device mode
    // SC = 0, DC = 1 
    GPIB_IO_LOW(SC);                              // REN IN, IFC IN
    GPIB_IO_HI(DC);                               // ATN IN, EOI IN, SRQ OUT OC
    // Always OC mode in case parallel poll happens
    // PE= 0, OC BUS transciever mode
    GPIB_IO_LOW(PE);                              // Enable OC GPIB BUS transceivers
    // TE is the ONLY SN75160B/SN75162B control bit we use in device mode
    // RX = 0, TX = 1
    GPIB_IO_LOW(TE);                              // BUS IN, DAV IN, NDAC OUT OC, NRFD OUT OC
#endif
 
    GPIB_BUS_SETTLE();                            // Let Data BUS settle
 
    SREG = sreg;
 
#if SDEBUG
    if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
        printf("[GPIB BUS_INIT]\n");
#endif
 
}
 
 
 
// This function sets the following states
// GPIB_BUS_LATCH_WR(0xff); // float BUS 
// GPIB_IO_LOW(TE);         // BUS IN
// BUS IN, DAV IN, NDAC OUT, NRFD OUT
// ATN IN, EOI IN, SRQ OUT OC
// ============
void gpib_rx_init(uint8_t busy)
{
    uint8_t sreg = SREG;
    cli();
    GPIB_BUS_IN();                                // CPU data direction IN
    GPIB_BUS_LATCH_WR(0xff);                      // Float them HIGH
 
    // RX, TE = 0, DAV = R, NDAC = T, NRFD = T
    GPIB_PIN_FLOAT_UP(DAV);                       // DAV FLOAT PULLUP
 
    GPIB_PIN_FLOAT_UP(EOI);                       // EOI FLOAT PULLUIP
 
//FIXME
// If ATN = 0, then set NRFD = 0, NDAC = 0
// (SPecification says within 200 nanoseconds) 
// To permit three-wire handshake 
 
    if(GPIB_PIN_TST(ATN) == 0 || busy)
    {
#if BOARD == 2
        GPIB_IO_LOW(TE);                          // BUS IN, DAV IN, NDAC OUT, NRFD OUT
#endif
        GPIB_IO_LOW(NDAC);
        GPIB_IO_LOW(NRFD);
 
    }
    if(!busy)
    {
        GPIB_PIN_FLOAT_UP(NRFD);                  // OC PULLUP
        GPIB_PIN_FLOAT_UP(NDAC);                  // OC PULLUP
#if BOARD == 2
        GPIB_IO_LOW(TE);                          // BUS IN, DAV IN, NDAC OUT, NRFD OUT
#endif
 
    }
    SREG = sreg;
}
 
 
 
// This function sets the following states
// GPIB_BUS_LATCH_WR(0xff); // float BUS 
// GPIB_IO_HI(TE);          // BUS OUT with OC PULLUP
// BUS IN, DAV OUT, NDAC IN, NRFD IN
// ATN IN, EOI IN/OUT, SRQ OUT OC
// ============
// EOI IN/OUT
// TX if TE = 1, ATN = 1
// RX if TE = 1, ATN = 0
// NOTE: IF ATN goes low when writing when should abort!
void gpib_tx_init()
{
    uint8_t sreg = SREG;
    cli();
    GPIB_BUS_IN();                                // CPU data direction IN
    GPIB_BUS_LATCH_WR(0xff);                      // Float them HIGH
    // TX, TE = 1, DAV = T, NDAC = R, NRFD = R
    GPIB_PIN_FLOAT_UP(DAV);                       // DAV FLOAT PULLUP
    GPIB_PIN_FLOAT_UP(NRFD);                      // SRQ FLOAT PULLUP
    GPIB_PIN_FLOAT_UP(NDAC);                      // NDAC FLOAT PULLUP
 
    GPIB_PIN_FLOAT_UP(EOI);                       // EOI FLOAT PULLUIP
#if BOARD == 2
    GPIB_IO_HI(TE);
#endif
    GPIB_BUS_OUT();
    SREG = sreg;
}
 
 
void gpib_state_init( void )
{
#if SDEBUG
    if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
        printf("[GPIB STATE INIT]\n");
#endif
// Disable Parallel Poll Response
    ppr_init();
 
    listen_cleanup();
 
    talk_cleanup();
 
    spoll = 0;                                    // SPOLL disabled
    talking = 0;                                  // Listening/Talking State
    talking_last = 0;
    listening = 0;
    listening_last  = 0;
    lastcmd = 0;
    current = 0;
    secondary = 0;
}
 
 
void gpib_enable_PPR(int bit)
{
    if(bit < 0 || bit > 7)
    {
        printf("gpib_enable_PPR: bit %d out of range\n", (int) bit);
        return;
    }
    ppr_bit_set(bit);
#if SDEBUG
    if(debuglevel & GPIB_PPR)
        printf("[EPPR bit:%d, mask:%02XH]\n",0xff & bit , 0xff & ppr_reg());
#endif
}
 
 
 
void gpib_disable_PPR(int bit)
{
    if(bit < 0 || bit > 7)
    {
        printf("gpib_disable_PPR: bit %d out of range\n", (int) bit);
        return;
    }
    ppr_bit_clr(bit);
#if SDEBUG
    if(debuglevel & GPIB_PPR)
        printf("[DPPR bit:%d, mask:%02XH]\n",0xff & bit, 0xff & ppr_reg());
#endif
}
 
 
 
uint8_t gpib_detect_PP()
{
    uint8_t ddr, pins;
 
    if(GPIB_PIN_TST(ATN) == 0 && GPIB_PIN_TST(EOI) == 0 )
    {
 
#if SDEBUG
        if(debuglevel & GPIB_PPR)
            gpib_timer_elapsed_begin();
#endif
 
        if(debuglevel & GPIB_PP_BUS_STATUS)
        {
            // Versions 2 hardware must have bus in READ mode
            // If not - then data reported wll not be correct 
            //  - harmless - debugging only
            pins = GPIB_PPR_RD(); // Reads Pin states without updating data direction
 
            ddr = GPIB_PPR_DDR_RD();
#if SDEBUG
            if(debuglevel & GPIB_PPR)
                printf("[PPR:%02XH, PIN:%02XH, DDR:%02XH]\n",
                    0xff & ppr_reg(), 0xff & pins, 0xff & ddr );
#endif
        }
        // Wait for the PPR state to end as there is no handshake
        while(GPIB_PIN_TST(ATN) == 0 && GPIB_PIN_TST(EOI) == 0 )
        {
            if(uart_keyhit(0))
            {
#if 0
                if(debuglevel & GPIB_ERR)
                    printf("gpib_detect_PP: ATN=0 EOI=0\n");
#endif
                break;
            }
 
            // IFC is always in for a device
            if(GPIB_PIN_TST(IFC) == 0)
            {
                // IFC test and gpib_bus_init() is tested 
                // in every state machine loop
                // So not needed here
                // gpib_bus_init();
                if(debuglevel & GPIB_ERR)
                    printf("gpib_detect_PP: IFC\n");
                break;
            }
        }
#if SDEBUG
        if(debuglevel & GPIB_PPR)
            gpib_timer_elapsed_end("PP released");
#endif
        return(1);
    }
    return(0);
}
 
 
 
uint16_t gpib_unread(uint16_t ch)
{
    if(!gpib_unread_f)
    {
        gpib_unread_data = ch;
        gpib_unread_f = 1;
    }
    else
    {
        if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
            printf("gpib_unread: error, can only be called once!\n");
    }
    return(ch);
}
 
 
uint8_t gpib_bus_read()
{
    uint8_t bus = ~(GPIB_BUS_RD());
 
    if(!GPIB_PIN_TST(ATN))
        bus &= 0x7f;
    else
        bus &= 0xff;
    return(bus);
}
 
 
uint16_t gpib_control_pin_read()
{
    uint16_t control = 0;
    if(GPIB_PIN_TST(ATN) == 0 )
        control |= ATN_FLAG;
    if(GPIB_PIN_TST(EOI) == 0 )
        control |= EOI_FLAG;
    if(GPIB_PIN_TST(SRQ) == 0 )
        control |= SRQ_FLAG;
    if(GPIB_PIN_TST(REN) == 0 )
        control |= REN_FLAG;
    if(GPIB_PIN_TST(IFC) == 0 )
        control |= IFC_FLAG;
    return(control);
}
 
 
uint16_t gpib_handshake_pin_read()
{
    uint16_t control = 0;
    if(GPIB_PIN_TST(DAV) == 0 )
        control |= DAV_FLAG;
    if(GPIB_PIN_TST(NRFD) == 0 )
        control |= NRFD_FLAG;
    if(GPIB_PIN_TST(NDAC) == 0 )
        control |= NDAC_FLAG;
    return(control);
}
 
 
uint16_t gpib_write_byte(uint16_t ch)
{
    uint8_t tx_state;
 
// We are always in READ state at this point 
// No need to initialize as READ mode
// Now Done in write_str
#if 0
    gpib_rx_init(0);    // NOT busy, NRFD and NDAC OC
#endif
 
    tx_state = GPIB_TX_START;
    gpib_timeout_set(HTIMEOUT);
    while(tx_state != GPIB_TX_DONE )
    {
    // Not called for writting
#if 0
        gpib_user_task();
#endif
 
        if(uart_keyhit(0))
        {
#if 0
            if(debuglevel & GPIB_ERR)
                printf("gpib_write_byte: KEY state=%d\n", tx_state);
#endif
            break;
        }
 
#if 0
// FIXME - this test used to break write:
// We assume that ATN and EOI are always IN during this test
// Try to detect PPR - only for debugging
        if(gpib_detect_PP())
            ch |= PP_FLAG;
#endif
 
// IFC is always in for a device
        if(GPIB_PIN_TST(IFC) == 0)
        {
            ch |= IFC_FLAG;
            gpib_bus_init();
            if(debuglevel & GPIB_ERR)
                printf("gpib_write_byte: IFC state=%d\n", tx_state);
            break;
        }
 
        switch(tx_state)
        {
            // DAV == 1 the bus is ready
            case GPIB_TX_START:
                gpib_tx_init();
                GPIB_PIN_FLOAT_UP(DAV);
                GPIB_BUS_SETTLE();                // Let Data BUS settle
 
                gpib_timeout_set(HTIMEOUT);
                tx_state = GPIB_TX_PUT_DATA;
                break;
 
// Wait for NRFD or NDAC LOW
            case GPIB_TX_WAIT_FOR_NRFD_OR_NDAC_LOW:
                if(GPIB_PIN_TST(NRFD) == 0 || GPIB_PIN_TST(NDAC) == 0)
                {
                    if(GPIB_PIN_TST(ATN) == 1)
                    {
                        gpib_timeout_set(HTIMEOUT);
                        tx_state = GPIB_TX_PUT_DATA;
                    }
                    else
                    {
#ifdef SDEBUG
                        if(debuglevel & GPIB_ERR)
                            printf("gpib_write_byte: ATN = 0 while waiting for NRFD LOW state =%d\n",tx_state);
#endif
                    }
                    break;
                }
                if (gpib_timeout_test())
                {
                    if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
                        printf("<gpib_write_byte timeout waiting for NRFD==1 && NDAC == 0>\n");
                    ch |= TIMEOUT_FLAG;
                    tx_state = GPIB_TX_ERROR;
                    break;
                }
                break;
 
// Write Data
            case GPIB_TX_PUT_DATA:
                if(ch & EOI_FLAG)
                    GPIB_IO_LOW(EOI);
                else
                    GPIB_PIN_FLOAT_UP(EOI);
                GPIB_BUS_WR((ch & 0xff) ^ 0xff);  // Write Data inverted
                GPIB_BUS_SETTLE();                // Let Data BUS settle
 
                gpib_timeout_set(HTIMEOUT);
                tx_state = GPIB_TX_WAIT_FOR_NRFD_HI;
                break;
 
// Wait for BOTH NRFD HI and NDAC LOW
            case GPIB_TX_WAIT_FOR_NRFD_HI:
#if 0
                if(GPIB_PIN_TST(NRFD) == 1 && GPIB_PIN_TST(NDAC) == 0)
#else
                if(GPIB_PIN_TST(NRFD))
#endif
                {
                    tx_state = GPIB_TX_SET_DAV_LOW;
                }
                if (gpib_timeout_test())
                {
                    if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
                        printf("<gpib_write_byte timeout waiting for NRFD==1 && NDAC == 0>\n");
                    ch |= TIMEOUT_FLAG;
                    tx_state = GPIB_TX_ERROR;
                    break;
                }
                break;
 
            case GPIB_TX_SET_DAV_LOW:
                GPIB_IO_LOW(DAV);
                GPIB_BUS_SETTLE();                
                gpib_timeout_set(HTIMEOUT);
                tx_state = GPIB_TX_WAIT_FOR_NDAC_HI;
                break;
 
            case GPIB_TX_WAIT_FOR_NDAC_HI:
                if(GPIB_PIN_TST(NDAC) == 1)       // Byte byte accepted
                {
                    tx_state = GPIB_TX_SET_DAV_HI;
                    break;
                }
                if (gpib_timeout_test())
                {
                    ch |= TIMEOUT_FLAG;
                    tx_state = GPIB_TX_ERROR;
                    if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
                        printf("<gpib_write_byte timeout waiting for NDAC==1>\n");
                }
                break;
 
            case GPIB_TX_SET_DAV_HI:
                GPIB_PIN_FLOAT_UP(DAV);
                GPIB_BUS_SETTLE();
                tx_state = GPIB_TX_FINISH;
                gpib_timeout_set(HTIMEOUT);
                break;
 
            case GPIB_TX_FINISH:
 
                tx_state = GPIB_TX_DONE;
                break;
 
            case GPIB_TX_ERROR:
                // Free BUS, BUSY on error
                gpib_rx_init(1);
                if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
                    printf("<GPIB TX TIMEOUT>\n");
                tx_state = GPIB_TX_DONE;
                break;
 
// FIXME do we want to be busy at this point
            case GPIB_TX_DONE:
                break;
        }
    }
    return(ch);
}
 
 
/*
DAV - Data Valid Used to Indicate the condition of the information on the Data (010)
    lines. Driven TRUE (low) by the source when data Is settled and valid and NRFD
    FALSE (high) has been sensed.
NRFD - Not Ready For Data Used to Indicate the condition of readiness of device(s)
    to accept data. An acceptor sets NRFD TRUE {low} to Indicate It Is not ready
    to accept data. It· sets this line FALSE (high) when It Is ready to accept data.
    However, the NRFD line to the source wlll not go high until all participating
    acceptors are ready to accept data.
NDAC - Not Data Accepted Used to Indicate the condition of acceptance of data
    by device(s). The acceptor sets NDAC TRUE (low) to indicate it has not accepted
    data. When It accepts data from the 010 lines, It will set Its NDAC line FALSE
    (high). However, the NDAC line to the source wlll not go high until the
    last/slowest participating· acceptor accepts the data..
*/
 
 
uint16_t gpib_read_byte(int trace)
{
    uint8_t rx_state;
    uint16_t ch;
    uint16_t bus, control, control_last;
    extern uint8_t gpib_unread_f;
    extern uint16_t gpib_unread_data;
 
    ch = 0;
    control_last = 0;
 
    // Return unread - last read - data and control lines
    if(gpib_unread_f)
    {
        // FYI any unread data has been traced
        gpib_unread_f = 0;
        return(gpib_unread_data);
    }
 
    // We start and end gpib_read_byte() with NRFD and NDAC LOW 
    // When ATN goes LOW all devices must pull NRFD and NDAC lines LOW
    // within 200 nanoseconds to permit three-wire handshake 
    // ATN requirements are met because we are always reading in command mode
    // ATN = 0 = COmmand Mode
    gpib_rx_init(1);
 
    // gpib_rx_init(1) sets the following states
    // NRFD = 0 Not Ready for Data, NDAC = 0 Data Not Accepted
    // GPIB_IO_LOW(TE);         // BUS IN
    // BUS IN, DAV IN, NDAC OUT , NRFD OUT 
    // ATN IN, EOI IN, SRQ OUT OC
 
    if(trace)
    {
        control_last = gpib_control_pin_read();
        control_last |= gpib_handshake_pin_read();
        gpib_trace_display(control_last, TRACE_BUS);
    }
 
    gpib_timeout_set(HTIMEOUT);
    rx_state = GPIB_RX_START;
    while(rx_state != GPIB_RX_DONE)
    {
 
        // User task that is called while waiting for commands
        gpib_user_task();
 
        if(uart_keyhit(0))
        {
#if 0
            if(debuglevel & GPIB_ERR)
                printf("gpib_read_byte: state=%d\n", rx_state);
#endif
            break;
        }
 
// Try to detect parallel poll (PP) for debugging 
// This test raily detects PP
// Can only work on V1 hardware
#if BOARD == 1
        if(gpib_detect_PP())
            ch |= PP_FLAG;
#endif
 
        // IFC is alwayon IN always in device mode
        if(GPIB_PIN_TST(IFC) == 0)
        {
            ch |= IFC_FLAG;
            if(debuglevel & GPIB_ERR)
                printf("gpib_read_byte: IFC state=%d\n", rx_state);
            gpib_bus_init();
            break;
        }
 
        switch(rx_state)
        {
 
            case GPIB_RX_START:
                //DEBUG
                if (GPIB_PIN_TST(DAV) == 1)
                {
                    GPIB_BUS_SETTLE();                // Let Data BUS settle
                    GPIB_PIN_FLOAT_UP(NRFD);
                    GPIB_BUS_SETTLE();                // Let Data BUS settle
                    rx_state = GPIB_RX_WAIT_FOR_DAV_LOW;
                }
                if (gpib_timeout_test())
                {
                    ch |= TIMEOUT_FLAG;
                    rx_state = GPIB_RX_ERROR;
                }
                break;
 
            // Wait for Data Avalable without timeout
            case GPIB_RX_WAIT_FOR_DAV_LOW:
                if ( GPIB_PIN_TST(DAV) == 0 )
                {
                    GPIB_BUS_SETTLE();                
                    rx_state = GPIB_RX_DAV_IS_LOW;
                }
                break;
 
            // Data is Avaliable
            case GPIB_RX_DAV_IS_LOW:
                GPIB_IO_LOW(NRFD); // BUSY
                GPIB_BUS_SETTLE();                
 
                // Read DATA and Control lines
                // gpib_bus_read() strips parity if ATN is low command state
 
                bus = gpib_bus_read();
                ch |= bus;
 
 
                control_last = gpib_control_pin_read();
                ch |= control_last;
 
                // In theory the control_last should not have changed
                // from the initial values. ONly the Data BUS
                if(trace)
                {
                    control_last |= gpib_handshake_pin_read();
                    gpib_trace_display(bus | control_last, TRACE_READ);
                }
 
                // Release NDAC to say we read the byte
                GPIB_PIN_FLOAT_UP(NDAC);
                GPIB_BUS_SETTLE();                // NDAC bus settle time
                gpib_timeout_set(HTIMEOUT);
                rx_state = GPIB_RX_WAIT_FOR_DAV_HI;
                break;
 
            case GPIB_RX_WAIT_FOR_DAV_HI:
                if (GPIB_PIN_TST(DAV) == 1)
                {
                    GPIB_BUS_SETTLE();
                    rx_state = GPIB_RX_DAV_IS_HI;
                }
                if (gpib_timeout_test())
                {
                    ch |= TIMEOUT_FLAG;
                    rx_state = GPIB_RX_ERROR;
                }
                break;
 
            case GPIB_RX_DAV_IS_HI:
                GPIB_IO_LOW(NDAC);
                GPIB_BUS_SETTLE();
                // Now BOTH NDAC and NRFD are LOW
                rx_state = GPIB_RX_DONE;
                break;
 
            case GPIB_RX_ERROR:
                GPIB_IO_LOW(NRFD);
                GPIB_IO_LOW(NDAC);
                rx_state = GPIB_RX_DONE;
                break;
 
            case GPIB_RX_DONE:
                break;
        }
 
        if(trace)
        {
            control = gpib_control_pin_read();
            control |= gpib_handshake_pin_read();
            if(control_last != control)
            {
                gpib_trace_display(control, TRACE_BUS);
                control_last = control;
            }
        }
    }
 
 
    lastcmd = current;
 
    if(ch & ERROR_MASK || (ch & ATN_FLAG) == 0)
        current = 0;
    else
        current = ch & CMD_MASK;
 
    return (ch);
}
 
 
void gpib_decode_header( FILE *fo)
{
    if(fo == NULL)
        fo = stdout;
 
    fprintf(fo,"==============================\n");
    fprintf(fo,"GPIB bus state\n");
    fprintf(fo,"HH . AESRPITB gpib\n");
    fprintf(fo,"HH = Hex value of Command or Data\n");
    fprintf(fo,"   . = ASCII of XX only for 0x20 .. 0x7e\n");
    fprintf(fo,"     A = ATN\n");
    fprintf(fo,"      E = EOI\n");
    fprintf(fo,"       S = SRQ\n");
    fprintf(fo,"        R = REN\n");
    fprintf(fo,"         I = IFC\n");
    fprintf(fo,"          P = Parallel Poll seen\n");
    fprintf(fo,"           T = TIMEOUT\n");
    fprintf(fo,"            B = BUS_ERROR\n");
    fprintf(fo,"              GPIB commands\n");
}
 
 
void gpib_trace_display(uint16_t status,int trace_state)
{
    char str[128];
    char *tmp= str;
    uint8_t bus = status & 0xff;
    extern FILE *gpib_log_fp;
 
    str[0] = 0;
 
// Display data bus ???
    if(trace_state == TRACE_DISABLE || trace_state == TRACE_READ)
    {
        uint8_t printable = ' ';                  // Data
        if( !(status & ATN_FLAG) && (bus >= 0x20 && bus <= 0x7e) )
            printable = bus;
        sprintf(str, "%02X %c ", (int)bus & 0xff, (int)printable);
    }
    else
    {
        sprintf(str, "     ");
    }
 
    tmp = str + strlen(str);
 
    if(status & ATN_FLAG)
        *tmp++ = 'A';
    else
        *tmp++ = '-';
 
    if(status & EOI_FLAG)
        *tmp++ = 'E';
    else
        *tmp++ = '-';
 
    if(status & SRQ_FLAG)
        *tmp++ = 'S';
    else
        *tmp++ = '-';
 
    if(status & REN_FLAG)
        *tmp++ = 'R';
    else
        *tmp++ = '-';
 
    if(status & IFC_FLAG)
        *tmp++ = 'I';
    else
        *tmp++ = '-';
 
    if(trace_state == TRACE_DISABLE)
    {
        if(status & PP_FLAG)
            *tmp++ = 'P';
        else
            *tmp++ = '-';
        if(status & TIMEOUT_FLAG)
            *tmp++ = 'T';
        else
            *tmp++ = '-';
        if(status & BUS_ERROR_FLAG)
            *tmp++ = 'B';
        else
            *tmp++ = '-';
    }
    else
    {
// not used when tracing
        *tmp++ = '-';
        *tmp++ = '-';
        *tmp++ = '-';
    }
    *tmp = 0;
 
    if(trace_state == TRACE_READ || trace_state == TRACE_BUS)
    {
        if(status & DAV_FLAG)
            strcat(str,"  DAV");
        else
            strcat(str,"     ");
        if(status & NRFD_FLAG)
            strcat(str," NRFD");
        else
            strcat(str,"     ");
        if(status & NDAC_FLAG)
            strcat(str," NDAC");
        else
            strcat(str,"     ");
    }
 
    if( (status & ATN_FLAG) )
    {
        int i;
        int cmd = status & CMD_MASK;
        if(cmd >= 0x020 && cmd <= 0x3e)
            sprintf(tmp," MLA %02Xh", cmd & 0x1f);
        else if(cmd >= 0x040 && cmd <= 0x4e)
            sprintf(tmp," MTA %02Xh", cmd & 0x1f);
        else if(cmd >= 0x060 && cmd <= 0x6f)
            sprintf(tmp," MSA %02Xh", cmd & 0x1f);
        else
        {
            for(i=0;gpib_tokens[i].cmd != -1;++i)
            {
                if(cmd == gpib_tokens[i].cmd)
                {
                    strcat(tmp," ");
                    strcat(tmp,gpib_tokens[i].name);
                    break;
                }
            }
        }
    }
 
    if(gpib_log_fp == NULL)
        gpib_log_fp = stdout;
 
// Echo to console unless file is the console
    if(gpib_log_fp != stdout)
        puts(str);
 
// Save to file
    fprintf(gpib_log_fp,"%s\n",str);
}
 
 
 
void gpib_decode(uint16_t ch)
{
    gpib_trace_display(ch,0);
}
 
 
int gpib_read_str(uint8_t *buf, int size, uint16_t *status)
{
    uint16_t val;
    int ind = 0;
 
    *status &= STATUS_MASK;
 
    if(!size)
    {
        if(debuglevel & (GPIB_ERR + GPIB_DEVICE_STATE_MESSAGES + GPIB_RW_STR_BUS_DECODE))
            printf("gpib_read_str: size = 0\n");
    }
 
    while(ind < size)
    {
        val = gpib_read_byte(NO_TRACE);
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_BUS_DECODE)
            gpib_decode(val);
#endif
        if(val & ERROR_MASK)
        {
            *status |= (val & ERROR_MASK);
            break;
        }
 
        if((*status & ATN_FLAG) != (val & ATN_FLAG))
        {
            if(debuglevel & (GPIB_ERR + GPIB_DEVICE_STATE_MESSAGES + GPIB_RW_STR_BUS_DECODE))
                printf("gpib_read_str(ind:%d): ATN %02XH unexpected\n",ind, 0xff & val);
            gpib_unread(val);
            break;
        }
 
        if(val & ATN_FLAG)
            buf[ind] = (val & CMD_MASK);
        else
            buf[ind] = (val & DATA_MASK);
        ++ind;
 
        if(!(val & ATN_FLAG) && (val & EOI_FLAG) )
        {
 
            if(*status & EOI_FLAG)
                return(ind);
            *status |= EOI_FLAG;
            break;
        }
    }
    if ( ind != size ) 
    {
        if(debuglevel & (GPIB_ERR + GPIB_DEVICE_STATE_MESSAGES))
            printf("[gpib_read_str read(%d) expected(%d)]\n", ind , size);
    }
    return(ind);
}
 
 
int gpib_write_str(uint8_t *buf, int size, uint16_t *status)
{
    uint16_t val, ch;
    int ind = 0;
 
    *status &= STATUS_MASK;
 
    if(!size)
    {
        if(debuglevel & (GPIB_ERR + GPIB_DEVICE_STATE_MESSAGES + GPIB_RW_STR_BUS_DECODE))
            printf("gpib_write_str: size = 0\n");
    }
 
    // Start with NRFD and NDAC = 1 - ie off the OC BUS
    gpib_rx_init(0);
 
// Wait until ATN is released!
#if 1
    if (GPIB_PIN_TST(ATN) == 0)
    {
        // Switch to READ mode and NRFD = 0, NDAC = 0
        // gpib_rx_init(0);
#if 0
        // This debug statements only proves ATN can be low when called
        printf("gpib_write_str: ATN = 1 at start\n");
#endif
        // Wait for ATN free
        // Keep in mind that we have been addressed to talk already
        // So waiting is ok - they won't be expecting a reply until
        // They are ready
        gpib_timeout_set(HTIMEOUT);
        while(GPIB_PIN_TST(ATN) == 0)
        {
            if(gpib_timeout_test())
            {
                gpib_rx_init(1);
                if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
                    printf("<gpib_write_str timeout waiting for ATN = 1>\n");
                *status |= (TIMEOUT_FLAG | BUS_ERROR_FLAG);
                return(ind);
            }
        }
    }
#endif
 
// Wait until DAV is released!
#if 1
    // Wait if DAV = 0 as the bus is busy
    gpib_timeout_set(HTIMEOUT);
    while ( GPIB_PIN_TST(DAV) == 0)
    {
        if(gpib_timeout_test())
        {
            if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
                printf("<BUS waiting for DAV==1>\n");
            *status |= (TIMEOUT_FLAG | BUS_ERROR_FLAG);
            return(ind);
        }
    }
#endif
 
    while(ind < size)
    {
        ch = buf[ind++] & 0xff;                   // unsigned
 
        if( (*status & EOI_FLAG) && (ind == size ) )
            ch |= EOI_FLAG;
 
 
        val = gpib_write_byte(ch);
        *status |= (val & ERROR_MASK);
 
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_BUS_DECODE)
            gpib_decode(val);
#endif
        if(val & ERROR_MASK)
        {
            break;
        }
 
    }                                             // while(ind < size)
 
// End by setting receive mode and set NRFD and NDAC busy until
// we get back to the main loop (this happens very quickly
    gpib_rx_init(1);    // BUSY
 
    if ( ind != size )
    {
        if(debuglevel & (GPIB_ERR + GPIB_DEVICE_STATE_MESSAGES + GPIB_RW_STR_BUS_DECODE))
            printf("[gpib_write_str sent(%d) expected(%d)]\n", ind,size);
    }
    return(ind);
}