0.2.3 BitArray

Author: RobTillaart

libraries/BitArray/.arduino-ci.yml

@@ -2,6 +2,10 @@ compile:
   # Choosing to run compilation tests on 2 different Arduino platforms
   platforms:
     - uno
-    - leonardo
-    - due
-    - zero
+    # - due
+    # - zero
+    # - leonardo
+    - m4
+    - esp32
+    # - esp8266
+    # - mega2560

libraries/BitArray/.github/workflows/arduino_test_runner.yml

@@ -4,10 +4,14 @@ name: Arduino CI
 on: [push, pull_request]
 
 jobs:
-  arduino_ci:
+  runTest:
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v2
-      - uses: Arduino-CI/action@master
-          #   Arduino-CI/[email protected]
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+      - run: |
+          gem install arduino_ci
+          arduino_ci.rb

libraries/BitArray/BitArray.cpp

@@ -1,32 +1,31 @@
 //
 //    FILE: BitArray.cpp
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.2.2
+// VERSION: 0.2.3
 // PURPOSE: BitArray library for Arduino
 //     URL: https://github.com/RobTillaart/BitArray
 //          http://forum.arduino.cc/index.php?topic=361167
 //
-// 16 bit clear is faster --> verify correctness
+// HISTORY
+//  0.1.00   initial version
+//  0.1.01   added clear() + fixed set bug
+//  0.1.02   first stable version (at last)
+//  0.1.03   refactoring
+//  0.1.04   improve performance
+//  0.1.05   added upper limits
+//  0.1.06   refactored
+//  0.1.07   private calls inline -> performance & footprint
+//  0.1.8    added toggle
+//  0.1.9    fix constructor bug
+//  0.2.0    2020-03-28  #pragma once, readme, fix Fibonacci demo
+//  0.2.1    2020-06-05  fix library.json
+//  0.2.2    2020-12-14  add Arduino-CI + unit test
+//  0.2.3    2021-10-19  update Arduino-CI + setAll(value)
 
 
-// 0.2.2    2020-12-14  add arduino-CI + unit test
-// 0.2.1    2020-06-05  fix library.json
-// 0.2.0    2020-03-28  #pragma once, readme, fix fibnacci demo
-//
-// 0.1.9  - fix constructor bug
-// 0.1.8  - added toggle
-// 0.1.07 - private calls inline -> performance & footprint
-// 0.1.06 - refactored
-// 0.1.05 - added upper limits
-// 0.1.04 - improve performance
-// 0.1.03 - refactoring
-// 0.1.02 - first stabile version (at last)
-// 0.1.01 - added clear() + fixed set bug
-// 0.1.00 - initial version
-//
-
 #include "BitArray.h"
 
+
 BitArray::BitArray()
 {
     for (uint8_t i = 0; i < BA_MAX_SEGMENTS; i++)
@@ -35,6 +34,7 @@ BitArray::BitArray()
     }
 }
 
+
 BitArray::~BitArray()
 {
     for (uint8_t i = 0; i < BA_MAX_SEGMENTS; i++)
@@ -43,6 +43,7 @@ BitArray::~BitArray()
     }
 }
 
+
 uint8_t BitArray::begin(const uint8_t bits, const uint16_t size)
 {
     if (bits == 0 || bits > 32)
@@ -67,19 +68,20 @@ uint8_t BitArray::begin(const uint8_t bits, const uint16_t size)
     uint16_t b = _bytes;
     while (b > 0)
     {
-        _ar[_segments] = (uint8_t*) malloc(min(b, BA_SEGMENT_SIZE));
+        _ar[_segments] = (uint8_t*) malloc(min(b, (uint16_t) BA_SEGMENT_SIZE));
         if (_ar[_segments] == NULL)
         {
             _error = BA_NO_MEMORY_ERR;
             return _error;
         }
-        b = b - min(b, BA_SEGMENT_SIZE);
+        b = b - min(b, (uint16_t) BA_SEGMENT_SIZE);
         _segments++;
     }
     _error = BA_OK;
     return _error;
 }
 
+
 uint32_t BitArray::get(const uint16_t idx)
 {
     // if (_error != BA_OK) return BA_ERR;
@@ -111,6 +113,7 @@ uint32_t BitArray::set(const uint16_t idx, uint32_t value)
     return value;
 }
 
