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      */
Iio(int device)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      */
Iio(const std::string & deviceName)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      */
~Iio()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
getDeviceName() const118     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
readInt(const std::string & attributeName) const133     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
readFloat(const std::string & attributeName) const155     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
writeInt(const std::string & attributeName,int value) const176     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
writeFloat(const std::string & attributeName,float value) const196     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
registerEventHandler(IioHandler * handler) const215     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:
private_event_handler(iio_event_data * data,void * args)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 }
246