Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
backend-hid.h
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
3 #pragma once
4 
5 #include "backend.h"
6 #include "types.h"
7 
8 #include <cassert>
9 #include <cstdlib>
10 #include <cstdio>
11 #include <cstring>
12 
13 #include <algorithm>
14 #include <functional>
15 #include <string>
16 #include <sstream>
17 #include <fstream>
18 #include <regex>
19 #include <thread>
20 #include <utility> // for pair
21 #include <chrono>
22 #include <thread>
23 #include <atomic>
24 
25 #include <dirent.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28 #include <limits.h>
29 #include <cmath>
30 #include <errno.h>
31 #include <sys/stat.h>
32 #include <sys/mman.h>
33 #include <sys/ioctl.h>
34 #include <linux/usb/video.h>
35 #include <linux/uvcvideo.h>
36 #include <linux/videodev2.h>
37 #include <fts.h>
38 #include <regex>
39 #include <list>
40 
41 namespace librealsense
42 {
43  namespace platform
44  {
46  {
47  std::string input = "";
48  std::string device_path = "";
49  int index = -1;
50  bool enabled = false;
51 
52  uint32_t big_endian = 0;
53  uint32_t bits_used = 0;
54  uint32_t bytes = 0;
55  uint32_t is_signed = 0;
56  uint32_t location = 0;
57  uint32_t shift = 0;
58  uint64_t mask;
59  // TODO: parse 'offset' and 'scale'
60  };
61 
62  // manage an IIO input. or what is called a scan.
63  class hid_input
64  {
65  public:
66  hid_input(const std::string& iio_device_path, const std::string& input_name);
67  ~hid_input();
68 
69  // enable scan input. doing so cause the input to be part of the data provided in the polling.
70  void enable(bool is_enable);
71 
72  const hid_input_info& get_hid_input_info() const { return info; }
73 
74  private:
75  // initialize the input by reading the input parameters.
76  void init();
77 
78  hid_input_info info;
79  };
80 
82  public:
83  hid_custom_sensor(const std::string& device_path, const std::string& sensor_name);
84 
86 
87  std::vector<uint8_t> get_report_data(const std::string& report_name, custom_sensor_report_field report_field);
88 
89  const std::string& get_sensor_name() const { return _custom_sensor_name; }
90 
91  // start capturing and polling.
92  void start_capture(hid_callback sensor_callback);
93 
94  void stop_capture();
95  private:
96  std::vector<uint8_t> read_report(const std::string& name_report_path);
97 
98  void init();
99 
100  void enable(bool state);
101 
102  void signal_stop();
103 
104  int _stop_pipe_fd[2]; // write to _stop_pipe_fd[1] and read from _stop_pipe_fd[0]
105  int _fd;
106  std::map<std::string, std::string> _reports;
107  std::string _custom_device_path;
108  std::string _custom_sensor_name;
109  std::string _custom_device_name;
110  hid_callback _callback;
111  std::atomic<bool> _is_capturing;
112  std::unique_ptr<std::thread> _hid_thread;
113  };
114 
115  // declare device sensor with all of its inputs.
117  public:
118  iio_hid_sensor(const std::string& device_path, uint32_t frequency);
119 
120  ~iio_hid_sensor();
121 
122  // start capturing and polling.
123  void start_capture(hid_callback sensor_callback);
124 
125  void stop_capture();
126 
127  const std::string& get_sensor_name() const { return _sensor_name; }
128 
129  private:
130  void clear_buffer();
131 
132  void set_frequency(uint32_t frequency);
133 
134  void signal_stop();
135 
136  bool has_metadata();
137 
138  static bool sort_hids(hid_input* first, hid_input* second);
139 
140  void create_channel_array();
141 
142  // initialize the device sensor. reading its name and all of its inputs.
143  void init(uint32_t frequency);
144 
145  // calculate the storage size of a scan
146  uint32_t get_channel_size() const;
147 
148  // calculate the actual size of data
149  uint32_t get_output_size() const;
150 
151  std::string get_sampling_frequency_name() const;
152 
153  // read the IIO device inputs.
154  void read_device_inputs();
155 
156  // configure hid device via fd
157  void write_integer_to_param(const std::string& param,int value);
158 
159  static const uint32_t buf_len = 128; // TODO
160  int _stop_pipe_fd[2]; // write to _stop_pipe_fd[1] and read from _stop_pipe_fd[0]
161  int _fd;
162  int _iio_device_number;
163  std::string _iio_device_path;
164  std::string _sensor_name;
165  std::string _sampling_frequency_name;
166  std::list<hid_input*> _inputs;
167  std::list<hid_input*> _channels;
168  hid_callback _callback;
169  std::atomic<bool> _is_capturing;
170  std::unique_ptr<std::thread> _hid_thread;
171  };
172 
173  class v4l_hid_device : public hid_device
174  {
175  public:
176  v4l_hid_device(const hid_device_info& info);
177 
178  ~v4l_hid_device();
179 
180  void open(const std::vector<hid_profile>& hid_profiles);
181 
182  void close();
183 
184  std::vector<hid_sensor> get_sensors();
185 
186  void start_capture(hid_callback callback);
187 
188  void stop_capture();
189 
190  std::vector<uint8_t> get_custom_report_data(const std::string& custom_sensor_name,
191  const std::string& report_name,
192  custom_sensor_report_field report_field);
193 
194  static void foreach_hid_device(std::function<void(const hid_device_info&)> action);
195 
196  private:
197  static bool get_hid_device_info(const char* dev_path, hid_device_info& device_info);
198 
199  std::vector<hid_profile> _hid_profiles;
200  std::vector<hid_device_info> _hid_device_infos;
201  std::vector<std::unique_ptr<iio_hid_sensor>> _iio_hid_sensors;
202  std::vector<std::unique_ptr<hid_custom_sensor>> _hid_custom_sensors;
203  std::vector<iio_hid_sensor*> _streaming_iio_sensors;
204  std::vector<hid_custom_sensor*> _streaming_custom_sensors;
205  static constexpr const char* custom_id{"custom"};
206  };
207  }
208 }
const std::string & get_sensor_name() const
Definition: backend-hid.h:127
uint64_t mask
Definition: backend-hid.h:58
Definition: backend-hid.h:173
Definition: backend.h:380
Definition: types.h:255
Definition: backend.h:397
std::string device_path
Definition: backend-hid.h:48
uint32_t is_signed
Definition: backend-hid.h:55
Definition: backend-hid.h:81
Definition: backend-hid.h:63
uint32_t location
Definition: backend-hid.h:56
Definition: algo.h:16
uint32_t bits_used
Definition: backend-hid.h:53
const hid_input_info & get_hid_input_info() const
Definition: backend-hid.h:72
uint32_t shift
Definition: backend-hid.h:57
Definition: context.h:46
Definition: backend-hid.h:45
std::string input
Definition: backend-hid.h:47
custom_sensor_report_field
Definition: backend.h:373
Definition: backend-hid.h:116
int index
Definition: backend-hid.h:49
const std::string & get_sensor_name() const
Definition: backend-hid.h:89
uint32_t bytes
Definition: backend-hid.h:54
std::function< void(const sensor_data &)> hid_callback
Definition: backend.h:395
bool enabled
Definition: backend-hid.h:50