लिनक्स पर सभी सीरियल डिवाइस (ttys, ttyUSB, ..) को बिना खोले कैसे खोजें?

Question

लिनक्स सिस्टम पर सभी उपलब्ध सीरियल पोर्ट / उपकरणों की सूची प्राप्त करने का उचित तरीका क्या है?

दूसरे शब्दों में, जब मैं सभी उपकरणों पर पुनरावृति /dev/करता हूं, तो मैं कैसे बताऊं कि कौन से क्लासिक तरीके से सीरियल पोर्ट हैं, अर्थात, जो आमतौर पर बॉड दरों और आरटीएस / सीटीएस प्रवाह नियंत्रण का समर्थन करते हैं?

समाधान सी में कोडित किया जाएगा।

मैं पूछता हूं क्योंकि मैं एक तृतीय-पक्ष लाइब्रेरी का उपयोग कर रहा हूं जो यह स्पष्ट रूप से गलत करता है: यह केवल पुनरावृति प्रतीत होता है /dev/ttyS*। समस्या यह है कि उदाहरण के लिए, USB पर सीरियल पोर्ट (USB-RS232 एडेप्टर द्वारा प्रदान किए गए) हैं, और वे / dev / ttyUSB * के तहत सूचीबद्ध हैं। और Linux.org पर Serial-HOWTO को पढ़कर , मुझे यह विचार आया कि समय आने पर अन्य नाम स्थान भी होंगे।

इसलिए मुझे धारावाहिक उपकरणों का पता लगाने का आधिकारिक तरीका खोजने की आवश्यकता है। समस्या यह है कि कोई भी प्रलेखित प्रतीत नहीं होता है, या मुझे नहीं मिल रहा है।

मुझे लगता है कि एक तरह से सभी फाइलों को खोलने /dev/tty*और ioctl()उन पर एक विशिष्ट कॉल करने के लिए होगा जो केवल धारावाहिक उपकरणों पर उपलब्ध है। हालांकि यह एक अच्छा समाधान होगा?

अपडेट करें

hricards ने "सेटसेरीअल" के स्रोत को देखने का सुझाव दिया। इसका कोड वही है जो मेरे मन में था:

सबसे पहले, यह एक उपकरण खोलता है:

fd = open (path, O_RDWR | O_NONBLOCK)

फिर यह आह्वान करता है:

ioctl (fd, TIOCGSERIAL, &serinfo)

यदि वह कॉल कोई त्रुटि नहीं देता है, तो यह एक सीरियल डिवाइस है, जाहिरा तौर पर।

मुझे सीरियल प्रोग्रामिंग / टर्मिनस में समान कोड मिला , जिसने O_NOCTTYविकल्प को जोड़ने का सुझाव दिया ।

इस दृष्टिकोण के साथ एक समस्या है, हालांकि:

जब मैंने बीएसडी यूनिक्स (यानी मैक ओएस एक्स) पर इस कोड का परीक्षण किया, तो इसने भी काम किया। हालांकि , ब्लूटूथ के माध्यम से प्रदान किए जाने वाले सीरियल डिवाइस ब्लूटूथ डिवाइस से कनेक्ट करने का प्रयास करने के लिए सिस्टम (ड्राइवर) का कारण बनते हैं, जो टाइमआउट त्रुटि के साथ वापस आने से पहले थोड़ी देर लेता है। यह केवल डिवाइस को खोलने के कारण होता है। और मैं कल्पना कर सकता हूं कि इसी तरह की चीजें लिनक्स पर भी हो सकती हैं - आदर्श रूप से, मुझे इसके प्रकार का पता लगाने के लिए डिवाइस को खोलने की आवश्यकता नहीं होनी चाहिए। मुझे आश्चर्य है कि अगर वहाँ भी एक तरह से ioctlखुले बिना कार्य करने का एक तरीका है , या एक उपकरण को इस तरह से खोलना है कि यह कनेक्शन का कारण नहीं बनता है?

मुझे क्या करना चाहिए?

Comments

