YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
PidGainsData.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
12
13namespace yarp::dev {
14
15// Constructor with field values
17 const double kd,
18 const double ki,
19 const double max_int,
20 const double scale,
21 const double max_output,
22 const double offset,
23 const double stiction_up_val,
24 const double stiction_down_val,
25 const double kff) :
26 WirePortable(),
27 kp(kp),
28 kd(kd),
29 ki(ki),
30 max_int(max_int),
31 scale(scale),
32 max_output(max_output),
33 offset(offset),
34 stiction_up_val(stiction_up_val),
35 stiction_down_val(stiction_down_val),
36 kff(kff)
37{
38}
39
40// Read structure on a Wire
42{
43 if (!read_kp(reader)) {
44 return false;
45 }
46 if (!read_kd(reader)) {
47 return false;
48 }
49 if (!read_ki(reader)) {
50 return false;
51 }
52 if (!read_max_int(reader)) {
53 return false;
54 }
55 if (!read_scale(reader)) {
56 return false;
57 }
58 if (!read_max_output(reader)) {
59 return false;
60 }
61 if (!read_offset(reader)) {
62 return false;
63 }
64 if (!read_stiction_up_val(reader)) {
65 return false;
66 }
67 if (!read_stiction_down_val(reader)) {
68 return false;
69 }
70 if (!read_kff(reader)) {
71 return false;
72 }
73 if (reader.isError()) {
74 return false;
75 }
76 return true;
77}
78
79// Read structure on a Connection
81{
82 yarp::os::idl::WireReader reader(connection);
83 if (!reader.readListHeader(10)) {
84 return false;
85 }
86 if (!read(reader)) {
87 return false;
88 }
89 return true;
90}
91
92// Write structure on a Wire
94{
95 if (!write_kp(writer)) {
96 return false;
97 }
98 if (!write_kd(writer)) {
99 return false;
100 }
101 if (!write_ki(writer)) {
102 return false;
103 }
104 if (!write_max_int(writer)) {
105 return false;
106 }
107 if (!write_scale(writer)) {
108 return false;
109 }
110 if (!write_max_output(writer)) {
111 return false;
112 }
113 if (!write_offset(writer)) {
114 return false;
115 }
116 if (!write_stiction_up_val(writer)) {
117 return false;
118 }
119 if (!write_stiction_down_val(writer)) {
120 return false;
121 }
122 if (!write_kff(writer)) {
123 return false;
124 }
125 if (writer.isError()) {
126 return false;
127 }
128 return true;
129}
130
131// Write structure on a Connection
133{
134 yarp::os::idl::WireWriter writer(connection);
135 if (!writer.writeListHeader(10)) {
136 return false;
137 }
138 if (!write(writer)) {
139 return false;
140 }
141 return true;
142}
143
144// Convert to a printable string
145std::string PidGainsData::toString() const
146{
148 if (!yarp::os::Portable::copyPortable(*this, b)) {
149 return {};
150 }
151 return b.toString();
152}
153
154// read kp field
155bool PidGainsData::read_kp(yarp::os::idl::WireReader& reader)
156{
157 if (reader.noMore()) {
158 reader.fail();
159 return false;
160 }
161 if (!reader.readFloat64(kp)) {
162 reader.fail();
163 return false;
164 }
165 return true;
166}
167
168// write kp field
169bool PidGainsData::write_kp(const yarp::os::idl::WireWriter& writer) const
170{
171 if (!writer.writeFloat64(kp)) {
172 return false;
173 }
174 return true;
175}
176
177// read (nested) kp field
178bool PidGainsData::nested_read_kp(yarp::os::idl::WireReader& reader)
179{
180 if (reader.noMore()) {
181 reader.fail();
182 return false;
183 }
184 if (!reader.readFloat64(kp)) {
185 reader.fail();
186 return false;
187 }
188 return true;
189}
190
191// write (nested) kp field
192bool PidGainsData::nested_write_kp(const yarp::os::idl::WireWriter& writer) const
193{
194 if (!writer.writeFloat64(kp)) {
195 return false;
196 }
197 return true;
198}
199
200// read kd field
201bool PidGainsData::read_kd(yarp::os::idl::WireReader& reader)
202{
203 if (reader.noMore()) {
204 reader.fail();
205 return false;
206 }
207 if (!reader.readFloat64(kd)) {
208 reader.fail();
209 return false;
210 }
211 return true;
212}
213
214// write kd field
215bool PidGainsData::write_kd(const yarp::os::idl::WireWriter& writer) const
216{
217 if (!writer.writeFloat64(kd)) {
218 return false;
219 }
220 return true;
221}
222
223// read (nested) kd field
224bool PidGainsData::nested_read_kd(yarp::os::idl::WireReader& reader)
225{
226 if (reader.noMore()) {
227 reader.fail();
228 return false;
229 }
230 if (!reader.readFloat64(kd)) {
231 reader.fail();
232 return false;
233 }
234 return true;
235}
236
237// write (nested) kd field
238bool PidGainsData::nested_write_kd(const yarp::os::idl::WireWriter& writer) const
239{
240 if (!writer.writeFloat64(kd)) {
241 return false;
242 }
243 return true;
244}
245
246// read ki field
247bool PidGainsData::read_ki(yarp::os::idl::WireReader& reader)
248{
249 if (reader.noMore()) {
250 reader.fail();
251 return false;
252 }
253 if (!reader.readFloat64(ki)) {
254 reader.fail();
255 return false;
256 }
257 return true;
258}
259
260// write ki field
261bool PidGainsData::write_ki(const yarp::os::idl::WireWriter& writer) const
262{
263 if (!writer.writeFloat64(ki)) {
264 return false;
265 }
266 return true;
267}
268
269// read (nested) ki field
270bool PidGainsData::nested_read_ki(yarp::os::idl::WireReader& reader)
271{
272 if (reader.noMore()) {
273 reader.fail();
274 return false;
275 }
276 if (!reader.readFloat64(ki)) {
277 reader.fail();
278 return false;
279 }
280 return true;
281}
282
283// write (nested) ki field
284bool PidGainsData::nested_write_ki(const yarp::os::idl::WireWriter& writer) const
285{
286 if (!writer.writeFloat64(ki)) {
287 return false;
288 }
289 return true;
290}
291
292// read max_int field
293bool PidGainsData::read_max_int(yarp::os::idl::WireReader& reader)
294{
295 if (reader.noMore()) {
296 reader.fail();
297 return false;
298 }
299 if (!reader.readFloat64(max_int)) {
300 reader.fail();
301 return false;
302 }
303 return true;
304}
305
306// write max_int field
307bool PidGainsData::write_max_int(const yarp::os::idl::WireWriter& writer) const
308{
309 if (!writer.writeFloat64(max_int)) {
310 return false;
311 }
312 return true;
313}
314
315// read (nested) max_int field
316bool PidGainsData::nested_read_max_int(yarp::os::idl::WireReader& reader)
317{
318 if (reader.noMore()) {
319 reader.fail();
320 return false;
321 }
322 if (!reader.readFloat64(max_int)) {
323 reader.fail();
324 return false;
325 }
326 return true;
327}
328
329// write (nested) max_int field
330bool PidGainsData::nested_write_max_int(const yarp::os::idl::WireWriter& writer) const
331{
332 if (!writer.writeFloat64(max_int)) {
333 return false;
334 }
335 return true;
336}
337
338// read scale field
339bool PidGainsData::read_scale(yarp::os::idl::WireReader& reader)
340{
341 if (reader.noMore()) {
342 reader.fail();
343 return false;
344 }
345 if (!reader.readFloat64(scale)) {
346 reader.fail();
347 return false;
348 }
349 return true;
350}
351
352// write scale field
353bool PidGainsData::write_scale(const yarp::os::idl::WireWriter& writer) const
354{
355 if (!writer.writeFloat64(scale)) {
356 return false;
357 }
358 return true;
359}
360
361// read (nested) scale field
362bool PidGainsData::nested_read_scale(yarp::os::idl::WireReader& reader)
363{
364 if (reader.noMore()) {
365 reader.fail();
366 return false;
367 }
368 if (!reader.readFloat64(scale)) {
369 reader.fail();
370 return false;
371 }
372 return true;
373}
374
375// write (nested) scale field
376bool PidGainsData::nested_write_scale(const yarp::os::idl::WireWriter& writer) const
377{
378 if (!writer.writeFloat64(scale)) {
379 return false;
380 }
381 return true;
382}
383
384// read max_output field
385bool PidGainsData::read_max_output(yarp::os::idl::WireReader& reader)
386{
387 if (reader.noMore()) {
388 reader.fail();
389 return false;
390 }
391 if (!reader.readFloat64(max_output)) {
392 reader.fail();
393 return false;
394 }
395 return true;
396}
397
398// write max_output field
399bool PidGainsData::write_max_output(const yarp::os::idl::WireWriter& writer) const
400{
401 if (!writer.writeFloat64(max_output)) {
402 return false;
403 }
404 return true;
405}
406
407// read (nested) max_output field
408bool PidGainsData::nested_read_max_output(yarp::os::idl::WireReader& reader)
409{
410 if (reader.noMore()) {
411 reader.fail();
412 return false;
413 }
414 if (!reader.readFloat64(max_output)) {
415 reader.fail();
416 return false;
417 }
418 return true;
419}
420
421// write (nested) max_output field
422bool PidGainsData::nested_write_max_output(const yarp::os::idl::WireWriter& writer) const
423{
424 if (!writer.writeFloat64(max_output)) {
425 return false;
426 }
427 return true;
428}
429
430// read offset field
431bool PidGainsData::read_offset(yarp::os::idl::WireReader& reader)
432{
433 if (reader.noMore()) {
434 reader.fail();
435 return false;
436 }
437 if (!reader.readFloat64(offset)) {
438 reader.fail();
439 return false;
440 }
441 return true;
442}
443
444// write offset field
445bool PidGainsData::write_offset(const yarp::os::idl::WireWriter& writer) const
446{
447 if (!writer.writeFloat64(offset)) {
448 return false;
449 }
450 return true;
451}
452
453// read (nested) offset field
454bool PidGainsData::nested_read_offset(yarp::os::idl::WireReader& reader)
455{
456 if (reader.noMore()) {
457 reader.fail();
458 return false;
459 }
460 if (!reader.readFloat64(offset)) {
461 reader.fail();
462 return false;
463 }
464 return true;
465}
466
467// write (nested) offset field
468bool PidGainsData::nested_write_offset(const yarp::os::idl::WireWriter& writer) const
469{
470 if (!writer.writeFloat64(offset)) {
471 return false;
472 }
473 return true;
474}
475
476// read stiction_up_val field
477bool PidGainsData::read_stiction_up_val(yarp::os::idl::WireReader& reader)
478{
479 if (reader.noMore()) {
480 reader.fail();
481 return false;
482 }
483 if (!reader.readFloat64(stiction_up_val)) {
484 reader.fail();
485 return false;
486 }
487 return true;
488}
489
490// write stiction_up_val field
491bool PidGainsData::write_stiction_up_val(const yarp::os::idl::WireWriter& writer) const
492{
493 if (!writer.writeFloat64(stiction_up_val)) {
494 return false;
495 }
496 return true;
497}
498
499// read (nested) stiction_up_val field
500bool PidGainsData::nested_read_stiction_up_val(yarp::os::idl::WireReader& reader)
501{
502 if (reader.noMore()) {
503 reader.fail();
504 return false;
505 }
506 if (!reader.readFloat64(stiction_up_val)) {
507 reader.fail();
508 return false;
509 }
510 return true;
511}
512
513// write (nested) stiction_up_val field
514bool PidGainsData::nested_write_stiction_up_val(const yarp::os::idl::WireWriter& writer) const
515{
516 if (!writer.writeFloat64(stiction_up_val)) {
517 return false;
518 }
519 return true;
520}
521
522// read stiction_down_val field
523bool PidGainsData::read_stiction_down_val(yarp::os::idl::WireReader& reader)
524{
525 if (reader.noMore()) {
526 reader.fail();
527 return false;
528 }
529 if (!reader.readFloat64(stiction_down_val)) {
530 reader.fail();
531 return false;
532 }
533 return true;
534}
535
536// write stiction_down_val field
537bool PidGainsData::write_stiction_down_val(const yarp::os::idl::WireWriter& writer) const
538{
539 if (!writer.writeFloat64(stiction_down_val)) {
540 return false;
541 }
542 return true;
543}
544
545// read (nested) stiction_down_val field
546bool PidGainsData::nested_read_stiction_down_val(yarp::os::idl::WireReader& reader)
547{
548 if (reader.noMore()) {
549 reader.fail();
550 return false;
551 }
552 if (!reader.readFloat64(stiction_down_val)) {
553 reader.fail();
554 return false;
555 }
556 return true;
557}
558
559// write (nested) stiction_down_val field
560bool PidGainsData::nested_write_stiction_down_val(const yarp::os::idl::WireWriter& writer) const
561{
562 if (!writer.writeFloat64(stiction_down_val)) {
563 return false;
564 }
565 return true;
566}
567
568// read kff field
569bool PidGainsData::read_kff(yarp::os::idl::WireReader& reader)
570{
571 if (reader.noMore()) {
572 reader.fail();
573 return false;
574 }
575 if (!reader.readFloat64(kff)) {
576 reader.fail();
577 return false;
578 }
579 return true;
580}
581
582// write kff field
583bool PidGainsData::write_kff(const yarp::os::idl::WireWriter& writer) const
584{
585 if (!writer.writeFloat64(kff)) {
586 return false;
587 }
588 return true;
589}
590
591// read (nested) kff field
592bool PidGainsData::nested_read_kff(yarp::os::idl::WireReader& reader)
593{
594 if (reader.noMore()) {
595 reader.fail();
596 return false;
597 }
598 if (!reader.readFloat64(kff)) {
599 reader.fail();
600 return false;
601 }
602 return true;
603}
604
605// write (nested) kff field
606bool PidGainsData::nested_write_kff(const yarp::os::idl::WireWriter& writer) const
607{
608 if (!writer.writeFloat64(kff)) {
609 return false;
610 }
611 return true;
612}
613
614} // namespace yarp::dev
double ki
integrative gain
double scale
scale for the pid output
double kp
proportional gain
double max_output
max output
double stiction_down_val
down stiction offset added to the pid output
double kff
feedforward gain
bool write(const yarp::os::idl::WireWriter &writer) const override
double stiction_up_val
up stiction offset added to the pid output
double kd
derivative gain
bool read(yarp::os::idl::WireReader &reader) override
double offset
pwm offset added to the pid output
double max_int
saturation threshold for the integrator
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
std::string toString() const
A simple collection of objects that can be described and transmitted in a portable way.
Definition Bottle.h:65
std::string toString() const override
Gives a human-readable textual representation of the bottle.
Definition Bottle.cpp:217
An interface for reading from a network connection.
An interface for writing to a network connection.
static bool copyPortable(const PortWriter &writer, PortReader &reader)
Copy one portable to another, via writing and reading.
Definition Portable.cpp:16
IDL-friendly connection reader.
Definition WireReader.h:27
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeListHeader(int len) const
bool writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const
For streams capable of holding different kinds of content, check what they actually have.