IIO.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/

#ifndef IIO_H_
#define IIO_H_

#include "IIODevice.H"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-attributes"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <Eigen/Dense>
#pragma GCC diagnostic pop

#include "DirectoryScanner.H"

#include <sstream>
#include <fstream>

#include <Thread.H>

struct iio_channel_info; 

class IIO : public std::vector<IIODevice> {
    static const char *iioDir; 

    std::string findChipName(std::string devicePath) {
        std::string chipName;
        std::ifstream nameFile((devicePath+"/name").c_str());
        if (nameFile.good()) // if we can open the name
            nameFile>>chipName;
        return chipName;
    }

public:
    IIO() {}
    virtual ~IIO() {
        close();
    }

    int findDevicesByChipName(std::string chipName) {
        vector<std::string> excluded; // paths we don't want to search
        excluded.push_back(".");
        excluded.push_back("..");

        DirectoryScanner ds(iioDir);
        if (ds.findAll(excluded)!=NO_ERROR) // find all of the directories
            return IIODebug().evaluateError(IIO_BAD_DEVICE_NAME_ERROR);
        ds.keepWithPattern("iio:device"); // only keep the entries of interest, namely the iio devices

        // If any of the devices have a name which matches the chipName we are after, then keep it.
        for (unsigned int i=0; i<ds.size(); i++) {
            std::string devicePath(iioDir);
            devicePath+=ds[i];
            //cout<<findChipName(devicePath)<<endl;
            // search for chipName (e.g. "ADAU7476") in the sysfs name file, which can be chipName+"_1" or some other suffix.
            if (findChipName(devicePath).find(chipName)!=std::string::npos) {
                push_back(IIODevice(devicePath, chipName)); // found a relevant device, so add it to the known devices
                operator[](size()-1).scanDevice();
            }
        }
        return NO_ERROR;
    }

//    /** Open an iio device by name.
//    \param deviceName The name of the iio device, e.g. "iio:1"
//    \return NOERROR on success, or the appropriate error number otherwise.
//    */
//    int open(std::string deviceName);

    uint getDeviceCnt() {
        return size();
    }

    uint getChCnt() {
        int chCnt=0;
        for (uint i=0; i<getDeviceCnt(); i++)
            chCnt+=operator[](i).getChCnt();
        return chCnt;
    }

    void printInfo() {
        for (uint i=0; i<getDeviceCnt(); i++) {
            printf("Device %d\t",i);
            operator[](i).printInfo();
        }
    }

    int open(void) {
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        int ret=NO_ERROR;
        for (unsigned int i=0; i<getDeviceCnt(); i++) {
            if ((ret=operator[](i).open())!=NO_ERROR) {
                std::stringstream deviceDetail;
                deviceDetail<<" Device "<<i;
                IIODebug().evaluateError(ret, deviceDetail.str());
                break;
            }
        }
        int closeRet;
        if (ret!=NO_ERROR) // if we couldn't open everything, then close everything
            for (unsigned int i=0; i<getDeviceCnt(); i++)
                if ((closeRet=operator[](i).close())!=NO_ERROR)
                    IIODebug().evaluateError(closeRet);
        return ret;
    }

    int close(void) {
        int closeRet;
        for (unsigned int i=0; i<getDeviceCnt(); i++)
            if ((closeRet=operator[](i).close())!=NO_ERROR)
                return IIODebug().evaluateError(closeRet);
        return NO_ERROR;
    }

    int getChFrameSize(void) {
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        uint frameSize=operator[](0).getChFrameSize();
        if (frameSize<0)
            return frameSize;
        for (unsigned int i=1; i<getDeviceCnt(); i++)
            if (operator[](i).getChFrameSize() != frameSize)
                return IIODebug().evaluateError(IIO_FRAEMSIZE_MISMATCH_ERROR);
        return frameSize;
    }

    int getDevFrameSize(void) {
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);

