added selection between active-low/active-high

Author: sakabug

README.md

@@ -1,26 +1,40 @@
 ## Bugtton
 Fast button debounce library for ATmega328P. Uses registers instead of digitalRead.
+Library tries to minimize any excess cycle time when buttons are unpressed.
+Individual Active-Low and Active-High.
+
+### Updates
+v1.0.5 you can set individual pins active-low (positive number), or active-high (negative number).
+
+If you have ideas, hit me message or make an issue.
 
 ### Usage In nutshell
-Compact to use.
 ```
 #include <Bugtton.h>
-const uint8_t buttonCount = 5;
-const uint8_t buttonPins[buttonCount] = {2,3,4,5,6};
-Bugtton buttons(buttonCount, buttonPins, INPUT_PULLUP, 25);
---
+
+const uint8_t buttonCount = 6;
+const uint8_t buttonPins[buttonCount] = {2,3,4,-5,6,7,14}; // pin5 with pull down resistor
+Bugtton buttons(buttonCount, buttonPins, 25);
+
+void setup() {
+    Serial.begin(57600);
+    delay(500);
+}
+
 void loop() {
-  buttons.update();
-  
-  if (buttons.fell(0))            //B0 down and debounced
-  if (buttons.heldUntil(1,3000))  //B1 has been pressed 3 seconds
-  --
+    buttons.update();
+    
+    // Testing buttons
+    if (buttons.fell(0))              // Button0 pressed, execute once
+    if (buttons.heldUntil(1,2000))    // Button1 down 2s, execute once
+    if (buttons.intervalTick(2,1000)) // Button2 down, execute once every 1s
+}
 ```
 
 ### Usable functions
 Function|Notes
 :--------|:--------
-**`Bugtton(buttonCount, *pinArray, mode, debounceTime)`**|*Creates button handler*<br>
+**`Bugtton(buttonCount, *pinArray, debounceTime)`**<br>|*Creates button handler*<br>
 **`void setMode(pin, mode)`**<br>|*If you need to set individual pins as INPUT and INPUT_PULLUP*
 **`void debounceTime(time)`**<br>|*If you need to test different debounce times*
 **`void update()`**<br>|*One update to rule them all*
@@ -31,11 +45,9 @@ Function|Notes
 **`bool held(button_i)`**<br>|*Is button_i pressed?*
 **`bool heldUntil(button_i, time)`**<br>|*Returns true ONCE when button_i have been pressed x time*
 **`bool upUntil(button_i, time)`**<br>|*Returns true ONCE when button_i have been unpressed x time*
-**`bool intervalTick(button_i, time)`**|*Returns true ONCE every set interval while button_i pressed*
-
-I use long press functionality alot in my codes, so I wanted to add suitable functions for it. Feel free to suggest new ideas.
+**`bool intervalTick(button_i, time)`**<br>|*Returns true ONCE every set interval while button_i pressed*
 
-### Why this library was made
+### Why another button library?
 Idea was to make fast button library when nothing is pressed so it would affect to the cycle time as little as possible.
 
 Doesn't matter if you have 1 or 18 buttons, update() takes between 3100-3250 microseconds per 1000 update on unpressed buttons -> 3us per loop

examples/Functions/Functions.ino

@@ -0,0 +1,43 @@
+// Functions example using Bugtton - button debounce library.
+// Created by Sami Kaukasalo / sakabug, July 20, 2021.
+
+#include <Bugtton.h>
+
+// Button count and button pin array
+// Default is Active-Low with pinMode INPUT_PULLUP
+// Negative pin number is Active-High with pinMode INPUT
+const uint8_t buttonCount = 6;
+const uint8_t buttonPins[buttonCount] = {2,-3,4,5,6,7}; // pin 3 on pull down resistor
+Bugtton buttons(buttonCount, buttonPins, 100);
+
+void setup() {
+    Serial.begin(57600);
+    delay(500);
+    buttons.debounceTime(25);   // Changing debounce time
+    buttons.setMode(7, INPUT);  // Setting pinMode INPUT for pull down resistor
+}
+
+void loop() {
+    buttons.update();
+    // Print every fell/rose
+    for (uint8_t i=0; i<buttonCount; i++){
+        if (buttons.fell(i)) {
+            Serial.print("B");
+            Serial.print(i);
+            Serial.println(" fell");
+        }
+        if (buttons.rose(i)){
+            Serial.print("B");
+            Serial.print(i);
+            Serial.println(" rose");
+        }
+    }
+    if (buttons.heldUntil(2,3000)) Serial.println("B1 held for 3s. Mode activated.");
+    if (buttons.held(3) && buttons.duration(3) >= 2000) Serial.println("Push it, baby");
+    if (buttons.intervalTick(4,1000)) {
+        Serial.print("B4 held for ");
+        Serial.print(buttons.duration(4)/1000);
+        Serial.println("s");
+    }
+    if (buttons.upUntil(5, 5000)) Serial.println("B5 haven't been pressed in 5s");
+}

