0.1.1 map2bits

Author: RobTillaart

libraries/map2bits/.arduino-ci.yml

@@ -25,3 +25,5 @@ compile:
     # - esp8266
     # - mega2560
     - rpipico
+  libraries:
+    - "printHelpers"

libraries/map2bits/.github/workflows/arduino-lint.yml

@@ -6,8 +6,8 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/arduino-lint-action@v1
+      - uses: actions/checkout@v5
+      - uses: arduino/arduino-lint-action@v2
         with:
           library-manager: update
           compliance: strict

libraries/map2bits/.github/workflows/arduino_test_runner.yml

@@ -8,7 +8,7 @@ jobs:
     timeout-minutes: 20
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 2.6

libraries/map2bits/.github/workflows/jsoncheck.yml

@@ -5,13 +5,15 @@ on:
     paths:
       - '**.json'
   pull_request:
+    paths:
+      - '**.json'
 
 jobs:
   test:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: json-syntax-check
         uses: limitusus/json-syntax-check@v2
         with:

libraries/map2bits/CHANGELOG.md

@@ -6,5 +6,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 
+## [0.1.1] - 2025-11-26
+- add map64(float) and map32() for "clean API"
+- add map16() for investigation, (~equal in performance).
+- increased MAXSIZE to 64
+- add example map2bits_analogRead.ino
+- update readme.md - test ESP32 performance
+- update GitHub actions
+- minor edits
+
 ## [0.1.0] - 2024-01-02
 - initial version.

libraries/map2bits/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-2024 Rob Tillaart
+Copyright (c) 2024-2025 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

libraries/map2bits/README.md

@@ -16,8 +16,10 @@ Arduino library for mapping a float to a number of bits.
 
 ## Description
 
-Map2bits is an **experimental** library which can be used to map a float 
-value to a number of HIGH bits in an 32 bits integer..
+**Experimental**
+
+Map2bits is an experimental library which can be used to map a float 
+value to a number of HIGH bits in an 32 bits integer.
 The float value can be the result of a calculation or measurement from a 
 sensor, e.g. temperature, humidity, light, distance, direction or pressure. 
 
@@ -36,7 +38,7 @@ In short many devices to drive or applications to think of.
 As always, feedback is welcome.
 
 
-#### Related
+### Related
 
 Other mapping libraries
 