        int frameSize=getChFrameSize();
        if (frameSize<0)
            return frameSize;
        return frameSize*getDeviceCnt();
    }

    template<typename TYPE>
    int getReadArray(uint N, Eigen::Array<TYPE, Eigen::Dynamic, Eigen::Dynamic> &array) {
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        if (sizeof(TYPE)!=operator[](0).getChFrameSize()) {
            std::stringstream msg;
            msg<<"The provided array type has "<<sizeof(TYPE)<<" bytes per sample, where as the IIO devices have "<<getChFrameSize()<<" bytes per sample\n";
            return IIODebug().evaluateError(IIO_ARRAY_FRAME_MISMATCH_ERROR, msg.str());
        }

        if (array.rows()!=N*operator[](0).getChCnt() && array.cols()!=getDeviceCnt())
            array.resize(N*operator[](0).getChCnt(), getDeviceCnt());
        return NO_ERROR;
    }

    template<typename TYPE>
    int getReadArraySampleCount(Eigen::Array<TYPE, Eigen::Dynamic, Eigen::Dynamic> &array) {
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        return array.rows()/operator[](0).getChCnt();
    }

    template<typename TYPE>
    int read(uint N, const Eigen::Array<TYPE, Eigen::Dynamic, Eigen::Dynamic> &array) {
        if (sizeof(TYPE)!=operator[](0).getChFrameSize()) {
            std::stringstream msg;
            msg<<"The provided array type has "<<sizeof(TYPE)<<" bytes per sample, where as the IIO devices have "<<getChFrameSize()<<" bytes per sample\n";
            return IIODebug().evaluateError(IIO_ARRAY_FRAME_MISMATCH_ERROR, msg.str());
        }
        if (array.rows()!=N*operator[](0).getChCnt() && array.cols()>getDeviceCnt()) {
            std::stringstream msg;
            msg<<"The provided array is not shaped correctly, size=("<<array.rows()<<", "<<array.cols()<<") but size=(N*device ch cnt, device cnt) is required, where size=("<<N*getChCnt()<<", "<<getDeviceCnt()<<")\n";
            return IIODebug().evaluateError(IIO_ARRAY_SIZE_MISMATCH_ERROR, msg.str());
        }
        uint NOrig=N;
        while (N){
            uint toRead=NOrig;
            //uint toRead=1024;
            if (toRead>N) toRead=N;
            for (int i=0; i <array.cols(); i++) { // read N samples from each device which is requested
                int ret=operator[](i).read(toRead, (void*)array.col(i).data());
                if (ret<0){ // error
                    std::stringstream msg;
                    msg<<"Couldn't read the desired number of samples from device "<<i<<std::endl;
                    return IIODebug().evaluateError(IIODEVICE_READ_ERROR, msg.str());
                } else
                    if (i==0){ // follow the lead of the first device
                        toRead=ret;
                        N-=ret;
                        //cout<<"read "<<ret<<" frames \t with "<<N<<" frames left\n";
                    }
            }
        }
        return NO_ERROR;
    }

    int enable(bool enable) {
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        for (unsigned int i=0; i<getDeviceCnt(); i++)
            operator[](i).enable(enable);
                return NO_ERROR;
    }

    int getChannelBufferCnt(){
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        int chBufCnt=operator[](0).getChannelBufferCnt();
        for (unsigned int i=1; i<getDeviceCnt(); i++)
            if (operator[](i).getChannelBufferCnt()!=chBufCnt)
                return IIODebug().evaluateError(IIODEVICE_CHBUFCNT_ERROR);
        return chBufCnt;
    }

    int setChannelBufferCnt(int chBufCnt){
        if (getDeviceCnt()<1)
            return IIODebug().evaluateError(IIO_NODEVICES_ERROR);
        int chBufCntOrig=getChannelBufferCnt();
        chBufCnt=operator[](0).setChannelBufferCnt(chBufCnt);
        for (unsigned int i=1; i<getDeviceCnt(); i++)
            if (operator[](i).setChannelBufferCnt(chBufCnt)!=chBufCnt){
                setChannelBufferCnt(chBufCntOrig); // try to rewind ... may be dissasterous ! TODO remove recurrence here
                return IIODebug().evaluateError(IIODEVICE_CHBUFCNT_ERROR);
            }
        return chBufCnt;
    }
};

const char *IIO::iioDir = "/sys/bus/iio/devices/";

#endif // IIO_H_