किसी अनाम व्यक्ति ने इस संपादन का सुझाव दिया था, जिसे अस्वीकार कर दिया गया था, इसलिए मैं इसे एक टिप्पणी के रूप में यहां छोड़ता हूं: यदि आप TIOCMGET के बजाय ioctl कॉल में TIOCGSERIAL ध्वज का उपयोग करते हैं, तो कॉल कुछ गलत रास्तों पर त्रुटि वापस नहीं करता है जो नहीं करते हैं COM (सीरियल) पोर्ट देखें। TIOCMGET ध्वज के साथ, ioctl केवल COM पोर्ट के साथ उपलब्ध है, जो TTY और TTYUSB दोनों संभावित एसटीएस में प्रवेश के लिए उपलब्ध है।

— थॉमस टेम्पेलमैन

Answer 1

/sysफाइल सिस्टम अपने प्रयास के लिए बहुत जानकारी शामिल करना चाहिए। मेरा सिस्टम (2.6.32-40-जेनेरिक # 87-उबंटू) सुझाव देता है:

/sys/class/tty

जो आपको सिस्टम में ज्ञात सभी TTY उपकरणों का विवरण देता है। एक छंटनी उदाहरण:

# ll /sys/class/tty/ttyUSB*
lrwxrwxrwx 1 root root 0 2012-03-28 20:43 /sys/class/tty/ttyUSB0 -> ../../devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.4/2-1.4:1.0/ttyUSB0/tty/ttyUSB0/
lrwxrwxrwx 1 root root 0 2012-03-28 20:44 /sys/class/tty/ttyUSB1 -> ../../devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.3/2-1.3:1.0/ttyUSB1/tty/ttyUSB1/

इन लिंक में से एक का पालन करें:

# ll /sys/class/tty/ttyUSB0/
insgesamt 0
drwxr-xr-x 3 root root    0 2012-03-28 20:43 ./
drwxr-xr-x 3 root root    0 2012-03-28 20:43 ../
-r--r--r-- 1 root root 4096 2012-03-28 20:49 dev
lrwxrwxrwx 1 root root    0 2012-03-28 20:43 device -> ../../../ttyUSB0/
drwxr-xr-x 2 root root    0 2012-03-28 20:49 power/
lrwxrwxrwx 1 root root    0 2012-03-28 20:43 subsystem -> ../../../../../../../../../../class/tty/
-rw-r--r-- 1 root root 4096 2012-03-28 20:43 uevent

यहाँ devफ़ाइल में यह जानकारी है:

# cat /sys/class/tty/ttyUSB0/dev
188:0

यह प्रमुख / मामूली नोड है। /devउपयोगकर्ता-अनुकूल नाम पाने के लिए इन्हें निर्देशिका में खोजा जा सकता है :

# ll -R /dev |grep "188, *0"
crw-rw----   1 root dialout 188,   0 2012-03-28 20:44 ttyUSB0

/sys/class/ttyDir सब TTY उपकरणों है, परंतु आप उन परेशान करने आभासी टर्मिनल और छद्म टर्मिनल बहिष्कृत करना चाहेंगे। मेरा सुझाव है कि आप केवल उन लोगों की जांच करें जिनके पास एक device/driverप्रविष्टि है:

# ll /sys/class/tty/*/device/driver
lrwxrwxrwx 1 root root 0 2012-03-28 19:07 /sys/class/tty/ttyS0/device/driver -> ../../../bus/pnp/drivers/serial/
lrwxrwxrwx 1 root root 0 2012-03-28 19:07 /sys/class/tty/ttyS1/device/driver -> ../../../bus/pnp/drivers/serial/
lrwxrwxrwx 1 root root 0 2012-03-28 19:07 /sys/class/tty/ttyS2/device/driver -> ../../../bus/platform/drivers/serial8250/
lrwxrwxrwx 1 root root 0 2012-03-28 19:07 /sys/class/tty/ttyS3/device/driver -> ../../../bus/platform/drivers/serial8250/
lrwxrwxrwx 1 root root 0 2012-03-28 20:43 /sys/class/tty/ttyUSB0/device/driver -> ../../../../../../../../bus/usb-serial/drivers/ftdi_sio/
lrwxrwxrwx 1 root root 0 2012-03-28 21:15 /sys/class/tty/ttyUSB1/device/driver -> ../../../../../../../../bus/usb-serial/drivers/ftdi_sio/

Comments

@entalpi आपको मिलेगा /dev/zero। क्या आप वास्तव में सोचते हैं, यह एक सीरियल डिवाइस है?

— एएच

/ Dev में खोज करना बेकार है, क्योंकि आपके पास पहले से ही / sys / class / tty में नाम है (डिफ़ॉल्ट रूप से udev / dev / DEVNAME नोड बनाता है)। आप जिस चीज के बारे में रुचि रखते हैं, वह / देव में कोई "प्रतीकात्मक" लिंक है जो ऐसे उपकरण को इंगित करता है। यह खोजने के लिए बहुत कठिन है।

— xryl669

Answer 2

हाल के कर्नेल में (जब से सुनिश्चित नहीं हो) आप अपने सिस्टम पर सीरियल पोर्ट की सूची प्राप्त करने के लिए / dev / सीरियल की सामग्री को सूचीबद्ध कर सकते हैं। वे वास्तव में सही / देव / नोड की ओर इशारा करते हुए सहानुभूति रखते हैं:

flu0@laptop:~$ ls /dev/serial/
total 0
drwxr-xr-x 2 root root 60 2011-07-20 17:12 by-id/
drwxr-xr-x 2 root root 60 2011-07-20 17:12 by-path/
flu0@laptop:~$ ls /dev/serial/by-id/
total 0
lrwxrwxrwx 1 root root 13 2011-07-20 17:12 usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0 -> ../../ttyUSB0
flu0@laptop:~$ ls /dev/serial/by-path/
total 0
lrwxrwxrwx 1 root root 13 2011-07-20 17:12 pci-0000:00:0b.0-usb-0:3:1.0-port0 -> ../../ttyUSB0

यह एक USB- सीरियल एडाप्टर है, जैसा कि आप देख सकते हैं। ध्यान दें कि जब सिस्टम पर कोई सीरियल पोर्ट नहीं हैं, तो / dev / सीरियल / निर्देशिका मौजूद नहीं है। उम्मीद है की यह मदद करेगा :)।

