Serial Wombat Arduino Library

Loading...
Searching...
No Matches
SerialWombat.h
Go to the documentation of this file.
1#ifndef SERIAL_WOMBAT_H__
2#define SERIAL_WOMBAT_H__
3
4/*
5 Copyright 2020-2026 Broadwell Consulting Inc.
6
7"Serial Wombat" is a registered trademark of Broadwell Consulting Inc. in
8 the United States. See SerialWombat.com for usage guidance.
9
10 Permission is hereby granted, free of charge, to any person obtaining a
11 * copy of this software and associated documentation files (the "Software"),
12 * to deal in the Software without restriction, including without limitation
13 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 * and/or sell copies of the Software, and to permit persons to whom the
15 * Software is furnished to do so, subject to the following conditions:
16
17 The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26 * OTHER DEALINGS IN THE SOFTWARE.
27*/
28
29#include <stdint.h>
30#include "Stream.h"
31//#include "Serial.h" // Using "" rather than <> for compatibility with Visual C++ simulation project
32#include "Wire.h"// Using "" rather than <> for compatibility with Visual C++ simulation project
33#include "Arduino.h"
34#ifndef INPUT
35#define INPUT 0x0
36#endif
37
38
41
42
43#include "SerialWombatErrors.h"
44
46#define SW_LE16(_a) (uint8_t)((_a) & 0xFF), (uint8_t)((_a) >>8)
47
49#define SW_LE32(_a) (uint8_t)((_a) & 0xFF), (uint8_t)((_a) >>8) , (uint8_t)((_a) >>16), (uint8_t)((_a) >>24)
50
51#define ARRAY_UINT32(_array,_index) ((((uint32_t) _array[_index +3])<<24) + (((uint32_t) _array[_index +2])<<16) + (((uint32_t) _array[_index +1])<<8) + _array[_index])
52#define SW18AB_LATEST_FIRMWARE 223
53#define SW08B_LATEST_FIRMWARE 223
54#define SW4B_LATEST_FIRMWARE 203
55
56 typedef enum
57{
58 SW_LOW = 0,
59 SW_HIGH = 1,
60 SW_INPUT = 2,
61}SerialWombatPinState_t;
62
63
65 enum class SerialWombatDataSource{
66
67 SW_DATA_SOURCE_PIN_0 = 0,
68 SW_DATA_SOURCE_PIN_1 = 1,
69 SW_DATA_SOURCE_PIN_2 = 2,
70 SW_DATA_SOURCE_PIN_3 = 3,
71 SW_DATA_SOURCE_PIN_4 = 4,
72 SW_DATA_SOURCE_PIN_5 = 5,
73 SW_DATA_SOURCE_PIN_6 = 6,
74 SW_DATA_SOURCE_PIN_7 = 7,
75 SW_DATA_SOURCE_PIN_8 = 8,
76 SW_DATA_SOURCE_PIN_9 = 9,
77 SW_DATA_SOURCE_PIN_10 = 10,
78 SW_DATA_SOURCE_PIN_11 = 11,
79 SW_DATA_SOURCE_PIN_12 = 12,
80 SW_DATA_SOURCE_PIN_13 = 13,
81 SW_DATA_SOURCE_PIN_14 = 14,
82 SW_DATA_SOURCE_PIN_15 = 15,
83 SW_DATA_SOURCE_PIN_16 = 16,
84 SW_DATA_SOURCE_PIN_17 = 17,
85 SW_DATA_SOURCE_PIN_18 = 18,
86 SW_DATA_SOURCE_PIN_19 = 19,
87// SW_DATA_SOURCE_PIN_20 = 20,
88// SW_DATA_SOURCE_PIN_21 = 21,
89// SW_DATA_SOURCE_PIN_22 = 22,
90// SW_DATA_SOURCE_PIN_23 = 23,
91// SW_DATA_SOURCE_PIN_24 = 24,
92// SW_DATA_SOURCE_PIN_25 = 25,
93// SW_DATA_SOURCE_PIN_26 = 26,
94// SW_DATA_SOURCE_PIN_27 = 27,
95// SW_DATA_SOURCE_PIN_28 = 28,
96// SW_DATA_SOURCE_PIN_29 = 29,
97// SW_DATA_SOURCE_PIN_30 = 30,
98// SW_DATA_SOURCE_PIN_31 = 31,
99// SW_DATA_SOURCE_PIN_32 = 32,
100// SW_DATA_SOURCE_PIN_33 = 33,
101// SW_DATA_SOURCE_PIN_34 = 34,
102// SW_DATA_SOURCE_PIN_35 = 35,
103// SW_DATA_SOURCE_PIN_36 = 36,
104// SW_DATA_SOURCE_PIN_37 = 37,
105// SW_DATA_SOURCE_PIN_38 = 38,
106// SW_DATA_SOURCE_PIN_39 = 39,
107// SW_DATA_SOURCE_PIN_40 = 40,
108// SW_DATA_SOURCE_PIN_41 = 41,
109// SW_DATA_SOURCE_PIN_42 = 42,
110// SW_DATA_SOURCE_PIN_43 = 43,
111// SW_DATA_SOURCE_PIN_44 = 44,
112// SW_DATA_SOURCE_PIN_45 = 45,
113// SW_DATA_SOURCE_PIN_46 = 46,
114// SW_DATA_SOURCE_PIN_47 = 47,
115// SW_DATA_SOURCE_PIN_48 = 48,
116// SW_DATA_SOURCE_PIN_49 = 49,
117// SW_DATA_SOURCE_PIN_50 = 50,
118// SW_DATA_SOURCE_PIN_51 = 51,
119// SW_DATA_SOURCE_PIN_52 = 52,
120// SW_DATA_SOURCE_PIN_53 = 53,
121// SW_DATA_SOURCE_PIN_54 = 54,
122// SW_DATA_SOURCE_PIN_55 = 55,
123// SW_DATA_SOURCE_PIN_56 = 56,
124// SW_DATA_SOURCE_PIN_57 = 57,
125// SW_DATA_SOURCE_PIN_58 = 58,
126// SW_DATA_SOURCE_PIN_59 = 59,
127// SW_DATA_SOURCE_PIN_60 = 60,
128// SW_DATA_SOURCE_PIN_61 = 61,
129// SW_DATA_SOURCE_PIN_62 = 62,
130// SW_DATA_SOURCE_PIN_63 = 63,
131 SW_DATA_SOURCE_INCREMENTING_NUMBER = 65,
132 SW_DATA_SOURCE_1024mvCounts = 66 ,
133 SW_DATA_SOURCE_FRAMES_RUN_LSW = 67,
134 SW_DATA_SOURCE_FRAMES_RUN_MSW = 68,
135 SW_DATA_SOURCE_OVERRUN_FRAMES = 69,
136 SW_DATA_SOURCE_TEMPERATURE = 70,
137 SW_DATA_SOURCE_PACKETS_RECEIVED = 71,
138 SW_DATA_SOURCE_ERRORS = 72,
139 SW_DATA_SOURCE_DROPPED_FRAMES = 73,
140 SW_DATA_SOURCE_SYSTEM_UTILIZATION = 74,
141 SW_DATA_SOURCE_VCC_mVOLTS = 75,
142 SW_DATA_SOURCE_VBG_COUNTS_VS_VREF = 76,
143
144 SW_DATA_SOURCE_RESET_REGISTER = 77,
145 SW_DATA_SOURCE_LFSR = 78,
146 SW_DATA_COM_ADDRESS_LOW = 79,
147 SW_DATA_COM_ADDRESS_HIGH = 80,
148 SW_DATA_SOURCE_0x55 = 85,
149 SW_DATA_SOURCE_PIN_0_MV = 100,
150 SW_DATA_SOURCE_PIN_1_MV = 101,
151 SW_DATA_SOURCE_PIN_2_MV = 102,
152 SW_DATA_SOURCE_PIN_3_MV = 103,
153 SW_DATA_SOURCE_PIN_4_MV = 104,
154 //NOT ANALOG SW_DATA_SOURCE_PIN_5_MV = 105,
155 //NOT ANALOG SW_DATA_SOURCE_PIN_6_MV = 106,
156 //NOT ANALOG SW_DATA_SOURCE_PIN_7_MV = 107,
157 //NOT ANALOG SW_DATA_SOURCE_PIN_8_MV = 108,
158 //NOT ANALOG SW_DATA_SOURCE_PIN_9_MV = 109,
159 //NOT ANALOG SW_DATA_SOURCE_PIN_10_MV = 110,
160 //NOT ANALOG SW_DATA_SOURCE_PIN_11_MV = 111,
161 //NOT ANALOG SW_DATA_SOURCE_PIN_12_MV = 112,
162 //NOT ANALOG SW_DATA_SOURCE_PIN_13_MV = 113,
163 //NOT ANALOG SW_DATA_SOURCE_PIN_14_MV = 114,
164 //NOT ANALOG SW_DATA_SOURCE_PIN_15_MV = 115,
165 SW_DATA_SOURCE_PIN_16_MV = 116,
166 SW_DATA_SOURCE_PIN_17_MV = 117,
167 SW_DATA_SOURCE_PIN_18_MV = 118,
168 SW_DATA_SOURCE_PIN_19_MV = 119,
169 SW_DATA_SOURCE_2HZ_SQUARE = 164,
170 SW_DATA_SOURCE_2HZ_SAW = 165,
171// SW_DATA_SOURCE_2HZ_SIN = 166,
172 SW_DATA_SOURCE_1HZ_SQUARE = 167,
173 SW_DATA_SOURCE_1HZ_SAW = 168,
174// SW_DATA_SOURCE_1HZ_SIN = 169,
175 SW_DATA_SOURCE_2SEC_SQUARE = 170,
176 SW_DATA_SOURCE_2SEC_SAW = 171,
177// SW_DATA_SOURCE_2SEC_SIN = 172,
178 SW_DATA_SOURCE_8SEC_SQUARE = 173,
179 SW_DATA_SOURCE_8SEC_SAW = 174,
180// SW_DATA_SOURCE_8SEC_SIN = 175,
181 SW_DATA_SOURCE_65SEC_SQUARE = 176,
182 SW_DATA_SOURCE_65SEC_SAW = 177,
183// SW_DATA_SOURCE_65SEC_SIN = 178,
184 SW_DATA_SOURCE_NONE = 255,
185};
186
187#define ERROR_HOST_INCORRECT_NUMBER_BYTES_WRITTEN 0x10000
188#define ERROR_HOST_DATA_TOO_LONG 0x10001
189#define ERROR_HOST_NACK_ADDRESS 0x10002
190#define ERROR_HOST_NACK_DATA 0x10003
191#define ERROR_HOST_OTHER_I2C_ERROR 0x10004
192
193#define WOMBAT_MAXIMUM_PINS 20
194
195 enum class SerialWombatCommands
196{
197 CMD_ECHO ='!',
198 CMD_READ_BUFFER_ASCII = 'G',
199 CMD_ASCII_SET_PIN ='P',
200 CMD_RESET = 'R',
201 CMD_SET_BUFFER_ASCII = 'S',
202 CMD_RESYNC = 'U',
203 CMD_VERSION = 'V',
204 CMD_SUPPLYVOLTAGE = 'v',
205 COMMAND_BINARY_READ_PIN_BUFFFER = 0x81,
206 COMMAND_BINARY_SET_PIN_BUFFFER = 0x82,
207 COMMAND_BINARY_READ_USER_BUFFER = 0x83,
208 COMMAND_BINARY_WRITE_USER_BUFFER = 0x84,
209 COMMAND_BINARY_WRITE_USER_BUFFER_CONTINUE = 0x85,
210 COMMAND_BINARY_PIN_POLL_THRESHOLD = 0x8F,
211 COMMAND_BINARY_QUEUE_INITIALIZE = 0x90,
212 COMMAND_BINARY_QUEUE_ADD_BYTES = 0x91,
213 COMMAND_BINARY_QUEUE_ADD_7BYTES = 0x92,
214 COMMAND_BINARY_QUEUE_READ_BYTES = 0x93,
215 COMMAND_BINARY_QUEUE_INFORMATION = 0x94,
216 COMMAND_BINARY_QUEUE_CLONE = 0x95,
217 COMMAND_BINARY_CONFIG_DATALOGGER = 0x96,
218 COMMAND_BINARY_CONFIGURE = 0x9F,
219 COMMAND_BINARY_READ_RAM = 0xA0,
220 COMMAND_BINARY_READ_FLASH = 0xA1,
221 COMMAND_BINARY_READ_EEPROM = 0xA2,
222 COMMAND_BINARY_WRITE_RAM = 0xA3,
223 COMMAND_BINARY_WRITE_FLASH = 0xA4,
224 COMMAND_CALIBRATE_ANALOG = 0xA5,
225 COMMAND_ENABLE_2ND_UART = 0xA6,
226 COMMAND_READ_LAST_ERROR_PACKET = 0xA7,
227 COMMAND_UART0_TX_7BYTES = 0xB0,
228 COMMAND_UART0_RX_7BYTES = 0xB1,
229 COMMAND_UART1_TX_7BYTES = 0xB2,
230 COMMAND_UART1_RX_7BYTES = 0xB3,
231 COMMAND_BINARY_TEST_SEQUENCE = 0xB4,
232 COMMAND_BINARY_RW_PIN_MEMORY = 0xB5,
233 COMMAND_CAPTURE_STARTUP_SEQUENCE = 0xB6,
234 COMMAND_ADJUST_FREQUENCY = 0xB7,
235 COMMAND_SET_PIN_HW = 0xB8,
236 COMMAND_BINARY_SET_ADDRESS = 0xB9,
237 CONFIGURE_PIN_MODE0 = 200,
238 CONFIGURE_PIN_MODE1 = 201,
239 CONFIGURE_PIN_MODE2 = 202,
240 CONFIGURE_PIN_MODE3 = 203,
241 CONFIGURE_PIN_MODE4 = 204,
242 CONFIGURE_PIN_MODE5 = 205,
243 CONFIGURE_PIN_MODE6 = 206,
244 CONFIGURE_PIN_MODE7 = 207,
245 CONFIGURE_PIN_MODE8 = 208,
246 CONFIGURE_PIN_MODE9 = 209,
247 CONFIGURE_PIN_MODE10 = 210,
248 CONFIGURE_PIN_OUTPUTSCALE = 210,
249 CONFIGURE_PIN_MODE_DISABLE = 219,
250 CONFIGURE_PIN_INPUTPROCESS = 211,
251 CONFIGURE_CHANNEL_MODE_CHECK_MODE_SUPPORTED = 218,
252 CONFIGURE_PIN_MODE_HW_0 = 220,
253 CONFIGURE_CHANNEL_MODE_HW_1 = 221,
254 CONFIGURE_CHANNEL_MODE_HW_2 = 222,
255 CONFIGURE_CHANNEL_MODE_HW_3 = 223,
256
257};
258
259
260 typedef enum {
261 PIN_MODE_DIGITALIO = 0,
262 PIN_MODE_CONTROLLED = 1,
263 PIN_MODE_ANALOGINPUT = 2,
264 PIN_MODE_SERVO = 3,
265 PIN_MODE_THROUGHPUT_CONSUMER = 4,
266 PIN_MODE_QUADRATUREENCODER = 5,
267 PIN_MODE_HBRIDGE = 6,
268 PIN_MODE_WATCHDOG = 7,
269 PIN_MODE_PROTECTED_OUTPUT = 8,
270 PIN_MODE_DEBOUNCE = 10,
271 PIN_MODE_TM1637 = 11,
272 PIN_MODE_WS2812 = 12,
273 PIN_MODE_SW_UART = 13,
274 PIN_MODE_INPUT_PROCESSOR = 14,
275 PIN_MODE_MATRIX_KEYPAD = 15,
276 PIN_MODE_PWM = 16,
277 PIN_MODE_UART_RX_TX = 17,
278 PIN_MODE_PULSETIMER = 18,
279 PIN_MODE_FRAME_TIMER = 21,
280 PIN_MODE_SW18AB_CAPTOUCH = 22,
281 PIN_MODE_UART1_RX_TX = 23,
282 PIN_MODE_RESISTANCEINPUT = 24,
283 PIN_MODE_PULSE_ON_CHANGE = 25,
284 PIN_MODE_HS_SERVO = 26,
285 PIN_MODE_ULTRASONIC_DISTANCE = 27,
286 PIN_MODE_LIQUIDCRYSTAL = 28,
287 PIN_MODE_HS_CLOCK = 29,
288 PIN_MODE_HS_COUNTER = 30,
289 PIN_MODE_VGA = 31,
290 PIN_MODE_PS2KEYBOARD = 32,
291 PIN_MODE_I2C_CONTROLLER = 33,
292 PIN_MODE_QUEUED_PULSE_OUTPUT = 34,
293 PIN_MODE_FREQUENCY_OUTPUT = 36,
294 PIN_MODE_IRRX = 37,
295 PIN_MODE_IRTX = 38,
296 PIN_MODE_BLINK = 40,
297 PIN_MODE_SPI = 41,
298 PIN_MODE_UNKNOWN = 255,
299}SerialWombatPinMode_t;
300
301 class SerialWombatChip;
302
303 typedef void (*SerialWombatErrorHandler_t) (uint16_t errorNumber, SerialWombatChip* sw);
304
314 class SerialWombatChip
315{
316 private:
317
318 char version[8] = { 0 };
319 HardwareSerial * Serial = NULL;
320 TwoWire* i2cInterface = NULL;
321 uint8_t _pinmode[WOMBAT_MAXIMUM_PINS]={}; // Includes Pullup
322 bool _pullDown[WOMBAT_MAXIMUM_PINS]={};
323 bool _openDrain[WOMBAT_MAXIMUM_PINS]={};
324 bool _highLow[WOMBAT_MAXIMUM_PINS] = {};
325 bool _asleep = false;
326 SerialWombatErrorHandler_t errorHandler = NULL;
327 bool _currentlyCommunicating = false;
328 public:
335 uint16_t _supplyVoltagemV = 0;
336
338 uint8_t model[4] = { 0 };
339
341 uint8_t fwVersion[4] = { 0 };
342
348 uint8_t uniqueIdentifier[16];
349
354 uint8_t uniqueIdentifierLength = 0;
355
360 uint16_t deviceIdentifier;
361
366 uint16_t deviceRevision;
368 uint16_t errorCount = 0;
369
371 bool inBoot = false;
372
374 int16_t lastErrorCode = 0;
375
384
385 void configureDigitalPin(uint8_t pin, uint8_t highLow)
386 {
387 uint8_t tx[8] = { 200,pin,0,0,0,0,0,0x55 };
388 uint8_t rx[8];
389 switch (_pinmode[pin])
390 {
391 case INPUT: // Arduino input
392 {
393 tx[3] = 2; //Input
394 }
395 break;
396 case OUTPUT:
397 {
398 if (highLow == LOW)
399 {
400 tx[3] = 0;
401 }
402 else if (highLow == HIGH)
403 {
404 tx[3] = 1;
405 }
406 else
407 {
408 return;
409 }
410 }
411 break;
412 case INPUT_PULLUP:
413 {
414 tx[3] = 2; //Input
415 tx[4] = 1; //Pullup on
416 }
417 break;
418 default:
419 {
420 return;
421 }
422 }
423 tx[6] = _openDrain[pin];
424 tx[5] = _pullDown[pin];
425 sendPacket(tx, rx, true);
426 }
427
431 uint32_t sendReadyTime = 0;
432
436 int16_t initialize()
437 {
438 lastErrorCode = 0;
439 readVersion();
440 readSupplyVoltage_mV();
441 readUniqueIdentifier();
442 readDeviceIdentifier();
443 return(lastErrorCode);
444 }
445
452 void readUniqueIdentifier()
453 {
454 uniqueIdentifierLength = 0;
455 if (version[0] == 'S' && version[1] == '0' && version[2] == '4')
456 { //16F15214
457 for (uint32_t address = 0x8100; address <= 0x8108; ++address)
458 {
459 uint32_t data = readFlashAddress(address);
460 uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)data;
461 ++uniqueIdentifierLength;
462 /* Always zero... leave out
463 uniqueIdentifier[uniqueIdentifierLength] = (uint8_t)(data>>8);
464 ++uniqueIdentifierLength;
465 */
466 }
467 }
468 else if (isSW18())
469 {
470 for (uint32_t address = 0x801600; address <= 0x801608; address += 2)
471 {
472 uint32_t data = readFlashAddress(address);
473 uniqueIdentifier[uniqueIdentifierLength] = data;
474 ++uniqueIdentifierLength;
475 uniqueIdentifier[uniqueIdentifierLength] = data >> 8;
476 ++uniqueIdentifierLength;
477 uniqueIdentifier[uniqueIdentifierLength] = data >> 16;
478 ++uniqueIdentifierLength;
479 }
480 }
481 else if (isSW08())
482 {
483 //TODO
484 }
485
486 }
487
494
495 void readDeviceIdentifier()
496 {
497 if (version[0] == 'S' && version[1] == '0' && version[2] == '4')
498 { //16F15214
499
500 uint32_t data = readFlashAddress(0x8006);
501 deviceIdentifier = (uint16_t)data;
502 data = readFlashAddress(0x8005);
503 deviceRevision = (uint16_t)data;
504 }
505 else if (isSW18())
506 {
507 uint32_t data = readFlashAddress(0xFF0000);
508 deviceIdentifier = (uint16_t)data;
509 data = readFlashAddress(0xFF0002);
510 deviceRevision = (uint16_t)data & 0xF;
511 }
512 }
513
519 uint16_t returnErrorCode(uint8_t* rx)
520 {
521 uint16_t result = rx[1] - '0';
522 result *= 10;
523 result += rx[2] - '0';
524 result *= 10;
525 result += rx[3] - '0';
526 result *= 10;
527 result += rx[4] - '0';
528 result *= 10;
529 result += rx[5] - '0';
530 return(result);
531 }
532
533
534
535 public:
536 SerialWombatChip();
550 int16_t begin(HardwareSerial& serial, bool reset = true)
551 {
552 Serial = &serial;
553 Serial->begin(115200);
554 Serial->setTimeout(2);
555 Serial->write((uint8_t*)"UUUUUUUU", 8);
556 delay(5);
557 while (Serial->read() >= 0);
558 if (reset)
559 {
560 hardwareReset();
561 sendReadyTime = millis() + 1000;
562 return(1);
563 }
564 else
565 {
566 return initialize();
567 }
568
569
570 }
571
581 int16_t begin(uint8_t i2cAddress);
582
596 int16_t begin(TwoWire& wire, uint8_t i2cAddress, bool reset = true)
597 {
598 i2cInterface = &wire;
599 address = i2cAddress;
600
601 Wire.beginTransmission(i2cAddress);
602 int error = Wire.endTransmission();
603
604
605 if (error != 0)
606 {
607 return(-1);
608 }
609
610 if (reset)
611 {
612 hardwareReset();
613 sendReadyTime = millis() + 250;
614 return(1);
615 }
616 else
617 {
618 sendReadyTime = 0;
619 return initialize();
620
621 }
622 }
623
624 ~SerialWombatChip();
625
636 int sendPacket( uint8_t tx[], uint8_t rx[]);
637
647 int sendPacket(uint8_t tx[]);
648
662 int sendPacket(uint8_t tx[], uint8_t rx[], bool retryIfEchoDoesntMatch, uint8_t beginningBytesToMatch = 8, uint8_t endBytesToMatch = 0);
673 int sendPacket(uint8_t tx[], bool retryIfEchoDoesntMatch);
674
683
684 int sendPacketNoResponse(uint8_t tx[]);
685
694 char* readVersion(void)
695 {
696 uint8_t tx[] = { 'V',0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
697 uint8_t rx[8];
698 sendPacket(tx, rx);
699 memcpy(version, &rx[1], 7);
700 version[7] = '\0';
701 memcpy(model, &rx[1], 3);
702 model[3] = '\0';
703 fwVersion[0] = rx[5];
704 fwVersion[1] = rx[6];
705 fwVersion[2] = rx[7];
706 return (version);
707 }
708
715 uint32_t readVersion_uint32(void)
716 {
717 readVersion();
718 return (
719 ((uint32_t)fwVersion[0] - '0') * 100 +
720 ((uint32_t)fwVersion[1] - '0') * 10 +
721 (uint32_t)fwVersion[2] - '0');
722 }
723
728 bool isLatestFirmware(void)
729 {
730 uint32_t v = readVersion_uint32();
731 if (isSW18())
732 {
733 return (v == SW18AB_LATEST_FIRMWARE);
734 }
735 else if (isSW08())
736 {
737 return (v == SW08B_LATEST_FIRMWARE);
738 }
739 else
740 {
741 return (v == SW4B_LATEST_FIRMWARE);
742
743 }
744 }
745
755 uint16_t readPublicData(uint8_t pin)
756 {
757 uint8_t tx[] = { 0x81,pin,255,255,0x55,0x55,0x55,0x55 };
758 uint8_t rx[8];
759 sendPacket(tx, rx);
760 return(rx[2] + (uint16_t)rx[3] * 256);
761 }
762
772 uint16_t readPublicData(SerialWombatDataSource dataSource)
773 {
774 return (readPublicData((uint8_t)dataSource));
775 }
776
782 uint16_t writePublicData(uint8_t pin, uint16_t value)
783 {
784 uint8_t tx[] = { 0x82,pin,(uint8_t)(value & 0xFF),(uint8_t)(value >> 8) ,255,0x55,0x55,0x55 };
785 uint8_t rx[8];
786 sendPacket(tx, rx);
787 return (rx[2] + rx[3] * 256);
788 }
789
790 uint32_t comparePublicDataToThreshold(uint16_t threshold = 0)
791 {
792 uint8_t tx[] = { (uint8_t) SerialWombatCommands::COMMAND_BINARY_PIN_POLL_THRESHOLD,SW_LE16(threshold) ,0x55, 0x55,0x55,0x55,0x55 };
793 uint8_t rx[8];
794 sendPacket(tx, rx);
795 return (ARRAY_UINT32(rx,1));
796 }
797
807
808 uint16_t readSupplyVoltage_mV(void)
809 {
810 if (isSW18() || isSW08())
811 {
812 _supplyVoltagemV = readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_VCC_mVOLTS);
813 }
814 else
815 {
816 int32_t counts = readPublicData(66); // Get FVR counts (1.024 v)
817 if (counts > 0)
818 {
819 uint32_t mv = 1024 * 65536 / counts;
820 _supplyVoltagemV = (uint16_t)mv;
821 }
822 else
823 {
824 _supplyVoltagemV = 0;
825 }
826 }
827 return(_supplyVoltagemV);
828 }
829
830
841 int16_t readTemperature_100thsDegC(void)
842 {
843 if (isSW18())
844 {
845 int32_t result = readPublicData(70);
846 if (result >= 32768)
847 {
848 result = result - 65536;
849 }
850 return ((int16_t)result);
851 }
852 else
853 {
854 return 2500;
855 }
856 }
857
864 void hardwareReset()
865 {
866 uint8_t tx[9] = "ReSeT!#*";
867 sendPacketNoResponse(tx);
868 }
869
878 void pinMode(uint8_t pin, uint8_t mode, bool pullDown = false, bool openDrain = false)
879 {
880 if (pin >= WOMBAT_MAXIMUM_PINS)
881 {
882 return;
883 }
884 _pullDown[pin] = pullDown;
885 _openDrain[pin] = openDrain;
886 _pinmode[pin] = mode;
887 configureDigitalPin(pin, mode);
888 }
889
897 void digitalWrite(uint8_t pin, uint8_t val)
898 {
899 configureDigitalPin(pin, val);
900 }
901
907 int digitalRead(uint8_t pin)
908 {
909 if (readPublicData(pin) > 0)
910 {
911 return (HIGH);
912 }
913 else
914 {
915 return (LOW);
916 }
917 }
918
928 int analogRead(uint8_t pin)
929 {
930 uint8_t tx[] = { 200,pin,PIN_MODE_ANALOGINPUT,0,0,0,0,0 };
931 uint8_t rx[8];
932 sendPacket(tx, rx);
933 return (readPublicData(pin) >> 6); // Scale from 16 bit value to 10 bit value.
934 }
935
947 void analogWrite(uint8_t pin, int val)
948 {
949 uint8_t dutyCycleLow = 0;
950 if (val == 255)
951 {
952 dutyCycleLow = 255;
953 }
954 uint8_t tx[] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE0,pin,PIN_MODE_PWM,pin,dutyCycleLow,(uint8_t) val,false,0x55 };
955 uint8_t rx[8];
956 sendPacket(tx, rx);
957 }
958
969 bool queryVersion()
970 {
971 uint8_t tx[8] = { 'V',0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
972 uint8_t rx[8];
973 sendPacket(tx, rx);
974 if (rx[0] == 'V' && (rx[1] == 'S' || rx[1] == 'B'))
975 {
976 model[0] = rx[1];
977 model[1] = rx[2];
978 model[2] = rx[3];
979 model[3] = 0;
980 fwVersion[0] = rx[5];
981 fwVersion[1] = rx[6];
982 fwVersion[2] = rx[7];
983 fwVersion[3] = 0;
984
985 inBoot = (rx[1] == 'B');
986 return (true);
987 }
988 return (false);
989 }
990
997 uint32_t readFramesExecuted()
998 {
999 uint8_t tx[8] = { 0x81,67,68,0x55,0x55,0x55,0x55,0x55 };
1000 uint8_t rx[8];
1001 sendPacket(tx, rx);
1002 uint32_t returnval = rx[2] + (((uint32_t)rx[3]) << 8) + (((uint32_t)rx[4]) << 16) + (((uint32_t)rx[5]) << 24);
1003 return (returnval);
1004 }
1005
1013
1014 uint16_t readOverflowFrames()
1015 {
1016 return readPublicData(69);
1017 }
1018
1028 void jumpToBoot()
1029 {
1030 uint8_t tx[] = "BoOtLoAd";
1031 sendPacket(tx);
1032 }
1033
1054 uint8_t readRamAddress(uint16_t address)
1055 {
1056 uint8_t tx[8] = { 0xA0,SW_LE16(address),0x55,0x55,0x55,0x55,0x55 };
1057 uint8_t rx[8];
1058 sendPacket(tx, rx);
1059 return(rx[3]);
1060 }
1061
1081
1082 int16_t writeRamAddress(uint16_t address, uint8_t value)
1083 {
1084 uint8_t tx[8] = { 0xA3,SW_LE16(address),0,0,value,0x55,0x55};
1085 return sendPacket(tx);
1086 }
1087
1102
1103 uint32_t readFlashAddress(uint32_t address)
1104 {
1105 uint8_t tx[8] = { 0xA1,SW_LE32(address),0x55,0x55,0x55 };
1106 uint8_t rx[8];
1107 sendPacket(tx, rx);
1108 return(((uint32_t)rx[4]) + (((uint32_t)rx[5]) <<8) + (((uint32_t)rx[6]) <<16) + (((uint32_t)rx[7]) <<24));
1109 }
1110
1122 int16_t readUserBuffer(uint16_t index, uint8_t* buffer, uint16_t count)
1123 {
1124 uint16_t bytesRead = 0;
1125 while (bytesRead < count)
1126 {
1127 byte tx[] = {(byte)SerialWombatCommands::COMMAND_BINARY_READ_USER_BUFFER, (byte)(index & 0xFF), (byte)(index >> 8), 0x55, 0x55, 0x55, 0x55, 0x55};
1128 byte rx[8];
1129 int16_t result = sendPacket(tx, rx);
1130 if (result >= 0)
1131 {
1132 for (int i = 1; i < 8; ++i)
1133 {
1134 buffer[bytesRead] = rx[i];
1135 ++bytesRead;
1136 ++index;
1137 if (bytesRead >= count)
1138 {
1139 break;
1140 }
1141 }
1142 }
1143 else
1144 {
1145 return (bytesRead);
1146 }
1147 }
1148 return (bytesRead);
1149 }
1150
1162 void sleep4B()
1163 {
1164 uint8_t tx[8] = { 'S','l','E','e','P','!','#','*'};
1165 sendPacket(tx);
1166 _asleep = true;
1167 }
1168
1187 void sleep8B(uint16_t delay)
1188 {
1189 uint8_t tx[8] = { 'S','l','E','e','P','!',SW_LE16(delay)};
1190
1191 sendPacket(tx);
1192 _asleep = true;
1193 }
1194
1196 void wake()
1197 {
1198 uint8_t tx[8] = { '!','!','!','!','!','!','!','!' };
1199 sendPacket(tx);
1200 }
1201
1203 bool isSW04()
1204 {
1205 return ( model[1] == '0' && model[2] == '4');
1206 }
1207
1208
1210 bool isSW18()
1211 {
1212 return ( model[1] == '1' && model[2] == '8');
1213 }
1214
1215 bool isSW08()
1216 {
1217 return ( model[1] == '0' && model[2] == '8');
1218 }
1219
1225 bool isPinModeSupported(int pinMode)
1226 {
1227 return isPinModeSupported((SerialWombatPinMode_t)pinMode);
1228 }
1229
1234 bool isPinModeSupported(SerialWombatPinMode_t pinMode)
1235 {
1236 if (isSW04())
1237 {
1238 switch (pinMode)
1239 {
1240 case PIN_MODE_DIGITALIO:
1241 case PIN_MODE_ANALOGINPUT:
1242 case PIN_MODE_CONTROLLED:
1243 case PIN_MODE_SERVO:
1244 case PIN_MODE_PWM:
1245 case PIN_MODE_DEBOUNCE:
1246 case PIN_MODE_QUADRATUREENCODER:
1247 case PIN_MODE_WATCHDOG:
1248 case PIN_MODE_PULSETIMER:
1249 case PIN_MODE_PROTECTED_OUTPUT:
1250 return true;
1251
1252 default:
1253 return false;
1254 }
1255 }
1256
1257 uint8_t tx[8] = {(uint8_t)SerialWombatCommands::CONFIGURE_CHANNEL_MODE_CHECK_MODE_SUPPORTED, 1, (uint8_t)pinMode, 0x55, 0x55, 0x55, 0x55, 0x55};
1258 int16_t returnVal = sendPacket(tx);
1259 returnVal *= -1;
1260 return (returnVal != SW_ERROR_UNKNOWN_PIN_MODE);
1261 }
1262
1263
1264
1265
1267 int16_t eraseFlashPage(uint32_t address)
1268 {
1269 uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_BINARY_WRITE_FLASH,
1270 0, //Erase Page
1271 SW_LE32(address),
1272 0x55,0x55 };
1273 return sendPacket(tx);
1274 }
1275
1276
1278 int16_t writeFlashRow(uint32_t address)
1279 {
1280 uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_BINARY_WRITE_FLASH,
1281 1, // Write entire row
1282 SW_LE32(address),0x55,0x55 };
1283 return sendPacket(tx);
1284 }
1285
1286
1287
1288
1298 int16_t setThroughputPin(uint8_t pin)
1299 {
1300 uint8_t tx[8] = { (uint8_t)SerialWombatCommands::CONFIGURE_PIN_MODE0,pin,PIN_MODE_FRAME_TIMER,0x55,0x55,0x55,0x55,0x55 };
1301 return sendPacket(tx);
1302 }
1303
1317 int16_t setThroughputPin(uint32_t address)
1318 {
1319 uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_BINARY_SET_ADDRESS,SW_LE32(address),0x55,0x55,0x55 };
1320 return sendPacket(tx);
1321 }
1322
1330 int writeUserBuffer(uint16_t index, uint8_t* buffer, uint16_t count)
1331 {
1332 uint16_t bytesSent = 0;
1333 if (count == 0)
1334 {
1335 return 0;
1336 }
1337
1338 { // Send first packet of up to 4 bytes
1339 uint8_t bytesToSend = 4;
1340 if (count < 4)
1341 {
1342 bytesToSend = (uint8_t)count;
1343 count = 0;
1344 }
1345 else
1346 {
1347 count -= 4;
1348 }
1349
1350 uint8_t tx[8] = { 0x84,SW_LE16(index), bytesToSend,0x55,0x55,0x55,0x55 };
1351 uint8_t rx[8];
1352
1353 uint8_t i;
1354 for (i = 0; i < bytesToSend; ++i)
1355 {
1356 tx[4 + i] = buffer[i];
1357 }
1358 int result = sendPacket(tx, rx);
1359 if (rx[0] == 'E')
1360 {
1361 return (result);
1362 }
1363 bytesSent = bytesToSend;
1364 }
1365 while (count >= 7) // Continue sending
1366 {
1367
1368 count -= 7;
1369 uint8_t tx[8] = { 0x85,0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
1370 uint8_t rx[8];
1371 uint8_t i;
1372 for (i = 0; i < 7; ++i)
1373 {
1374 tx[1 + i] = buffer[bytesSent + i];
1375 }
1376 int result = sendPacket(tx, rx);
1377 if (rx[0] == 'E')
1378 {
1379 return (result);
1380 }
1381 bytesSent += 7;
1382 }
1383 while (count > 0)
1384 {
1385
1386 { // Send first packet of up to 4 bytes
1387 uint8_t bytesToSend = 4;
1388 if (count < 4)
1389 {
1390 bytesToSend = (uint8_t)count;
1391 count = 0;
1392 }
1393 else
1394 {
1395 count -= 4;
1396 }
1397
1398 uint8_t tx[8] = { 0x84,SW_LE16(index + bytesSent), bytesToSend,0x55,0x55,0x55,0x55 };
1399 uint8_t rx[8];
1400
1401 uint8_t i;
1402 for (i = 0; i < bytesToSend; ++i)
1403 {
1404 tx[4 + i] = buffer[i + bytesSent];
1405 }
1406 int result = sendPacket(tx, rx);
1407 if (rx[0] == 'E')
1408 {
1409 return (result);
1410 }
1411 bytesSent += bytesToSend;
1412 }
1413 }
1414 return(bytesSent);
1415
1416
1417 }
1418
1425 int writeUserBuffer(uint16_t index, char* s)
1426 {
1427 return writeUserBuffer(index, (uint8_t*)s, (uint16_t)strlen(s));
1428 }
1429
1436 int writeUserBuffer(uint16_t index, const char s[])
1437 {
1438 return writeUserBuffer(index, (uint8_t*)s, (uint16_t)strlen(s));
1439 }
1440
1441
1442
1454 int16_t writeFrameTimerPin(uint8_t pin)
1455{
1456 uint8_t tx[] = { 0xC8 ,pin,(uint8_t)PIN_MODE_FRAME_TIMER,0x55,0x55,0x55,0x55,0x55 };
1457 return sendPacket(tx);
1458}
1459
1460
1468 static uint8_t find(bool keepTrying = false)
1469 {
1470 do
1471 {
1472 for (int i2cAddress = 0x60; i2cAddress <= 0x6F; ++i2cAddress)
1473 {
1474 Wire.beginTransmission(i2cAddress);
1475 int error = Wire.endTransmission();
1476
1477
1478 if (error == 0)
1479 {
1480 uint8_t tx[8] = { 'V',0x55,0x55,0x55,0x55,0x55,0x55,0x55 };
1481 uint8_t rx[8];
1482 Wire.beginTransmission(i2cAddress);
1483 Wire.write(tx, 8);
1484 Wire.endTransmission();
1485 Wire.requestFrom((uint8_t)i2cAddress, (uint8_t)8);
1486
1487 int count = 0;
1488 while (Wire.available() && count < 8)
1489 {
1490 rx[count] = Wire.read();
1491 ++count;
1492 }
1493 if (count == 8)
1494 {
1495 if (rx[0] == 'V' && (rx[1] == 'S' || rx[1]=='B'))
1496 {
1497 return(i2cAddress); // Found one.
1498 }
1499 }
1500 }
1501 }
1502 delay(0);
1503 }while (keepTrying);
1504 return(0); // Didn't find one.
1505 }
1506
1507
1514 int16_t readLastErrorCommand(uint8_t* cmd)
1515{
1516
1517 uint8_t tx[8] = { (uint8_t)SerialWombatCommands::COMMAND_READ_LAST_ERROR_PACKET, 0,0x55,0x55,0x55,0x55,0x55,0x55 };
1518 uint8_t rx[8];
1519 if (sendPacket(tx, rx) >= 0)
1520 {
1521 for (int i = 1; i < 8; ++i)
1522 {
1523 cmd[i - 1] = rx[i];
1524 }
1525 }
1526 else
1527 {
1528 return (lastErrorCode);
1529 }
1530 tx[1] = 7;
1531 if (sendPacket(tx, rx) >= 0)
1532 {
1533 cmd[7] = rx[1];
1534 }
1535 return(lastErrorCode);
1536}
1537
1542 void registerErrorHandler(SerialWombatErrorHandler_t handler)
1543 {
1544 errorHandler = handler;
1545 }
1546
1548 uint8_t address = 0;
1549
1551 uint8_t communicationErrorRetries = 5;
1552
1559 int16_t echo(uint8_t data[], uint8_t count = 7)
1560 {
1561 uint8_t tx[] = "!UUUUUUU";
1562 for (int i = 0; i < 7 && i < count; ++i)
1563 {
1564 tx[i + 1] = (uint8_t)data[i];
1565 }
1566 return sendPacket(tx);
1567 }
1568
1574
1575 int16_t echo(char* data)
1576 {
1577 int length = strlen(data);
1578 uint8_t tx[] = "!UUUUUUU";
1579 for (int i = 0; i < 7 && i < length; ++i)
1580 {
1581 tx[i + 1] = (uint8_t)data[i];
1582 }
1583 return sendPacket(tx);
1584 }
1585
1590 uint32_t readBirthday()
1591 {
1592 if (isSW18())
1593 {
1594 uint32_t birthday = (readFlashAddress(0x2A00C) >> 8) & 0xFF;
1595 birthday *= 100;
1596 birthday += (readFlashAddress(0x2A00C)) & 0xFF;
1597 birthday *= 100;
1598 birthday += readFlashAddress(0x2A00E) & 0xFF;
1599 birthday *= 100;
1600 birthday += readFlashAddress(0x2A010) & 0xFF;
1601 return (birthday);
1602 }
1603 return 0;
1604 }
1605
1610 int16_t readBrand(char* data)
1611 {
1612 uint8_t length = 0;
1613 if (isSW18())
1614 {
1615 for (int i = 0; i < 32; ++i)
1616 {
1617 uint32_t val = readFlashAddress(0x2A020 + i * 2) ;
1618 if ((val & 0xFF) != 0xFF)
1619 {
1620 data[i ] = (char)(val & 0xFF);
1621 ++length;
1622 }
1623 else
1624 {
1625 data[length] = 0;
1626 return (length);
1627 }
1628 }
1629 data[length] = 0;
1630 return (length);
1631 }
1632
1633 data[0] = 0;
1634 return 0 ;
1635 }
1636
1637};
1638
1652 class SerialWombat18ABOscillatorTuner
1653{
1654 private:
1655 SerialWombatChip& _sw;
1656 uint32_t lastMillis = 0;
1657 uint32_t lastFrames = 0;
1658 public:
1663 SerialWombat18ABOscillatorTuner(SerialWombatChip& serialWombatChip) : _sw(serialWombatChip) { }
1664
1668 void update() {
1669 uint32_t m = millis();
1670 if (lastMillis == 0)
1671 {
1672 lastMillis = m;
1673 uint32_t frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
1674 uint16_t frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
1675 if (frames != _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW))
1676 {
1677 frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
1678 frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
1679 }
1680 frames <<= 16;
1681 frames += frameslsb;
1682 lastFrames = frames;
1683
1684 }
1685 else if ((m - lastMillis) < 10000)
1686 {
1687 //Do nothing
1688 }
1689 else if (m < lastMillis)
1690 {
1691 //Has it been 47 days already?
1692 lastMillis = 0;
1693 }
1694 else
1695 {
1696 uint32_t diff = m - lastMillis;
1697
1698 uint32_t frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
1699 uint16_t frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
1700
1701 if (frames != _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW))
1702 {
1703 frameslsb = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW);
1704 frames = _sw.readPublicData(SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW);
1705 }
1706 frames <<= 16;
1707 frames += frameslsb;
1708 uint32_t framesDif = frames - lastFrames;
1709
1710 if (diff > framesDif )
1711 {
1712 // Running slow
1713 uint8_t tx[] = { (uint8_t)SerialWombatCommands::COMMAND_ADJUST_FREQUENCY,
1714 SW_LE16(1),//Counts to increment
1715 SW_LE16(0), // Counts to decrement
1716 0x55,0x55,0x55};
1717 _sw.sendPacket(tx);
1718 }
1719 else if (diff < framesDif)
1720 {
1721 // Running mfast
1722 uint8_t tx[] = { (uint8_t)SerialWombatCommands::COMMAND_ADJUST_FREQUENCY,
1723 SW_LE16(0),//Counts to increment
1724 SW_LE16(1), // Counts to decrement
1725 0x55,0x55,0x55 };
1726 _sw.sendPacket(tx);
1727
1728 }
1729
1730 lastMillis = m;
1731 lastFrames = frames;
1732
1733 }
1734
1735 }
1736
1737};
1738
1739/*
1740 End of cross platform code synchronization. Random string to help the compare tool sync lines:
1741 asdkj38vjn1nasdnvuwlamafdjiivnowalskive
1742*/
1743
1745 class SerialWombat : public SerialWombatChip {};
1746
1747
1748
1749
1750
1758 void SerialWombatSerialErrorHandlerBrief(uint16_t error, SerialWombatChip* sw);
1759
1767 void SerialWombatSerialErrorHandlerVerbose(uint16_t error, SerialWombatChip* sw);
1768
1769#include "SerialWombatPin.h"
1770#include "SerialWombatQueue.h"
1771#include "SerialWombat18ABDataLogger.h"
1772#include "SerialWombatAbstractButton.h"
1773#include "SerialWombatAbstractProcessedInput.h"
1774#include "SerialWombatAbstractScaledOutput.h"
1775#include "SerialWombatBlink.h"
1776#include "SerialWombat18CapTouch.h"
1777#include "SerialWombat18ABVGA.h"
1778#include "SerialWombatAnalogInput.h"
1779#include "SerialWombatDebouncedInput.h"
1780#include "SerialWombatDigitalInput.h"
1781#include "SerialWombatDigitalOutput.h"
1782#include "SerialWombatFrequencyOutput.h"
1783#include "SerialWombatHBridge.h"
1784#include "SerialWombatHSClock.h"
1785#include "SerialWombatHSCounter.h"
1786#include "SerialWombatIRRx.h"
1787#include "SerialWombatIRTx.h"
1788#include "SerialWombatLiquidCrystal.h"
1789#include "SerialWombatMatrixKeypad.h"
1790#include "SerialWombatProcessedInputPin.h"
1791#include "SerialWombatProtectedOutput.h"
1792#include "SerialWombatPS2Keyboard.h"
1793#include "SerialWombatPulseOnChange.h"
1794#include "SerialWombatPulseTimer.h"
1795#include "SerialWombatPWM.h"
1796#include "SerialWombatQuadEnc.h"
1797#include "SerialWombatQueuedPulseOutput.h"
1798#include "SerialWombatResistanceInput.h"
1799#include "SerialWombatServo.h"
1800#include "SerialWombatSPI.h"
1801#include "SerialWombatTM1637.h"
1802#include "SerialWombatUART.h"
1803#include "SerialWombatUltrasonicDistanceSensor.h"
1804#include "SerialWombatWatchdog.h"
1805#include "SerialWombatWS2812.h"
1806#include "SerialWombatThroughputConsumer.h"
1807#include "PCB0030_Bridge.h"
1808#include "PCB0031_Grip.h"
1809#include "PCB0041_Remcon.h"
1810#include "PCB0042_LSD.h"
1811#include "PCB0046_HSD.h"
1812#include "PCB0048_Mux.h"
1813
1814#endif
PCB0030_Bridge.h
PCB0031_Grip.h
PCB0041_Remcon.h
PCB0042_LSD.h
PCB0046_HSD.h
PCB0048_Mux.h
SerialWombat18ABDataLogger.h
SerialWombat18ABVGA.h
SerialWombat18CapTouch.h
INPUT
#define INPUT
Definition SerialWombat.h:35
SW18AB_LATEST_FIRMWARE
#define SW18AB_LATEST_FIRMWARE
Definition SerialWombat.h:52
WOMBAT_MAXIMUM_PINS
#define WOMBAT_MAXIMUM_PINS
Definition SerialWombat.h:193
SerialWombatSerialErrorHandlerBrief
void SerialWombatSerialErrorHandlerBrief(uint16_t error, SerialWombatChip *sw)
a sample error handler that can be registered with registerErrorHandler to report protocol errors on ...
Definition SerialWombat.cpp:340
SW_LE16
#define SW_LE16(_a)
Convert a uint16_t to two bytes in little endian format for array initialization.
Definition SerialWombat.h:46
SerialWombatCommands
SerialWombatCommands
Definition SerialWombat.h:196
SerialWombatCommands::COMMAND_CAPTURE_STARTUP_SEQUENCE
@ COMMAND_CAPTURE_STARTUP_SEQUENCE
(0xB6)
Definition SerialWombat.h:233
SerialWombatCommands::COMMAND_BINARY_WRITE_FLASH
@ COMMAND_BINARY_WRITE_FLASH
(0xA4)
Definition SerialWombat.h:223
SerialWombatCommands::COMMAND_BINARY_READ_USER_BUFFER
@ COMMAND_BINARY_READ_USER_BUFFER
(0x83)
Definition SerialWombat.h:207
SerialWombatCommands::COMMAND_BINARY_QUEUE_INFORMATION
@ COMMAND_BINARY_QUEUE_INFORMATION
(0x94)
Definition SerialWombat.h:215
SerialWombatCommands::CONFIGURE_PIN_MODE0
@ CONFIGURE_PIN_MODE0
(200)
Definition SerialWombat.h:237
SerialWombatCommands::COMMAND_BINARY_QUEUE_INITIALIZE
@ COMMAND_BINARY_QUEUE_INITIALIZE
(0x90)
Definition SerialWombat.h:211
SerialWombatCommands::COMMAND_BINARY_SET_PIN_BUFFFER
@ COMMAND_BINARY_SET_PIN_BUFFFER
(0x82)
Definition SerialWombat.h:206
SerialWombatCommands::COMMAND_ENABLE_2ND_UART
@ COMMAND_ENABLE_2ND_UART
(0xA6)
Definition SerialWombat.h:225
SerialWombatCommands::COMMAND_UART1_RX_7BYTES
@ COMMAND_UART1_RX_7BYTES
(0xB3)
Definition SerialWombat.h:230
SerialWombatCommands::COMMAND_ADJUST_FREQUENCY
@ COMMAND_ADJUST_FREQUENCY
(0xB7)
Definition SerialWombat.h:234
SerialWombatCommands::COMMAND_BINARY_WRITE_USER_BUFFER
@ COMMAND_BINARY_WRITE_USER_BUFFER
(0x84)
Definition SerialWombat.h:208
SerialWombatCommands::CONFIGURE_PIN_MODE3
@ CONFIGURE_PIN_MODE3
(203)
Definition SerialWombat.h:240
SerialWombatCommands::CMD_RESET
@ CMD_RESET
('R')
Definition SerialWombat.h:200
SerialWombatCommands::CONFIGURE_PIN_MODE4
@ CONFIGURE_PIN_MODE4
(204)
Definition SerialWombat.h:241
SerialWombatCommands::CONFIGURE_PIN_MODE_DISABLE
@ CONFIGURE_PIN_MODE_DISABLE
(219)
Definition SerialWombat.h:249
SerialWombatCommands::CMD_READ_BUFFER_ASCII
@ CMD_READ_BUFFER_ASCII
('G')
Definition SerialWombat.h:198
SerialWombatCommands::COMMAND_BINARY_QUEUE_CLONE
@ COMMAND_BINARY_QUEUE_CLONE
(0x95)
Definition SerialWombat.h:216
SerialWombatCommands::COMMAND_BINARY_QUEUE_ADD_BYTES
@ COMMAND_BINARY_QUEUE_ADD_BYTES
(0x91)
Definition SerialWombat.h:212
SerialWombatCommands::CMD_RESYNC
@ CMD_RESYNC
('U')
Definition SerialWombat.h:202
SerialWombatCommands::COMMAND_BINARY_READ_EEPROM
@ COMMAND_BINARY_READ_EEPROM
(0xA2)
Definition SerialWombat.h:221
SerialWombatCommands::CMD_SUPPLYVOLTAGE
@ CMD_SUPPLYVOLTAGE
('v')
Definition SerialWombat.h:204
SerialWombatCommands::CONFIGURE_PIN_MODE5
@ CONFIGURE_PIN_MODE5
(205)
Definition SerialWombat.h:242
SerialWombatCommands::COMMAND_BINARY_QUEUE_ADD_7BYTES
@ COMMAND_BINARY_QUEUE_ADD_7BYTES
(0x92)
Definition SerialWombat.h:213
SerialWombatCommands::CONFIGURE_PIN_MODE8
@ CONFIGURE_PIN_MODE8
(208)
Definition SerialWombat.h:245
SerialWombatCommands::CONFIGURE_PIN_MODE_HW_0
@ CONFIGURE_PIN_MODE_HW_0
(220)
Definition SerialWombat.h:252
SerialWombatCommands::CONFIGURE_PIN_MODE6
@ CONFIGURE_PIN_MODE6
(206)
Definition SerialWombat.h:243
SerialWombatCommands::CMD_SET_BUFFER_ASCII
@ CMD_SET_BUFFER_ASCII
('S')
Definition SerialWombat.h:201
SerialWombatCommands::CONFIGURE_PIN_MODE2
@ CONFIGURE_PIN_MODE2
(202)
Definition SerialWombat.h:239
SerialWombatCommands::COMMAND_UART0_TX_7BYTES
@ COMMAND_UART0_TX_7BYTES
(0xB0)
Definition SerialWombat.h:227
SerialWombatCommands::COMMAND_BINARY_QUEUE_READ_BYTES
@ COMMAND_BINARY_QUEUE_READ_BYTES
(0x93)
Definition SerialWombat.h:214
SerialWombatCommands::COMMAND_BINARY_SET_ADDRESS
@ COMMAND_BINARY_SET_ADDRESS
(0xB9)
Definition SerialWombat.h:236
SerialWombatCommands::CONFIGURE_PIN_INPUTPROCESS
@ CONFIGURE_PIN_INPUTPROCESS
(211)
Definition SerialWombat.h:250
SerialWombatCommands::CONFIGURE_CHANNEL_MODE_CHECK_MODE_SUPPORTED
@ CONFIGURE_CHANNEL_MODE_CHECK_MODE_SUPPORTED
(218)
Definition SerialWombat.h:251
SerialWombatCommands::CMD_VERSION
@ CMD_VERSION
('V')
Definition SerialWombat.h:203
SerialWombatCommands::CMD_ASCII_SET_PIN
@ CMD_ASCII_SET_PIN
('P')
Definition SerialWombat.h:199
SerialWombatCommands::CONFIGURE_PIN_MODE10
@ CONFIGURE_PIN_MODE10
(210)
Definition SerialWombat.h:247
SerialWombatCommands::COMMAND_BINARY_WRITE_USER_BUFFER_CONTINUE
@ COMMAND_BINARY_WRITE_USER_BUFFER_CONTINUE
(0x85)
Definition SerialWombat.h:209
SerialWombatCommands::COMMAND_BINARY_CONFIG_DATALOGGER
@ COMMAND_BINARY_CONFIG_DATALOGGER
(0x96)
Definition SerialWombat.h:217
SerialWombatCommands::CONFIGURE_PIN_MODE9
@ CONFIGURE_PIN_MODE9
(209)
Definition SerialWombat.h:246
SerialWombatCommands::COMMAND_UART1_TX_7BYTES
@ COMMAND_UART1_TX_7BYTES
(0xB2)
Definition SerialWombat.h:229
SerialWombatCommands::COMMAND_UART0_RX_7BYTES
@ COMMAND_UART0_RX_7BYTES
(0xB1)
Definition SerialWombat.h:228
SerialWombatCommands::COMMAND_BINARY_RW_PIN_MEMORY
@ COMMAND_BINARY_RW_PIN_MEMORY
(0xB5)
Definition SerialWombat.h:232
SerialWombatCommands::COMMAND_READ_LAST_ERROR_PACKET
@ COMMAND_READ_LAST_ERROR_PACKET
(0xA7)
Definition SerialWombat.h:226
SerialWombatCommands::COMMAND_BINARY_WRITE_RAM
@ COMMAND_BINARY_WRITE_RAM
(0xA3)
Definition SerialWombat.h:222
SerialWombatCommands::COMMAND_BINARY_READ_RAM
@ COMMAND_BINARY_READ_RAM
(0xA0)
Definition SerialWombat.h:219
SerialWombatCommands::COMMAND_BINARY_TEST_SEQUENCE
@ COMMAND_BINARY_TEST_SEQUENCE
(0xB4)
Definition SerialWombat.h:231
SerialWombatCommands::CONFIGURE_CHANNEL_MODE_HW_2
@ CONFIGURE_CHANNEL_MODE_HW_2
(222)
Definition SerialWombat.h:254
SerialWombatCommands::COMMAND_BINARY_READ_PIN_BUFFFER
@ COMMAND_BINARY_READ_PIN_BUFFFER
(0x81)
Definition SerialWombat.h:205
SerialWombatCommands::CONFIGURE_CHANNEL_MODE_HW_1
@ CONFIGURE_CHANNEL_MODE_HW_1
(221)
Definition SerialWombat.h:253
SerialWombatCommands::COMMAND_BINARY_READ_FLASH
@ COMMAND_BINARY_READ_FLASH
(0xA1)
Definition SerialWombat.h:220
SerialWombatCommands::CONFIGURE_CHANNEL_MODE_HW_3
@ CONFIGURE_CHANNEL_MODE_HW_3
(223)
Definition SerialWombat.h:255
SerialWombatCommands::COMMAND_SET_PIN_HW
@ COMMAND_SET_PIN_HW
(0xB8)
Definition SerialWombat.h:235
SerialWombatCommands::COMMAND_CALIBRATE_ANALOG
@ COMMAND_CALIBRATE_ANALOG
(0xA5)
Definition SerialWombat.h:224
SerialWombatCommands::CMD_ECHO
@ CMD_ECHO
('!')
Definition SerialWombat.h:197
SerialWombatCommands::CONFIGURE_PIN_MODE7
@ CONFIGURE_PIN_MODE7
(207)
Definition SerialWombat.h:244
SerialWombatCommands::CONFIGURE_PIN_MODE1
@ CONFIGURE_PIN_MODE1
(201)
Definition SerialWombat.h:238
SerialWombatCommands::COMMAND_BINARY_PIN_POLL_THRESHOLD
@ COMMAND_BINARY_PIN_POLL_THRESHOLD
(0x8F)
Definition SerialWombat.h:210
SerialWombatCommands::CONFIGURE_PIN_OUTPUTSCALE
@ CONFIGURE_PIN_OUTPUTSCALE
(210)
Definition SerialWombat.h:248
SerialWombatCommands::COMMAND_BINARY_CONFIGURE
@ COMMAND_BINARY_CONFIGURE
(0x9F)
Definition SerialWombat.h:218
SW08B_LATEST_FIRMWARE
#define SW08B_LATEST_FIRMWARE
Definition SerialWombat.h:53
SW_LE32
#define SW_LE32(_a)
Convert a uint32_t to four bytes in little endian format for array initialization.
Definition SerialWombat.h:49
SW4B_LATEST_FIRMWARE
#define SW4B_LATEST_FIRMWARE
Definition SerialWombat.h:54
SerialWombatPinMode_t
SerialWombatPinMode_t
Definition SerialWombat.h:260
PIN_MODE_PULSE_ON_CHANGE
@ PIN_MODE_PULSE_ON_CHANGE
(25)
Definition SerialWombat.h:283
PIN_MODE_FRAME_TIMER
@ PIN_MODE_FRAME_TIMER
(21)
Definition SerialWombat.h:279
PIN_MODE_UNKNOWN
@ PIN_MODE_UNKNOWN
(0xFF)
Definition SerialWombat.h:298
PIN_MODE_TM1637
@ PIN_MODE_TM1637
(11)
Definition SerialWombat.h:271
PIN_MODE_PULSETIMER
@ PIN_MODE_PULSETIMER
(18)
Definition SerialWombat.h:278
PIN_MODE_PS2KEYBOARD
@ PIN_MODE_PS2KEYBOARD
(32)
Definition SerialWombat.h:290
PIN_MODE_FREQUENCY_OUTPUT
@ PIN_MODE_FREQUENCY_OUTPUT
(36)
Definition SerialWombat.h:293
PIN_MODE_HS_SERVO
@ PIN_MODE_HS_SERVO
(26)
Definition SerialWombat.h:284
PIN_MODE_CONTROLLED
@ PIN_MODE_CONTROLLED
(1)
Definition SerialWombat.h:262
PIN_MODE_QUEUED_PULSE_OUTPUT
@ PIN_MODE_QUEUED_PULSE_OUTPUT
(34)
Definition SerialWombat.h:292
PIN_MODE_HBRIDGE
@ PIN_MODE_HBRIDGE
(6)
Definition SerialWombat.h:267
PIN_MODE_SW18AB_CAPTOUCH
@ PIN_MODE_SW18AB_CAPTOUCH
(22)
Definition SerialWombat.h:280
PIN_MODE_LIQUIDCRYSTAL
@ PIN_MODE_LIQUIDCRYSTAL
(28)
Definition SerialWombat.h:286
PIN_MODE_IRRX
@ PIN_MODE_IRRX
(37)
Definition SerialWombat.h:294
PIN_MODE_QUADRATUREENCODER
@ PIN_MODE_QUADRATUREENCODER
(5)
Definition SerialWombat.h:266
PIN_MODE_UART_RX_TX
@ PIN_MODE_UART_RX_TX
(17)
Definition SerialWombat.h:277
PIN_MODE_WATCHDOG
@ PIN_MODE_WATCHDOG
(7)
Definition SerialWombat.h:268
PIN_MODE_HS_COUNTER
@ PIN_MODE_HS_COUNTER
< (29)
Definition SerialWombat.h:288
PIN_MODE_PROTECTED_OUTPUT
@ PIN_MODE_PROTECTED_OUTPUT
(8)
Definition SerialWombat.h:269
PIN_MODE_ANALOGINPUT
@ PIN_MODE_ANALOGINPUT
(2)
Definition SerialWombat.h:263
PIN_MODE_UART1_RX_TX
@ PIN_MODE_UART1_RX_TX
(23)
Definition SerialWombat.h:281
PIN_MODE_I2C_CONTROLLER
@ PIN_MODE_I2C_CONTROLLER
(33)
Definition SerialWombat.h:291
PIN_MODE_PWM
@ PIN_MODE_PWM
(16)
Definition SerialWombat.h:276
PIN_MODE_RESISTANCEINPUT
@ PIN_MODE_RESISTANCEINPUT
(24)
Definition SerialWombat.h:282
PIN_MODE_DEBOUNCE
@ PIN_MODE_DEBOUNCE
(10)
Definition SerialWombat.h:270
PIN_MODE_BLINK
@ PIN_MODE_BLINK
(40)
Definition SerialWombat.h:296
PIN_MODE_INPUT_PROCESSOR
@ PIN_MODE_INPUT_PROCESSOR
(14)
Definition SerialWombat.h:274
PIN_MODE_ULTRASONIC_DISTANCE
@ PIN_MODE_ULTRASONIC_DISTANCE
(27)
Definition SerialWombat.h:285
PIN_MODE_HS_CLOCK
@ PIN_MODE_HS_CLOCK
Definition SerialWombat.h:287
PIN_MODE_SERVO
@ PIN_MODE_SERVO
(3)
Definition SerialWombat.h:264
PIN_MODE_DIGITALIO
@ PIN_MODE_DIGITALIO
(0)
Definition SerialWombat.h:261
PIN_MODE_THROUGHPUT_CONSUMER
@ PIN_MODE_THROUGHPUT_CONSUMER
(4)
Definition SerialWombat.h:265
PIN_MODE_MATRIX_KEYPAD
@ PIN_MODE_MATRIX_KEYPAD
(15)
Definition SerialWombat.h:275
PIN_MODE_SW_UART
@ PIN_MODE_SW_UART
(13)
Definition SerialWombat.h:273
PIN_MODE_SPI
@ PIN_MODE_SPI
(41)
Definition SerialWombat.h:297
PIN_MODE_IRTX
@ PIN_MODE_IRTX
(38)
Definition SerialWombat.h:295
PIN_MODE_VGA
@ PIN_MODE_VGA
(31)
Definition SerialWombat.h:289
PIN_MODE_WS2812
@ PIN_MODE_WS2812
(12)
Definition SerialWombat.h:272
SerialWombatSerialErrorHandlerVerbose
void SerialWombatSerialErrorHandlerVerbose(uint16_t error, SerialWombatChip *sw)
a sample error handler that can be registered with registerErrorHandler to report protocol errors on ...
SerialWombatDataSource
SerialWombatDataSource
A list of Serial Wombat public data sources.
Definition SerialWombat.h:65
SerialWombatDataSource::SW_DATA_SOURCE_PIN_10
@ SW_DATA_SOURCE_PIN_10
(10) 16 bit public data provided by Pin 10
Definition SerialWombat.h:77
SerialWombatDataSource::SW_DATA_SOURCE_VBG_COUNTS_VS_VREF
@ SW_DATA_SOURCE_VBG_COUNTS_VS_VREF
(76) A/D conversion of VBG against VRef . Used for mfg calibration
Definition SerialWombat.h:142
SerialWombatDataSource::SW_DATA_SOURCE_PIN_5
@ SW_DATA_SOURCE_PIN_5
(5) 16 bit public data provided by Pin 5
Definition SerialWombat.h:72
SerialWombatDataSource::SW_DATA_SOURCE_PIN_14
@ SW_DATA_SOURCE_PIN_14
(14) 16 bit public data provided by Pin 14
Definition SerialWombat.h:81
SerialWombatDataSource::SW_DATA_SOURCE_PIN_13
@ SW_DATA_SOURCE_PIN_13
(13) 16 bit public data provided by Pin 13
Definition SerialWombat.h:80
SerialWombatDataSource::SW_DATA_SOURCE_1024mvCounts
@ SW_DATA_SOURCE_1024mvCounts
(66) The number of ADC counts that result from a 1.024V reading
Definition SerialWombat.h:132
SerialWombatDataSource::SW_DATA_SOURCE_TEMPERATURE
@ SW_DATA_SOURCE_TEMPERATURE
(70)The internal core temperature expressed in 100ths deg C
Definition SerialWombat.h:136
SerialWombatDataSource::SW_DATA_SOURCE_PIN_1
@ SW_DATA_SOURCE_PIN_1
(1) 16 bit public data provided by Pin 1
Definition SerialWombat.h:68
SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_LSW
@ SW_DATA_SOURCE_FRAMES_RUN_LSW
(67) The number of frames run since reset, least significant 16 bits
Definition SerialWombat.h:133
SerialWombatDataSource::SW_DATA_SOURCE_VCC_mVOLTS
@ SW_DATA_SOURCE_VCC_mVOLTS
(75) The system source voltage in mV
Definition SerialWombat.h:141
SerialWombatDataSource::SW_DATA_SOURCE_PIN_11
@ SW_DATA_SOURCE_PIN_11
(11) 16 bit public data provided by Pin 11
Definition SerialWombat.h:78
SerialWombatDataSource::SW_DATA_SOURCE_8SEC_SAW
@ SW_DATA_SOURCE_8SEC_SAW
(174)Sawtooth wave that goes from 0 to 65535 to 0 every 8192 frames
Definition SerialWombat.h:179
SerialWombatDataSource::SW_DATA_SOURCE_PIN_4_MV
@ SW_DATA_SOURCE_PIN_4_MV
(104) Pin 4 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:153
SerialWombatDataSource::SW_DATA_SOURCE_PIN_6
@ SW_DATA_SOURCE_PIN_6
(6) 16 bit public data provided by Pin 6
Definition SerialWombat.h:73
SerialWombatDataSource::SW_DATA_SOURCE_PIN_15
@ SW_DATA_SOURCE_PIN_15
(15) 16 bit public data provided by Pin 15
Definition SerialWombat.h:82
SerialWombatDataSource::SW_DATA_SOURCE_LFSR
@ SW_DATA_SOURCE_LFSR
A Linear FeedBack Shift register (32,7,5,3,2,1) based pseudo-random number generator.
Definition SerialWombat.h:145
SerialWombatDataSource::SW_DATA_SOURCE_OVERRUN_FRAMES
@ SW_DATA_SOURCE_OVERRUN_FRAMES
(69) The number of frames that ran more than 1mS
Definition SerialWombat.h:135
SerialWombatDataSource::SW_DATA_SOURCE_PIN_9
@ SW_DATA_SOURCE_PIN_9
(9) 16 bit public data provided by Pin 9
Definition SerialWombat.h:76
SerialWombatDataSource::SW_DATA_SOURCE_PIN_12
@ SW_DATA_SOURCE_PIN_12
(12) 16 bit public data provided by Pin 12
Definition SerialWombat.h:79
SerialWombatDataSource::SW_DATA_SOURCE_PIN_3_MV
@ SW_DATA_SOURCE_PIN_3_MV
(103) Pin 3 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:152
SerialWombatDataSource::SW_DATA_SOURCE_PIN_8
@ SW_DATA_SOURCE_PIN_8
(8) 16 bit public data provided by Pin 8
Definition SerialWombat.h:75
SerialWombatDataSource::SW_DATA_SOURCE_PIN_18
@ SW_DATA_SOURCE_PIN_18
(18) 16 bit public data provided by Pin 18
Definition SerialWombat.h:85
SerialWombatDataSource::SW_DATA_SOURCE_8SEC_SQUARE
@ SW_DATA_SOURCE_8SEC_SQUARE
(173)Square wave that alternates between 0 and 65535 every 4096 frames
Definition SerialWombat.h:178
SerialWombatDataSource::SW_DATA_SOURCE_0x55
@ SW_DATA_SOURCE_0x55
(85) 0x55 is a reserved value for resyncing. Returns 0x55 0x55
Definition SerialWombat.h:148
SerialWombatDataSource::SW_DATA_SOURCE_RESET_REGISTER
@ SW_DATA_SOURCE_RESET_REGISTER
Hardware dependent reset reason register contents.
Definition SerialWombat.h:144
SerialWombatDataSource::SW_DATA_SOURCE_2SEC_SQUARE
@ SW_DATA_SOURCE_2SEC_SQUARE
(170)Square wave that alternates between 0 and 65535 every 1024 frames
Definition SerialWombat.h:175
SerialWombatDataSource::SW_DATA_COM_ADDRESS_LOW
@ SW_DATA_COM_ADDRESS_LOW
The Communications Address of the Device (Lower 16 bits)
Definition SerialWombat.h:146
SerialWombatDataSource::SW_DATA_SOURCE_PIN_18_MV
@ SW_DATA_SOURCE_PIN_18_MV
(118) Pin 18 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:167
SerialWombatDataSource::SW_DATA_COM_ADDRESS_HIGH
@ SW_DATA_COM_ADDRESS_HIGH
The Communications Address of the Device (HIGHER 16 bits) Anticipated for CAN ID.
Definition SerialWombat.h:147
SerialWombatDataSource::SW_DATA_SOURCE_ERRORS
@ SW_DATA_SOURCE_ERRORS
(72)The number of incoming packets that have caused errors since reset (rolls over at 65535)
Definition SerialWombat.h:138
SerialWombatDataSource::SW_DATA_SOURCE_PIN_0_MV
@ SW_DATA_SOURCE_PIN_0_MV
(100) Pin 0 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:149
SerialWombatDataSource::SW_DATA_SOURCE_PIN_4
@ SW_DATA_SOURCE_PIN_4
(4) 16 bit public data provided by Pin 4
Definition SerialWombat.h:71
SerialWombatDataSource::SW_DATA_SOURCE_SYSTEM_UTILIZATION
@ SW_DATA_SOURCE_SYSTEM_UTILIZATION
(74) A number between 0 and 65535 that scales to the average length of pin processing frames between ...
Definition SerialWombat.h:140
SerialWombatDataSource::SW_DATA_SOURCE_PACKETS_RECEIVED
@ SW_DATA_SOURCE_PACKETS_RECEIVED
(71) The nubmer of incoming command packets that have been processed since reset (rolls over at 65535...
Definition SerialWombat.h:137
SerialWombatDataSource::SW_DATA_SOURCE_1HZ_SQUARE
@ SW_DATA_SOURCE_1HZ_SQUARE
(167) Square wave that alternates between 0 and 65535 every 512 frames
Definition SerialWombat.h:172
SerialWombatDataSource::SW_DATA_SOURCE_2SEC_SAW
@ SW_DATA_SOURCE_2SEC_SAW
(171)Sawtooth wave that goes from 0 to 65535 to 0 every 2048 frames
Definition SerialWombat.h:176
SerialWombatDataSource::SW_DATA_SOURCE_PIN_17_MV
@ SW_DATA_SOURCE_PIN_17_MV
(117) Pin 17 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:166
SerialWombatDataSource::SW_DATA_SOURCE_PIN_1_MV
@ SW_DATA_SOURCE_PIN_1_MV
(101) Pin 1 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:150
SerialWombatDataSource::SW_DATA_SOURCE_DROPPED_FRAMES
@ SW_DATA_SOURCE_DROPPED_FRAMES
(73) The number of times since reset that a frame ran so far behind that it crossed two subsequent 1m...
Definition SerialWombat.h:139
SerialWombatDataSource::SW_DATA_SOURCE_PIN_16_MV
@ SW_DATA_SOURCE_PIN_16_MV
(116) Pin 16 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:165
SerialWombatDataSource::SW_DATA_SOURCE_PIN_0
@ SW_DATA_SOURCE_PIN_0
(0) 16 bit public data provided by Pin 0
Definition SerialWombat.h:67
SerialWombatDataSource::SW_DATA_SOURCE_PIN_2
@ SW_DATA_SOURCE_PIN_2
(2) 16 bit public data provided by Pin 2
Definition SerialWombat.h:69
SerialWombatDataSource::SW_DATA_SOURCE_PIN_2_MV
@ SW_DATA_SOURCE_PIN_2_MV
(102) Pin 2 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:151
SerialWombatDataSource::SW_DATA_SOURCE_PIN_16
@ SW_DATA_SOURCE_PIN_16
(16) 16 bit public data provided by Pin 16
Definition SerialWombat.h:83
SerialWombatDataSource::SW_DATA_SOURCE_1HZ_SAW
@ SW_DATA_SOURCE_1HZ_SAW
(168) Sawtooth wave that goes from 0 to 65535 to 0 every 1024 frames
Definition SerialWombat.h:173
SerialWombatDataSource::SW_DATA_SOURCE_PIN_19_MV
@ SW_DATA_SOURCE_PIN_19_MV
(119) Pin 19 public output expressed in mV (for analog modes only)
Definition SerialWombat.h:168
SerialWombatDataSource::SW_DATA_SOURCE_PIN_7
@ SW_DATA_SOURCE_PIN_7
(7) 16 bit public data provided by Pin 7
Definition SerialWombat.h:74
SerialWombatDataSource::SW_DATA_SOURCE_FRAMES_RUN_MSW
@ SW_DATA_SOURCE_FRAMES_RUN_MSW
(68) The number of frames run since reset, most significant 16 bits
Definition SerialWombat.h:134
SerialWombatDataSource::SW_DATA_SOURCE_INCREMENTING_NUMBER
@ SW_DATA_SOURCE_INCREMENTING_NUMBER
(65) An number that increments each time it is accessed.
Definition SerialWombat.h:131
SerialWombatDataSource::SW_DATA_SOURCE_PIN_19
@ SW_DATA_SOURCE_PIN_19
(19) 16 bit public data provided by Pin 19
Definition SerialWombat.h:86
SerialWombatDataSource::SW_DATA_SOURCE_2HZ_SAW
@ SW_DATA_SOURCE_2HZ_SAW
(165) Sawtooth wave that goes from 0 to 65535 to 0 every 512 frames
Definition SerialWombat.h:170
SerialWombatDataSource::SW_DATA_SOURCE_PIN_17
@ SW_DATA_SOURCE_PIN_17
(17) 16 bit public data provided by Pin 17
Definition SerialWombat.h:84
SerialWombatDataSource::SW_DATA_SOURCE_PIN_3
@ SW_DATA_SOURCE_PIN_3
(3) 16 bit public data provided by Pin 3
Definition SerialWombat.h:70
SerialWombatDataSource::SW_DATA_SOURCE_65SEC_SAW
@ SW_DATA_SOURCE_65SEC_SAW
(177 )Sawtooth wave that goes from 0 to 65535 to 0 every 65536 frames
Definition SerialWombat.h:182
SerialWombatDataSource::SW_DATA_SOURCE_NONE
@ SW_DATA_SOURCE_NONE
(255 ) Used to mean "No Source Selected"
Definition SerialWombat.h:184
SerialWombatDataSource::SW_DATA_SOURCE_2HZ_SQUARE
@ SW_DATA_SOURCE_2HZ_SQUARE
(164) Square wave that alternates between 0 and 65535 every 256 frames
Definition SerialWombat.h:169
SerialWombatDataSource::SW_DATA_SOURCE_65SEC_SQUARE
@ SW_DATA_SOURCE_65SEC_SQUARE
(176) Square wave that alternates between 0 and 65535 every 32768 frames
Definition SerialWombat.h:181
ARRAY_UINT32
#define ARRAY_UINT32(_array, _index)
Definition SerialWombat.h:51
SerialWombatErrorHandler_t
void(* SerialWombatErrorHandler_t)(uint16_t errorNumber, SerialWombatChip *sw)
Definition SerialWombat.h:303
SerialWombatPinState_t
SerialWombatPinState_t
Definition SerialWombat.h:57
SW_INPUT
@ SW_INPUT
Definition SerialWombat.h:60
SW_HIGH
@ SW_HIGH
Definition SerialWombat.h:59
SW_LOW
@ SW_LOW
Definition SerialWombat.h:58
SerialWombatAbstractButton.h
SerialWombatAbstractProcessedInput.h
SerialWombatAbstractScaledOutput.h
SerialWombatAnalogInput.h
SerialWombatBlink.h
SerialWombatDebouncedInput.h
SerialWombatDigitalInput.h
SerialWombatDigitalOutput.h
SerialWombatErrors.h
SW_ERROR_UNKNOWN_PIN_MODE
@ SW_ERROR_UNKNOWN_PIN_MODE
(#3) A Pin mode was indicated that is not avaialble on this model or version of Serial Wombat chip
Definition SerialWombatErrors.h:28
SerialWombatFrequencyOutput.h
SerialWombatHBridge.h
SerialWombatHSClock.h
SerialWombatHSCounter.h
SerialWombatIRRx.h
SerialWombatIRTx.h
SerialWombatLiquidCrystal.h
SerialWombatMatrixKeypad.h
SerialWombatPS2Keyboard.h
SerialWombatPWM.h
SerialWombatPin.h
SerialWombatProcessedInputPin.h
SerialWombatProtectedOutput.h
SerialWombatPulseOnChange.h
SerialWombatPulseTimer.h
SerialWombatQuadEnc.h
SerialWombatQueue.h
SerialWombatQueuedPulseOutput.h
SerialWombatResistanceInput.h
SerialWombatSPI.h
SerialWombatServo.h
SerialWombatTM1637.h
SerialWombatThroughputConsumer.h
SerialWombatUART.h
SerialWombatUltrasonicDistanceSensor.h
SerialWombatWS2812.h
SerialWombatWatchdog.h
SerialWombat18ABOscillatorTuner::SerialWombat18ABOscillatorTuner
SerialWombat18ABOscillatorTuner(SerialWombatChip &serialWombatChip)
Class constructor for SerialWombat18OscillatorTuner.
Definition SerialWombat.h:1663
SerialWombat18ABOscillatorTuner::update
void update()
Call periodically to tune the SW18AB oscillator to reported millis.
Definition SerialWombat.h:1668
SerialWombatChip
Class for a Serial Wombat chip. Each Serial Wombat chip on a project should have its own instance.
Definition SerialWombat.h:315
SerialWombatChip::setThroughputPin
int16_t setThroughputPin(uint32_t address)
Set this chip Address (SW8B only)
Definition SerialWombat.h:1317
SerialWombatChip::uniqueIdentifier
uint8_t uniqueIdentifier[16]
Definition SerialWombat.h:348
SerialWombatChip::isLatestFirmware
bool isLatestFirmware(void)
Check if the firmware is the latest version (or more precisely, if the firmware matches this verison ...
Definition SerialWombat.h:728
SerialWombatChip::address
uint8_t address
The I2C address of the SerialWombatChip instance.
Definition SerialWombat.h:1548
SerialWombatChip::deviceRevision
uint16_t deviceRevision
Definition SerialWombat.h:366
SerialWombatChip::wake
void wake()
Called to send a dummy packet to the Serial Wombat 8B chip to wake it from sleep and ready it for oth...
Definition SerialWombat.h:1196
SerialWombatChip::SerialWombatChip
SerialWombatChip()
Definition SerialWombat.cpp:31
SerialWombatChip::sendReadyTime
uint32_t sendReadyTime
Used as a countdown after a reset command is issued.
Definition SerialWombat.h:431
SerialWombatChip::uniqueIdentifierLength
uint8_t uniqueIdentifierLength
Definition SerialWombat.h:354
SerialWombatChip::isSW04
bool isSW04()
Returns true if the instance received a model number corresponding to the Serial Wombat 18 series of ...
Definition SerialWombat.h:1203
SerialWombatChip::comparePublicDataToThreshold
uint32_t comparePublicDataToThreshold(uint16_t threshold=0)
Definition SerialWombat.h:790
SerialWombatChip::echo
int16_t echo(uint8_t data[], uint8_t count=7)
Echo a byte array back to the host. Used for testing and debugging.
Definition SerialWombat.h:1559
SerialWombatChip::digitalWrite
void digitalWrite(uint8_t pin, uint8_t val)
Set an output pin High or Low.
Definition SerialWombat.h:897
SerialWombatChip::readFlashAddress
uint32_t readFlashAddress(uint32_t address)
Read Address from Flash based on 32 bit address.
Definition SerialWombat.h:1103
SerialWombatChip::inBoot
bool inBoot
Set to true if boot mode is indicated by a version query.
Definition SerialWombat.h:371
SerialWombatChip::isPinModeSupported
bool isPinModeSupported(int pinMode)
Check if a specific pin mode is supported by the firmware in the Serial Wombat chip....
Definition SerialWombat.h:1225
SerialWombatChip::isPinModeSupported
bool isPinModeSupported(SerialWombatPinMode_t pinMode)
Check if a specific pin mode is supported by the firmware in the Serial Wombat chip....
Definition SerialWombat.h:1234
SerialWombatChip::isSW08
bool isSW08()
Returns true if the instance received a model number corresponding to the Serial Wombat 08 series of ...
Definition SerialWombat.h:1215
SerialWombatChip::readUniqueIdentifier
void readUniqueIdentifier()
Read the unique identifier from the Serial Wombat chip and store it in uniqueIdentifier.
Definition SerialWombat.h:452
SerialWombatChip::readVersion
char * readVersion(void)
Request version string (combined model and firmware) and return pointer to it.
Definition SerialWombat.h:694
SerialWombatChip::configureDigitalPin
void configureDigitalPin(uint8_t pin, uint8_t highLow)
Configure a pin to a digital state with the same parameters as Arduino's digitalWrite() function.
Definition SerialWombat.h:385
SerialWombatChip::readPublicData
uint16_t readPublicData(uint8_t pin)
Read the 16 Bit public data associated with a Serial Wombat Pin Mode.
Definition SerialWombat.h:755
SerialWombatChip::fwVersion
uint8_t fwVersion[4]
Contains the last firmware Version retreived by queryVersion() as a zero-terminated string.
Definition SerialWombat.h:341
SerialWombatChip::readBirthday
uint32_t readBirthday()
Read the birthday of the Serial Wombat 18AB chip.
Definition SerialWombat.h:1590
SerialWombatChip::communicationErrorRetries
uint8_t communicationErrorRetries
How many times to retry a packet if communcation bus (such as I2C) error.
Definition SerialWombat.h:1551
SerialWombatChip::echo
int16_t echo(char *data)
Echo a byte array back to the host. Used for testing and debugging.
Definition SerialWombat.h:1575
SerialWombatChip::readOverflowFrames
uint16_t readOverflowFrames()
Get the number of times an overflow Frame has occured.
Definition SerialWombat.h:1014
SerialWombatChip::find
static uint8_t find(bool keepTrying=false)
Search the I2C Bus addresses 0x68 to 0x6F for I2C devices, and test to see if they respond to Serial ...
Definition SerialWombat.h:1468
SerialWombatChip::readDeviceIdentifier
void readDeviceIdentifier()
Read the device identifier from the Serial Wombat chip and store it in deviceIdentifier.
Definition SerialWombat.h:495
SerialWombatChip::writeUserBuffer
int writeUserBuffer(uint16_t index, uint8_t *buffer, uint16_t count)
Write bytes to the User Memory Buffer in the Serial Wombat chip.
Definition SerialWombat.h:1330
SerialWombatChip::readTemperature_100thsDegC
int16_t readTemperature_100thsDegC(void)
Measure the Serial Wombat chip's internal temperature.
Definition SerialWombat.h:841
SerialWombatChip::sendPacketNoResponse
int sendPacketNoResponse(uint8_t tx[])
Send an 8 byte packet to the Serial Wombat chip, don't wait for a response.
Definition SerialWombat.cpp:280
SerialWombatChip::~SerialWombatChip
~SerialWombatChip()
Definition SerialWombat.cpp:37
SerialWombatChip::readRamAddress
uint8_t readRamAddress(uint16_t address)
Read Address from RAM based on 16 bit address.
Definition SerialWombat.h:1054
SerialWombatChip::readUserBuffer
int16_t readUserBuffer(uint16_t index, uint8_t *buffer, uint16_t count)
Read data from the Serial Wombat 18AB's internal RAM buffer.
Definition SerialWombat.h:1122
SerialWombatChip::isSW18
bool isSW18()
Returns true if the instance received a model number corresponding to the Serial Wombat 18 series of ...
Definition SerialWombat.h:1210
SerialWombatChip::lastErrorCode
int16_t lastErrorCode
The last error code returned as part of a protocol error message expressed as a positive integer.
Definition SerialWombat.h:374
SerialWombatChip::readBrand
int16_t readBrand(char *data)
Read the brand of the Serial Wombat 18AB chip.
Definition SerialWombat.h:1610
SerialWombatChip::pinMode
void pinMode(uint8_t pin, uint8_t mode, bool pullDown=false, bool openDrain=false)
Set a pin to INPUT or OUTPUT, with options for pull Ups and open Drain settings.
Definition SerialWombat.h:878
SerialWombatChip::setThroughputPin
int16_t setThroughputPin(uint8_t pin)
Set a pin to be a throughput monitoring pin.
Definition SerialWombat.h:1298
SerialWombatChip::begin
int16_t begin(HardwareSerial &serial, bool reset=true)
initialize a Serial Wombat chip to use a Serial Interface.
Definition SerialWombat.h:550
SerialWombatChip::sendPacket
int sendPacket(uint8_t tx[], uint8_t rx[])
Send an 8 byte packet to the Serial Wombat chip and wait for 8 bytes back.
Definition SerialWombat.cpp:115
SerialWombatChip::sleep4B
void sleep4B()
Shuts down most functions of the Serial Wombat 4B chip reducing power consumption.
Definition SerialWombat.h:1162
SerialWombatChip::readVersion_uint32
uint32_t readVersion_uint32(void)
Request version as a uint32.
Definition SerialWombat.h:715
SerialWombatChip::writePublicData
uint16_t writePublicData(uint8_t pin, uint16_t value)
Write a 16 bit value to a Serial Wombat pin Mode.
Definition SerialWombat.h:782
SerialWombatChip::readSupplyVoltage_mV
uint16_t readSupplyVoltage_mV(void)
Measure the Serial Wombat chip's Supply voltage.
Definition SerialWombat.h:808
SerialWombatChip::writeFlashRow
int16_t writeFlashRow(uint32_t address)
Writes a row in flash. Intended for use with the Bootloader, not by end users outside of bootloading ...
Definition SerialWombat.h:1278
SerialWombatChip::writeUserBuffer
int writeUserBuffer(uint16_t index, char *s)
Write bytes to the User Memory Buffer in the Serial Wombat chip.
Definition SerialWombat.h:1425
SerialWombatChip::eraseFlashPage
int16_t eraseFlashPage(uint32_t address)
Erases a page in flash. Intended for use with the Bootloader, not by end users outside of bootloading...
Definition SerialWombat.h:1267
SerialWombatChip::returnErrorCode
uint16_t returnErrorCode(uint8_t *rx)
Convert an ASCII Error code from a received packet into an integer error code.
Definition SerialWombat.h:519
SerialWombatChip::deviceIdentifier
uint16_t deviceIdentifier
Definition SerialWombat.h:360
SerialWombatChip::writeRamAddress
int16_t writeRamAddress(uint16_t address, uint8_t value)
Write byte to Address in RAM based on 16 bit address.
Definition SerialWombat.h:1082
SerialWombatChip::initialize
int16_t initialize()
An internal function used to set up the Serial Wombat chip and this class. Call begin() instead of th...
Definition SerialWombat.h:436
SerialWombatChip::writeFrameTimerPin
int16_t writeFrameTimerPin(uint8_t pin)
Set a pin to be a frame timer for system utilization (SW18AB Only)
Definition SerialWombat.h:1454
SerialWombatChip::_supplyVoltagemV
uint16_t _supplyVoltagemV
Definition SerialWombat.h:335
SerialWombatChip::registerErrorHandler
void registerErrorHandler(SerialWombatErrorHandler_t handler)
Registers an error handler that is called by the SerialWombatChip sendPacket() command when a protoco...
Definition SerialWombat.h:1542
SerialWombatChip::begin
int16_t begin(TwoWire &wire, uint8_t i2cAddress, bool reset=true)
initialize a Serial Wombat chip to use a specified I2C Interface and address.
Definition SerialWombat.h:596
SerialWombatChip::analogWrite
void analogWrite(uint8_t pin, int val)
Set a pin to PWM output.
Definition SerialWombat.h:947
SerialWombatChip::sleep8B
void sleep8B(uint16_t delay)
Shuts down the Serial Wombat 8B chip reducing power consumption as low as 10uA.
Definition SerialWombat.h:1187
SerialWombatChip::errorCount
uint16_t errorCount
Incremented every time a communication or command error is detected.
Definition SerialWombat.h:368
SerialWombatChip::writeUserBuffer
int writeUserBuffer(uint16_t index, const char s[])
Write bytes to the User Memory Buffer in the Serial Wombat chip.
Definition SerialWombat.h:1436
SerialWombatChip::analogRead
int analogRead(uint8_t pin)
Configures pin as analog input and does an immediate A/D conversion.
Definition SerialWombat.h:928
SerialWombatChip::readPublicData
uint16_t readPublicData(SerialWombatDataSource dataSource)
Read the 16 Bit public data associated with a Serial Wombat Pin Mode.
Definition SerialWombat.h:772
SerialWombatChip::queryVersion
bool queryVersion()
Send a version request to the Serial Wombat chip.
Definition SerialWombat.h:969
SerialWombatChip::jumpToBoot
void jumpToBoot()
Jump to Bootloader and wait for a UART download of new firmware.
Definition SerialWombat.h:1028
SerialWombatChip::digitalRead
int digitalRead(uint8_t pin)
Reads the state of a Pin.
Definition SerialWombat.h:907
SerialWombatChip::hardwareReset
void hardwareReset()
Send a reset command to the Serial Wombat chip.
Definition SerialWombat.h:864
SerialWombatChip::model
uint8_t model[4]
Contains the last model retreived by queryVersion() as a zero-terminated string.
Definition SerialWombat.h:338
SerialWombatChip::readFramesExecuted
uint32_t readFramesExecuted()
Get the number of 1mS frames that have been executed since Serial Wombat chip reset.
Definition SerialWombat.h:997
SerialWombatChip::readLastErrorCommand
int16_t readLastErrorCommand(uint8_t *cmd)
Returns the last Serial Wombat command that produced a protocol error.
Definition SerialWombat.h:1514
SerialWombat
This class name is depricated. Do not use for new development. Use SerialWombatChip instead.
Definition SerialWombat.h:1745