update libs

Author: RobTillaart

libraries/Angle/Warning.txt

@@ -3,23 +3,33 @@
 //  AUTHOR: Rob Tillaart
 //    DATE: 2020-12-03
 // PURPOSE: unit tests for the Cozir CO2 library
-//          https://github.com/RobTillaart/
+//          https://github.com/RobTillaart/Cozir
 //          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)
+// assertEqual(expected, actual);               // a == b
+// assertNotEqual(unwanted, actual);            // a != b
+// assertComparativeEquivalent(expected, actual);    // abs(a - b) == 0 or (!(a > b) && !(a < b))
+// assertComparativeNotEquivalent(unwanted, actual); // abs(a - b) > 0  or ((a > b) || (a < b))
+// assertLess(upperBound, actual);              // a < b
+// assertMore(lowerBound, actual);              // a > b
+// assertLessOrEqual(upperBound, actual);       // a <= b
+// assertMoreOrEqual(lowerBound, actual);       // a >= b
+// assertTrue(actual);
+// assertFalse(actual);
+// assertNull(actual);
+
+// // special cases for floats
+// assertEqualFloat(expected, actual, epsilon);    // fabs(a - b) <= epsilon
+// assertNotEqualFloat(unwanted, actual, epsilon); // fabs(a - b) >= epsilon
+// assertInfinity(actual);                         // isinf(a)
+// assertNotInfinity(actual);                      // !isinf(a)
+// assertNAN(arg);                                 // isnan(a)
+// assertNotNAN(arg);                              // !isnan(a)
+
 
 #include <ArduinoUnitTests.h>
 
@@ -60,6 +70,7 @@ unittest(test_software_serial)
   assertEqual("K 2\r\n", state->digitalPin[transmitPin].toAscii(1, bigEndian));
 }
 
