serial.hpp

Go to the documentation of this file.

//
// Copyright 2010-2013 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//

#ifndef INCLUDED_UHD_TYPES_SERIAL_HPP
#define INCLUDED_UHD_TYPES_SERIAL_HPP

#include <uhd/config.hpp>
#include <boost/shared_ptr.hpp>
#include <stdint.h>
#include <vector>

namespace uhd{

    typedef std::vector<uint8_t> byte_vector_t;

    class UHD_API i2c_iface{
    public:
        typedef boost::shared_ptr<i2c_iface> sptr;

        virtual ~i2c_iface(void);

        i2c_iface::sptr eeprom16(void);

        virtual void write_i2c(
            uint16_t addr,
            const byte_vector_t &buf
        ) = 0;

        virtual byte_vector_t read_i2c(
            uint16_t addr,
            size_t num_bytes
        ) = 0;

        virtual void write_eeprom(
            uint16_t addr,
            uint16_t offset,
            const byte_vector_t &buf
        );

        virtual byte_vector_t read_eeprom(
            uint16_t addr,
            uint16_t offset,
            size_t num_bytes
        );
    };

    struct UHD_API spi_config_t{
        enum edge_t{
            EDGE_RISE = 'r',
            EDGE_FALL = 'f'
        };

        edge_t mosi_edge;

        edge_t miso_edge;

        bool use_custom_divider;

        size_t divider;

        spi_config_t(edge_t edge = EDGE_RISE);
    };

    class UHD_API spi_iface{
    public:
        typedef boost::shared_ptr<spi_iface> sptr;

        virtual ~spi_iface(void);

        virtual uint32_t transact_spi(
            int which_slave,
            const spi_config_t &config,
            uint32_t data,
            size_t num_bits,
            bool readback
        ) = 0;

        virtual uint32_t read_spi(
            int which_slave,
            const spi_config_t &config,
            uint32_t data,
            size_t num_bits
        );

        virtual void write_spi(
            int which_slave,
            const spi_config_t &config,
            uint32_t data,
            size_t num_bits
        );
    };

    class UHD_API uart_iface{
    public:
        typedef boost::shared_ptr<uart_iface> sptr;

        virtual ~uart_iface(void);

        virtual void write_uart(const std::string &buf) = 0;

        virtual std::string read_uart(double timeout) = 0;
    };

} //namespace uhd

#endif /* INCLUDED_UHD_TYPES_SERIAL_HPP */