comport.c

Open DMT Client C Source code

    } else

#if defined(COMPORT_SUPPORT_USB)
    // 'ttyUSB' serial port
    if (strStartsWithIgnoreCase(p, ComName_TTYUSB)) {
        pnum = p + strlen(ComName_TTYUSB);
        dft  = -1; // must be a valid #
        base = 0;  // indexes start at '0' for "ttyUSB" devices
        type = COMTYPE_USB;
    } else
#endif

    // Error (name not recognized)
    {
        // name not found, exit now
        return -1L;
    }

    /* if found, extract index and return port */
    int port0 = (int)strParseInt32(pnum, dft) - base;
    if ((port0 >= 0) && (port0 <= MAX_COM_PORT)) {
        return (type | PORT_Index0(port0));
    } else {
        return -1L;
    }

}

/* return the name of the specified port */
static char tempPortName[MAX_COM_NAME_SIZE + 1];
static const char *_comPortNameForPort(char *name, Int32 port)
{
    if (!name) { name = tempPortName; } // not thread safe
    // 'name' must be at least (MAX_COM_NAME_SIZE + 1) bytes long
    *name = 0;
    
    // Standard serial port
    if (PORT_IsSTANDARD(port)) {
#if defined(USE_COM_NAMES)
        sprintf(name, "%s%d", ComName_COM, PORT_Index1(port));
#else
        sprintf(name, "%s%d", ComName_TTYS, PORT_Index0(port));
#endif
    } else 
    
#if defined(COMPORT_SUPPORT_USB)
    // USB serial port
    if (PORT_IsUSB(port)) {
#  if defined(USE_COM_NAMES)
        sprintf(name, "%s%d", ComName_USB, PORT_Index1(port));
#  else
        sprintf(name, "%s%d", ComName_TTYUSB, PORT_Index0(port));
#  endif
    } else
#endif
    
#if defined(COMPORT_SUPPORT_CONSOLE)
    // Console serial emulator
    if (PORT_IsCONSOLE(port)) {
        strcpy(name, ComName_CONSOLE);
    } else
#endif

#if defined(COMPORT_SUPPORT_PIPE)
    // Server Pipe serial emulator
    if (PORT_IsSPIPE(port)) {
        sprintf(name, "%s%d", ComName_SPIPE, PORT_Index0(port));
    } else
#endif

#if defined(COMPORT_SUPPORT_PIPE)
    // Client Pipe serial emulator
    if (PORT_IsCPIPE(port)) {
        sprintf(name, "%s%d", ComName_CPIPE, PORT_Index0(port));
    } else
#endif

#if defined(COMPORT_SUPPORT_SOCKET)
    // Client socket serial emulator
    if (PORT_IsCSOCK(port)) {
        sprintf(name, "%s%d", ComName_CSOCK, PORT_Index0(port));
    } else
    // Client socket serial emulator
    if (PORT_IsNMEAD(port)) {
        sprintf(name, "%s%d", ComName_NMEAD, PORT_Index0(port));
    } else
    // Server socket serial emulator
    if (PORT_IsSSOCK(port)) {
        sprintf(name, "%s%d", ComName_SSOCK, PORT_Index0(port));
    } else
#endif

#if defined(COMPORT_SUPPORT_BLUETOOTH)
    // Bluetooth serial port
    if (PORT_IsBLUETOOTH(port)) { 
#  if defined(TARGET_GUMSTIX)
        strcpy(name, ComName_RFCOMM0);
#  else
        sprintf(name, "%s%d", ComName_BT, PORT_Index1(port));
#  endif
    } else
#endif

    // Error (port not recognized)
    {
        strcpy(name, ComName_INVALID);
    }
    
    return name;
}

/* return true if specified name is valid */
utBool comPortIsValidName(const char *portName)
{
    return (_comPortPortForName(portName) > 0L)? utTrue : utFalse;
}

// ----------------------------------------------------------------------------

