gpib_task.c

Go to the documentation of this file.

 
#include "user_config.h"
 
#include "defines.h"
#include "drives.h"
#include "gpib_hal.h"
#include "gpib.h"
#include "gpib_task.h"
#include "amigo.h"
#include "ss80.h"
#include "vector.h"
#include "printer.h"
#include "debug.h"
 
char cfgfile[] = "/hpdisk.cfg";
FIL  fp_file;
 
int debuglevel = 1;
 
FILE *gpib_log_fp = NULL;
 
void gpib_file_init()
{
    int errors;
 
    debuglevel = 0;
 
    errors = Read_Config(cfgfile);
    if(errors > 0)
        printf("%s had %d errors\n", cfgfile, errors);
    if(errors < 0)
        printf("%s open failure\n", cfgfile);
 
    set_Config_Defaults();
 
    if(mmc_wp_status())
        printf("Card is write protected\n");
}
 
 
void gpib_log( char *str )
{
    if(gpib_log_fp != NULL )
        fprintf(gpib_log_fp,"%s\n", str);
}
 
 
int SS80_is_MLA(int address)
{
    int index = find_device(SS80_TYPE, address, BASE_MLA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
int SS80_is_MTA(int address)
{
    int index = find_device(SS80_TYPE, address, BASE_MTA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
int SS80_is_MSA(int address)
{
    int index = find_device(SS80_TYPE, address, BASE_MSA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
#ifdef AMIGO
int AMIGO_is_MLA(int address)
{
    int index = find_device(AMIGO_TYPE, address, BASE_MLA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
int AMIGO_is_MTA(int address)
{
    int index = find_device(AMIGO_TYPE, address, BASE_MTA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
int AMIGO_is_MSA(int address)
{
    int index = find_device(AMIGO_TYPE, address, BASE_MSA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
#endif                                            // #ifdef AMIGO
 
int PRINTER_is_MLA(int address)
{
    int index = find_device(PRINTER_TYPE, address, BASE_MLA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
int PRINTER_is_MTA(int address)
{
    int index = find_device(PRINTER_TYPE, address, BASE_MTA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
int PRINTER_is_MSA(int address)
{
    int index = find_device(PRINTER_TYPE, address, BASE_MSA);
    if(index == -1)
        return(0);
    return(set_active_device(index));
}
 
 
 
void gpib_trace_task( char *name , int detail)
{
    int ch;
 
    if(name && *name)
    {
        name = skipspaces(name);
        printf("Capturing GPIB BUS to:%s\n", name);
        if(detail)
            printf("FULL GPIB BUS handshake logging requested\n");
        printf("Press ANY key to exit\n");
 
        gpib_log_fp = fopen(name,"wb");
        if(gpib_log_fp == NULL)
        {
            perror("open failed");
            printf("exiting...\n");
            return;
        }
    }
    else
    {
        gpib_log_fp = stdout;
    }
 
    // gpib_state_init();                            // Init PPR talking and listening states
    // gpib_state_init is in gpib_init_devices()
    gpib_init_devices();
 
    gpib_decode_header(gpib_log_fp);
    while(1)                                      // Main loop, forever
    {
        if(uart_keyhit(0))
            break;
 
        ch = gpib_read_byte(detail);
        if(!detail)
            gpib_decode(ch);
    }
 
    printf("Done\n");
    if(gpib_log_fp)
    {
        fclose(gpib_log_fp);
        printf("Capturing Closed\n");
        gpib_log_fp = stdout;
    }
}
 
 
 
uint16_t gpib_error_test(uint16_t val)
{
 
    if(val & ERROR_MASK || uart_keyhit(0) || mmc_ins_status() != 1 )
    {
        val &= ERROR_MASK;
 
        if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_TOP_LEVEL_BUS_DECODE + GPIB_DEVICE_STATE_MESSAGES))
        {
            if(val & IFC_FLAG)
                printf("<IFC>\n");
        }
 
        if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_TOP_LEVEL_BUS_DECODE + GPIB_DEVICE_STATE_MESSAGES))
        {
            if(val & TIMEOUT_FLAG)
                printf("<TIMEOUT>\n");
            if(val & BUS_ERROR_FLAG)
                printf("<BUS>\n");
        }
 
        if(uart_keyhit(0))
            printf("<INTERRUPT>\n");
 
        if( mmc_ins_status() != 1 )
            printf("<MEDIA MISSING>\n");
 
        if(val & IFC_FLAG)
        {
            gpib_init_devices();
        }
 
        if(uart_keyhit(0))
        {
            gpib_init_devices();
            return(ABORT_FLAG);
        }
 
        if( mmc_ins_status() != 1 )
        {
            return(ABORT_FLAG);
        }
 
// Wait for IFC free
        if(val & IFC_FLAG )
        {
            while(GPIB_IO_RD(IFC) == 0)
                ;
        }
        return(val);
    }
    return(0);
}
 
 
void gpib_init_devices(void)
{
    gpib_bus_init();                              // Not busy - we have to free all pins on the BUS
 
// Init PPR talking and listening states
// Enable this 14 April 2020 - testing MIke Gore
    gpib_state_init();
 
    SS80_init();                                  // SS80 state init
 
#ifdef AMIGO
    amigo_init();                                 // AMIGO state init
#endif
 
    printer_close();                              // Close any open fprinter files
}
 
 
 
uint16_t GPIB_COMMANDS(uint16_t val, uint8_t unread)
{
    uint16_t status;
 
    if(talking != UNT)
    {
 
#ifdef AMIGO
        if ( AMIGO_is_MLA(listening) )
        {
            if(unread)
                gpib_unread(val);
// secondary was previously set
            status = AMIGO_COMMANDS(secondary);
            secondary = 0;
            return(status);
        }
#endif                                    // ifdef AMIGO
 
        if ( SS80_is_MLA(listening) )
        {
            if(unread)
                gpib_unread(val);
// secondary was previously set
            status = SS80_COMMANDS(secondary);
            secondary = 0;
            return(status);
        }
 
        if ( PRINTER_is_MLA(listening) )
        {
            if(unread)
                gpib_unread(val);
            status = PRINTER_COMMANDS(secondary);
            secondary = 0;
            return(status);
        }
    }
 
    if(listening != UNL)
    {
#ifdef AMIGO
        if ( AMIGO_is_MTA(talking) )
        {
            if(unread)
                gpib_unread(val);
            status = AMIGO_COMMANDS(secondary);
            secondary = 0;
            return(status);
        }
#endif
 
        if ( SS80_is_MTA(talking) )
        {
            if(unread)
                gpib_unread(val);
            status = SS80_COMMANDS(secondary);
            secondary = 0;
            return(status);
        }
 
        if ( PRINTER_is_MTA(talking) )
        {
            if(unread)
                gpib_unread(val);
            status = PRINTER_COMMANDS(secondary);
            secondary = 0;
            return(status);
        }
    }
    return(0);
}
 
 
 
void gpib_task(void)
{
    uint16_t val;
    uint8_t ch;
    uint16_t status;
 
    gpib_init_devices();                          // Init devices
    // gpib_state_init() is now done in gpib_init_devices
    // gpib_state_init();                            // Init PPR talking and listening states
 
    gpib_log_fp = NULL;
 
    while(1)
    {
 
 
        val = gpib_read_byte(NO_TRACE);
 
#if SDEBUG
        if(debuglevel & GPIB_TOP_LEVEL_BUS_DECODE)
            gpib_decode(val);
#endif
        status = gpib_error_test(val);
        if(status & ABORT_FLAG)
        {
            return;
        }
        else if(status & MEDIA_FLAG)
        {
            return;
        }
        else if(status)
        {
            continue;
        }
        if(val & ATN_FLAG)
        {
            ch = val & CMD_MASK;
            if(ch <= 0x1f)
            {
                GPIB(ch);
                continue;
            }
            if(ch >= 0x20 && ch <= 0x3f)
            {
                GPIB_LISTEN(ch);
                continue;
            }
            if(ch >= 0x40 && ch <= 0x5f)
            {
                GPIB_TALK(ch);
                continue;
            }
 
 
            if( listening && lastcmd == UNT)
            {
                secondary = 0;
                GPIB_SECONDARY_ADDRESS(ch);
                continue;
            }
 
            secondary = ch;
            status = GPIB_COMMANDS(secondary,0);
            status = gpib_error_test(status);
            if(status & ( ABORT_FLAG | MEDIA_FLAG ))
            {
                return;
            }
            if(status)
            {
                continue;
            }
            continue;
 
        }                                         // GPIB ATN
 
        else                                      // GPIB Data
        {
            if ( PRINTER_is_MLA(listening) )
            {
                printer_buffer( 0xff & val );
                continue;
            }
 
            if(!secondary)
                continue;
 
// ONLY secondar commands at this point
            status = GPIB_COMMANDS(val,1);
            status = gpib_error_test(status);
 
            if(status & ( ABORT_FLAG | MEDIA_FLAG ))
            {
                return;
            }
            if(status)
            {
                continue;
            }
            continue;
        }
    }                                             // while(1)
    return;
}
 
 
 
int Send_Identify(uint8_t ch, uint16_t ID)
{
    uint16_t status = EOI_FLAG;
    uint8_t tmp[2];
 
    V2B_MSB(tmp,0,2,ID);
    if(gpib_write_str(tmp,2, &status) != 2)
    {
        if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[IDENT Unit:%02XH=%04XH FAILED]\n",
                (int)ch,(int)ID);
        return(status & ERROR_MASK);
    }
#if SDEBUG
    if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
        printf("[IDENT Unit:%02XH=%04XH]\n", (int)ch,(int)ID);
#endif
    return (status & ERROR_MASK);
}
 
 
 
int GPIB(uint8_t ch)
{
    if(ch == PPC)
    {
        if(debuglevel & (GPIB_ERR + GPIB_PPR + GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_TODO))
            printf("[PPC unsupported TODO]\n");
        spoll = 0;
        return 0;
    }
    if(ch == PPU)
    {
        if(debuglevel & (GPIB_ERR + GPIB_PPR + GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_TODO))
            printf("[PPU unsupported TODO]\n");
        spoll = 0;
        return 0;
    }
 
#if defined(SPOLL)
    if(ch == SPE)
    {
#if SDEBUG
        if(debuglevel & (GPIB_PPR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
            printf("[SPE]\n");
#endif
        spoll = 1;
        if(SS80_is_MTA(talking))
        {
            return( SS80_Report() );
        }
        return 0;
    }
 
    if(ch == SPD)
    {
#if SDEBUG
        if(debuglevel & (GPIB_PPR + GPIB_BUS_OR_CMD_BYTE_MESSAGES))
            printf("[SPD]\n");
#endif
        spoll = 0;
        return 0;
    }
#endif                                        // #if defined(SPOLL)
 
    if(ch == SDC )
    {
#if SDEBUG
        if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
            printf("[SDC]\n");
#endif
        if(SS80_is_MLA(listening))
        {
#if SDEBUG
            if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SDC SS80]\n");
#endif
            return(SS80_Selected_Device_Clear(SS80s->unitNO) );
        }
 
#ifdef AMIGO
        if(AMIGO_is_MLA(listening))
        {
#if SDEBUG
            if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SDC AMIGO]\n");
#endif
            return( amigo_cmd_clear() );
        }
#endif                                    // #ifdef AMIGO
 
        return( 0 );
    }
 
    if(ch == DCL )
    {
#if SDEBUG
        if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
            printf("[DCL]\n");
#endif
        SS80_Universal_Device_Clear();
 
#ifdef AMIGO
        amigo_cmd_clear();
#endif
 
        printer_close();
        return( 0 );
    }
 
    if(debuglevel & (GPIB_ERR + GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_TODO))
        printf("[GPIB (%02XH) not defined TODO]\n", 0xff & ch);
    return(0);
}
 
 
 
int GPIB_LISTEN(uint8_t ch)
{
    listening_last = listening;
    listening = ch;
 
    listen_cleanup();
 
    if(ch == UNL)
    {
        listening = 0;
 
#if SDEBUG
        if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
        {
            printf("[UNL]\n");
            if(lastcmd == UNT)
                printf("\n");
        }
#endif
        return(0);
    }
 
#ifdef AMIGO
    if(AMIGO_is_MLA(ch))
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[LA %02XH AMIGO]\n", 0xff & ch);
#endif
        return(0);
    }
#endif                                        // #ifdef AMIGO
 
    if(SS80_is_MLA(ch))
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[LA %02XH SS80]\n", 0xff & ch);
#endif
        return(0);
    }
 
    if(PRINTER_is_MLA(ch))
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[LA %02XH PRINTER]\n", 0xff & ch);
#endif
        if(talking != UNT)
        {
// FIXME use printer structure to permit multiple printers
            printer_open(NULL);
        }
        return(0);
    }
#if SDEBUG
    if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
        printf("[LA %02XH]\n", 0xff & ch);
#endif
    return(0);
}                                                 // Listen Primary Address group
 
 
 
int GPIB_TALK(uint8_t ch)
{
 
    talking_last = talking;
    talking = ch;
 
    talk_cleanup();
 
    if(ch == UNT)
    {
//FIXME talking = 0 ????
#if SDEBUG
        if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
            printf("[UNT]\n");
#endif
        return(0);
    }
 
    if(SS80_is_MTA(ch))
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[TA %02XH SS80]\n", 0xff & ch);
#endif
 
        if (spoll)
        {
            SS80_Report();
        }
        return(0);
    }
 
#ifdef AMIGO
    if(AMIGO_is_MTA(ch))
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[TA %02XH AMIGO]\n", 0xff & ch);
#endif
        return(0);
    }
#endif                                        // #ifdef AMIGO
 
    if(PRINTER_is_MTA(ch))
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[TA %02XH PRINTER]\n", 0xff & ch);
#endif
        return(0);
    }
 
    if(PRINTER_is_MLA(listening))
    {
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[PRINTER OPEN]\n");
        printer_open(NULL);
        return(0);
    }
 
#if SDEBUG
    if(debuglevel & GPIB_BUS_OR_CMD_BYTE_MESSAGES)
        printf("[TA %02XH]\n", 0xff & ch);
#endif
    return(0);
}                                                 // Talk Address primary address group
 
 
int GPIB_SECONDARY_ADDRESS(uint8_t ch)
{
 
    if(SS80_is_MSA(ch) )
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[SA %02XH SS80]\n", 0xff & ch);
#endif
        gpib_disable_PPR(SS80p->HEADER.PPR);
        return(Send_Identify( ch, SS80p->CONFIG.ID) );
 
    }
 
#ifdef AMIGO
    if(AMIGO_is_MSA(ch) )
    {
#if SDEBUG
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[SA %02XH AMIGO]\n", 0xff & ch);
#endif
        gpib_disable_PPR(AMIGOp->HEADER.PPR);
        return( Send_Identify( ch, AMIGOp->CONFIG.ID) );
    }
#endif                                        // #ifdef AMIGO
 
#if SDEBUG
    if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
        printf("[SA %02XH, listen:%02XH, talk:%02XH]\n",
            0xff & ch, 0xff & listening, 0xff & talking);
#endif
    return(0);
}
 
 
void listen_cleanup()
{
    if(listening_last)
    {
        int index = find_device(PRINTER_TYPE, listening_last, BASE_MLA);
        if(index == -1)
            return;
 
//We should not set the active device globally
//FIXME if we have to then printer close should temprarily do so
        if(debuglevel & (GPIB_BUS_OR_CMD_BYTE_MESSAGES + GPIB_DEVICE_STATE_MESSAGES))
            printf("[PRINTER close]\n");
        printer_close();
    }
}
 
 
 
void talk_cleanup()
{
 
}
 
 
 
void DumpData(unsigned char *ptr,int length)
{
    int i,j;
    char ch;
    printf("[Dump: %d]\n",length);
    for(j=0;j<80&&(j*16<length);j++)
    {
        printf("\n");
        for(i=0;i<16 && (i+j*16<length);i++)
        {
            ch = *(ptr+i+j*16);
            printf(" %02X",ch&0xFF);
        }
        printf(" | ");
        for(i=0;i<16 && (i+j*16<length);i++)
        {
            if(*(ptr+i+j*16)>' ') printf("%c",(*(ptr+i+j*16))&0xFF);
            else printf(".");
        }
    }
    printf("\n");
}