मैं चरित्र उपकरणों में बहुत अच्छा नहीं हूँ, इसलिए मुझे आपकी सहायता की आवश्यकता है। A के पास एक चार डिवाइस है (इसे /dev/my_light कहते हैं) जो एक लाइट सेंसर है। मुझे इस फ़ाइल के डेटा को पढ़ना है और इसे ब्राइटनेस वैल्यू में बदलना है और फिर इसे ब्राइटनेस मैनेजर को पास करना है जो मेरी स्क्रीन की ब्राइटनेस को बदल देता है। समस्या यह है कि जब मैं कुछ समय के लिए मूल्य पढ़ता हूं तो मुझे फ़ाइल से पुराने मान मिलते हैं। मुझे लगता है कि एक बफर है (फिर सुनिश्चित नहीं है कि चरित्र डिवाइस वास्तव में कैसे काम करते हैं)। जबकि जब मैं cat /dev/my_light का उपयोग करता हूं तो मुझे नया डेटा दिखाई देता है! क्या बफर से छुटकारा पाना और नए मान पढ़ना संभव है जो अभी फ़ाइल में लिखे गए थे। क्यूटी में मेरा कोड यहां दिया गया है:

    void MySensor::updateMySensor()
    {
        Packet packet;
        packet.startByte = 0;
        packet.mantissa = 0;
        packet.exp = 0;

        d->device = ::open(d->path.toStdString().c_str(), O_RDONLY);
        if (d->device == -1)
        {
            qDebug() << Q_FUNC_INFO << "can't open the sensor";
            return;
        }

        ssize_t size = ::read(d->device, &packet, sizeof(packet));
        close(d->device);

        if (size == -1)
        {
            qDebug() << errno;
            return;
        }

        packet.exp &= 0x0F;

        float illumination = pow(2, packet.exp) * packet.mantissa * 0.045;

        if(d->singleShot) emit lightSensorIsRunning(true);
        emit illuminationRead(illumination);
    }

mySensor फ़ंक्शन को हर सेकेंड कहा जाता है। मैंने इसे प्रत्येक 200 मिसे पर कॉल करने की कोशिश की लेकिन इससे कोई फायदा नहीं हुआ। रोशनी का मान लगभग 7 सेकंड (!) के लिए पुराना रहता है जबकि cat से मुझे जो मूल्य मिलता है वह तुरंत नया होता है।

आपका अग्रिम में ही बहुत धन्यवाद!

2
Polina Bodnar 10 जिंदा 2019, 19:13

1 उत्तर

सबसे बढ़िया उत्तर

मैं आपके विशिष्ट डिवाइस के साथ परीक्षण नहीं कर सकता, हालांकि, मैं कीबोर्ड का उपयोग केवल पढ़ने के लिए डिवाइस के रूप में कर रहा हूं।

प्रोग्राम कीबोर्ड से कनेक्ट करने और विंडो के अंदर और बाहर दबाए गए सभी कुंजियों को पढ़ने का प्रयास करता है। यह एक व्यापक समाधान है जिसे आपको अपनी मांगों को पूरा करने के लिए अनुकूलित करना होगा।

ध्यान दें कि मैं फ़ाइल को O_RDONLY | O_NONBLOCK के साथ खोल रहा हूं जिसका अर्थ है कि केवल पढ़ने के लिए मोड में खुला है और ईवेंट के ट्रिगर होने की कोई प्रतीक्षा नहीं है (कुछ नोटिफ़ायर को यह जानने की आवश्यकता है कि डेटा कब तैयार है!)

इस उदाहरण को चलाने के लिए आपको सुपर उपयोगकर्ता विशेषाधिकार की आवश्यकता होगी!

#include <QtCore>
#include <fcntl.h>
#include <linux/input.h>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    const char *device_name = "/dev/input/by-path/platform-i8042-serio-0-event-kbd";

    int descriptor = open(device_name, O_RDONLY | O_NONBLOCK);

    if (descriptor < 0)
    {
        qDebug() << "Error" << strerror(errno);
        return a.exec();
    }

    QFile device;

    if (!device.open(descriptor, QFile::ReadOnly))
    {
        qDebug() << "Error" << qPrintable(device.errorString());
        return a.exec();
    }

    QSocketNotifier notifier(device.handle(), QSocketNotifier::Read);

    QObject::connect(&notifier, &QSocketNotifier::activated, &notifier, [&](int socket){
        Q_UNUSED(socket)

        struct input_event ev;

        QByteArray data = device.readAll();

        qDebug() << "Event caught:"
                 << "\n\nDATA SIZE" << data.size()
                 << "\nSTRUCT COUNT" << data.size() / int(sizeof(input_event))
                 << "\nSTRUCT SIZE" << sizeof(input_event);

        qDebug() << ""; //New line

        while (data.size() >= int(sizeof(input_event)))
        {
            memcpy(&ev, data.data(), sizeof(input_event));

            data.remove(0, int(sizeof(input_event)));

            qDebug() << "TYPE" << ev.type << "CODE" << ev.code << "VALUE" << ev.value << "TIME" << ev.time.tv_sec;
        }

        qDebug() << ""; //New line
    });

    return a.exec();
}
2
Antonio Dias 12 जिंदा 2019, 06:25