Qt 嵌入式开发 #

┌─────────────────────────────────────────────────────────────┐
│                    Qt 嵌入式版本                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Qt for Embedded Linux                                      │
│  ├── 无 X11 依赖                                           │
│  ├── 直接操作帧缓冲                                        │
│  └── 适合资源受限设备                                      │
│                                                             │
│  Qt Device Creation                                         │
│  ├── Qt 官方嵌入式解决方案                                 │
│  ├── Boot to Qt                                            │
│  └── Qt Automotive Suite                                   │
│                                                             │
│  应用场景：                                                  │
│  ├── 工业触摸屏                                            │
│  ├── 车载系统                                              │
│  ├── 医疗设备                                              │
│  └── 智能家居                                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# 指定交叉编译器
QMAKE_CC = arm-linux-gnueabihf-gcc
QMAKE_CXX = arm-linux-gnueabihf-g++
QMAKE_LINK = arm-linux-gnueabihf-g++

# 指定 sysroot
QMAKE_SYSROOT = /path/to/sysroot

# 指定库路径
QMAKE_LIBDIR += $$QMAKE_SYSROOT/usr/lib
QMAKE_INCDIR += $$QMAKE_SYSROOT/usr/include

# toolchain-arm.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)

set(CMAKE_SYSROOT /path/to/sysroot)
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

// Linux GPIO 操作
class Gpio
{
public:
    Gpio(int pin) : m_pin(pin) {}
    
    bool exportPin()
    {
        QFile file("/sys/class/gpio/export");
        if (!file.open(QIODevice::WriteOnly)) {
            return false;
        }
        file.write(QByteArray::number(m_pin));
        file.close();
        return true;
    }
    
    void setDirection(bool output)
    {
        QString path = QString("/sys/class/gpio/gpio%1/direction").arg(m_pin);
        QFile file(path);
        if (file.open(QIODevice::WriteOnly)) {
            file.write(output ? "out" : "in");
            file.close();
        }
    }
    
    void setValue(bool value)
    {
        QString path = QString("/sys/class/gpio/gpio%1/value").arg(m_pin);
        QFile file(path);
        if (file.open(QIODevice::WriteOnly)) {
            file.write(value ? "1" : "0");
            file.close();
        }
    }
    
    bool value()
    {
        QString path = QString("/sys/class/gpio/gpio%1/value").arg(m_pin);
        QFile file(path);
        if (file.open(QIODevice::ReadOnly)) {
            return file.readAll().trimmed() == "1";
        }
        return false;
    }

private:
    int m_pin;
};

class I2cDevice
{
public:
    I2cDevice(int bus, int address) 
        : m_address(address)
    {
        QString device = QString("/dev/i2c-%1").arg(bus);
        m_fd = open(device.toLatin1(), O_RDWR);
        if (m_fd >= 0) {
            ioctl(m_fd, I2C_SLAVE, address);
        }
    }
    
    ~I2cDevice()
    {
        if (m_fd >= 0) {
            close(m_fd);
        }
    }
    
    bool writeByte(uint8_t reg, uint8_t value)
    {
        uint8_t buf[2] = {reg, value};
        return ::write(m_fd, buf, 2) == 2;
    }
    
    uint8_t readByte(uint8_t reg)
    {
        ::write(m_fd, &reg, 1);
        uint8_t value;
        ::read(m_fd, &value, 1);
        return value;
    }

private:
    int m_fd = -1;
    int m_address;
};

// 使用轻量级控件
// 避免使用复杂的 QWidgets，考虑使用 QQuickView

// 减少图片资源
QPixmap pixmap;
pixmap.load(":/image.png");
pixmap = pixmap.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);

// 及时释放资源
void cleanup()
{
    // 删除不需要的对象
    qDeleteAll(unusedWidgets);
    unusedWidgets.clear();
}

// 缓存绘制结果
void MyWidget::paintEvent(QPaintEvent *)
{
    if (m_cache.isNull()) {
        m_cache = QPixmap(size());
        QPainter cachePainter(&m_cache);
        // 绘制到缓存
        drawToCache(&cachePainter);
    }
    
    QPainter painter(this);
    painter.drawPixmap(0, 0, m_cache);
}