api/mraa/iio.hpp

   1 /*
   2  * Author: Henry Bruce <henry.bruce@intel.com>
   3  * Copyright (c) 2015 Intel Corporation.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be
  14  * included in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #pragma once
  26
  27 #include <stdexcept>
  28  #include <sstream>
  29 #include "iio.h"
  30 #include "types.hpp"
  31
  32 namespace mraa
  33 {
  34
  35 struct IioEventData
  36 {
  37     int channelType;
  38     int modifier;
  39     int type;
  40     int direction;
  41     int channel;
  42     int channel2;
  43     int diff;
  44 };
  45
  46 class IioHandler
  47 {
  48 public:
  49   virtual void onIioEvent(const IioEventData& eventData) = 0;
  50 };
  51
  52
  53 /**
  54  * @brief API to Industrial IO
  55  *
  56  * This file defines the C++ iio interface for libmraa
  57  *
  58  * @snippet iio_dummy_test.cpp Interesting
  59  */
  60 class Iio
  61 {
  62   public:
  63     /**
  64      * Iio Constructor, takes a device number which will map directly to sysfs
  65      * e.g. device 0 maps to /sys/bus/iio/devices/iio:device0
  66      *
  67      * @param device IIO device number
  68      *
  69      * @throws std::invalid_argument if initialization fails
  70      */
  71     Iio(int device)
  72     {
  73         m_iio = mraa_iio_init(device);
  74         if (m_iio == NULL) {
  75             std::ostringstream oss;
  76             oss << "IIO device " << device << " is not valid";
  77             throw std::invalid_argument(oss.str());
  78         }
  79     }
  80
  81     /**
  82      * Iio Constructor
  83      *
  84      * @param deviceName IIO device name
  85      *
  86      * @throws std::invalid_argument if initialization fails
  87      */
  88     Iio(const std::string& deviceName)
  89     {
  90         std::ostringstream oss;
  91         int id = mraa_iio_get_device_num_by_name(deviceName.c_str());
  92         if (id == -1) {
  93             oss << "IIO device name " << deviceName << " not found";
  94             throw std::invalid_argument(oss.str());
  95         }
  96         m_iio = mraa_iio_init(id);
  97         if (m_iio == NULL) {
  98             oss << "IIO device " << deviceName << " is not valid";
  99             throw std::invalid_argument(oss.str());
 100         }
 101     }
 102
 103     /**
 104      * Iio destructor
 105      */
 106     ~Iio()
 107     {
 108         mraa_iio_close(m_iio);
 109     }
 110
 111
 112     /**
 113      * Get device name
 114      *
 115      * @returns The device name
 116      */
 117     std::string
 118     getDeviceName() const
 119     {
 120         return mraa_iio_get_device_name(m_iio);
 121     }
 122
 123     /**
 124      * Read an int value from specified attribute.
 125      *
 126      * @param attributeName attribute mame
 127      *
 128      * @returns The int value
 129      *
 130      * @throws std::invalid_argument if read fails
 131      */
 132     int
 133     readInt(const std::string& attributeName) const
 134     {
 135         int value;
 136         mraa_result_t res = mraa_iio_read_int(m_iio, attributeName.c_str(), &value);
 137         if (res != MRAA_SUCCESS) {
 138             std::ostringstream oss;
 139             oss << "IIO readInt for attibute " << attributeName << " failed";
 140             throw std::runtime_error(oss.str());
 141         }
 142         return value;
 143     }
 144
 145     /**
 146      * Read a float value from specified attribute.
 147      *
 148      * @param attributeName attribute mame
 149      *
 150      * @returns The float value
 151      *
 152      * @throws std::invalid_argument if read fails
 153      */
 154     float
 155     readFloat(const std::string& attributeName) const
 156     {
 157         float value;
 158         mraa_result_t res = mraa_iio_read_float(m_iio, attributeName.c_str(), &value);
 159         if (res != MRAA_SUCCESS) {
 160             std::ostringstream oss;
 161             oss << "IIO readFloat for attibute " << attributeName << " failed";
 162             throw std::runtime_error(oss.str());
 163         }
 164         return value;
 165     }
 166
 167     /**
 168      * Write an int value to specified attribute.
 169      *
 170      * @param attributeName attribute mame
 171      * @param value int value
 172      *
 173      * @throws std::invalid_argument if write fails
 174      */
 175     void
 176     writeInt(const std::string& attributeName, int value) const
 177     {
 178         mraa_result_t res = mraa_iio_write_int(m_iio, attributeName.c_str(), value);
 179         if (res != MRAA_SUCCESS) {
 180             std::ostringstream oss;
 181             oss << "IIO writeInt for attibute " << attributeName << " failed";
 182             throw std::runtime_error(oss.str());
 183         }
 184
 185     }
 186
 187     /**
 188      * Write a float value to specified attribute.
 189      *
 190      * @param attributeName attribute mame
 191      * @param value float value
 192      *
 193      * @throws std::invalid_argument if write fails
 194      */
 195     void
 196     writeFloat(const std::string& attributeName, float value) const
 197     {
 198         mraa_result_t res = mraa_iio_write_float(m_iio, attributeName.c_str(), value);
 199         if (res != MRAA_SUCCESS) {
 200             std::ostringstream oss;
 201             oss << "IIO writeFloat for attibute " << attributeName << " failed";
 202             throw std::runtime_error(oss.str());
 203         }
 204
 205     }
 206
 207     /**
 208      * Register event handler.
 209      *
 210      * @param handler handler class that implements IioHandler
 211      *
 212      * @throws std::invalid_argument on failure
 213      */
 214     void
 215     registerEventHandler(IioHandler* handler) const
 216     {
 217         mraa_result_t res = mraa_iio_event_setup_callback(m_iio, private_event_handler, handler);
 218         if (res != MRAA_SUCCESS) {
 219             throw std::runtime_error("registerEventHandler failed");
 220         }
 221     }
 222
 223   private:
 224     static void private_event_handler(iio_event_data* data, void *args)
 225     {
 226         if (args != NULL) {
 227             IioHandler* handler = (IioHandler*)args;
 228             IioEventData eventData;
 229             int chan_type, modifier, type, direction, channel, channel2, different;
 230             mraa_iio_event_extract_event(data, &chan_type, &modifier, &type, &direction, &channel, &channel2, &different);
 231             eventData.channelType = chan_type;
 232             eventData.modifier = modifier;
 233             eventData.type = type;
 234             eventData.direction = direction;
 235             eventData.channel = channel;
 236             eventData.channel2 = channel2;
 237             eventData.diff = different;
 238             handler->onIioEvent(eventData);
 239         }
 240         }
 241
 242     mraa_iio_context m_iio;
 243 };
 244
 245 }