libftdi1: ftdi.cpp Source File

libftdi1 1.5

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

ftdi.cpp
Go to the documentation of this file.
1 /***************************************************************************
2 ftdi.cpp - C++ wrapper for libftdi
3 -------------------
4 begin : Mon Oct 13 2008
5 copyright : (C) 2008-2020 by Marek Vavruša / libftdi developers
6 email : opensource@intra2net.com and marek@vavrusa.com
7 ***************************************************************************/
8 /*
9 Copyright (C) 2008-2017 by Marek Vavruša / libftdi developers
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 #include <libusb.h>
30 #define _FTDI_DISABLE_DEPRECATED
31 #include "ftdi.hpp"
32 #include "ftdi_i.h"
33 #include "ftdi.h"
34
35 namespace Ftdi
36 {
37
38 class Context::Private
39 {
40 public:
41 Private()
42 : open(false), ftdi(0), dev(0)
43 {
44 ftdi = ftdi_new();
45 }
46
47 ~Private()
48 {
49 if (open)
50 ftdi_usb_close(ftdi);
51
52 ftdi_free(ftdi);
53 }
54
55 bool open;
56
57 struct ftdi_context* ftdi;
58 struct libusb_device* dev;
59
60 std::string vendor;
61 std::string description;
62 std::string serial;
63 };
64
67 Context::Context()
68 : d( new Private() )
69 {
70 }
71
74 Context::~Context()
75 {
76 }
77
78 bool Context::is_open()
79 {
80 return d->open;
81 }
82
83 int Context::open(int vendor, int product)
84 {
85 // Open device
86 int ret = ftdi_usb_open(d->ftdi, vendor, product);
87
88 if (ret < 0)
89 return ret;
90
91 return get_strings_and_reopen(false,false,false);
92 }
93
94 int Context::open(int vendor, int product, const std::string& description, const std::string& serial, unsigned int index)
95 {
96 // translate empty strings to NULL
97 // -> do not use them to find the device (vs. require an empty string to be set in the EEPROM)
98 const char* c_description=NULL;
99 const char* c_serial=NULL;
100 if (!description.empty())
101 c_description=description.c_str();
102 if (!serial.empty())
103 c_serial=serial.c_str();
104
105 int ret = ftdi_usb_open_desc_index(d->ftdi, vendor, product, c_description, c_serial, index);
106
107 if (ret < 0)
108 return ret;
109
110 return get_strings_and_reopen(false,!description.empty(),!serial.empty());
111 }
112
113 int Context::open(const std::string& description)
114 {
115 int ret = ftdi_usb_open_string(d->ftdi, description.c_str());
116
117 if (ret < 0)
118 return ret;
119
120 return get_strings_and_reopen(false,true,false);
121 }
122
123 int Context::open(struct libusb_device *dev)
124 {
125 if (dev != 0)
126 d->dev = dev;
127
128 if (d->dev == 0)
129 return -1;
130
131 return get_strings_and_reopen();
132 }
133
134 int Context::close()
135 {
136 d->open = false;
137 d->dev = 0;
138 return ftdi_usb_close(d->ftdi);
139 }
140
141 int Context::reset()
142 {
143 return ftdi_usb_reset(d->ftdi);
144 }
145
146 int Context::flush(int mask)
147 {
148 int ret;
149
150 switch (mask & (Input | Output)) {
151 case Input:
152 ret = ftdi_usb_purge_rx_buffer(d->ftdi);
153 break;
154
155 case Output:
156 ret = ftdi_usb_purge_tx_buffer(d->ftdi);
157 break;
158
159 case Input | Output:
160 ret = ftdi_usb_purge_buffers(d->ftdi);
161 break;
162
163 default:
164 // Emulate behavior of previous version.
165 ret = 1;
166 break;
167 }
168
169 return ret;
170 }
171
172 int Context::tcflush(int mask)
173 {
174 int ret;
175
176 switch (mask & (Input | Output)) {
177 case Input:
178 ret = ftdi_tciflush(d->ftdi);
179 break;
180
181 case Output:
182 ret = ftdi_tcoflush(d->ftdi);
183 break;
184
185 case Input | Output:
186 ret = ftdi_tcioflush(d->ftdi);
187 break;
188
189 default:
190 // Emulate behavior of previous version.
191 ret = 1;
192 break;
193 }
194
195 return ret;
196 }
197
198 int Context::set_interface(enum ftdi_interface interface)
199 {
200 return ftdi_set_interface(d->ftdi, interface);
201 }
202
203 void Context::set_usb_device(struct libusb_device_handle *dev)
204 {
205 ftdi_set_usbdev(d->ftdi, dev);
206 d->dev = libusb_get_device(dev);
207 }
208
209 int Context::set_baud_rate(int baudrate)
210 {
211 return ftdi_set_baudrate(d->ftdi, baudrate);
212 }
213
214 int Context::set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
215 {
216 return ftdi_set_line_property(d->ftdi, bits, sbit, parity);
217 }
218
219 int Context::set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type)
220 {
221 return ftdi_set_line_property2(d->ftdi, bits, sbit, parity, break_type);
222 }
223
224 int Context::get_usb_read_timeout() const
225 {
226 return d->ftdi->usb_read_timeout;
227 }
228
229 void Context::set_usb_read_timeout(int usb_read_timeout)
230 {
231 d->ftdi->usb_read_timeout = usb_read_timeout;
232 }
233
234 int Context::get_usb_write_timeout() const
235 {
236 return d->ftdi->usb_write_timeout;
237 }
238
239 void Context::set_usb_write_timeout(int usb_write_timeout)
240 {
241 d->ftdi->usb_write_timeout = usb_write_timeout;
242 }
243
244 int Context::read(unsigned char *buf, int size)
245 {
246 return ftdi_read_data(d->ftdi, buf, size);
247 }
248
249 int Context::set_read_chunk_size(unsigned int chunksize)
250 {
251 return ftdi_read_data_set_chunksize(d->ftdi, chunksize);
252 }
253
254 int Context::read_chunk_size()
255 {
256 unsigned chunk = -1;
257 if (ftdi_read_data_get_chunksize(d->ftdi, &chunk) < 0)
258 return -1;
259
260 return chunk;
261 }
262
263 int Context::write(const unsigned char *buf, int size)
264 {
265 return ftdi_write_data(d->ftdi, buf, size);
266 }
267
268 int Context::set_write_chunk_size(unsigned int chunksize)
269 {
270 return ftdi_write_data_set_chunksize(d->ftdi, chunksize);
271 }
272
273 int Context::write_chunk_size()
274 {
275 unsigned chunk = -1;
276 if (ftdi_write_data_get_chunksize(d->ftdi, &chunk) < 0)
277 return -1;
278
279 return chunk;
280 }
281
282 int Context::set_flow_control(int flowctrl)
283 {
284 return ftdi_setflowctrl(d->ftdi, flowctrl);
285 }
286
287 int Context::set_modem_control(int mask)
288 {
289 int dtr = 0, rts = 0;
290
291 if (mask & Dtr)
292 dtr = 1;
293 if (mask & Rts)
294 rts = 1;
295
296 return ftdi_setdtr_rts(d->ftdi, dtr, rts);
297 }
298
299 int Context::set_dtr(bool state)
300 {
301 return ftdi_setdtr(d->ftdi, state);
302 }
303
304 int Context::set_rts(bool state)
305 {
306 return ftdi_setrts(d->ftdi, state);
307 }
308
309 int Context::set_latency(unsigned char latency)
310 {
311 return ftdi_set_latency_timer(d->ftdi, latency);
312 }
313
314 unsigned Context::latency()
315 {
316 unsigned char latency = 0;
317 ftdi_get_latency_timer(d->ftdi, &latency);
318 return latency;
319 }
320
321 unsigned short Context::poll_modem_status()
322 {
323 unsigned short status = 0;
324 ftdi_poll_modem_status(d->ftdi, &status);
325 return status;
326 }
327
328 int Context::set_event_char(unsigned char eventch, unsigned char enable)
329 {
330 return ftdi_set_event_char(d->ftdi, eventch, enable);
331 }
332
333 int Context::set_error_char(unsigned char errorch, unsigned char enable)
334 {
335 return ftdi_set_error_char(d->ftdi, errorch, enable);
336 }
337
338 int Context::set_bitmode(unsigned char bitmask, unsigned char mode)
339 {
340 return ftdi_set_bitmode(d->ftdi, bitmask, mode);
341 }
342
343 int Context::set_bitmode(unsigned char bitmask, enum ftdi_mpsse_mode mode)
344 {
345 return ftdi_set_bitmode(d->ftdi, bitmask, mode);
346 }
347
348 int Context::bitbang_disable()
349 {
350 return ftdi_disable_bitbang(d->ftdi);
351 }
352
353 int Context::read_pins(unsigned char *pins)
354 {
355 return ftdi_read_pins(d->ftdi, pins);
356 }
357
358 const char* Context::error_string()
359 {
360 return ftdi_get_error_string(d->ftdi);
361 }
362
363 int Context::get_strings(bool vendor, bool description, bool serial)
364 {
365 // Prepare buffers
366 char ivendor[512], idesc[512], iserial[512];
367
368 int ret = ftdi_usb_get_strings(d->ftdi, d->dev, vendor?ivendor:NULL, 512, description?idesc:NULL, 512, serial?iserial:NULL, 512);
369
370 if (ret < 0)
371 return -1;
372
373 d->vendor = ivendor;
374 d->description = idesc;
375 d->serial = iserial;
376
377 return 1;
378 }
379
380 int Context::get_strings_and_reopen(bool vendor, bool description, bool serial)
381 {
382 int ret = 0;
383
384 if(vendor || description || serial)
385 {
386 if (d->dev == 0)
387 {
388 d->dev = libusb_get_device(d->ftdi->usb_dev);
389 }
390
391 // Get device strings (closes device)
392 ret=get_strings(vendor, description, serial);
393 if (ret < 0)
394 {
395 d->open = 0;
396 return ret;
397 }
398
399 // Reattach device
400 ret = ftdi_usb_open_dev(d->ftdi, d->dev);
401 d->open = (ret >= 0);
402 }
403
404 return ret;
405 }
406
409 const std::string& Context::vendor()
410 {
411 if(d->vendor.empty())
412 get_strings_and_reopen(true,false,false);
413 return d->vendor;
414 }
415
418 const std::string& Context::description()
419 {
420 if(d->description.empty())
421 get_strings_and_reopen(false,true,false);
422 return d->description;
423 }
424
427 const std::string& Context::serial()
428 {
429 if(d->serial.empty())
430 get_strings_and_reopen(false,false,true);
431 return d->serial;
432 }
433
434 void Context::set_context(struct ftdi_context* context)
435 {
436 ftdi_free(d->ftdi);
437 d->ftdi = context;
438 }
439
440 void Context::set_usb_device(struct libusb_device *dev)
441 {
442 d->dev = dev;
443 }
444
445 struct ftdi_context* Context::context()
446 {
447 return d->ftdi;
448 }
449
450 class Eeprom::Private
451 {
452 public:
453 Private()
454 : context(0)
455 {}
456
457 struct ftdi_eeprom eeprom;
458 struct ftdi_context* context;
459 };
460
461 Eeprom::Eeprom(Context* parent)
462 : d ( new Private() )
463 {
464 d->context = parent->context();
465 }
466
467 Eeprom::~Eeprom()
468 {
469 }
470
471 int Eeprom::init_defaults(char* manufacturer, char *product, char * serial)
472 {
473 return ftdi_eeprom_initdefaults(d->context, manufacturer, product, serial);
474 }
475
476 int Eeprom::chip_id(unsigned int *chipid)
477 {
478 return ftdi_read_chipid(d->context, chipid);
479 }
480
481 int Eeprom::build(unsigned char *output)
482 {
483 return ftdi_eeprom_build(d->context);
484 }
485
486 int Eeprom::read(unsigned char *eeprom)
487 {
488 return ftdi_read_eeprom(d->context);
489 }
490
491 int Eeprom::write(unsigned char *eeprom)
492 {
493 return ftdi_write_eeprom(d->context);
494 }
495
496 int Eeprom::read_location(int eeprom_addr, unsigned short *eeprom_val)
497 {
498 return ftdi_read_eeprom_location(d->context, eeprom_addr, eeprom_val);
499 }
500
501 int Eeprom::write_location(int eeprom_addr, unsigned short eeprom_val)
502 {
503 return ftdi_write_eeprom_location(d->context, eeprom_addr, eeprom_val);
504 }
505
506 int Eeprom::erase()
507 {
508 return ftdi_erase_eeprom(d->context);
509 }
510
511 class List::Private
512 {
513 public:
514 Private(struct ftdi_device_list* _devlist)
515 : devlist(_devlist)
516 {}
517
518 ~Private()
519 {
520 if(devlist)
521 ftdi_list_free(&devlist);
522 }
523
524 std::list<Context> list;
525 struct ftdi_device_list* devlist;
526 };
527
528 List::List(struct ftdi_device_list* devlist)
529 : d( new Private(devlist) )
530 {
531 if (devlist != 0)
532 {
533 // Iterate list
534 for (; devlist != 0; devlist = devlist->next)
535 {
536 Context c;
537 c.set_usb_device(devlist->dev);
538 c.get_strings();
539 d->list.push_back(c);
540 }
541 }
542 }
543
544 List::~List()
545 {
546 }
547
552 List::iterator List::begin()
553 {
554 return d->list.begin();
555 }
556
561 List::iterator List::end()
562 {
563 return d->list.end();
564 }
565
570 List::const_iterator List::begin() const
571 {
572 return d->list.begin();
573 }
574
579 List::const_iterator List::end() const
580 {
581 return d->list.end();
582 }
583
588 List::reverse_iterator List::rbegin()
589 {
590 return d->list.rbegin();
591 }
592
597 List::reverse_iterator List::rend()
598 {
599 return d->list.rend();
600 }
601
606 List::const_reverse_iterator List::rbegin() const
607 {
608 return d->list.rbegin();
609 }
610
615 List::const_reverse_iterator List::rend() const
616 {
617 return d->list.rend();
618
619 }
620
625 List::ListType::size_type List::size() const
626 {
627 return d->list.size();
628 }
629
634 bool List::empty() const
635 {
636 return d->list.empty();
637 }
638
644 void List::clear()
645 {
646 ListType().swap(d->list);
647
648 // Free device list
649 if (d->devlist)
650 {
651 ftdi_list_free(&d->devlist);
652 d->devlist = 0;
653 }
654 }
655
660 void List::push_back(const Context& element)
661 {
662 d->list.push_back(element);
663 }
664
669 void List::push_front(const Context& element)
670 {
671 d->list.push_front(element);
672 }
673
679 List::iterator List::erase(iterator pos)
680 {
681 return d->list.erase(pos);
682 }
683
690 List::iterator List::erase(iterator beg, iterator end)
691 {
692 return d->list.erase(beg, end);
693 }
694
695 List* List::find_all(Context &context, int vendor, int product)
696 {
697 struct ftdi_device_list* dlist = 0;
698 ftdi_usb_find_all(context.context(), &dlist, vendor, product);
699 return new List(dlist);
700 }
701
702 }
Ftdi::List::empty
bool empty() const
Definition: ftdi.cpp:634
ftdi_read_pins
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
Definition: ftdi.c:2240
ftdi_usb_open
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
Definition: ftdi.c:707
Ftdi::Context::set_modem_control
int set_modem_control(int mask=Dtr|Rts)
Definition: ftdi.cpp:287
Ftdi::Context::tcflush
int tcflush(int mask=Input|Output)
Definition: ftdi.cpp:172
ftdi_device_list
list of usb devices created by ftdi_usb_find_all()
Definition: ftdi.h:394
ftdi_device_list::next
struct ftdi_device_list * next
Definition: ftdi.h:397
Ftdi::List::end
iterator end()
Definition: ftdi.cpp:561
ftdi_read_data_get_chunksize
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:2170
ftdi_usb_purge_tx_buffer
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:1113
Ftdi::Context::write
int write(const unsigned char *buf, int size)
Definition: ftdi.cpp:263
ftdi_read_eeprom_location
int ftdi_read_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
Definition: ftdi.c:4437
Ftdi::Context::Output
Definition: ftdi.hpp:59
ftdi_set_usbdev
void ftdi_set_usbdev(struct ftdi_context *ftdi, libusb_device_handle *usb)
Definition: ftdi.c:272
Ftdi::Context
FTDI device context. Represents single FTDI device context.
Definition: ftdi.hpp:47
Ftdi::Context::read_chunk_size
int read_chunk_size()
Definition: ftdi.cpp:254
ftdi_tcoflush
int ftdi_tcoflush(struct ftdi_context *ftdi)
Definition: ftdi.c:1087
Ftdi::Context::description
const std::string & description()
Device strings properties.
Definition: ftdi.cpp:418
Ftdi::List::rbegin
reverse_iterator rbegin()
Definition: ftdi.cpp:588
ftdi_interface
ftdi_interface
Definition: ftdi.h:82
Ftdi::List::push_front
void push_front(const Context &element)
Definition: ftdi.cpp:669
ftdi_usb_open_desc_index
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial, unsigned int index)
Definition: ftdi.c:764
Ftdi::Context::read
int read(unsigned char *buf, int size)
Definition: ftdi.cpp:244
ftdi_tciflush
int ftdi_tciflush(struct ftdi_context *ftdi)
Definition: ftdi.c:1030
Ftdi::Eeprom::Private::context
struct ftdi_context * context
Definition: ftdi.cpp:458
Ftdi::Context::Dtr
Definition: ftdi.hpp:66
ftdi_set_baudrate
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
Definition: ftdi.c:1448
Ftdi::Context::error_string
const char * error_string()
Definition: ftdi.cpp:358
Ftdi::List::iterator
ListType::iterator iterator
Iterator type for the container.
Definition: ftdi.hpp:187
Ftdi::Context::reset
int reset()
Definition: ftdi.cpp:141
ftdi_write_data
int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
Definition: ftdi.c:1583
Ftdi::Context::vendor
const std::string & vendor()
Device strings properties.
Definition: ftdi.cpp:409
Ftdi::Eeprom::~Eeprom
~Eeprom()
Definition: ftdi.cpp:467
ftdi_context
Main context structure for all libftdi functions.
Definition: ftdi.h:271
Ftdi::Eeprom::read_location
int read_location(int eeprom_addr, unsigned short *eeprom_val)
Definition: ftdi.cpp:496
Ftdi::Context::Private
Definition: ftdi.cpp:38
Ftdi::List::ListType
std::list< Context > ListType
List type storing "Context" objects.
Definition: ftdi.hpp:185
ftdi_set_event_char
int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable)
Definition: ftdi.c:2520
Ftdi::List::Private::list
std::list< Context > list
Definition: ftdi.cpp:524
Ftdi::Context::get_usb_write_timeout
int get_usb_write_timeout() const
Definition: ftdi.cpp:234
Ftdi::Context::~Context
~Context()
Destructor.
Definition: ftdi.cpp:74
ftdi_set_bitmode
int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
Definition: ftdi.c:2191
Ftdi::Context::bitbang_disable
int bitbang_disable()
Definition: ftdi.cpp:348
ftdi_list_free
void ftdi_list_free(struct ftdi_device_list **devlist)
Definition: ftdi.c:362
Ftdi::Context::get_strings
int get_strings(bool vendor=true, bool description=true, bool serial=true)
Definition: ftdi.cpp:363
Ftdi::Context::flush
int DEPRECATED() flush(int mask=Input|Output)
Definition: ftdi.cpp:146
Ftdi::List::Private::~Private
~Private()
Definition: ftdi.cpp:518
ftdi_set_line_property
int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
Definition: ftdi.c:1494
Ftdi::List::begin
iterator begin()
Definition: ftdi.cpp:552
Ftdi::Context::write_chunk_size
int write_chunk_size()
Definition: ftdi.cpp:273
ftdi_usb_purge_rx_buffer
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:1060
Ftdi::Context::open
int open(struct libusb_device *dev=0)
Definition: ftdi.cpp:123
Ftdi::Context::Private::open
bool open
Definition: ftdi.cpp:55
Ftdi::Context::set_latency
int set_latency(unsigned char latency)
Definition: ftdi.cpp:309
Ftdi::Context::serial
const std::string & serial()
Device strings properties.
Definition: ftdi.cpp:427
ftdi_new
struct ftdi_context * ftdi_new(void)
Definition: ftdi.c:132
ftdi_erase_eeprom
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4669
ftdi_set_interface
int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
Definition: ftdi.c:161
ftdi_eeprom_initdefaults
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
Definition: ftdi.c:2579
Ftdi::Context::Private::dev
struct libusb_device * dev
Definition: ftdi.cpp:58
ftdi_set_error_char
int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable)
Definition: ftdi.c:2549
Ftdi::Context::Private::serial
std::string serial
Definition: ftdi.cpp:62
Ftdi::Context::Input
Definition: ftdi.hpp:58
ftdi_device_list::dev
struct libusb_device * dev
Definition: ftdi.h:399
Ftdi::Eeprom::erase
int erase()
Definition: ftdi.cpp:506
Ftdi::List::Private
Definition: ftdi.cpp:511
ftdi_bits_type
ftdi_bits_type
Definition: ftdi.h:62
Ftdi::Context::get_strings_and_reopen
int get_strings_and_reopen(bool vendor=true, bool description=true, bool serial=true)
Definition: ftdi.cpp:380
Ftdi::Context::set_interface
int set_interface(enum ftdi_interface interface)
Definition: ftdi.cpp:198
Ftdi::Context::set_read_chunk_size
int set_read_chunk_size(unsigned int chunksize)
Definition: ftdi.cpp:249
Ftdi::Context::get_usb_read_timeout
int get_usb_read_timeout() const
Definition: ftdi.cpp:224
Ftdi::Context::Private::vendor
std::string vendor
Definition: ftdi.cpp:60
Ftdi::List::Private::Private
Private(struct ftdi_device_list *_devlist)
Definition: ftdi.cpp:514
Ftdi::Context::set_rts
int set_rts(bool state)
Definition: ftdi.cpp:304
Ftdi::Context::latency
unsigned latency()
Definition: ftdi.cpp:314
Ftdi::Context::close
int close()
Definition: ftdi.cpp:134
Ftdi::Context::poll_modem_status
unsigned short poll_modem_status()
Definition: ftdi.cpp:321
Ftdi::Context::set_usb_write_timeout
void set_usb_write_timeout(int usb_write_timeout)
Definition: ftdi.cpp:239
Ftdi::Context::set_write_chunk_size
int set_write_chunk_size(unsigned int chunksize)
Definition: ftdi.cpp:268
ftdi_poll_modem_status
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
Definition: ftdi.c:2347
ftdi_setdtr_rts
int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
Definition: ftdi.c:2484
ftdi.hpp
Ftdi
Definition: ftdi.cpp:35
Ftdi::Eeprom::Private::Private
Private()
Definition: ftdi.cpp:453
ftdi_write_data_set_chunksize
int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:1965
Ftdi::List::reverse_iterator
ListType::reverse_iterator reverse_iterator
Reverse iterator type for the container.
Definition: ftdi.hpp:191
ftdi.h
ftdi_usb_open_dev
int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
Definition: ftdi.c:589
Ftdi::Context::Private::~Private
~Private()
Definition: ftdi.cpp:47
Ftdi::Context::set_usb_read_timeout
void set_usb_read_timeout(int usb_read_timeout)
Definition: ftdi.cpp:229
Ftdi::List::rend
reverse_iterator rend()
Definition: ftdi.cpp:597
Ftdi::List::push_back
void push_back(const Context &element)
Definition: ftdi.cpp:660
Ftdi::Context::set_usb_device
void set_usb_device(struct libusb_device_handle *dev)
Definition: ftdi.cpp:203
Ftdi::Eeprom::Private::eeprom
struct ftdi_eeprom eeprom
Definition: ftdi.cpp:457
ftdi_setflowctrl
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
Definition: ftdi.c:2375
Ftdi::Context::Private::Private
Private()
Definition: ftdi.cpp:41
Ftdi::List::List
List(struct ftdi_device_list *devlist=0)
Definition: ftdi.cpp:528
Ftdi::Context::set_flow_control
int set_flow_control(int flowctrl)
Definition: ftdi.cpp:282
Ftdi::List::erase
iterator erase(iterator pos)
Definition: ftdi.cpp:679
ftdi_get_error_string
const char * ftdi_get_error_string(struct ftdi_context *ftdi)
Definition: ftdi.c:4731
Ftdi::Eeprom::build
int build(unsigned char *output)
Definition: ftdi.cpp:481
ftdi_break_type
ftdi_break_type
Definition: ftdi.h:64
Ftdi::Eeprom::chip_id
int chip_id(unsigned int *chipid)
Definition: ftdi.cpp:476
ftdi_usb_close
int ftdi_usb_close(struct ftdi_context *ftdi)
Definition: ftdi.c:1197
ftdi_setrts
int ftdi_setrts(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2453
Ftdi::Context::set_bitmode
int set_bitmode(unsigned char bitmask, unsigned char mode)
Definition: ftdi.cpp:338
Ftdi::List::~List
~List()
Definition: ftdi.cpp:544
ftdi_usb_reset
int ftdi_usb_reset(struct ftdi_context *ftdi)
Definition: ftdi.c:1003
ftdi_get_latency_timer
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
Definition: ftdi.c:2293
ftdi_usb_get_strings
int ftdi_usb_get_strings(struct ftdi_context *ftdi, struct libusb_device *dev, char *manufacturer, int mnf_len, char *description, int desc_len, char *serial, int serial_len)
Definition: ftdi.c:413
Ftdi::Context::set_error_char
int set_error_char(unsigned char errorch, unsigned char enable)
Definition: ftdi.cpp:333
ftdi_parity_type
ftdi_parity_type
Definition: ftdi.h:58
ftdi_read_data_set_chunksize
int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:2133
Ftdi::Eeprom::Private
Definition: ftdi.cpp:450
Ftdi::Context::Context
Context()
Constructor.
Definition: ftdi.cpp:67
ftdi_write_data_get_chunksize
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:1983
ftdi_write_eeprom
int ftdi_write_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4614
ftdi_usb_open_string
int ftdi_usb_open_string(struct ftdi_context *ftdi, const char *description)
Definition: ftdi.c:910
ftdi_disable_bitbang
int ftdi_disable_bitbang(struct ftdi_context *ftdi)
Definition: ftdi.c:2217
ftdi_setdtr
int ftdi_setdtr(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2423
Ftdi::List::clear
void clear()
Definition: ftdi.cpp:644
Ftdi::Eeprom::init_defaults
int init_defaults(char *manufacturer, char *product, char *serial)
Definition: ftdi.cpp:471
Ftdi::Context::Private::ftdi
struct ftdi_context * ftdi
Definition: ftdi.cpp:57
ftdi_set_latency_timer
int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
Definition: ftdi.c:2266
ftdi_eeprom
FTDI eeprom structure.
Definition: ftdi_i.h:31
ftdi_stopbits_type
ftdi_stopbits_type
Definition: ftdi.h:60
Ftdi::Context::set_dtr
int set_dtr(bool state)
Definition: ftdi.cpp:299
ftdi_read_eeprom
int ftdi_read_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4461
Ftdi::List
Device list.
Definition: ftdi.hpp:176
Ftdi::Context::set_line_property
int set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
Definition: ftdi.cpp:214
ftdi_eeprom_build
int ftdi_eeprom_build(struct ftdi_context *ftdi)
Definition: ftdi.c:2910
ftdi_i.h
Ftdi::List::const_iterator
ListType::const_iterator const_iterator
Const iterator type for the container.
Definition: ftdi.hpp:189
ftdi_usb_purge_buffers
int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
Definition: ftdi.c:1168
Ftdi::Context::context
struct ftdi_context * context()
Definition: ftdi.cpp:445
Ftdi::Context::Rts
Definition: ftdi.hpp:67
ftdi_read_data
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:2007
Ftdi::List::Private::devlist
struct ftdi_device_list * devlist
Definition: ftdi.cpp:525
ftdi_write_eeprom_location
int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
Definition: ftdi.c:4558
Ftdi::Eeprom::Eeprom
Eeprom(Context *parent)
Definition: ftdi.cpp:461
Ftdi::Eeprom::read
int read(unsigned char *eeprom)
Definition: ftdi.cpp:486
Ftdi::Context::set_baud_rate
int set_baud_rate(int baudrate)
Definition: ftdi.cpp:209
Ftdi::List::size
ListType::size_type size() const
Definition: ftdi.cpp:625
Ftdi::Context::Private::description
std::string description
Definition: ftdi.cpp:61
Ftdi::Eeprom::write
int write(unsigned char *eeprom)
Definition: ftdi.cpp:491
ftdi_tcioflush
int ftdi_tcioflush(struct ftdi_context *ftdi)
Definition: ftdi.c:1137
ftdi_free
void ftdi_free(struct ftdi_context *ftdi)
Definition: ftdi.c:260
ftdi_read_chipid
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
Definition: ftdi.c:4520
ftdi_mpsse_mode
ftdi_mpsse_mode
Definition: ftdi.h:67
Ftdi::List::const_reverse_iterator
ListType::const_reverse_iterator const_reverse_iterator
Const reverse iterator type for the container.
Definition: ftdi.hpp:193
Ftdi::List::find_all
static List * find_all(Context &context, int vendor, int product)
Definition: ftdi.cpp:695
Ftdi::Context::set_event_char
int set_event_char(unsigned char eventch, unsigned char enable)
Definition: ftdi.cpp:328
Ftdi::Context::is_open
bool is_open()
Definition: ftdi.cpp:78
ftdi_usb_find_all
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
Definition: ftdi.c:314
Ftdi::Context::read_pins
int read_pins(unsigned char *pins)
Definition: ftdi.cpp:353
ftdi_set_line_property2
int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type)
Definition: ftdi.c:1513
Ftdi::Context::set_context
void set_context(struct ftdi_context *context)
Definition: ftdi.cpp:434
ftdi_context::eeprom
struct ftdi_eeprom * eeprom
Definition: ftdi.h:317
Ftdi::Eeprom::write_location
int write_location(int eeprom_addr, unsigned short eeprom_val)
Definition: ftdi.cpp:501