Serial Wombat Arduino Library

Loading...
Searching...
No Matches
SerialWombatAbstractScaledOutput.h
Go to the documentation of this file.
1#pragma once
2/*
3 Copyright 2021-2025 Broadwell Consulting Inc.
4
5"Serial Wombat" is a registered trademark of Broadwell Consulting Inc. in
6 the United States. See SerialWombat.com for usage guidance.
7
8 Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14
15 The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
25*/
26
27#include "SerialWombat.h"
28#include "limits.h"
29
32
33
62 class SerialWombatAbstractScaledOutput
63{
64 public:
70 SerialWombatAbstractScaledOutput(SerialWombatChip& sw):_asosw(sw){}
71
72 enum Period {
73 PERIOD_1mS = 0,
74 PERIOD_2mS = 1,
75 PERIOD_4mS = 2,
76 PERIOD_8mS = 3,
77 PERIOD_16mS = 4,
78 PERIOD_32mS = 5,
79 PERIOD_64mS = 6,
80 PERIOD_128mS = 7,
81 PERIOD_256mS = 8,
82 PERIOD_512mS = 9,
83 PERIOD_1024mS = 10,
84 };
85
86 enum RampMode{
87 RAMP_MODE_BOTH = 0,
88 RAMP_MODE_INCREMENT = 1,
89 RAMP_MODE_DECREMENT = 2,
90 };
91
92
108 int16_t writeTimeout(uint16_t timeout_mS, uint16_t timeoutOutputValue)
109 {
110
111 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
112 pin(),
113 swPinModeNumber(),
114 1,
115 SW_LE16(timeout_mS),
116 SW_LE16(timeoutOutputValue),
117 };
118
119 int16_t result = _asosw.sendPacket(tx);
120
121 return(result);
122
123 }
124
133 int16_t writeScalingEnabled(bool enabled, uint8_t sourcePin)
134 {
135 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
136 pin(), swPinModeNumber(),
137 0, //Enable/disable scaling, set source pin
138 enabled,
139 sourcePin,
140 0x55, 0x55};
141
142 int16_t result = _asosw.sendPacket(tx);
143 return(result);
144 }
145
159 int16_t writeInputScaling(uint16_t inputMin, uint16_t inputMax)
160 {
161 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
162 pin(),
163 swPinModeNumber(),
164 2, // Set input scaling
165 SW_LE16(inputMin),
166 SW_LE16(inputMax),
167 };
168 return(_asosw.sendPacket(tx));
169 }
170
186 int16_t writeOutputScaling(uint16_t outputMin, uint16_t outputMax)
187 {
188 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
189 pin(),
190 swPinModeNumber(),
191 5, //Set output scaling
192 SW_LE16(outputMin),
193 SW_LE16(outputMax),
194 };
195 return(_asosw.sendPacket(tx));
196 }
197
205 int16_t writeScalingInvertedInput(bool inverted)
206 {
207 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
208 pin(),
209 swPinModeNumber(),
210 3, // Set inverted/not inverted
211 inverted,
212 0x55,0x55,0x55,
213 };
214 return(_asosw.sendPacket(tx));
215 }
216
229 int16_t writeScalingTargetValue(uint16_t target)
230 {
231 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
232 pin(),
233 swPinModeNumber(),
234 6, // Set target value for PID controller
235 SW_LE16(target),0x55,0x55,
236 };
237 return(_asosw.sendPacket(tx));
238 }
239
253 int16_t writeRateControl(Period samplePeriod, uint16_t maximumChangecounts)
254 {
255 {
256 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
257 pin(),
258 swPinModeNumber(),
259 4, // Set filter mode
260 1, // Filter mode rate control
261 SW_LE16(maximumChangecounts),0x55,
262 };
263 int16_t result = _asosw.sendPacket(tx);
264 if (result < 0)
265 {
266 return(result);
267 }
268 }
269 {
270 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
271 pin(),
272 swPinModeNumber(),
273 7, // Set Sample Rate
274 (uint8_t)samplePeriod,
275 0x55,0x55,0x55,
276 };
277 return(_asosw.sendPacket(tx));
278 }
279 }
280
294 int16_t write1stOrderFiltering(Period sampleRate, uint16_t filterConstant)
295 {
296 {
297 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
298 pin(),
299 swPinModeNumber(),
300 4, // Set filter mode
301 2, // Filter mode 1st Order
302 SW_LE16(filterConstant),0x55,
303 };
304 int16_t result = _asosw.sendPacket(tx);
305 if (result < 0)
306 {
307 return(result);
308 }
309 }
310 {
311 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
312 pin(),
313 swPinModeNumber(),
314 7, // Set Sample Rate
315 (uint8_t)sampleRate,
316 0x55,0x55,0x55,
317 };
318 return(_asosw.sendPacket(tx));
319 }
320 }
321
336 int16_t writeHysteresis(uint16_t lowLimit, uint16_t lowOutputValue, uint16_t highLimit, uint16_t highOutputValue, uint16_t initialOutputValue)
337 {
338 {
339 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
340 pin(),
341 swPinModeNumber(),
342 50, // Set hysteresis high limit/output
343 SW_LE16(highLimit),
344 SW_LE16(highOutputValue)
345 };
346 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
347 }
348
349 {
350 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
351 pin(),
352 swPinModeNumber(),
353 51, // Set hysteresis low limit/output
354 SW_LE16(lowLimit),
355 SW_LE16(lowOutputValue)
356 };
357 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
358 }
359 {
360 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
361 pin(),
362 swPinModeNumber(),
363 52, // Set hysteresis low limit/output
364 SW_LE16(initialOutputValue),
365 0x55,0x55
366 };
367 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
368 }
369 return(0);
370 }
371
392 int16_t writeRamp(uint16_t slowIncrement, uint16_t incrementThreshold, uint16_t fastIncrement,Period samplePeriod, RampMode rampMode)
393 {
394 {
395 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
396 pin(),
397 swPinModeNumber(),
398 7, // Set Sample Rate
399 (uint8_t) samplePeriod,
400 0x55,0x55,0x55
401 };
402 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
403 }
404 {
405 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
406 pin(),
407 swPinModeNumber(),
408 60, // Set ramp slow increment, threshold
409 SW_LE16(slowIncrement),
410 SW_LE16(incrementThreshold)
411
412 };
413 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
414 }
415 {
416 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
417 pin(),
418 swPinModeNumber(),
419 61, // Set ramp fast increment, mode
420 SW_LE16(fastIncrement),
421 (uint8_t) rampMode, 0x55
422 };
423 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
424 }
425 return 0;
426
427 }
428
462 int16_t writePID(uint16_t kp, uint16_t ki, uint16_t kd,uint16_t target,Period samplePeriod, uint8_t targetPin = 255, bool biDirectional = false)
463 {
464 {
465 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
466 pin(),
467 swPinModeNumber(),
468 100, // Set kp and ki
469 SW_LE16(kp),
470 SW_LE16(ki)
471 };
472 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
473 }
474 {
475 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
476 pin(),
477 swPinModeNumber(),
478 101, // Set kd
479 SW_LE16(kd),
480 0x55,0x55
481 };
482 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
483 }
484 writeScalingTargetValue(target);
485 {
486 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
487 pin(),
488 swPinModeNumber(),
489 7, // Set Sample Rate
490 (uint8_t)samplePeriod,
491 0x55,0x55,0x55,
492 };
493 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
494 }
495 {
496 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
497 pin(),
498 swPinModeNumber(),
499 102, // Reset Integrator
500 0x55,0x55,0x55,0x55
501 };
502 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
503 }
504 {
505 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
506 pin(),
507 swPinModeNumber(),
508 109, // Configure target and bidirectional
509 targetPin,
510 biDirectional,
511 0x55,0x55
512 };
513 int16_t result = _asosw.sendPacket(tx); if (result < 0) { return(result); }
514 }
515 return 0;
516
517 }
518
519
527 uint16_t readLastOutputValue()
528 {
529 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
530 pin(),
531 swPinModeNumber(),
532 9, // Read Last Value
533 0x55, 0x55,0x55,0x55,
534 };
535 uint8_t rx[8];
536 if (_asosw.sendPacket(tx, rx) >= 0)
537 {
538 return(rx[4] + (uint16_t)rx[5] * 256);
539 }
540 else
541 {
542 return (0);
543 }
544
545 }
546
547 int16_t writeScalingTargetValueResetIntegrator(uint16_t target)
548 {
549 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
550 pin(),
551 swPinModeNumber(),
552 110, // Write target Value and Reset Integrator
553 (byte)(target & 0xFF),(byte)(target >> 8),0x55,0x55
554 };
555 return _asosw.sendPacket(tx);
556 }
557 int32_t PIDGetLastError()
558 {
559 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
560 pin(),
561 swPinModeNumber(),
562 103, // Get Last Error
563 0x55,0x55,0x55,0x55
564 };
565 uint8_t rx[8];
566
567 _asosw.sendPacket(tx, rx);
568 int32_t returnVal;
569 memcpy(&returnVal,&rx[4],4);
570 return returnVal;
571
572 }
573
574
575 int32_t PIDGetLastIntegrator()
576 {
577 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
578 pin(),
579 swPinModeNumber(),
580 104, // Get Last Integrator
581 0x55,0x55,0x55,0x55
582 };
583 uint8_t rx[8];
584
585 _asosw.sendPacket(tx, rx);
586
587 int32_t returnVal;
588 memcpy(&returnVal,&rx[4],4);
589 return returnVal;
590 }
591
592 int32_t PIDGetLastIntegratorEffort()
593 {
594 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
595 pin(),
596 swPinModeNumber(),
597 105, // Get Last Integrator Effort
598 0x55,0x55,0x55,0x55
599 };
600 uint8_t rx[8];
601
602 _asosw.sendPacket(tx, rx);
603
604 int32_t returnVal;
605 memcpy(&returnVal,&rx[4],4);
606 return returnVal;
607 }
608
609 int32_t PIDGetLastProportionalEffort()
610 {
611 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
612 pin(),
613 swPinModeNumber(),
614 106, // Get Last Proportional Effort
615 0x55,0x55,0x55,0x55
616 };
617 uint8_t rx[8];
618
619 _asosw.sendPacket(tx, rx);
620
621 int32_t returnVal;
622 memcpy(&returnVal,&rx[4],4);
623 return returnVal;
624 }
625
626 int32_t PIDGetLastDerivativeEffort()
627 {
628 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
629 pin(),
630 swPinModeNumber(),
631 107, // Get Last Derivative Effort
632 0x55,0x55,0x55,0x55
633 };
634 uint8_t rx[8];
635
636 _asosw.sendPacket(tx, rx);
637
638 int32_t returnVal;
639 memcpy(&returnVal,&rx[4],4);
640 return returnVal;
641 }
642
643 int32_t PIDGetLastEffort()
644 {
645 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
646 pin(),
647 swPinModeNumber(),
648 108, // Get Last Total Effort
649 0x55,0x55,0x55,0x55
650 };
651 uint8_t rx[8];
652
653 _asosw.sendPacket(tx, rx);
654
655 int32_t returnVal;
656 memcpy(&returnVal,&rx[4],4);
657 return returnVal;
658 }
659
660 uint16_t ReadLastTarget()
661 {
662 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
663 pin(),
664 swPinModeNumber(),
665 111, // Get Last Target
666 0x55,0x55,0x55,0x55
667 };
668 uint8_t rx[8];
669
670 _asosw.sendPacket(tx, rx);
671
672 return ((uint16_t)(rx[4] + 256 * rx[5]));
673 }
674
686 int16_t Enable2DLookupOutputScaling(uint16_t IndexInUserMemory
687 )
688 {
689 uint8_t tx[] = {(uint8_t)SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE,
690 pin(),
691 swPinModeNumber(),
692 10, // Set 2D Lookup Index
693 SW_LE16(IndexInUserMemory),0x55,0x55 };
694 return _asosw.sendPacket(tx);
695 }
696
698 virtual uint8_t pin() = 0;
700 virtual uint8_t swPinModeNumber() = 0;
701
702 private:
703 SerialWombatChip& _asosw;
704
705};
706
707
SerialWombat.h
SW_LE16
#define SW_LE16(_a)
Convert a uint16_t to two bytes in little endian format for array initialization.
Definition SerialWombat.h:41
SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE
@ CONFIGURE_PIN_OUTPUTSCALE
(210)
Definition SerialWombat.h:239
SerialWombatAbstractScaledOutput::writeScalingEnabled
int16_t writeScalingEnabled(bool enabled, uint8_t sourcePin)
Enable scaling and set which pin or public data is used as the input source.
Definition SerialWombatAbstractScaledOutput.h:133
SerialWombatAbstractScaledOutput::writeTimeout
int16_t writeTimeout(uint16_t timeout_mS, uint16_t timeoutOutputValue)
Enable a timeout value which will cause the output to go to a default value if not updated.
Definition SerialWombatAbstractScaledOutput.h:108
SerialWombatAbstractScaledOutput::writeRateControl
int16_t writeRateControl(Period samplePeriod, uint16_t maximumChangecounts)
Definition SerialWombatAbstractScaledOutput.h:253
SerialWombatAbstractScaledOutput::writeHysteresis
int16_t writeHysteresis(uint16_t lowLimit, uint16_t lowOutputValue, uint16_t highLimit, uint16_t highOutputValue, uint16_t initialOutputValue)
Controls the output based on hystersis control.
Definition SerialWombatAbstractScaledOutput.h:336
SerialWombatAbstractScaledOutput::ReadLastTarget
uint16_t ReadLastTarget()
Definition SerialWombatAbstractScaledOutput.h:660
SerialWombatAbstractScaledOutput::Enable2DLookupOutputScaling
int16_t Enable2DLookupOutputScaling(uint16_t IndexInUserMemory)
Set Up 2D Lookup Output Scaling.
Definition SerialWombatAbstractScaledOutput.h:686
SerialWombatAbstractScaledOutput::SerialWombatAbstractScaledOutput
SerialWombatAbstractScaledOutput(SerialWombatChip &sw)
Constructor for the SerialWombatAbstractScaledOutput Class.
Definition SerialWombatAbstractScaledOutput.h:70
SerialWombatAbstractScaledOutput::writeOutputScaling
int16_t writeOutputScaling(uint16_t outputMin, uint16_t outputMax)
Reduces the output range from 0 to 65535 to user specified range.
Definition SerialWombatAbstractScaledOutput.h:186
SerialWombatAbstractScaledOutput::writeRamp
int16_t writeRamp(uint16_t slowIncrement, uint16_t incrementThreshold, uint16_t fastIncrement, Period samplePeriod, RampMode rampMode)
Configure the scaled output block into Ramp control mode.
Definition SerialWombatAbstractScaledOutput.h:392
SerialWombatAbstractScaledOutput::PIDGetLastProportionalEffort
int32_t PIDGetLastProportionalEffort()
Definition SerialWombatAbstractScaledOutput.h:609
SerialWombatAbstractScaledOutput::writeScalingTargetValue
int16_t writeScalingTargetValue(uint16_t target)
The target input value for PID control.
Definition SerialWombatAbstractScaledOutput.h:229
SerialWombatAbstractScaledOutput::pin
virtual uint8_t pin()=0
Facilitates inheritance.
SerialWombatAbstractScaledOutput::write1stOrderFiltering
int16_t write1stOrderFiltering(Period sampleRate, uint16_t filterConstant)
Definition SerialWombatAbstractScaledOutput.h:294
SerialWombatAbstractScaledOutput::readLastOutputValue
uint16_t readLastOutputValue()
Request Last Output Value.
Definition SerialWombatAbstractScaledOutput.h:527
SerialWombatAbstractScaledOutput::PIDGetLastEffort
int32_t PIDGetLastEffort()
Definition SerialWombatAbstractScaledOutput.h:643
SerialWombatAbstractScaledOutput::writeInputScaling
int16_t writeInputScaling(uint16_t inputMin, uint16_t inputMax)
Scale incoming values to a range of 0 to 65535.
Definition SerialWombatAbstractScaledOutput.h:159
SerialWombatAbstractScaledOutput::PIDGetLastDerivativeEffort
int32_t PIDGetLastDerivativeEffort()
Definition SerialWombatAbstractScaledOutput.h:626
SerialWombatAbstractScaledOutput::RampMode
RampMode
Definition SerialWombatAbstractScaledOutput.h:86
SerialWombatAbstractScaledOutput::RAMP_MODE_DECREMENT
@ RAMP_MODE_DECREMENT
Definition SerialWombatAbstractScaledOutput.h:89
SerialWombatAbstractScaledOutput::RAMP_MODE_BOTH
@ RAMP_MODE_BOTH
Definition SerialWombatAbstractScaledOutput.h:87
SerialWombatAbstractScaledOutput::RAMP_MODE_INCREMENT
@ RAMP_MODE_INCREMENT
Definition SerialWombatAbstractScaledOutput.h:88
SerialWombatAbstractScaledOutput::PIDGetLastIntegratorEffort
int32_t PIDGetLastIntegratorEffort()
Definition SerialWombatAbstractScaledOutput.h:592
SerialWombatAbstractScaledOutput::writeScalingTargetValueResetIntegrator
int16_t writeScalingTargetValueResetIntegrator(uint16_t target)
Definition SerialWombatAbstractScaledOutput.h:547
SerialWombatAbstractScaledOutput::writePID
int16_t writePID(uint16_t kp, uint16_t ki, uint16_t kd, uint16_t target, Period samplePeriod, uint8_t targetPin=255, bool biDirectional=false)
Configure the scaled output block into PID control mode.
Definition SerialWombatAbstractScaledOutput.h:462
SerialWombatAbstractScaledOutput::writeScalingInvertedInput
int16_t writeScalingInvertedInput(bool inverted)
if enabled subtract the input value from 65535 before doing any other processing.
Definition SerialWombatAbstractScaledOutput.h:205
SerialWombatAbstractScaledOutput::PIDGetLastIntegrator
int32_t PIDGetLastIntegrator()
Definition SerialWombatAbstractScaledOutput.h:575
SerialWombatAbstractScaledOutput::Period
Period
Definition SerialWombatAbstractScaledOutput.h:72
SerialWombatAbstractScaledOutput::PERIOD_2mS
@ PERIOD_2mS
Definition SerialWombatAbstractScaledOutput.h:74
SerialWombatAbstractScaledOutput::PERIOD_256mS
@ PERIOD_256mS
Definition SerialWombatAbstractScaledOutput.h:81
SerialWombatAbstractScaledOutput::PERIOD_128mS
@ PERIOD_128mS
Definition SerialWombatAbstractScaledOutput.h:80
SerialWombatAbstractScaledOutput::PERIOD_64mS
@ PERIOD_64mS
Definition SerialWombatAbstractScaledOutput.h:79
SerialWombatAbstractScaledOutput::PERIOD_32mS
@ PERIOD_32mS
Definition SerialWombatAbstractScaledOutput.h:78
SerialWombatAbstractScaledOutput::PERIOD_8mS
@ PERIOD_8mS
Definition SerialWombatAbstractScaledOutput.h:76
SerialWombatAbstractScaledOutput::PERIOD_4mS
@ PERIOD_4mS
Definition SerialWombatAbstractScaledOutput.h:75
SerialWombatAbstractScaledOutput::PERIOD_512mS
@ PERIOD_512mS
Definition SerialWombatAbstractScaledOutput.h:82
SerialWombatAbstractScaledOutput::PERIOD_16mS
@ PERIOD_16mS
Definition SerialWombatAbstractScaledOutput.h:77
SerialWombatAbstractScaledOutput::PERIOD_1mS
@ PERIOD_1mS
Definition SerialWombatAbstractScaledOutput.h:73
SerialWombatAbstractScaledOutput::PERIOD_1024mS
@ PERIOD_1024mS
Definition SerialWombatAbstractScaledOutput.h:83
SerialWombatAbstractScaledOutput::PIDGetLastError
int32_t PIDGetLastError()
Definition SerialWombatAbstractScaledOutput.h:557
SerialWombatAbstractScaledOutput::swPinModeNumber
virtual uint8_t swPinModeNumber()=0
Facilitates inheritance.
SerialWombatChip
Class for a Serial Wombat chip. Each Serial Wombat chip on a project should have its own instance.
Definition SerialWombat.h:297