examples/Multibutton/Multibutton.ino

@@ -0,0 +1,36 @@
+// Simple example using Bugtton - button debounce library.
+// Created by Sami Kaukasalo / sakabug, July 20, 2021.
+
+#include <Bugtton.h>
+
+// Button count and button pin array
+// Default is Active-Low with pinMode INPUT_PULLUP
+// Negative pin number is Active-High with pinMode INPUT
+const uint8_t buttonCount = 18;
+const uint8_t buttonPins[buttonCount] = {2,3,4,-5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+Bugtton buttons(buttonCount, buttonPins, 25);
+
+void setup() {
+    Serial.begin(57600);
+    delay(500);
+}
+
+void loop() {
+    
+    // Update button states handler
+    buttons.update();
+    
+    // Testing buttons
+    for (uint8_t i=0; i<buttonCount; i++){
+        if (buttons.fell(i)) {
+            Serial.print("B");
+            Serial.print(i);
+            Serial.println(" fell");
+        }
+        if (buttons.rose(i)){
+            Serial.print("B");
+            Serial.print(i);
+            Serial.println(" rose");
+        }
+    }
+}

examples/Simple/Simple.ino

@@ -1,9 +1,9 @@
 name=Bugtton
-version=1.0.4
+version=1.0.5
 author=Sami Kaukasalo <[email protected]>
 maintainer=Sami Kaukasalo <[email protected]>
 sentence=Fast button debounce library for ATmega328P. Uses registers instead of digitalRead.
-paragraph=It's fast and I want it faster.
+paragraph=Library tries to minimize any excess cycle time when buttons are unpressed. Individual Active-Low and Active-High.
 category=Signal Input/Output
 url=https://github.com/sakabug/Bugtton
 architectures=avr

library.properties

@@ -5,7 +5,6 @@
 // It's fast and I want it faster.
 
 // Created by Sami Kaukasalo / sakabug, July 20, 2021.
-// Updated 9.12.2021
 
 // MIT License
 
@@ -32,26 +31,38 @@
 #include "Bugtton.h"
 
 // Bugtton buttons(buttonCount, buttonPins(array), INPUT/INPUT_PULLUP, debounce time)
-Bugtton::Bugtton(const uint8_t a, const uint8_t *b, uint8_t mode, uint8_t dt){
+Bugtton::Bugtton(const uint8_t a, const uint8_t *b, uint8_t dt){
     // Init values
     _maskD = B00000000;
     _maskB = B00000000;
     _maskC = B00000000;
+    _idleD = B00000000;
+    _idleB = B00000000;
+    _idleC = B00000000;
     _count = a;
     _debounceTime = dt;
     _allStable = false;
     _flag1 = false;
 
-    // Create buttons (was first separate classes, but this is the way I went)
+    // Create buttons
     _pins = new uint8_t[_count];
     _bits = new uint8_t[_count];
     _stateStarted = new uint32_t[_count];
     _ticksStarted = new uint32_t[_count];
     // Init button data
     for(uint8_t i=0; i<_count; i++){
-        setMode(b[i], mode);
-        _pins[i] = b[i];
-        _bits[i] = B11100000;
+        // If pin # negative, it's inverted pin
+        int8_t pin = b[i];
+        if(pin<0){
+            pin *= -1;
+            _bits[i] = B11100001;
+            setMode(pin, INPUT);
+        }
+        else{
+            _bits[i] = B11100000;
+            setMode(pin, INPUT_PULLUP);
+        }
+        _pins[i] = pin;
         _stateStarted[i] = 0;
         _ticksStarted[i] = 0;
     }
@@ -60,12 +71,30 @@ Bugtton::Bugtton(const uint8_t a, const uint8_t *b, uint8_t mode, uint8_t dt){
     makeMasks();
 }
 
-// Bitmask for registers, formed from pin array
+// Bitmask for registers, formed from pin array, mark active registers
 void Bugtton::makeMasks(){
     for (uint8_t i=0; i<_count; i++){
-        if (_pins[i] < 8) bitWrite(_maskD, _pins[i], 1);
-        else if (_pins[i] >= 8 && _pins[i] < 14) bitWrite(_maskB, (_pins[i]-8), 1);
-        else if (_pins[i] >= 14 && _pins[i] < 20) bitWrite(_maskC, (_pins[i]-14), 1);
+        if (_pins[i] < 8) {
+            // Write to maskD   (active buttons)
+            bitWrite(_maskD, _pins[i], 1);
+            // Write to idleD  (button idle state)
+            if (flippedBit(i)) bitWrite(_idleD, _pins[i], 0);
+            else bitWrite(_idleD, _pins[i], 1);
+        }
+        else if (_pins[i] >= 8 && _pins[i] < 14) {
+            // Write to maskB (active buttons)
+            bitWrite(_maskB, (_pins[i]-8), 1);
+            // Write to idleB  (button idle state)
+            if (flippedBit(i)) bitWrite(_idleB, (_pins[i]-8), 0);
+            else bitWrite(_idleB, (_pins[i]-8), 1);
+        }
+        else if (_pins[i] >= 14 && _pins[i] < 20) {
+            // Write to maskC (active buttons)
+            bitWrite(_maskC, (_pins[i]-14), 1);
+            // Write to idleC  (button idle state)
+            if (flippedBit(i)) bitWrite(_idleC, (_pins[i]-14), 0);
+            else bitWrite(_idleC, (_pins[i]-14), 1);
+        }
     }
 }
 
@@ -79,14 +108,14 @@ void Bugtton::printBIN(uint8_t b){
 // If you need set debounce time with code, THIS IS set at constructor
 void Bugtton::debounceTime(uint16_t a){ _debounceTime = a; }
 
-// Updates all buttons at once, needs to run only once in loop, this is what I wanted
+// Updates all buttons at once, needs to run only once in loop
 void Bugtton::update(){
-    _allUp = false;
     if (_allStable){
-        if ((_maskD == (PIND&_maskD)) &&
-            (_maskB == (PINB&_maskB)) &&
-            (_maskC == (PINC&_maskC)) ){
-            // if no buttons down, and buttons states are stable
+        // Buttons unpressed?
+        if ((_idleD == (PIND&_maskD)) &&
+            (_idleB == (PINB&_maskB)) &&
+            (_idleC == (PINC&_maskC)) ){
+            // Let function run once, then keep skipping until changes in registers
             if (_flag1) {
                 return;
             }
@@ -95,21 +124,25 @@ void Bugtton::update(){
     }
     //Update bits
     for (uint8_t i=0; i<_count; i++){
-        
         // Reset changedBit
         changedBit(i, 0);
-        
-        // Update currentBit from registers
-        if (_pins[i] < 8) currentBit(i, PIND&(1<<_pins[i]) );
-        else if (_pins[i] < 14) currentBit(i, PINB&(1<<(_pins[i]-8) ));
-        else if (_pins[i] < 20) currentBit(i, PINC&(1<<(_pins[i]-14) ));
-        
+        // Active low (pull up)
+        if ((_bits[i]&B00000001) == B00000000){
+            if (_pins[i] < 8)       currentBit(i, PIND&(1<<_pins[i]) );
+            else if (_pins[i] < 14) currentBit(i, PINB&(1<<(_pins[i]-8) ));
+            else if (_pins[i] < 20) currentBit(i, PINC&(1<<(_pins[i]-14) ));
+        }
+        // Active high (pull down)
+        else{
+            if (_pins[i] < 8)       currentBit(i, !(PIND&(1<<_pins[i])) );
+            else if (_pins[i] < 14) currentBit(i, !(PINB&(1<<(_pins[i]-8)) ));
+            else if (_pins[i] < 20) currentBit(i, !(PINC&(1<<(_pins[i]-14)) ));
+        }
         //No change in button state
         if ( currentBit(i) == oldBit(i)){
           stableBit(i, 1);
           _allStable = true;
         }
-        
         //Change in button state
         else {
             _allStable = false;
@@ -145,6 +178,8 @@ void Bugtton::heldUntilUsed(uint8_t i, bool a) { bitWrite(_bits[i], 3, a); }
 bool Bugtton::heldUntilUsed(uint8_t i)      { return bitRead(_bits[i], 3); }
 void Bugtton::tickBit(uint8_t i, bool a)    { bitWrite(_bits[i], 2, a); }
 bool Bugtton::tickBit(uint8_t i)            { return bitRead(_bits[i], 2); }
+void Bugtton::flippedBit(uint8_t i, bool a) { bitWrite(_bits[i], 0, a); }
+bool Bugtton::flippedBit(uint8_t i)         { return bitRead(_bits[i], 0); }
 
 // Timestamps for debounce, and duration function
 void Bugtton::stateStarted(uint8_t i, uint32_t a){ _stateStarted[i] = a; }
@@ -246,8 +281,3 @@ bool Bugtton::intervalTick(uint8_t i, uint32_t t){
     }
     return false;
 }
-
-
-
-
-