+
 uint32_t BitArray::toggle(const uint16_t idx)
 {
     // if (_error != BA_OK) return BA_ERR;
@@ -125,6 +128,7 @@ uint32_t BitArray::toggle(const uint16_t idx)
     return v;
 }
 
+
 void BitArray::clear()
 {
     uint16_t b = _bytes;
@@ -133,7 +137,7 @@ void BitArray::clear()
         uint8_t *p = _ar[s];
         if (p)
         {
-            uint8_t t = min(b, BA_SEGMENT_SIZE);
+            uint8_t t = min(b, (uint16_t) BA_SEGMENT_SIZE);
             b -= t;
             while(t--)
             {
@@ -144,7 +148,20 @@ void BitArray::clear()
     }
 }
 
-// 16 bit address usage is faster 
+
+
+void BitArray::setAll(uint32_t value)
+{
+  for (uint16_t i = 0; i < capacity(); i++)
+  {
+    set(i, value);
+  }
+}
+
+
+//      16 bit address usage is faster
+// TODO verify correctness
+//
 // void BitArray::clear()
 // {
     // uint16_t b = _bytes;
@@ -163,6 +180,7 @@ void BitArray::clear()
     // }
 // }
 
+
 // PRIVATE
 inline uint8_t BitArray::_bitget(uint16_t pos)
 {
@@ -180,6 +198,7 @@ inline uint8_t BitArray::_bitget(uint16_t pos)
     return (p[by] >> bi) & 0x01; // bitRead(p[by], bi);
 }
 
+
 inline void BitArray::_bitset(uint16_t pos, uint8_t value)
 {
     uint8_t se = 0;
@@ -197,6 +216,7 @@ inline void BitArray::_bitset(uint16_t pos, uint8_t value)
     else p[by] |= (1 << bi);             // bitSet(p[by], bi);
 }
 
+
 inline uint8_t BitArray::_bittoggle(const uint16_t pos)
 {
     uint8_t se = 0;
@@ -215,4 +235,5 @@ inline uint8_t BitArray::_bittoggle(const uint16_t pos)
     return (mask > 0);
 }
 
-// END OF FILE
+
+// -- END OF FILE --

libraries/BitArray/BitArray.h

@@ -2,26 +2,26 @@
 //
 //    FILE: bitArray.h
 //  AUTHOR: Rob dot Tillaart at gmail dot com
-// VERSION: 0.2.2
+// VERSION: 0.2.3
 // PURPOSE: BitArray library for Arduino
 //     URL: https://github.com/RobTillaart/BitArray
 
 
 // BitArray allows you to make a compact array of objects with a size
 // expressed in bits. typically 1..10.
 // The interface uses uint32_t as that will be enough for most purposes.
-// The main requirement is to optimize storage space
+// The main requirement is to optimize storage space.
 //
-// the bitarray uses an array of segments and the space per segment 
+// The BitArray uses an array of segments and the space per segment 
 // may not exceed 256 bytes as this is a limit on some processors.
 //
 // Originally created to store lot of numbers between 1..6 dice rolls
-// the storage is also usable to store e.g. raw 10 bit analogReads
+// the storage is also usable to store e.g. raw 10 bit analogRead()'s.
 //
 
 #include "Arduino.h"
 
-#define BITARRAY_LIB_VERSION "0.2.2"
+#define BITARRAY_LIB_VERSION      (F("0.2.3"))
 
 
 
@@ -80,6 +80,7 @@ class BitArray
   void     clear();
   uint32_t get(const uint16_t idx);
   uint32_t set(const uint16_t idx, uint32_t value);
+  void     setAll(uint32_t value);
   uint32_t toggle(const uint16_t idx);
 
 private:

libraries/BitArray/README.md

@@ -1,12 +1,16 @@
 
 [![Arduino CI](https://github.com/RobTillaart/BitArray/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)
+[![Arduino-lint](https://github.com/RobTillaart/BitArray/actions/workflows/arduino-lint.yml/badge.svg)](https://github.com/RobTillaart/BitArray/actions/workflows/arduino-lint.yml)
+[![JSON check](https://github.com/RobTillaart/BitArray/actions/workflows/jsoncheck.yml/badge.svg)](https://github.com/RobTillaart/BitArray/actions/workflows/jsoncheck.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/BitArray/blob/master/LICENSE)
 [![GitHub release](https://img.shields.io/github/release/RobTillaart/BitArray.svg?maxAge=3600)](https://github.com/RobTillaart/BitArray/releases)
 
+
 # BitArray
 
 Arduino library for compact array of objects with a size expressed in bits. typically 1..10
 
+
 ## Description
 
 The BitArray class allows the user to instantiate an array of elements, each of the same size in bits.
@@ -20,30 +24,42 @@ can take more time. You need to check if your application needs more performance
 this library can deliver. 
 
 The BitArray library is one from a set of three:
-- BitArray  for elements of user defined size in bits (values 0 .. 2^n-1)
-- BoolArray for elements of 1 bit (values 0 .. 1)
-- nybbleArray for elements of 4 bits (values 0 .. 15)
+- **BitArray** for elements of user defined size in bits (values 0 .. 2^n-1)
+- **BoolArray** for elements of 1 bit (values 0 .. 1)
+- **nybbleArray** for elements of 4 bits (values 0 .. 15)
 
 
 ## Operations
+
 In the function **begin(#elementsize, #elements)** the element size and number of elements 
 needs to be defined. The maximum number of elements is 65535 if memory allows, 
 the maximum element size is 32.
 
 The basic functions of the class are
-- **set(index, value)**
-- **get(index)**
-- **toggle(index)**
+
+- **set(uint16_t index, uint32_t value)**
+- **get(uint16_t index)**
+- **toggle(uint16_t index)**
+- **setAll(uint32_t value)**
 - **clear()**
 
 Check out the examples.
 
+
 ## Notes
 
-The BitArray class dynamicly allocates memory, so called BA_SEGMENTS, 
+The BitArray class allocates dynamic memory, so called BA_SEGMENTS, 
 each of 200 bytes.
 As the memory size of different processors differ the maximum amount of SEGMENTS 
 depends on architecture.
 
 The library is tested on AVR architecture only.
 
+
+## Future
+
+- testing
+- functional examples
+- documentation
+- investigate element size of 64 (for doubles) and beyond.
+

libraries/BitArray/examples/bitArrayDemo0/bitArrayDemo0.ino

@@ -4,21 +4,16 @@
 // VERSION: 0.1.02
 // PURPOSE: demo - store 2000 dice rolls
 //    DATE: 14-11-2015
-//     URL:
-//
-// Released to the public domain
-//
+//     URL: https://github.com/RobTillaart/BitArray
 
-#include "BitArray.h"
 
-//#include "avrheap.h"
+#include "BitArray.h"
 
 #define SAMPLES 2000
 
 BitArray diceRolls;
 int count[7] = { 0, 0, 0, 0, 0, 0, 0 };
 
-//Avrheap myheap;
 
 void setup()
 {
@@ -32,8 +27,6 @@ void setup()
     if (x == BA_NO_MEMORY_ERR) Serial.println("no mem");
     diceRolls.clear();
 
-    // myheap.followHeap();
-
     Serial.print("CAPACITY:\t");
     Serial.println(diceRolls.capacity());
     Serial.print("  MEMORY:\t");
@@ -59,7 +52,6 @@ void setup()
     }
     Serial.println();
 
-    // myheap.followHeap();
 
     Serial.println();
     for (int i = 0; i < SAMPLES; i++)
@@ -107,7 +99,11 @@ void setup()
     Serial.println("\n finish test...\n");
 }
 
+
 void loop()
 {
 }
 
+
+// -- END OF FILE --
+

libraries/BitArray/examples/bitArrayDemo1/bitArrayDemo1.ino

@@ -4,15 +4,14 @@
 // VERSION: 0.1.00
 // PURPOSE: demo
 //    DATE: 14-11-2015
-//     URL:
-//
-// Released to the public domain
-//
+//     URL: https://github.com/RobTillaart/BitArray
+
 
 #include "BitArray.h"
 
 BitArray b;
 
+
 void setup()
 {
   Serial.begin(115200);
@@ -27,6 +26,7 @@ void setup()
   test(4, 3000);   // 16 steps
 }
 
+
 void test(byte bits, uint16_t samples)
 {
   b.begin(bits, samples);
@@ -64,3 +64,6 @@ void loop()
 {
 }
 
+
+// -- END OF FILE --
+