LinuxSPI.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "SPIInterface.hpp"
#include <string>
#include <thread>
#include <atomic>
#include <map>
#include <fstream>
#include <fcntl.h>
 
#ifdef _WIN32
#include <io.h>
#else
#include <unistd.h>
#endif
 
class LinuxSPI : public SPIInterface {
    public:
    LinuxSPI(const std::string& device = "/dev/spidev0.0", 
        uint32_t speed = 1000000,
        uint8_t mode = 0);
 
    ~LinuxSPI();
        
    bool open();
    
    void close();
    
    std::vector<uint8_t> transfer(const std::vector<uint8_t>& write_data, size_t read_length = 0);
    
    bool digitalWrite(uint8_t pin, bool value);
    
    bool digitalRead(uint8_t pin);
    
    bool pinMode(uint8_t pin, uint8_t mode);
    
    bool configureInterrupt(uint8_t pin, bool enable) override {
        // Basic implementation using sysfs
        // In a real implementation, would use proper GPIO interrupts
        std::string gpio_path = "/sys/class/gpio/gpio" + std::to_string(pin);
        
        // Check if GPIO exists
        if (access(gpio_path.c_str(), F_OK) == -1) {
            // Need to export
            std::ofstream export_file("/sys/class/gpio/export");
            if (!export_file.is_open()) {
                return false;
            }
            export_file << pin;
            export_file.close();
        }
        
        // Configure edge for interrupt
        std::string edge_path = gpio_path + "/edge";
        std::ofstream edge_file(edge_path);
        if (!edge_file.is_open()) {
            return false;
        }
        edge_file << (enable ? "both" : "none");
        edge_file.close();
        
        return true;
    }
    
    bool setInterruptCallback(InterruptCallback callback) override;
    
    bool enableInterrupt(bool enable) override;
    
    bool isActive() const override {
        return fd >= 0;
    }
 
private:
    std::string device_path;
    uint32_t speed_hz;
    uint8_t spi_mode;
    int fd; // File descriptor para el dispositivo SPI
    
    // GPIO paths
    std::string gpio_export_path;
    std::string gpio_unexport_path;
    std::map<uint8_t, std::string> gpio_pin_paths;
    
    // Interrupt handling
    InterruptCallback interruptCallback;
    std::atomic<bool> interrupt_running;
    std::thread interrupt_thread;
    int interrupt_pin;
    InterruptCallback interrupt_callback;
    bool interrupt_enabled = false;
    
    bool exportGPIO(uint8_t pin);
 
    bool unexportGPIO(uint8_t pin);
 
    bool setGPIODirection(uint8_t pin, const std::string& direction);
 
    bool writeGPIOValue(uint8_t pin, bool value);
 
    bool readGPIOValue(uint8_t pin);
 
    void interruptThread();
};