sprint/io/ftdiserial.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::ftdiserial
*
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_FTDI_SERIAL_H
#define _SPRINT_FTDI_SERIAL_H

#define OUTPUTDEBUGSTRING(a) 

#ifdef WIN32
# include <windows.h>
#endif

#include <sprint/cpptraits.h>
#include <sprint/log.h>

#include <ftd2xx.h>
#include <vector>
#include <string>

namespace sprint {
          
template<bool handle>
class Tftdiserial: public if_copiable<handle> {
public:
  
        FT_HANDLE m_handle;
    FT_STATUS m_ftStatus;

  static  const char *ErrToStr(int err)
  {
  static const char *errs[]={
        "FT_OK",
        "FT_INVALID_HANDLE",
        "FT_DEVICE_NOT_FOUND",
        "FT_DEVICE_NOT_OPENED",
        "FT_IO_ERROR",
        "FT_INSUFFICIENT_RESOURCES",
        "FT_INVALID_PARAMETER",
        "FT_INVALID_BAUD_RATE",

        "FT_DEVICE_NOT_OPENED_FOR_ERASE",
        "FT_DEVICE_NOT_OPENED_FOR_WRITE",
        "FT_FAILED_TO_WRITE_DEVICE",
        "FT_EEPROM_READ_FAILED",
        "FT_EEPROM_WRITE_FAILED",
        "FT_EEPROM_ERASE_FAILED",
        "FT_EEPROM_NOT_PRESENT",
        "FT_EEPROM_NOT_PROGRAMMED",
        "FT_INVALID_ARGS",
        "FT_NOT_SUPPORTED",
        "FT_OTHER_ERROR",
        "FT_DEVICE_LIST_NOT_READY"};
        return errs[err]; }

public:
        Tftdiserial() : m_handle(0) { }
        
        Tftdiserial(int index)
        {
      open(index);
    }
        
        ~Tftdiserial()
        {
       if(!handle)
         FT_Close(m_handle);    
    }
    
    bool open(int index)
    {
         m_ftStatus = FT_Open(index, &m_handle);
         return m_ftStatus == FT_OK;
    }
    
    bool set_timeout(int read, int write)
    {
         m_ftStatus = FT_SetTimeouts(m_handle, read, write);
         return m_ftStatus == FT_OK;
     }
     
    bool set_queue_lenght(int l)
    { 
         m_ftStatus = FT_SetUSBParameters(m_handle, l, 4096);
         return m_ftStatus == FT_OK;
    }

    unsigned int queue_lenght() 
    {
        DWORD dwQueueLenght;
        m_ftStatus = FT_GetQueueStatus(m_handle, &dwQueueLenght);
        return dwQueueLenght;
    }
    
    bool disable_flow_control()
    {
         m_ftStatus = FT_SetFlowControl(m_handle, FT_FLOW_NONE, 0, 0);
         return m_ftStatus == FT_OK;
    }

    bool set_flow_control(unsigned int flow_control, unsigned char xOn, unsigned char xOff)
    {
    }
    
    bool set_format(unsigned int word_lenght = FT_BITS_8, unsigned int stop_bits = FT_STOP_BITS_1, int parity = FT_PARITY_NONE)
    {
         m_ftStatus = FT_SetDataCharacteristics(m_handle, word_lenght, stop_bits, parity);
         return m_ftStatus == FT_OK;
    }
    
        bool set_baud_rate(unsigned int rate)
        {
         m_ftStatus = FT_SetBaudRate(m_handle, rate);
         return m_ftStatus == FT_OK;
        }

        inline void close()
                {
        FT_Close(m_handle);
                m_handle = 0;
                }

  int read(char *buf, unsigned int size)
  {
      DWORD dwBytesReaded;
      m_ftStatus = FT_Read(m_handle, (LPVOID) buf, size, &dwBytesReaded);
      
      if(m_ftStatus!=FT_OK)
        {
        logPutsf(LOG_LEVEL_ERROR, "FT_Read error: return %u (%s)\n", m_ftStatus, ErrToStr(m_ftStatus) );
        return -1;
        }
      
      return dwBytesReaded;
  }

  int write(const char *buf, unsigned int size)
  {
      DWORD dwWritten;
      m_ftStatus = FT_Write(m_handle, (LPVOID) buf, size, &dwWritten);
      return dwWritten;
  }
  
  bool good() const { return m_ftStatus == FT_OK; }

};

typedef Tftdiserial<false> ftdiserial;

typedef Tftdiserial<true> ftdiserialhandle;

} // sprint

#endif