/* return the device name for the specified port */
static const char *_comPortDeviceForPort(char *device, Int32 port)
{
    if (device) {
        // 'device' must be at least (MAX_COM_DEV_SIZE + 1) bytes long
        *device = 0;
        
        // Standard serial ports
        if (PORT_IsSTANDARD(port)) {
#if defined(TARGET_WINCE)
            sprintf(device, "%s%d:", ComDev_COM, PORT_Index1(port));
#else
//          sprintf(device, "%s%s%d", ComDev_DIR, ComDev_COM, PORT_Index1(port));
//          strToLowerCase(device);
            sprintf(device, "%s%s%d", ComDev_DIR, ComDev_ttyS, PORT_Index0(port));
#endif
        } else
        
#if defined(COMPORT_SUPPORT_USB)
        // USB serial ports
        if (PORT_IsUSB(port)) {
#  if defined(TARGET_WINCE)
            sprintf(device, "%s%d:", ComDev_COM, PORT_Index1(port));
#  else
            sprintf(device, "%s%s%d", ComDev_DIR, ComDev_ttyUSB, PORT_Index0(port));
#  endif
        } else
#endif

#if defined(COMPORT_SUPPORT_BLUETOOTH)
        // Bluetooth serial ports
        if (PORT_IsBLUETOOTH(port)) {
#  if defined(TARGET_WINCE)
            sprintf(device, "%s%d:", ComDev_COM, PORT_Index1(port));
#  elif defined(TARGET_GUMSTIX)
            // special case port for bluetooth connectivity
            // this port exists only when a bluetooth connection is present
            sprintf(device, "%s%s", ComDev_DIR, ComDev_rfcomm0);
#  else
            sprintf(device, "%s%s%d", ComDev_DIR, ComDev_ttyS, PORT_Index0(port));
#  endif
        } else
#endif

        // Error (port not recognized)
        {
#if defined(TARGET_WINCE)
            sprintf(device, "%s?:", ComDev_COM);
#else
            sprintf(device, "%s%s?", ComDev_DIR, ComDev_ttyS);
#endif
        }

    }
    return device;
}

// ----------------------------------------------------------------------------

/* log data to console */
static void _comPortDefaultLogger(const UInt8 *data, int dataLen)
{
    // this function is used for DEBUG purposes only
    int i;
    for (i = 0; i < dataLen; i++) {
        fprintf(stdout, "%c", data[i]);  // logging: ignore returned error code
        if (data[i] == '\n') {
            fprintf(stdout, "\r");       // logging: ignore returned error code
        } else
        if (data[i] == '\r') {
            fprintf(stdout, "\n");       // logging: ignore returned error code
        }
    }
    fflush(stdout);                      // logging: ignore returned error code
}

/* set external function data logger */
void comPortSetDebugLogger(ComPort_t *com, void (*logger)(const UInt8*, int))
{
    if (com) {
        com->logger = logger? logger : &_comPortDefaultLogger;
        comPortAddOptions(com, COMOPT_LOGDEBUG);
    }
}

// ----------------------------------------------------------------------------

/* initialize ComPort_t structure */
ComPort_t *comPortInitStruct(ComPort_t *com)
{
    if (com) {
        
        /* clear common */
        memset(com, 0, sizeof(ComPort_t));
        com->open     = utFalse;
        com->port     = -1L;
        com->push     = -1;
        com->error    = COMERR_NONE;
        
        /* WinCE fields */
#if defined(TARGET_WINCE)
        errno         = ERROR_SUCCESS;
        com->portId   = INVALID_HANDLE_VALUE;
        // Linux, Cygwin, etc. fields
#else
        com->read_fd  = -1;
        com->write_fd = -1;
#endif

    }
    return com;
}

// ----------------------------------------------------------------------------

/* open ComPort with specified speed (8N1 is assumed) */
#if defined(TARGET_WINCE)
utBool comPortSetTimeouts(ComPort_t *com, UInt32 readInterval, UInt32 readTotal, UInt32 writeTotal)
{
    COMMTIMEOUTS commTimeouts;
    commTimeouts.ReadIntervalTimeout            = readInterval;  // ms between chars
    commTimeouts.ReadTotalTimeoutMultiplier     = 1;
    commTimeouts.ReadTotalTimeoutConstant       = readTotal;
    commTimeouts.WriteTotalTimeoutMultiplier    = 5;
    commTimeouts.WriteTotalTimeoutConstant      = writeTotal;
    if (!SetCommTimeouts(com->portId, &commTimeouts)) {
        // Possible Errors:
        //  87  ERROR_INVALID_PARAMETER
        DWORD err = GetLastError();
        if (err == ERROR_INVALID_PARAMETER) {
            // maybe this device doesn't support timeouts?
            logWARNING(LOGSRC,"This device doesn't seem to support timeouts?");
            return utFalse; // utTrue;
        } else {
            logERROR(LOGSRC,"Unable to set ComPort timeouts [%lu] ...", (UInt32)err);
            return utFalse;
        }
    } else {
        return utTrue;
    }
}
#endif

// ----------------------------------------------------------------------------

