From 1cb27fdb7558c83d7a265218ba52b5d43d545059 Mon Sep 17 00:00:00 2001 From: rob tillaart Date: Mon, 14 Feb 2022 20:53:03 +0100 Subject: [PATCH] 0.1.0 X9C10X --- libraries/X9C10X/.arduino-ci.yml | 14 ++ .../X9C10X/.github/workflows/arduino-lint.yml | 13 ++ .../.github/workflows/arduino_test_runner.yml | 17 +++ .../X9C10X/.github/workflows/jsoncheck.yml | 18 +++ libraries/X9C10X/LICENSE | 21 +++ libraries/X9C10X/README.md | 105 +++++++++++++ libraries/X9C10X/X9C10X.cpp | 144 ++++++++++++++++++ libraries/X9C10X/X9C10X.h | 92 +++++++++++ .../X9C10X_performance/X9C10X_performance.ino | 122 +++++++++++++++ .../X9C10X_performance/performance_0.1.0.txt | 24 +++ .../examples/X9C10X_test/X9C10X_test.ino | 90 +++++++++++ libraries/X9C10X/keywords.txt | 26 ++++ libraries/X9C10X/library.json | 23 +++ libraries/X9C10X/library.properties | 11 ++ libraries/X9C10X/test/unit_test_001.cpp | 127 +++++++++++++++ 15 files changed, 847 insertions(+) create mode 100644 libraries/X9C10X/.arduino-ci.yml create mode 100644 libraries/X9C10X/.github/workflows/arduino-lint.yml create mode 100644 libraries/X9C10X/.github/workflows/arduino_test_runner.yml create mode 100644 libraries/X9C10X/.github/workflows/jsoncheck.yml create mode 100644 libraries/X9C10X/LICENSE create mode 100644 libraries/X9C10X/README.md create mode 100644 libraries/X9C10X/X9C10X.cpp create mode 100644 libraries/X9C10X/X9C10X.h create mode 100644 libraries/X9C10X/examples/X9C10X_performance/X9C10X_performance.ino create mode 100644 libraries/X9C10X/examples/X9C10X_performance/performance_0.1.0.txt create mode 100644 libraries/X9C10X/examples/X9C10X_test/X9C10X_test.ino create mode 100644 libraries/X9C10X/keywords.txt create mode 100644 libraries/X9C10X/library.json create mode 100644 libraries/X9C10X/library.properties create mode 100644 libraries/X9C10X/test/unit_test_001.cpp diff --git a/libraries/X9C10X/.arduino-ci.yml b/libraries/X9C10X/.arduino-ci.yml new file mode 100644 index 00000000..a6382323 --- /dev/null +++ b/libraries/X9C10X/.arduino-ci.yml @@ -0,0 +1,14 @@ +compile: + # Choosing to run compilation tests on 2 different Arduino platforms + platforms: + - uno + # - due + # - zero + # - leonardo + - m4 + - esp32 + # - esp8266 + # - mega2560 + + libraries: + - "printHelpers" diff --git a/libraries/X9C10X/.github/workflows/arduino-lint.yml b/libraries/X9C10X/.github/workflows/arduino-lint.yml new file mode 100644 index 00000000..b2ca058c --- /dev/null +++ b/libraries/X9C10X/.github/workflows/arduino-lint.yml @@ -0,0 +1,13 @@ + +name: Arduino-lint + +on: [push, pull_request] +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: arduino/arduino-lint-action@v1 + with: + library-manager: update + compliance: strict diff --git a/libraries/X9C10X/.github/workflows/arduino_test_runner.yml b/libraries/X9C10X/.github/workflows/arduino_test_runner.yml new file mode 100644 index 00000000..096b975b --- /dev/null +++ b/libraries/X9C10X/.github/workflows/arduino_test_runner.yml @@ -0,0 +1,17 @@ +--- +name: Arduino CI + +on: [push, pull_request] + +jobs: + runTest: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - uses: ruby/setup-ruby@v1 + with: + ruby-version: 2.6 + - run: | + gem install arduino_ci + arduino_ci.rb diff --git a/libraries/X9C10X/.github/workflows/jsoncheck.yml b/libraries/X9C10X/.github/workflows/jsoncheck.yml new file mode 100644 index 00000000..04603d08 --- /dev/null +++ b/libraries/X9C10X/.github/workflows/jsoncheck.yml @@ -0,0 +1,18 @@ +name: JSON check + +on: + push: + paths: + - '**.json' + pull_request: + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: json-syntax-check + uses: limitusus/json-syntax-check@v1 + with: + pattern: "\\.json$" + diff --git a/libraries/X9C10X/LICENSE b/libraries/X9C10X/LICENSE new file mode 100644 index 00000000..cb502675 --- /dev/null +++ b/libraries/X9C10X/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022-2022 Rob Tillaart + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/libraries/X9C10X/README.md b/libraries/X9C10X/README.md new file mode 100644 index 00000000..eebb6a00 --- /dev/null +++ b/libraries/X9C10X/README.md @@ -0,0 +1,105 @@ + +[![Arduino CI](https://github.com/RobTillaart/X9C10X/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci) +[![Arduino-lint](https://github.com/RobTillaart/X9C10X/actions/workflows/arduino-lint.yml/badge.svg)](https://github.com/RobTillaart/X9C10X/actions/workflows/arduino-lint.yml) +[![JSON check](https://github.com/RobTillaart/X9C10X/actions/workflows/jsoncheck.yml/badge.svg)](https://github.com/RobTillaart/X9C10X/actions/workflows/jsoncheck.yml) +[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/X9C10X/blob/master/LICENSE) +[![GitHub release](https://img.shields.io/github/release/RobTillaart/X9C10X.svg?maxAge=3600)](https://github.com/RobTillaart/X9C10X/releases) + + +# X9C10X + +Arduino Library for X9C10X series digital potentiometer. + + +## Description + +This experimental library provides a X9C10X base class and four derived classes for specific digital potentiometer. + +| type | resistance | notes | +|:------:|:----------:|:-------------| +| X9C10X | generic | base class | +| X9C102 | 1 KΩ | 10 \* 10^2 | +| X9C103 | 10 KΩ | 10 \* 10^3 | +| X9C104 | 100 KΩ | 10 \* 10^4 | +| X9C503 | 50 KΩ | 50 \* 10^3 | + + +_Note: Ω ohm sign = ALT-234_ + +The library keeps cache of the position. + + +## Interface + + +## X9C10X base class + +Use **\#include "X9C10X.h"** + +- **X9C10X(uint32_t ohm = 10000)** Constructor, default initializes the resistance to 10000 Ω. +To calibrate one can fill in any other value e.g. 9950 Ω. +- **void begin(uint8_t pulsePin, uint8_t directionPin, uint8_t selectPin, uint8_t position = 0)** +sets the pins used by the device, and resets the position (default to 0). +The position parameter allows to start the device with a previous stored position. +Use this position with care. + +Note: **begin()** has a hard coded 500uS delay so the device can wake up. + +Note: multiple devices can be controlled, just by giving them an unique selectPin. +This behaviour is similar to the SPI select pin. + +- **void setPosition(uint8_t position)** sets the wiper to a position between 0 and 99. +- **uint8_t getPosition()** returns the current position. +- **void incr()** moves one position up (if possible). +- **void decr()** moves one position down (if possible). +- **uint32_t getOhm()** returns the position expressed in ohm. +The returned value does depend on the value passed in the constructor. +- **uint32_t getMaxOhm()** returns the maximum value ( = parameter from constructor). + + +#### Store + +Warning: use with care. + +- **uint8_t store()** stores the current position in the NVRAM of the device, +and returns the current position so it can later be used as position parameter for **begin()**. + +If one uses an incorrect parameter position in **begin()** the internal state and the device +will probably be out of sync. One way to sync is call **begin()** with the right parameters. +The other way is to call **setPosition(0)** followed by **setPosition(99)** (or vice versa) +to get a defined internal state. + + +## derived classes + +There are 4 derived classes, each with a other (appropriate) default value for the resistance. + +- **X9C102(uint32_t ohm = 1000)** +- **X9C103(uint32_t ohm = 10000)** +- **X9C104(uint32_t ohm = 100000)** +- **X9C503(uint32_t ohm = 50000)** + +These classes have the same interface as the base class. + + +#### Performance + +No hardware to test yet. + + +## Operation + +See examples. + + +## Future + +- buy and test different versions of the hardware +- test different platform +- test performance +- documentation +- optimize **setPosition()** +- do we need the hardcoded 500us delay in **begin()**? +- do we need **getType()** +- add error codes? + diff --git a/libraries/X9C10X/X9C10X.cpp b/libraries/X9C10X/X9C10X.cpp new file mode 100644 index 00000000..8435869d --- /dev/null +++ b/libraries/X9C10X/X9C10X.cpp @@ -0,0 +1,144 @@ +// +// FILE: X9C10X.cpp +// AUTHOR: Rob Tillaart +// VERSION: 0.1.0 +// PURPOSE: Arduino Library for X9C10X series digital potentiometer. +// +// HISTORY +// 0.1.0 2022-01-26 initial version +// + + +#include "X9C10X.h" + +// minimum pulse width CLOCK = ? us (datasheet); +// digitalWrite takes enough time on UNO / AVR so clock_delay == 0 +// Note that if clock pulses are long enough the data pulses are too. +#ifdef __AVR__ +#define X9C10X_DELAYMICROS 0 +#else +#define X9C10X_DELAYMICROS 1 +#endif + +#define X9C10X_UP HIGH +#define X9C10X_DOWN LOW + + +X9C10X::X9C10X(uint32_t ohm) +{ + _ohm = ohm; +} + + +void X9C10X::begin(uint8_t pulsePin, uint8_t directionPin, uint8_t selectPin, uint8_t position) +{ + _pulsePin = pulsePin; + _directionPin = directionPin; + _selectPin = selectPin; + + pinMode(_pulsePin, OUTPUT); + pinMode(_directionPin, OUTPUT); + pinMode(_selectPin, OUTPUT); + + digitalWrite(_pulsePin, HIGH); + digitalWrite(_directionPin, HIGH); + digitalWrite(_selectPin, HIGH); + + // wiper power up time. Page 5. + delayMicroseconds(500); + + // reset defined position. + _position = position; +} + + +// initial implementation, to be optimized. +void X9C10X::setPosition(uint8_t position) +{ + if (position > 99) position = 99; + while (position > _position) incr(); + while (position < _position) decr(); +} + + +void X9C10X::incr() +{ + if (_position >= 99) return; + _position++; + _move(X9C10X_UP); +} + + +void X9C10X::decr() +{ + if (_position == 0) return; + _position--; + _move(X9C10X_DOWN); +} + + +uint8_t X9C10X::store() +{ + // _pulsePin starts default HIGH + digitalWrite(_selectPin, LOW); + if (X9C10X_DELAYMICROS > 0) delayMicroseconds(X9C10X_DELAYMICROS); + digitalWrite(_selectPin, HIGH); + delay(20); // Tcph page 5 + return _position; +} + + +//////////////////////////////////////////////////////////////////// +// +// PRIVATE +// +void X9C10X::_move(uint8_t direction, uint8_t steps) +{ + digitalWrite(_directionPin, direction); + delayMicroseconds(3); // Tdi (page 5) + + // _pulsePin starts default HIGH + digitalWrite(_selectPin, LOW); + while (steps--) + { + digitalWrite(_pulsePin, HIGH); + if (X9C10X_DELAYMICROS > 0) delayMicroseconds(X9C10X_DELAYMICROS); + digitalWrite(_pulsePin, LOW); + if (X9C10X_DELAYMICROS > 0) delayMicroseconds(X9C10X_DELAYMICROS); + } + // _pulsePin == LOW, (No Store, page 7) + digitalWrite(_selectPin, HIGH); + // reset _pulsePin to default. + digitalWrite(_pulsePin, HIGH); +} + + + +///////////////////////////////////////////////////////// +// +// DERIVED +// +X9C102::X9C102(uint32_t ohm) : X9C10X(ohm) +{ + _type = 102; +} + +X9C103::X9C103(uint32_t ohm) : X9C10X(ohm) +{ + _type = 103; +} + +X9C104::X9C104(uint32_t ohm) : X9C10X(ohm) +{ + _type = 104; +} + +X9C503::X9C503(uint32_t ohm) : X9C10X(ohm) +{ + _type = 503; +} + + +// -- END OF FILE -- + + diff --git a/libraries/X9C10X/X9C10X.h b/libraries/X9C10X/X9C10X.h new file mode 100644 index 00000000..71a7ceae --- /dev/null +++ b/libraries/X9C10X/X9C10X.h @@ -0,0 +1,92 @@ +#pragma once +// +// FILE: X9C10X.h +// AUTHOR: Rob Tillaart +// VERSION: 0.1.0 +// PURPOSE: Arduino Library for X9C10X series digital potentiometer. +// + + +#include "Arduino.h" + +#define X9C10X_LIB_VERSION (F("0.1.0")) + + +class X9C10X +{ +public: + // ohm can be actual measured value e.g 9950 ohm (calibration) + X9C10X(uint32_t ohm = 10000); + + void begin(uint8_t pulsePin, uint8_t directionPin, uint8_t selectPin, uint8_t position = 0); + + // position = 0..99 + void setPosition(uint8_t position); + uint8_t getPosition() { return _position; }; + + // step size 1. + void incr(); + void decr(); + + // use with care + uint8_t store(); + + // current resistance in ohm. + // Q: rounding needed? + uint32_t getOhm() { return (_ohm * _position) / 99; }; + // misc + uint32_t getMaxOhm() { return _ohm; }; + + // Q: needed? + uint16_t getType() { return _type; }; + + +protected: + uint8_t _pulsePin; + uint8_t _directionPin; + uint8_t _selectPin; + + uint32_t _ohm; + uint8_t _position; + uint16_t _type = 0; // needed? + + void _move(uint8_t direction, uint8_t steps = 1); +}; + + +///////////////////////////////////////////////////////// +// +// DERIVED +// +class X9C102 : public X9C10X +{ +public: + X9C102(uint32_t ohm = 1000); +}; + + +class X9C103 : public X9C10X +{ +public: + X9C103(uint32_t ohm = 10000); +}; + + +class X9C104 : public X9C10X +{ +public: + X9C104(uint32_t ohm = 100000); +}; + + +class X9C503 : public X9C10X +{ +public: + X9C503(uint32_t ohm = 50000); +}; + + + + +// -- END OF FILE -- + diff --git a/libraries/X9C10X/examples/X9C10X_performance/X9C10X_performance.ino b/libraries/X9C10X/examples/X9C10X_performance/X9C10X_performance.ino new file mode 100644 index 00000000..56cea9b2 --- /dev/null +++ b/libraries/X9C10X/examples/X9C10X_performance/X9C10X_performance.ino @@ -0,0 +1,122 @@ +// +// FILE: X9C10X_performance.ino +// AUTHOR: Rob Tillaart +// PURPOSE: demo + +#include "Arduino.h" +#include "X9C10X.h" + + +X9C10X pot(12345); // 100KΩ (ALT-234) + +uint32_t start, stop; + +volatile uint8_t pos; +volatile uint32_t ohm; + +void setup() +{ + Serial.begin(115200); + while (!Serial); + + Serial.println(); + Serial.print("X9C10X_LIB_VERSION: "); + Serial.println(X9C10X_LIB_VERSION); + + pot.begin(8, 9, 10, 0); // pulse, direction, select, position + + start = micros(); + pos = pot.getPosition(); + stop = micros(); + Serial.print("getPosition:\t"); + Serial.println(stop - start); + delay(100); + + Serial.println("\nfrom 0 to ..."); + pot.setPosition(0); + start = micros(); + pot.setPosition(33); + stop = micros(); + Serial.print("setPosition(33):\t"); + Serial.println(stop - start); + delay(100); + + pot.setPosition(0); + start = micros(); + pot.setPosition(66); + stop = micros(); + Serial.print("setPosition(66):\t"); + Serial.println(stop - start); + delay(100); + + pot.setPosition(0); + start = micros(); + pot.setPosition(99); + stop = micros(); + Serial.print("setPosition(99):\t"); + Serial.println(stop - start); + delay(100); + + Serial.println("\nfrom n to m"); + pot.setPosition(0); + start = micros(); + pot.setPosition(33); + stop = micros(); + Serial.print("setPosition(33):\t"); + Serial.println(stop - start); + delay(100); + + start = micros(); + pot.setPosition(66); + stop = micros(); + Serial.print("setPosition(66):\t"); + Serial.println(stop - start); + delay(100); + + start = micros(); + pot.setPosition(99); + stop = micros(); + Serial.print("setPosition(99):\t"); + Serial.println(stop - start); + delay(100); + + Serial.println(); + start = micros(); + ohm = pot.getMaxOhm(); + stop = micros(); + Serial.print("getMaxOhm():\t"); + Serial.println(stop - start); + delay(100); + + start = micros(); + ohm = pot.getOhm(); + stop = micros(); + Serial.print("getOhm():\t"); + Serial.println(stop - start); + delay(100); + + Serial.println(); + pot.setPosition(0); + start = micros(); + for (int i = 0; i < 10; i++) pot.incr(); + stop = micros(); + Serial.print("10 x incr():\t"); + Serial.println(stop - start); + delay(100); + + pot.setPosition(50); + start = micros(); + for (int i = 0; i < 10; i++) pot.decr(); + stop = micros(); + Serial.print("10 x decr():\t"); + Serial.println(stop - start); + delay(100); +} + + +void loop() +{ +} + + +// -- END OF FILE -- diff --git a/libraries/X9C10X/examples/X9C10X_performance/performance_0.1.0.txt b/libraries/X9C10X/examples/X9C10X_performance/performance_0.1.0.txt new file mode 100644 index 00000000..a102c45e --- /dev/null +++ b/libraries/X9C10X/examples/X9C10X_performance/performance_0.1.0.txt @@ -0,0 +1,24 @@ + +Tested on Arduino UNO +IDE 1.18.19 + +X9C10X_LIB_VERSION: 0.1.0 +getPosition: 4 + +from 0 to ... +setPosition(33): 1024 +setPosition(66): 1860 +setPosition(99): 2788 + +from n to m +setPosition(33): 932 +setPosition(66): 936 +setPosition(99): 932 + +getMaxOhm(): 4 +getOhm(): 44 + +10 x incr(): 284 +10 x decr(): 284 + + diff --git a/libraries/X9C10X/examples/X9C10X_test/X9C10X_test.ino b/libraries/X9C10X/examples/X9C10X_test/X9C10X_test.ino new file mode 100644 index 00000000..eec2723d --- /dev/null +++ b/libraries/X9C10X/examples/X9C10X_test/X9C10X_test.ino @@ -0,0 +1,90 @@ +// +// FILE: X9C10X_test.ino +// AUTHOR: Rob Tillaart +// PURPOSE: demo + + +#include "Arduino.h" +#include "X9C10X.h" + +X9C10X pot(12345); // 100KΩ (ALT-234) + +void setup() +{ + Serial.begin(115200); + while (!Serial); + + Serial.println(); + Serial.print("X9C10X_LIB_VERSION: "); + Serial.println(X9C10X_LIB_VERSION); + + pot.begin(8, 9, 10, 0); // pulse, direction, select, position + + Serial.print("POS:\t0\t"); + Serial.println(pot.getPosition()); + Serial.print("VAL:\t\t"); + Serial.print(pot.getOhm()); + Serial.println(" Ω"); + Serial.println(); + + pot.setPosition(50); + Serial.print("POS:\t50\t"); + Serial.println(pot.getPosition()); + Serial.print("VAL:\t\t"); + Serial.print(pot.getOhm()); + Serial.println(" Ω"); + Serial.println(); + + pot.setPosition(110); + Serial.print("POS:\t110\t"); + Serial.println(pot.getPosition()); + Serial.print("VAL:\t\t"); + Serial.print(pot.getOhm()); + Serial.println(" Ω"); + Serial.print("OHM:\t\t"); + Serial.print(pot.getMaxOhm()); + Serial.println(" Ω"); + Serial.println(); + + pot.setPosition(0); + Serial.print("POS:\t0\t"); + Serial.println(pot.getPosition()); + Serial.print("VAL:\t\t"); + Serial.print(pot.getOhm()); + Serial.println(" Ω"); + Serial.print("OHM:\t\t"); + Serial.print(pot.getMaxOhm()); + Serial.println(" Ω"); + Serial.println(); + + for (uint8_t i = 0; i < 100; i++) + { + pot.incr(); + Serial.print(i); + Serial.print("\t"); + Serial.print(pot.getPosition()); + Serial.print("\t"); + Serial.println(pot.getOhm()); + } + Serial.println(); + + for (uint8_t i = 0; i < 100; i++) + { + pot.decr(); + Serial.print(i); + Serial.print("\t"); + Serial.print(pot.getPosition()); + Serial.print("\t"); + Serial.println(pot.getOhm()); + } + Serial.println(); + +} + + +void loop() +{ +} + + +// -- END OF FILE -- diff --git a/libraries/X9C10X/keywords.txt b/libraries/X9C10X/keywords.txt new file mode 100644 index 00000000..99e7cbf5 --- /dev/null +++ b/libraries/X9C10X/keywords.txt @@ -0,0 +1,26 @@ +# Syntax Colouring Map For X9C10X + +# Data types (KEYWORD1) +X9C10X KEYWORD1 +X9C102 KEYWORD1 +X9C103 KEYWORD1 +X9C104 KEYWORD1 +X9C503 KEYWORD1 + + +# Methods and Functions (KEYWORD2) +begin KEYWORD2 +setPosition KEYWORD2 +getPosition KEYWORD2 +incr KEYWORD2 +decr KEYWORD2 + +getOhm KEYWORD2 +getMaxOhm KEYWORD2 + +store KEYWORD2 + + +# Constants (LITERAL1) +X9C10X_LIB_VERSION LITERAL1 + diff --git a/libraries/X9C10X/library.json b/libraries/X9C10X/library.json new file mode 100644 index 00000000..c2387c70 --- /dev/null +++ b/libraries/X9C10X/library.json @@ -0,0 +1,23 @@ +{ + "name": "X9C10X", + "keywords": "potentiometer,X9C102,X9C103,X9C104,X9C503", + "description": "Arduino Library for X9C10X series digital potentiometer.", + "authors": + [ + { + "name": "Rob Tillaart", + "email": "Rob.Tillaart@gmail.com", + "maintainer": true + } + ], + "repository": + { + "type": "git", + "url": "https://github.com/RobTillaart/X9C10X.git" + }, + "version": "0.1.0", + "license": "MIT", + "frameworks": "arduino", + "platforms": "*", + "headers": "X9C10X.h" +} diff --git a/libraries/X9C10X/library.properties b/libraries/X9C10X/library.properties new file mode 100644 index 00000000..66518499 --- /dev/null +++ b/libraries/X9C10X/library.properties @@ -0,0 +1,11 @@ +name=X9C10X +version=0.1.0 +author=Rob Tillaart +maintainer=Rob Tillaart +sentence=Arduino Library for X9C10X series digital potentiometer. +paragraph=X9C102, X9C103, X9C104, X9C503 +category=Signal Input/Output +url=https://github.com/RobTillaart/X9C10X +architectures=* +includes=X9C10X.h +depends= diff --git a/libraries/X9C10X/test/unit_test_001.cpp b/libraries/X9C10X/test/unit_test_001.cpp new file mode 100644 index 00000000..7c35e4f5 --- /dev/null +++ b/libraries/X9C10X/test/unit_test_001.cpp @@ -0,0 +1,127 @@ +// +// FILE: unit_test_001.cpp +// AUTHOR: Rob Tillaart +// DATE: 2022-02-11 +// PURPOSE: unit tests for the X9C10X library +// https://github.com/RobTillaart/X9C10X +// https://github.com/Arduino-CI/arduino_ci/blob/master/REFERENCE.md +// + +// supported assertions +// https://github.com/Arduino-CI/arduino_ci/blob/master/cpp/unittest/Assertion.h#L33-L42 +// ---------------------------- +// assertEqual(expected, actual) +// assertNotEqual(expected, actual) +// assertLess(expected, actual) +// assertMore(expected, actual) +// assertLessOrEqual(expected, actual) +// assertMoreOrEqual(expected, actual) +// assertTrue(actual) +// assertFalse(actual) +// assertNull(actual) +// assertNotNull(actual) + +#include + + +#include "Arduino.h" +#include "X9C10X.h" + + + +unittest_setup() +{ + fprintf(stderr, "X9C10X_LIB_VERSION: %s\n", (char *) X9C10X_LIB_VERSION); +} + +unittest_teardown() +{ +} + + +unittest(test_constructor) +{ + X9C10X dp0; + X9C10X dp1(1000); + X9C10X dp2(900); + X9C10X dp3(1100); + + assertEqual(10000, dp0.getMaxOhm()); + assertEqual(1000, dp1.getMaxOhm()); + assertEqual(900, dp2.getMaxOhm()); + assertEqual(1100, dp3.getMaxOhm()); + + X9C102 x102; + X9C103 x103; + X9C104 x104; + X9C503 x503; + + assertEqual(1000, x102.getMaxOhm()); + assertEqual(10000, x103.getMaxOhm()); + assertEqual(100000, x104.getMaxOhm()); + assertEqual(50000, x503.getMaxOhm()); +} + + +unittest(test_position) +{ + X9C10X dp0; + + dp0.begin(7, 8, 9); + assertEqual(0, dp0.getPosition()); + + fprintf(stderr, "setPosition step 9\n"); + for (uint8_t pos = 0; pos < 100; pos += 9) + { + dp0.setPosition(pos); + assertEqual(pos, dp0.getPosition()); + } + + X9C10X dp1; + dp1.begin(7, 8, 9, 50); + assertEqual(50, dp1.getPosition()); +} + + +unittest(test_incr_decr) +{ + X9C10X dp0; + + dp0.begin(7, 8, 9); + assertEqual(0, dp0.getPosition()); + + dp0.setPosition(0); + for (uint8_t pos = 0; pos < 10; pos++) + { + assertEqual(pos, dp0.getPosition()); + dp0.incr(); + } + + for (uint8_t pos = 0; pos < 5; pos++) + { + assertEqual(10 - pos, dp0.getPosition()); + dp0.decr(); + } +} + + +unittest(test_getOhm) +{ + X9C10X dp0; + + dp0.begin(7, 8, 9); + assertEqual(0, dp0.getPosition()); + assertEqual(10000, dp0.getMaxOhm()); + + for (uint8_t pos = 0; pos < 100; pos += 9) + { + fprintf(stderr, "VALUE: %d %d Ω\n", dp0.getPosition(), dp0.getOhm()); + dp0.incr(); + } + +} + + +unittest_main() + +// --------