Comments

यह udv (विशेष रूप से /lib/udev/rules.d/??-persistent-serial.rules में इसका कॉन्फ़िगरेशन) का एक फ़ंक्शन है, जिसे 2.5 में पेश किया गया था।

— 14'13

महान टिप! दुर्भाग्य से मुझे नहीं लगता कि यह सीरियल पोर्ट में बनाया जाएगा, केवल USB सीरियल पोर्ट (जब संलग्न होने पर udev द्वारा देखा जाएगा)। मैं Ubuntu 14 में VM / VM (VM द्वारा प्रदत्त ttyS0 / COM1 के साथ) में / dev / धारावाहिक के लिए कुछ भी नहीं देखता, और udv नियम (60-लगातार-serial.rules) केवल udv उपकरणों को देख रहे हैं मुझे नहीं लगता कि udv को "बिल्ट-इन" ttyS * सीरियल पोर्ट के बारे में पता चलता है, उन्हें ioctl के साथ या अन्य उत्तरों के समान परीक्षण करना होगा।

— रीड हेजेस

ls / dev / serial / ls: '/ dev / serial /' तक नहीं पहुंच सकता: ऐसी कोई फ़ाइल या निर्देशिका Slackware 14.2 वर्तमान x64

— jpka

@jpka: ऐसा होता है अगर कोई सीरियल डिवाइस नहीं मिल रहा है। मैंने ऊपर जैसा किया और यह काम किया। मैंने तब USB से अपने (FTDI) सीरियल डिवाइस को अनप्लग कर दिया था और बाद में यह आपके द्वारा बताई गई त्रुटि उत्पन्न करता है।

— वारस्पेश

Answer 3

