developer.intra2net.com Git - libftdi/blob - ftdipp/ftdi.hpp

   1 /***************************************************************************
   2                           ftdi.hpp  -  C++ wrapper for libftdi
   3                              -------------------
   4     begin                : Mon Oct 13 2008
   5     copyright            : (C) 2008 by Marek Vavruša
   6     email                : opensource@intra2net.com and marek@vavrusa.com
   7  ***************************************************************************/
   8 /*
   9 Copyright (C) 2008 by Marek Vavruša
  10
  11 The software in this package is distributed under the GNU General
  12 Public License version 2 (with a special exception described below).
  13
  14 A copy of GNU General Public License (GPL) is included in this distribution,
  15 in the file COPYING.GPL.
  16
  17 As a special exception, if other files instantiate templates or use macros
  18 or inline functions from this file, or you compile this file and link it
  19 with other works to produce a work based on this file, this file
  20 does not by itself cause the resulting work to be covered
  21 by the GNU General Public License.
  22
  23 However the source code for this file must still be made available
  24 in accordance with section (3) of the GNU General Public License.
  25
  26 This exception does not invalidate any other reasons why a work based
  27 on this file might be covered by the GNU General Public License.
  28 */
  29 #ifndef __libftdi_hpp__
  30 #define __libftdi_hpp__
  31
  32 #include <list>
  33 #include <string>
  34 #include <boost/shared_ptr.hpp>
  35 #include "ftdi.h"
  36
  37 namespace Ftdi
  38 {
  39
  40 /* Forward declarations*/
  41 class List;
  42 class Eeprom;
  43
  44 /*! \brief FTDI device context.
  45  * Represents single FTDI device context.
  46  */
  47 class Context
  48 {
  49     /* Friends */
  50     friend class Eeprom;
  51     friend class List;
  52
  53 public:
  54     /*! \brief Direction flags for flush().
  55      */
  56     enum Direction
  57     {
  58         Input,
  59         Output
  60     };
  61
  62     /*! \brief Modem control flags.
  63      */
  64     enum ModemCtl
  65     {
  66         Dtr,
  67         Rts
  68     };
  69
  70     /* Constructor, Destructor */
  71     Context();
  72     ~Context();
  73
  74     /* Properties */
  75     Eeprom* eeprom();
  76     const std::string& vendor();
  77     const std::string& description();
  78     const std::string& serial();
  79
  80     /* Device manipulators */
  81     bool is_open();
  82     int open(struct usb_device *dev = 0);
  83     int open(int vendor, int product, const std::string& description = std::string(), const std::string& serial = std::string());
  84     int close();
  85     int reset();
  86     int flush(int mask = Input|Output);
  87     int set_interface(enum ftdi_interface interface);
  88     void set_usb_device(struct usb_dev_handle *dev);
  89
  90     /* Line manipulators */
  91     int set_baud_rate(int baudrate);
  92     int set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity);
  93     int set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type);
  94
  95     /* I/O */
  96     int read(unsigned char *buf, int size);
  97     int write(unsigned char *buf, int size);
  98     int set_read_chunk_size(unsigned int chunksize);
  99     int set_write_chunk_size(unsigned int chunksize);
 100     int read_chunk_size();
 101     int write_chunk_size();
 102
 103     /* Async IO
 104     TODO: should wrap?
 105     int writeAsync(unsigned char *buf, int size);
 106     void asyncComplete(int wait_for_more);
 107     */
 108
 109     /* Flow control */
 110     int set_event_char(unsigned char eventch, unsigned char enable);
 111     int set_error_char(unsigned char errorch, unsigned char enable);
 112     int set_flow_control(int flowctrl);
 113     int set_modem_control(int mask = Dtr|Rts);
 114     int set_latency(unsigned char latency);
 115     int set_dtr(bool state);
 116     int set_rts(bool state);
 117
 118     unsigned short poll_modem_status();
 119     unsigned latency();
 120
 121     /* BitBang mode */
 122     int set_bitmode(unsigned char bitmask, unsigned char mode);
 123     int bitbang_enable(unsigned char bitmask);
 124     int bitbang_disable();
 125     int read_pins(unsigned char *pins);
 126
 127     /* Misc */
 128     char* error_string();
 129
 130 protected:
 131     int get_strings();
 132
 133     /* Properties */
 134     struct ftdi_context* context();
 135     void set_context(struct ftdi_context* context);
 136     void set_usb_device(struct usb_device *dev);
 137
 138 private:
 139     class Private;
 140     boost::shared_ptr<Private> d;
 141 };
 142
 143 /*! \brief Device EEPROM.
 144  */
 145 class Eeprom
 146 {
 147 public:
 148     Eeprom(Context* parent);
 149     ~Eeprom();
 150
 151     void init_defaults();
 152     void set_size(int size);
 153     int size(unsigned char *eeprom, int maxsize);
 154     int chip_id(unsigned int *chipid);
 155     int build(unsigned char *output);
 156     int read(unsigned char *eeprom);
 157     int write(unsigned char *eeprom);
 158     int erase();
 159
 160 private:
 161     class Private;
 162     boost::shared_ptr<Private> d;
 163 };
 164
 165 typedef std::list<Context> ListBase;
 166
 167 /*! \brief Device list.
 168  */
 169 class List : public ListBase
 170 {
 171 public:
 172     List(struct ftdi_device_list* devlist = 0);
 173     ~List();
 174
 175     static List* find_all(int vendor, int product);
 176
 177 private:
 178     class Private;
 179     boost::shared_ptr<Private> d;
 180 };
 181
 182 }
 183
 184 #endif