@@ -54,15 +56,25 @@ Other mapping libraries
 #include "map2bits.h"
 ```
 
-#### Functions
+### Constructor
 
 - **map2bits()** Constructor, defines a default mapping of (0..100 => 10)
 - **uint8_t init(float in_min, float in_max, uint32_t bits)** defines the mapping
 input range and how many bits output should be generated.
+
+### Mapping
+
+The output of the **map()** functions is a bit mask and can be used to drive e.g. a led bar etc.
+
 - **uint32_t map(float value)** maps value to an uint32_t with the appropriate 
 number of bits set. These are constrained by the number of bits set in **init()**.
-
-The output of **map()** is a bit mask and can be used to drive e.g. a led bar etc.
+- **uint16_t map16(float value)** maps value to an uint16_t with the appropriate 
+number of bits set. These are constrained by the number of bits set in **init()**.
+Slightly faster (~2.5%).
+- **uint32_t map32(float value)** equals map().
+- **uint64_t map64(float value)** maps value to an uint64_t with the appropriate 
+number of bits set. These are constrained by the number of bits set in **init()**.
+Typical only used if one wants more than 32 bits.
 
 
 ## Operation
@@ -85,15 +97,33 @@ See examples.
 
 Indicative performance measured with the **map2bits_performance.ino** example.
 Performance depends on input chosen, platform support of float, and if
-values are constrained (out range) or interpolated (in range)
+values are constrained (out range) or interpolated (in range).
+Run tests on your own board to get the numbers.
+
+Note: times in microseconds per call  
+Note: UNO at 16 MHz, ESP32 at 240 MHz  
+Note: out of range == 33% in range, 66% out range  
+Note: map() == map32()
+
+|  board   |  function  |  in range  |  out range  |  notes  |
+|:--------:|:----------:|:----------:|:-----------:|:--------|
+|  UNO R3  |    map16   |    45.22   |     22.08   |
+|  UNO R3  |    map32   |    46.28   |     22.49   |
+|  UNO R3  |    map64   |    49.00   |     23.60   |  for > 32 bits
+|          |            |            |             |
+|   ESP32  |    map16   |     0.42   |      0.24   |
+|   ESP32  |    map32   |     0.41   |      0.23   |
+|   ESP32  |    map64   |     0.52   |      0.33   |  for > 32 bits
+
+
+## Polarity
 
-Note: time in microseconds per call
-Note: UNO at 16 MHz, ESP32 at 240 MHz
+The user can swap polarity by inverting with ~ 
 
-|  board  |  map - in range |  map - out range  |  notes  |
-|:-------:|:---------------:|:-----------------:|:--------|
-|  UNO    |  45.35 us       |  22.20 us         |  33% in range, 66% out range
-|  ESP32  |                 |                   |  to do
+```cpp
+x = ~mb.map(42);            //   x = 0xFFFFFFF0  => 
+x = ~mb.map(42) & 0xFFFF    //   x = 0x0000FFF0 optional mask.
+```
 
 
 ## Future
@@ -105,29 +135,25 @@ Note: UNO at 16 MHz, ESP32 at 240 MHz
 
 #### Should
 
-- extend the idea to applications
-- add examples
-- optimize
+- add examples / applications
+- investigate optimize
+  - do we need map16() => optimizer does clean up.
 
 #### Could
 
-- test other boards
-- **map2bits64(value)** uint64_t for 33 - 64 bits output
-  - might need printHelpers
-- **map2bitsDouble(value)** Double version (input range + precision)
-- **map2bitsDouble64(value)** Double version (33 - 64 bits output)
-- uint32_t input version
+- map logarithmic  (map exponent)
+- MSB/LSB   00000011 <> 0000110000 ?  (SIZE = 6)
+  - reverse from CRC library
+
+#### Wont
+
 - map2DAC? 
   - maps a range to analogWrite()..
   - separate class. 
 - polarity  0001 <> 1110 ?
   - ~operator
-- MSB/LSB   0001 <> 1000 ?
-  - reverse from CRC library
-
-
-#### Wont
-
+- map16(uint32_t) map32(uint32_t) map64(uint32_t) => accuracy float is sufficient
+- map2bitsDouble(value), map2bitsDouble64(value) Double version (input range + precision)
 
 ## Support
 

libraries/map2bits/examples/map2bits_analogRead/map2bits_analogRead.ino

@@ -0,0 +1,33 @@
+//
+//    FILE: map2bits_analogRead.ino
+//  AUTHOR: Rob Tillaart
+// PURPOSE: map2bits demo
+//     URL: https://github.com/RobTillaart/map2bits
+
+
+#include "map2bits.h"
+
+map2bits mb;
+
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println(__FILE__);
+  Serial.print("MAP2BITS_LIB_VERSION: ");
+  Serial.println(MAP2BITS_LIB_VERSION);
+  Serial.println();
+
+  mb.init(0, 1023, 16);
+}
+
+
+void loop()
+{
+  Serial.println(mb.map(analogRead(A0)), BIN);
+  delay(50);
+}
+
+
+// -- END OF FILE --

libraries/map2bits/examples/map2bits_demo/map2bits_demo.ino

@@ -13,6 +13,7 @@ map2bits mb;
 void setup()
 {
   Serial.begin(115200);
+  Serial.println();
   Serial.println(__FILE__);
   Serial.print("MAP2BITS_LIB_VERSION: ");
   Serial.println(MAP2BITS_LIB_VERSION);