/* open ComPort with specified speed */
#if defined(TARGET_WINCE)
// NOTE: port number indexes start at '1'
ComPort_t *comPortOpen(ComPort_t *com, const char *portName, long bps, const char *dataFmt, utBool hwFlow)
{
   
    /* null structure? */
    if (!com) {
        // internal error
        logWARNING(LOGSRC,"ComPort structure is 'null'");
        return (ComPort_t*)0;
    }

    /* clear structure */
    comPortInitStruct(com);
    com->port = _comPortPortForName(portName);
    if (com->port < 0L) {
        // internal error
        logWARNING(LOGSRC,"Unrecognized port name: %s", portName);
        com->error = COMERR_INIT;
        strCopy(com->name, sizeof(com->name), portName, -1);
        return (ComPort_t*)0;
    }
    _comPortNameForPort(com->name, com->port);
    _comPortDeviceForPort(com->dev, com->port);
    logDEBUG(LOGSRC,"ComPort name=%s, port=0x%04lX, dev=%s", com->name, com->port, com->dev);
    
    /* control options */
    com->hwFlow = hwFlow;
    utBool isReadOnly = utFalse;

    /* open */
    wchar_t wceDev[sizeof(com->dev)];
    strWideCopy(wceDev, sizeof(wceDev)/sizeof(wceDev[0]), com->dev, -1);
    //logDEBUG(LOGSRC,"Open ComPort: %s [%s]", portName, com->dev);
    com->portId = CreateFile(wceDev, 
        (isReadOnly? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE)),
        0,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL
        );
    if (com->portId == INVALID_HANDLE_VALUE) {
        // Possible errors:
        //  55   ERROR_DEV_NOT_EXIST
        DWORD err = GetLastError();
        comPortClose(com);
        if (err == ERROR_DEV_NOT_EXIST) {
            logERROR(LOGSRC,"ComPort does not exist [%lu] - '%ls'", err, wceDev);
            com->error = COMERR_BADDEV;
        } else {
            logERROR(LOGSRC,"Unable to open ComPort [%lu] - '%ls'", err, wceDev);
            com->error = COMERR_GENERAL;
        }
        return (ComPort_t*)0;
    }
        
    /* buffers */
    //logINFO(LOGSRC,"comPortOpen: SetupComm ...");
    SetupComm(com->portId, 2048, 2048);
    
    /* speed */
    com->bps = bps;
    switch (bps) {
        case   BPS_1200: com->speed =   CBR_1200; break;
        case   BPS_2400: com->speed =   CBR_2400; break;
        case   BPS_4800: com->speed =   CBR_4800; break;
        case   BPS_9600: com->speed =   CBR_9600; break;
        case  BPS_19200: com->speed =  CBR_19200; break;
        case  BPS_38400: com->speed =  CBR_38400; break;
        case  BPS_57600: com->speed =  CBR_57600; break;
        case BPS_115200: com->speed = CBR_115200; break;
        default:
            // this would be an internal error
            logWARNING(LOGSRC,"Unsupport BPS: %s %ld\n", portName, com->bps);
            comPortClose(com);
            com->error = COMERR_SPEED;
            return (ComPort_t*)0;
    }

    /* data format */
    BYTE _dtaBits   = (BYTE)8;      // 8
    BYTE _dtaParity = NOPARITY;     // N
    BYTE _dtaStop   = ONESTOPBIT;   // 1
    if (!dataFmt || !*dataFmt || strEqualsIgnoreCase(dataFmt,DTAFMT_8N1)) {
        // 8 data bits, no parity, 1 stop bit (default)
        _dtaBits   = (BYTE)8;
        _dtaParity = NOPARITY;
        _dtaStop   = ONESTOPBIT;
    } else
    if (strEqualsIgnoreCase(dataFmt,DTAFMT_8O1)) {
        // 8 data bits, odd parity, 1 stop bit (non-standard)
        _dtaBits   = (BYTE)8;
        _dtaParity = ODDPARITY;
        _dtaStop   = ONESTOPBIT;
    } else
    if (strEqualsIgnoreCase(dataFmt,DTAFMT_8E1)) {
        // 8 data bits, odd parity, 1 stop bit (non-standard)
        _dtaBits   = (BYTE)8;
        _dtaParity = EVENPARITY;
        _dtaStop   = ONESTOPBIT;
    } else
    if (strEqualsIgnoreCase(dataFmt,DTAFMT_7N2)) {
        // 7 data bits, no parity, 2 stop bits
        _dtaBits   = (BYTE)7;
        _dtaParity = NOPARITY;
        _dtaStop   = TWOSTOPBITS;
    } else
    if (strEqualsIgnoreCase(dataFmt,DTAFMT_7E1)) {
        // 7 data bits, even parity, 1 stop bits
        _dtaBits   = (BYTE)7;
        _dtaParity = EVENPARITY;
        _dtaStop   = ONESTOPBIT;
    } else
    if (strEqualsIgnoreCase(dataFmt,DTAFMT_7O1)) {
        // 7 data bits, even parity, 1 stop bits
        _dtaBits   = (BYTE)7;
        _dtaParity = ODDPARITY;
        _dtaStop   = ONESTOPBIT;
    } else {
        logWARNING(LOGSRC,"Unrecognized data format: %s", dataFmt);
    }
    
    /* DTR assertion */
    UInt16 dtrControl = hwFlow? DTR_CONTROL_HANDSHAKE : DTR_CONTROL_DISABLE;
    UInt16 rtsControl = hwFlow? RTS_CONTROL_HANDSHAKE : RTS_CONTROL_DISABLE;