मैं निम्नलिखित कोड की तरह कुछ कर रहा हूँ। यह USB- डिवाइसेस के लिए काम करता है और यह भी बेवकूफ serial8250-devuices कि हम सभी के 30 हैं - लेकिन उनमें से केवल एक जोड़े ने काम किया है।

मूल रूप से मैं पिछले उत्तरों से अवधारणा का उपयोग करता हूं। सबसे पहले / टीएसई / क्लास / ट्टी / में सभी टटी-डिवाइसेस को एन्यूमरेट करें। जिन डिवाइस में / डिवाइस सबडिर नहीं होता है, उन्हें फ़िल्टर किया जाता है। / sys / class / tty / कंसोल एक ऐसा उपकरण है। तब डिवाइस में वास्तव में एक डिवाइस युक्त डिवाइस को ड्राइवर-सिमलिंक fx के लक्ष्य के आधार पर मान्य सीरियल-पोर्ट के रूप में स्वीकार किया जाता है।

$ ls -al /sys/class/tty/ttyUSB0//device/driver
lrwxrwxrwx 1 root root 0 sep  6 21:28 /sys/class/tty/ttyUSB0//device/driver -> ../../../bus/platform/drivers/usbserial

और ttyS0 के लिए

$ ls -al /sys/class/tty/ttyS0//device/driver
lrwxrwxrwx 1 root root 0 sep  6 21:28 /sys/class/tty/ttyS0//device/driver -> ../../../bus/platform/drivers/serial8250