+
 unittest(test_constructor)
 {
   GodmodeState* state = GODMODE();
@@ -269,6 +280,18 @@ unittest(test_streaming_mode)
   co.SetOutputFields(CZR_HUMIDITY | CZR_RAWTEMP | CZR_RAWCO2);
   assertEqual("M 4226\r\n", state->serialPort[0].dataOut);
 
+  fprintf(stderr, "COZIR.GetRecentFields()\n");
+  state->serialPort[0].dataIn = "";
+  state->serialPort[0].dataOut = "";
+  co.GetRecentFields();
+  assertEqual("Q\r\n", state->serialPort[0].dataOut);
+  
+  fprintf(stderr, "COZIR.ClrOutputFields()\n");
+  state->serialPort[0].dataIn = "";
+  state->serialPort[0].dataOut = "";
+  co.ClrOutputFields();
+  assertEqual("M 1\r\n", state->serialPort[0].dataOut);
+
   fprintf(stderr, "COZIR.GetRecentFields()\n");
   state->serialPort[0].dataIn = "";
   state->serialPort[0].dataOut = "";
@@ -306,6 +329,27 @@ unittest(test_eeprom)
 
 
 
+unittest(test_PPM)
+{
+  GodmodeState* state = GODMODE();
+
+  COZIR co(&Serial);
+
+  fprintf(stderr, "COZIR.init()\n");
+  state->serialPort[0].dataIn = "";
+  state->serialPort[0].dataOut = "";
+  co.init();
+  assertEqual("K 2\r\n", state->serialPort[0].dataOut);
+
+  fprintf(stderr, "COZIR.getPPMFactor()\n");
+  state->serialPort[0].dataIn = "";
+  state->serialPort[0].dataOut = "";
+  co.getPPMFactor();
+  assertEqual(".\r\n", state->serialPort[0].dataOut);
+}
+
+
+
 unittest_main()
 
 // --------

libraries/Cozir/test/unit_test_001.cpp

@@ -0,0 +1,7 @@
+compile:
+  # Choosing to run compilation tests on 2 different Arduino platforms
+  platforms:
+    - uno
+    - leonardo
+    - due
+    - zero

libraries/Currency/.arduino-ci.yml

@@ -0,0 +1,13 @@
+---
+name: Arduino CI
+
+on: [push, pull_request]
+
+jobs:
+  arduino_ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: Arduino-CI/action@master
+          #   Arduino-CI/[email protected]

libraries/Currency/.github/workflows/arduino_test_runner.yml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2021 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.

libraries/Currency/LICENSE

@@ -0,0 +1,87 @@
+
+[![Arduino CI](https://github.com/RobTillaart/currency/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/currency/blob/master/LICENSE)
+[![GitHub release](https://img.shields.io/github/release/RobTillaart/currency.svg?maxAge=3600)](https://github.com/RobTillaart/currency/releases)
+
+
+
+# Currency
+
+Arduino library to help formatting integers for printing as currency
+
+## Warning: experimental
+
+
+## Description
+
+The currency library contains a number of functions that help to print 
+integers as currency.
+
+The currency functions assume you do the currency math in integer units.
+For dollars and euro's this would be cents. For numbers with more decimals 
+it is a smaller unit. 
+
+Using integers makes addition, subtraction and multiplication exact. 
+
+Choosing int32_t as 'base' also means that there is a limit in terms 
+of minimum and maximum values. When large amounts are needed one can 
+use the currency64() or one of its derived formatters as this is based
+upon int64_t numbers.
+
+There is a relation with the printhelpers class - https://github.com/RobTillaart/printHelpers
+When this library has matured it might be merged with it.
+
+
+## Interface
+
+The following functions are implemented:
+
+
+### Core function
+
+- **char \* currency(int32_t value, uint8_t decimals, char decimalseparator, char thousandseparator, char symbol);** 
+- **char \* currency64(int64_t value, uint8_t decimals, char decimalseparator, char thousandseparator, char symbol);**
+
+
+### int32 Wrapper functions
+
+- **char \* bitcoin(int32_t value)**
+- **char \* dollar(int32_t value)**
+- **char \* euro(int32_t value)**
+- **char \* roebel(int32_t value)**
+- **char \* yen(int32_t value)**
+- **char \* yuan(int32_t value)**
+
+
+### int64 Wrapper functions
+
+- **char \* bitcoin64(int64_t value)**
+- **char \* dollar64(int64_t value)**
+- **char \* euro64(int64_t value)**
+- **char \* roebel64(int64_t value)**
+- **char \* yen64(int64_t value)**
+- **char \* yuan64(int64_t value)**
+
+
+### float Wrapper functions
+
+Even more experimental - not tested
+
+- **char \* bitcoinf(double value)**
+- **char \* dollarf(double value)**
+- **char \* eurof(double value)**
+- **char \* roebelf(double value)**
+- **char \* yenf(double value)**
+- **char \* yuanf(double value)**
+
+
+## Future
+
+- More wrapper functions?
+- test double parameters.
+
+
+## Operation
+
+See examples
+

libraries/Currency/README.md

@@ -0,0 +1,132 @@
+#pragma once
+
+//
+//    FILE: currency.h
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: Currency library for Arduino
+//     URL: https://github.com/RobTillaart/Currency
+
+//  HISTORY
+//  0.1.0   2021-02-27  initial version
+
+
+#include "Arduino.h"
+
+
+#define CURRENCY_VERSION        (F("0.1.0"))
+
+
+// TODO 
+// optimize this 99% same code currency - currency64  
+// print to string and "merge" with formatters?
+//
+// ALT-0165 = ¥
+// ALT-0128 = €
+// U+20BF   = Bitcoin
+
+
+char * currency(int32_t value, int decimals, char dsep, char tsep, char sym)
+{
+  static char tmp[16];
+  int idx = 0;
+
+  int32_t v = value;
+  bool neg = v < 0;
+  if (neg) v = -v;
+
+  int p = -decimals; // decimal places
+
+  while ((p < 1) || ( v > 0))
+  {
+    // separators
+    if ((p == 0) && (decimals > 0) ) tmp[idx++] = dsep;
+    if ((p > 0) && (p % 3 == 0) && (v > 0)) tmp[idx++] = tsep;
+
+    int d = (v % 10) + '0';
+    v /= 10;
+    tmp[idx++] = d;
+    p++;
+  }
+  if (neg) tmp[idx++] = '-';
+  else     tmp[idx++] = ' ';
+  tmp[idx++] = sym;
+  tmp[idx] = 0;
+
+  // reverse string
+  int len = strlen(tmp);
+  for (int i = 0; i < len / 2; i++)
+  {
+    char c = tmp[i];
+    tmp[i] = tmp[len - i - 1];
+    tmp[len - i - 1] = c;
+  }
+  return tmp;
+}
+
+
+char * currency64(int64_t value, int decimals, char dsep, char tsep, char sym)
+{
+  static char tmp[32];
+  int idx = 0;
+
+  int64_t v = value;
+  bool neg = v < 0;
+  if (neg) v = -v;
+
+  int p = -decimals; // decimal places
+
+  while ((p < 1) || ( v > 0))
+  {
+    // separators
+    if ((p == 0) && (decimals > 0) ) tmp[idx++] = dsep;
+    if ((p > 0) && (p % 3 == 0) && (v > 0)) tmp[idx++] = tsep;
+
+    int d = (v % 10) + '0';
+    v /= 10;
+    tmp[idx++] = d;
+    p++;
+  }
+  if (neg) tmp[idx++] = '-';
+  else     tmp[idx++] = ' ';
+  tmp[idx++] = sym;
+  tmp[idx] = 0;
+
+  // reverse string
+  int len = strlen(tmp);
+  for (int i = 0; i < len / 2; i++)
+  {
+    char c = tmp[i];
+    tmp[i] = tmp[len - i - 1];
+    tmp[len - i - 1] = c;
+  }
+  return tmp;
+}
+
+
+//
+//  DERIVED FUNCTIONS
+//
+char * bitcoin(int32_t value)   { return currency(value, 6,  '.',  ',',  'B'); }  
+char * dollar(int32_t value)    { return currency(value, 2,  '.',  ',',  '$'); }
+char * euro(int32_t value)      { return currency(value, 2,  ',',  '.',  'E'); }
+char * roebel(int32_t value)    { return currency(value, 2,  ',',  '.',  'P'); }
+char * yen(int32_t value)       { return currency(value, 2,  '.',  ',',  'Y'); }
+char * yuan(int32_t value)      { return currency(value, 2,  '.',  ',',  'R'); }
+
+char * bitcoin64(int64_t value) { return currency64(value, 6,  '.',  ',',  'B'); }  
+char * dollar64(int64_t value)  { return currency64(value, 2,  '.',  ',',  '$'); }
+char * euro64(int64_t value)    { return currency64(value, 2,  ',',  '.',  'E'); }
+char * roebel64(int64_t value)  { return currency64(value, 2,  ',',  '.',  'P'); }
+char * yen64(int64_t value)     { return currency64(value, 2,  '.',  ',',  'Y'); }
+char * yuan64(int64_t value)    { return currency64(value, 2,  '.',  ',',  'R'); }
+
+char * bitcoinf(double value)   { return currency64(round(value * 1000000), 6,  '.',  ',',  'B'); }  
+char * dollarf(double value)    { return currency64(round(value * 100), 2,  '.',  ',',  '$'); }
+char * eurof(double value)      { return currency64(round(value * 100), 2,  ',',  '.',  'E'); }
+char * roebelf(double value)    { return currency64(round(value * 100), 2,  ',',  '.',  'P'); }
+char * yenf(double value)       { return currency64(round(value * 100), 2,  '.',  ',',  'Y'); }
+char * yuanf(double value)      { return currency64(round(value * 100), 2,  '.',  ',',  'R'); }
+
+
+// -- END OF FILE --