Serial8250 द्वारा चालित सभी ड्राइवर पहले उल्लेखित ioctl का उपयोग करके जांच रहे होंगे।

        if (ioctl(fd, TIOCGSERIAL, &serinfo)==0) {
            // If device type is no PORT_UNKNOWN we accept the port
            if (serinfo.type != PORT_UNKNOWN)
                the_port_is_valid

केवल एक मान्य डिवाइस-प्रकार की रिपोर्टिंग पोर्ट ही मान्य है।

धारावाहिकों की गणना करने का पूरा स्रोत इस तरह दिखता है। परिवर्धन का स्वागत है।

#include <stdlib.h>
#include <dirent.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <linux/serial.h>

#include <iostream>
#include <list>

using namespace std;

static string get_driver(const string& tty) {
    struct stat st;
    string devicedir = tty;

    // Append '/device' to the tty-path
    devicedir += "/device";

    // Stat the devicedir and handle it if it is a symlink
    if (lstat(devicedir.c_str(), &st)==0 && S_ISLNK(st.st_mode)) {
        char buffer[1024];
        memset(buffer, 0, sizeof(buffer));

        // Append '/driver' and return basename of the target
        devicedir += "/driver";

        if (readlink(devicedir.c_str(), buffer, sizeof(buffer)) > 0)
            return basename(buffer);
    }
    return "";
}

static void register_comport( list<string>& comList, list<string>& comList8250, const string& dir) {
    // Get the driver the device is using
    string driver = get_driver(dir);

    // Skip devices without a driver
    if (driver.size() > 0) {
        string devfile = string("/dev/") + basename(dir.c_str());

        // Put serial8250-devices in a seperate list
        if (driver == "serial8250") {
            comList8250.push_back(devfile);
        } else
            comList.push_back(devfile); 
    }
}

static void probe_serial8250_comports(list<string>& comList, list<string> comList8250) {
    struct serial_struct serinfo;
    list<string>::iterator it = comList8250.begin();

    // Iterate over all serial8250-devices
    while (it != comList8250.end()) {

        // Try to open the device
        int fd = open((*it).c_str(), O_RDWR | O_NONBLOCK | O_NOCTTY);

        if (fd >= 0) {
            // Get serial_info
            if (ioctl(fd, TIOCGSERIAL, &serinfo)==0) {
                // If device type is no PORT_UNKNOWN we accept the port
                if (serinfo.type != PORT_UNKNOWN)
                    comList.push_back(*it);
            }
            close(fd);
        }
        it ++;
    }
}

list<string> getComList() {
    int n;
    struct dirent **namelist;
    list<string> comList;
    list<string> comList8250;
    const char* sysdir = "/sys/class/tty/";

    // Scan through /sys/class/tty - it contains all tty-devices in the system
    n = scandir(sysdir, &namelist, NULL, NULL);
    if (n < 0)
        perror("scandir");
    else {
        while (n--) {
            if (strcmp(namelist[n]->d_name,"..") && strcmp(namelist[n]->d_name,".")) {

                // Construct full absolute file path
                string devicedir = sysdir;
                devicedir += namelist[n]->d_name;

                // Register the device
                register_comport(comList, comList8250, devicedir);
            }
            free(namelist[n]);
        }
        free(namelist);
    }

    // Only non-serial8250 has been added to comList without any further testing
    // serial8250-devices must be probe to check for validity
    probe_serial8250_comports(comList, comList8250);

    // Return the lsit of detected comports
    return comList;
}


int main() {
    list<string> l = getComList();

    list<string>::iterator it = l.begin();
    while (it != l.end()) {
        cout << *it << endl;
        it++;
    }

    return 0;   
}

Comments

लोन लिंक को एक खराब उत्तर माना जाता है क्योंकि यह अपने आप से अर्थहीन है और भविष्य में लक्ष्य संसाधन को जीवित रहने की गारंटी नहीं है। कृपया उन सूचनाओं के कम से कम सारांश को शामिल करने का प्रयास करें जिन्हें आप लिंक कर रहे हैं।

— j0k

सोरेन के लिए धन्यवाद, यहां तक ​​कि हम एपीआई और उस पर कुछ विचार जानते हैं, लेकिन आपने वास्तव में अच्छा सोरेन किया था, फिर से धन्यवाद।

— ind79ra

Answer 4

मुझे लगता है कि मुझे अपने कर्नेल स्रोत प्रलेखन में उत्तर मिला: /usr/src/linux-2.6.37-rc3/Documentation/filesystems/proc.txt

1.7 TTY info in /proc/tty
-------------------------

Information about  the  available  and actually used tty's can be found in the
directory /proc/tty.You'll  find  entries  for drivers and line disciplines in
this directory, as shown in Table 1-11.


Table 1-11: Files in /proc/tty
..............................................................................
 File          Content                                        
 drivers       list of drivers and their usage                
 ldiscs        registered line disciplines                    
 driver/serial usage statistic and status of single tty lines 
..............................................................................

To see  which  tty's  are  currently in use, you can simply look into the file
/proc/tty/drivers:

  > cat /proc/tty/drivers 
  pty_slave            /dev/pts      136   0-255 pty:slave 
  pty_master           /dev/ptm      128   0-255 pty:master 
  pty_slave            /dev/ttyp       3   0-255 pty:slave 
  pty_master           /dev/pty        2   0-255 pty:master 
  serial               /dev/cua        5   64-67 serial:callout 
  serial               /dev/ttyS       4   64-67 serial 
  /dev/tty0            /dev/tty0       4       0 system:vtmaster 
  /dev/ptmx            /dev/ptmx       5       2 system 
  /dev/console         /dev/console    5       1 system:console 
  /dev/tty             /dev/tty        5       0 system:/dev/tty 
  unknown              /dev/tty        4    1-63 console 

यहाँ इस फाइल का लिंक दिया गया है: http://git.kernel.org/?p=linux/kernel/git/next/linux-next.git/a=blob_plain=f=Documentation/filesystems-proc.txt=hb = e8883f8057c0f7c9950fa9f20568f37bfa62f34a

Comments

हाँ, यह काम करने लगता है। हालाँकि, इस समाधान के लिए मुझे एक पाठ फ़ाइल पढ़ने और उसे पार्स करने की आवश्यकता है। मुझे आश्चर्य है कि एक बेहतर दूर, यानी एक एपीआई जो मुझे एक संरचित बाइनरी प्रारूप में इन सामग्रियों को प्राप्त करने देता है।

— थॉमस टेम्पेलमैन

Answer 5

मुझे मिला

dmesg | grep tty

काम कर रहा है।

Answer 6

-g विकल्प के साथ सेटर्सिअल वह करता है जो आप चाहते हैं और सी स्रोत http://www.koders.com/c/fid39344DABD14604E70DF1B8FEA7D920A94AF7820F8.aspx पर उपलब्ध है ।

Comments

मैंने कोड को देखा और इसमें वह दोष है जो मैं अपने प्रश्न में अंत में समझाता हूं क्योंकि इसमें डिवाइस को खोलना है, जिससे पहले से ही कनेक्शन का प्रयास हो सकता है - जो बदले में अच्छा नहीं है। लेकिन फिर, शायद लिनक्स ड्राइवर मौजूदा OSX ड्राइवर की तुलना में अधिक स्मार्ट होते हैं, जब ब्लूटूथ समर्थन की बात आती है, क्योंकि वे अभी कनेक्शन नहीं खोलेंगे? कौन जानता है? हो सकता है कि मैं विशेष रूप से स्पष्ट करने के लिए एक नया प्रश्न शुरू करूं। अगर यह पता चला कि यह ठीक है, तो मैं यहां भी आपके उत्तर को स्वीकार कर सकता हूं। हम्मम ...

— थॉमस टेम्पेलमैन

Answer 7

इसका परीक्षण करने के लिए मेरे पास कोई सीरियल डिवाइस नहीं है, लेकिन अगर आपके पास अजगर और डब है तो आप इसे स्वयं आज़मा सकते हैं।

import dbus
bus = dbus.SystemBus()
hwmanager = bus.get_object('org.freedesktop.Hal', '/org/freedesktop/Hal/Manager')
hwmanager_i = dbus.Interface(hwmanager, 'org.freedesktop.Hal.Manager')
print hwmanager_i.FindDeviceByCapability("serial")

यदि यह विफल हो जाता है तो आप यह hwmanager_i.GetAllDevicesWithProperties()देखने के लिए अंदर देख सकते हैं कि क्या क्षमता नाम "धारावाहिक" है जो मुझे लगता है कि एक अलग नाम है।

HTH

Answer 8

मेरे पास USB सीरियल डिवाइस नहीं है, लेकिन HAL पुस्तकालयों का सीधे उपयोग करके असली पोर्ट खोजने का एक तरीका होना चाहिए:

====================================================================
#! /usr/bin/env bash
#
# Uses HAL to find existing serial hardware
#

for sport in $(hal-find-by-capability --capability serial) ; do
  hal-get-property --udi "${sport}" --key serial.device
done

====================================================================

पोस्ट किए गए पायथन-डबस कोड और न ही इस sh स्क्रिप्ट में ब्लूटूथ / dev / rfcomm * डिवाइस को सूचीबद्ध किया गया है, इसलिए यह सबसे अच्छा समाधान नहीं है।

ध्यान दें कि अन्य यूनिक्स प्लेटफार्मों पर, सीरियल पोर्ट का नाम ttyS नहीं है? और यहां तक ​​कि लिनक्स में, कुछ सीरियल कार्ड आपको उपकरणों का नाम देने की अनुमति देते हैं। धारावाहिक उपकरणों के नामों में एक पैटर्न मान लेना गलत है।

Comments

उबंटू से बहुत खराब एचएएल को हटा दिया गया था (12.04 के बाद), इसमें कुछ आसान उपकरण थे। क्या किसी को पता है कि ऊपर प्रतिस्थापन है? लेकिन अगर आप एक ऐसे संस्करण / डिस्ट्रो पर हैं, जिसमें एचएएल है तो यह अच्छा लग रहा है।

— रीड हेजेज

Answer 9

/ Proc / tty / ड्राइवर का उपयोग केवल इंगित करता है कि कौन से tty ड्राइवर लोड किए गए हैं। यदि आप सीरियल पोर्ट्स की सूची की जाँच कर रहे हैं / dev / सीरियल, तो इसके दो उपनिर्देशिकाएँ होंगी: बाय-आईडी और बाय-पाथ।

पूर्व:

# find . -type l
./by-path/usb-0:1.1:1.0-port0
./by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0

इस पोस्ट के लिए धन्यवाद: /superuser/131044/how-do-i-know-which-dev-ttys-is-my-serial-port

Comments

जाहिर है यह डिस्ट्रो-डिपेंडेंट है। मैं अपने बॉक्स पर (डेबियन चल रहा) / देव / धारावाहिक नहीं पा रहा हूं

— सिमोन

Answer 10

समूह डायलआउट के माध्यम से मेरा दृष्टिकोण ls -l /dev/tty* | grep 'dialout' केवल ' फ़ोल्डर ' प्राप्त करने के लिए उपयोगकर्ता 'डायलआउट' के साथ हर ट्टी को प्राप्त करने के लिए है ls -l /dev/tty* | grep 'dialout' | rev | cut -d " " -f1 | rev

जब tduino धारावाहिक बाहर निकलता है तो ट्टी आउटपुट को सुनना आसान है: head --lines 1 < /dev/ttyUSB0

केवल एक लाइन के लिए हर ट्टी को सुनें: for i in $(ls -l /dev/tty* | grep 'dialout' | rev | cut -d " " -f1 | rev); do head --lines 1 < $i; done

मुझे वास्तव में ड्राइवरों की तलाश के माध्यम से दृष्टिकोण पसंद है: ll /sys/class/tty/*/device/driver

अब आप tty-Name चुन सकते हैं: ls /sys/class/tty/*/device/driver | grep 'driver' | cut -d "/" -f 5

Answer 11

धारावाहिक संचार प्रबंधक पुस्तकालय में आपके द्वारा इच्छित कार्य के लिए लक्षित कई एपीआई और विशेषताएं हैं। यदि डिवाइस USB-UART है तो इसका VID / PID का उपयोग किया जा सकता है। यदि डिवाइस बीटी-एसपीपी है तो प्लेटफॉर्म विशिष्ट एपीआई का उपयोग किया जा सकता है। सीरियल पोर्ट प्रोग्रामिंग के लिए इस परियोजना पर एक नज़र डालें: https://github.com/RishiGupta12/serial-communication-manager

Answer 12

हाँ, मुझे पता है, मुझे बहुत देर हो चुकी है (हमेशा की तरह)। यहाँ मेरा कोड ऑफ़ कोड है (mk2 के उत्तर के आधार पर)। शायद यह किसी की मदद करता है:

std::vector<std::string> find_serial_ports()
{
 std::vector<std::string> ports;
    std::filesystem::path kdr_path{"/proc/tty/drivers"};
    if (std::filesystem::exists(kdr_path))
    {
        std::ifstream ifile(kdr_path.generic_string());
        std::string line;
        std::vector<std::string> prefixes;
        while (std::getline(ifile, line))
        {
            std::vector<std::string> items;
            auto it = line.find_first_not_of(' ');
            while (it != std::string::npos)
            {

                auto it2 = line.substr(it).find_first_of(' ');
                if (it2 == std::string::npos)
                {
                    items.push_back(line.substr(it));
                    break;
                }
                it2 += it;
                items.push_back(line.substr(it, it2 - it));
                it = it2 + line.substr(it2).find_first_not_of(' ');
            }
            if (items.size() >= 5)
            {
                if (items[4] == "serial" && items[0].find("serial") != std::string::npos)
                {
                    prefixes.emplace_back(items[1]);
                }
            }
        }
        ifile.close();
        for (auto& p: std::filesystem::directory_iterator("/dev"))
        {
            for (const auto& pf : prefixes)
            {
                auto dev_path = p.path().generic_string();
                if (dev_path.size() >= pf.size() && std::equal(dev_path.begin(), dev_path.begin() + pf.size(), pf.begin()))
                {
                    ports.emplace_back(dev_path);
                }
            }
        }
    }
    return ports;
}

Comments

ऐसा लगता है कि आपका कोड पार्स करता है जो उत्तर stackoverflow.com/a/4701610/43615 को संदर्भित करता है। यदि हां, तो क्या आप अपने उत्तर में इसका उल्लेख करेंगे?

— थॉमस टेम्पेलमैन