v2.0.6 - Change register enum to avoid clash with ESP32 v2.0.4

PaulZC · PaulZC · commit 52287080ba32 · 2022-07-12T09:54:58.000+01:00
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=SparkFun Qwiic Button and Qwiic Switch Library
-version=2.0.5
+version=2.0.6
 author=SparkFun Electronics <techsupport@sparkfun.com>
 maintainer=Fischer Moseley <fischer.moseley@sparkfun.com>
 sentence=Communicates and configures the SparkFun Qwiic Button and Switch.
diff --git a/src/SparkFun_Qwiic_Button.cpp b/src/SparkFun_Qwiic_Button.cpp
@@ -48,32 +48,29 @@ bool QwiicButton::isConnected()
 
 uint8_t QwiicButton::deviceID()
 {
-    return readSingleRegister(ID); //read and return the value in the ID register
+    return readSingleRegister(SFE_QWIIC_BUTTON_ID); //read and return the value in the ID register
 }
 
 bool QwiicButton::checkDeviceID()
 {
-    // return ((deviceID() == DEV_ID_SW) || (deviceID() == DEV_ID_BTN)); //Return true if the device ID matches either the button or the switch
-    return (deviceID() == DEV_ID); //Return true if the device ID matches
+    return (deviceID() == SFE_QWIIC_BUTTON_DEV_ID); //Return true if the device ID matches
 }
 
 uint8_t QwiicButton::getDeviceType()
 {
     if (isConnected())
     { //only try to get the device ID if the device will acknowledge
         uint8_t id = deviceID();
-        if (id == DEV_ID)
+        if (id == SFE_QWIIC_BUTTON_DEV_ID)
             return 1;
-        // if (id == DEV_ID_SW)
-        //     return 2;
     }
     return 0;
 }
 
 uint16_t QwiicButton::getFirmwareVersion()
 {
-    uint16_t version = (readSingleRegister(FIRMWARE_MAJOR)) << 8;
-    version |= readSingleRegister(FIRMWARE_MINOR);
+    uint16_t version = (readSingleRegister(SFE_QWIIC_BUTTON_FIRMWARE_MAJOR)) << 8;
+    version |= readSingleRegister(SFE_QWIIC_BUTTON_FIRMWARE_MINOR);
     return version;
 }
 
@@ -85,7 +82,7 @@ bool QwiicButton::setI2Caddress(uint8_t address)
         return 1; //error immediately if the address is out of legal range
     }
 
-    bool success = writeSingleRegister(I2C_ADDRESS, address);
+    bool success = writeSingleRegister(SFE_QWIIC_BUTTON_I2C_ADDRESS, address);
 
     if (success == true)
     {
@@ -109,122 +106,122 @@ uint8_t QwiicButton::getI2Caddress()
 bool QwiicButton::isPressed()
 {
     statusRegisterBitField statusRegister;
-    statusRegister.byteWrapped = readSingleRegister(BUTTON_STATUS);
+    statusRegister.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);
     return statusRegister.isPressed;
 }
 
 bool QwiicButton::hasBeenClicked()
 {
     statusRegisterBitField statusRegister;
-    statusRegister.byteWrapped = readSingleRegister(BUTTON_STATUS);
+    statusRegister.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);
     return statusRegister.hasBeenClicked;
 }
 
 uint16_t QwiicButton::getDebounceTime()
 {
-    return readDoubleRegister(BUTTON_DEBOUNCE_TIME);
+    return readDoubleRegister(SFE_QWIIC_BUTTON_BUTTON_DEBOUNCE_TIME);
 }
 
 uint8_t QwiicButton::setDebounceTime(uint16_t time)
 {
-    return writeDoubleRegisterWithReadback(BUTTON_DEBOUNCE_TIME, time);
+    return writeDoubleRegisterWithReadback(SFE_QWIIC_BUTTON_BUTTON_DEBOUNCE_TIME, time);
 }
 
 /*------------------- Interrupt Status/Configuration ---------------- */
 uint8_t QwiicButton::enablePressedInterrupt()
 {
     interruptConfigBitField interruptConfigure;
-    interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);
+    interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);
     interruptConfigure.pressedEnable = 1;
-    return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
 }
 
 uint8_t QwiicButton::disablePressedInterrupt()
 {
     interruptConfigBitField interruptConfigure;
-    interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);
+    interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);
     interruptConfigure.pressedEnable = 0;
-    return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
 }
 
 uint8_t QwiicButton::enableClickedInterrupt()
 {
     interruptConfigBitField interruptConfigure;
-    interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);
+    interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);
     interruptConfigure.clickedEnable = 1;
-    return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
 }
 
 uint8_t QwiicButton::disableClickedInterrupt()
 {
     interruptConfigBitField interruptConfigure;
-    interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);
+    interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);
     interruptConfigure.clickedEnable = 0;
-    return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
 }
 
 bool QwiicButton::available()
 {
     statusRegisterBitField buttonStatus;
-    buttonStatus.byteWrapped = readSingleRegister(BUTTON_STATUS);
+    buttonStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);
     return buttonStatus.eventAvailable;
 }
 
 uint8_t QwiicButton::clearEventBits()
 {
     statusRegisterBitField buttonStatus;
-    buttonStatus.byteWrapped = readSingleRegister(BUTTON_STATUS);
+    buttonStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);
     buttonStatus.isPressed = 0;
     buttonStatus.hasBeenClicked = 0;
     buttonStatus.eventAvailable = 0;
-    return writeSingleRegisterWithReadback(BUTTON_STATUS, buttonStatus.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_BUTTON_STATUS, buttonStatus.byteWrapped);
 }
 
 uint8_t QwiicButton::resetInterruptConfig()
 {
     interruptConfigBitField interruptConfigure;
     interruptConfigure.pressedEnable = 1;
     interruptConfigure.clickedEnable = 1;
-    return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);
     statusRegisterBitField buttonStatus;
     buttonStatus.eventAvailable = 0;
-    return writeSingleRegisterWithReadback(BUTTON_STATUS, buttonStatus.byteWrapped);
+    return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_BUTTON_STATUS, buttonStatus.byteWrapped);
 }
 
 /*------------------------- Queue Manipulation ---------------------- */
 //pressed queue manipulation
 bool QwiicButton::isPressedQueueFull()
 {
     queueStatusBitField pressedQueueStatus;
-    pressedQueueStatus.byteWrapped = readSingleRegister(PRESSED_QUEUE_STATUS);
+    pressedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS);
     return pressedQueueStatus.isFull;
 }
 
 bool QwiicButton::isPressedQueueEmpty()
 {
     queueStatusBitField pressedQueueStatus;
-    pressedQueueStatus.byteWrapped = readSingleRegister(PRESSED_QUEUE_STATUS);
+    pressedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS);
     return pressedQueueStatus.isEmpty;
 }
 
 unsigned long QwiicButton::timeSinceLastPress()
 {
-    return readQuadRegister(PRESSED_QUEUE_FRONT);
+    return readQuadRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_FRONT);
 }
 
 unsigned long QwiicButton::timeSinceFirstPress()
 {
-    return readQuadRegister(PRESSED_QUEUE_BACK);
+    return readQuadRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_BACK);
 }
 
 unsigned long QwiicButton::popPressedQueue()
 {
     unsigned long tempData = timeSinceFirstPress(); //grab the oldest value on the queue
 
     queueStatusBitField pressedQueueStatus;
-    pressedQueueStatus.byteWrapped = readSingleRegister(PRESSED_QUEUE_STATUS);
+    pressedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS);
     pressedQueueStatus.popRequest = 1;
-    writeSingleRegister(PRESSED_QUEUE_STATUS, pressedQueueStatus.byteWrapped); //remove the oldest value from the queue
+    writeSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS, pressedQueueStatus.byteWrapped); //remove the oldest value from the queue
 
     return tempData; //return the value we popped
 }
@@ -233,44 +230,44 @@ unsigned long QwiicButton::popPressedQueue()
 bool QwiicButton::isClickedQueueFull()
 {
     queueStatusBitField clickedQueueStatus;
-    clickedQueueStatus.byteWrapped = readSingleRegister(CLICKED_QUEUE_STATUS);
+    clickedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS);
     return clickedQueueStatus.isFull;
 }
 
 bool QwiicButton::isClickedQueueEmpty()
 {
     queueStatusBitField clickedQueueStatus;
-    clickedQueueStatus.byteWrapped = readSingleRegister(CLICKED_QUEUE_STATUS);
+    clickedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS);
     return clickedQueueStatus.isEmpty;
 }
 
 unsigned long QwiicButton::timeSinceLastClick()
 {
-    return readQuadRegister(CLICKED_QUEUE_FRONT);
+    return readQuadRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_FRONT);
 }
 
 unsigned long QwiicButton::timeSinceFirstClick()
 {
-    return readQuadRegister(CLICKED_QUEUE_BACK);
+    return readQuadRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_BACK);
 }
 
 unsigned long QwiicButton::popClickedQueue()
 {
     unsigned long tempData = timeSinceFirstClick();
     queueStatusBitField clickedQueueStatus;
-    clickedQueueStatus.byteWrapped = readSingleRegister(CLICKED_QUEUE_STATUS);
+    clickedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS);
     clickedQueueStatus.popRequest = 1;
-    writeSingleRegister(CLICKED_QUEUE_STATUS, clickedQueueStatus.byteWrapped);
+    writeSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS, clickedQueueStatus.byteWrapped);
     return tempData;
 }
 
 /*------------------------ LED Configuration ------------------------ */
 bool QwiicButton::LEDconfig(uint8_t brightness, uint16_t cycleTime, uint16_t offTime, uint8_t granularity)
 {
-    bool success = writeSingleRegister(LED_BRIGHTNESS, brightness);
-    success &= writeSingleRegister(LED_PULSE_GRANULARITY, granularity);
-    success &= writeDoubleRegister(LED_PULSE_CYCLE_TIME, cycleTime);
-    success &= writeDoubleRegister(LED_PULSE_OFF_TIME, offTime);
+    bool success = writeSingleRegister(SFE_QWIIC_BUTTON_LED_BRIGHTNESS, brightness);
+    success &= writeSingleRegister(SFE_QWIIC_BUTTON_LED_PULSE_GRANULARITY, granularity);
+    success &= writeDoubleRegister(SFE_QWIIC_BUTTON_LED_PULSE_CYCLE_TIME, cycleTime);
+    success &= writeDoubleRegister(SFE_QWIIC_BUTTON_LED_PULSE_OFF_TIME, offTime);
     return success;
 }
 
diff --git a/src/SparkFun_Qwiic_Button.h b/src/SparkFun_Qwiic_Button.h
@@ -26,8 +26,8 @@ Distributed as-is; no warranty is given.
 #include <Arduino.h>
 #include "registers.h"
 
-#define DEFAULT_QWIIC_BUTTON_ADDRESS 0x6F //default I2C address of the button
-#define DEV_ID 0x5D          //device ID of the Qwiic Button
+#define SFE_QWIIC_BUTTON_DEFAULT_ADDRESS 0x6F //default I2C address of the button
+#define SFE_QWIIC_BUTTON_DEV_ID 0x5D          //device ID of the Qwiic Button
 
 class QwiicButton
 {
@@ -37,7 +37,7 @@ class QwiicButton
 
 public:
     //Device status
-    bool begin(uint8_t address = DEFAULT_QWIIC_BUTTON_ADDRESS, TwoWire &wirePort = Wire); //Sets device I2C address to a user-specified address, over whatever port the user specifies.
+    bool begin(uint8_t address = SFE_QWIIC_BUTTON_DEFAULT_ADDRESS, TwoWire &wirePort = Wire); //Sets device I2C address to a user-specified address, over whatever port the user specifies.
     bool isConnected();                                                      //Returns true if the button/switch will acknowledge over I2C, and false otherwise
     uint8_t deviceID();                                                      //Return the 8-bit device ID of the attached device.
     bool checkDeviceID();                                                    //Returns true if the device ID matches that of either the button or the switch
diff --git a/src/registers.h b/src/registers.h
@@ -23,23 +23,23 @@ Distributed as-is; no warranty is given.
 //Register Pointer Map
 enum Qwiic_Button_Register : uint8_t
 {
-    ID = 0x00,
-    FIRMWARE_MINOR = 0x01,
-    FIRMWARE_MAJOR = 0x02,
-    BUTTON_STATUS = 0x03,
-    INTERRUPT_CONFIG = 0x04,
-    BUTTON_DEBOUNCE_TIME = 0x05,
-    PRESSED_QUEUE_STATUS = 0x07,
-    PRESSED_QUEUE_FRONT = 0x08,
-    PRESSED_QUEUE_BACK = 0x0C,
-    CLICKED_QUEUE_STATUS = 0x10,
-    CLICKED_QUEUE_FRONT = 0x11,
-    CLICKED_QUEUE_BACK = 0x15,
-    LED_BRIGHTNESS = 0x19,
-    LED_PULSE_GRANULARITY = 0x1A,
-    LED_PULSE_CYCLE_TIME = 0x1B,
-    LED_PULSE_OFF_TIME = 0x1D,
-    I2C_ADDRESS = 0x1F,
+    SFE_QWIIC_BUTTON_ID = 0x00,
+    SFE_QWIIC_BUTTON_FIRMWARE_MINOR = 0x01,
+    SFE_QWIIC_BUTTON_FIRMWARE_MAJOR = 0x02,
+    SFE_QWIIC_BUTTON_BUTTON_STATUS = 0x03,
+    SFE_QWIIC_BUTTON_INTERRUPT_CONFIG = 0x04,
+    SFE_QWIIC_BUTTON_BUTTON_DEBOUNCE_TIME = 0x05,
+    SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS = 0x07,
+    SFE_QWIIC_BUTTON_PRESSED_QUEUE_FRONT = 0x08,
+    SFE_QWIIC_BUTTON_PRESSED_QUEUE_BACK = 0x0C,
+    SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS = 0x10,
+    SFE_QWIIC_BUTTON_CLICKED_QUEUE_FRONT = 0x11,
+    SFE_QWIIC_BUTTON_CLICKED_QUEUE_BACK = 0x15,
+    SFE_QWIIC_BUTTON_LED_BRIGHTNESS = 0x19,
+    SFE_QWIIC_BUTTON_LED_PULSE_GRANULARITY = 0x1A,
+    SFE_QWIIC_BUTTON_LED_PULSE_CYCLE_TIME = 0x1B,
+    SFE_QWIIC_BUTTON_LED_PULSE_OFF_TIME = 0x1D,
+    SFE_QWIIC_BUTTON_I2C_ADDRESS = 0x1F,
 };
 
 typedef union {

Original file line number	Diff line number	Diff line change
`@@ -48,32 +48,29 @@ bool QwiicButton::isConnected()`
`48`	`48`
`49`	`49`	`uint8_t QwiicButton::deviceID()`
`50`	`50`	`{`
`51`		`- return readSingleRegister(ID); //read and return the value in the ID register`
	`51`	`+ return readSingleRegister(SFE_QWIIC_BUTTON_ID); //read and return the value in the ID register`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`bool QwiicButton::checkDeviceID()`
`55`	`55`	`{`
`56`		`- // return ((deviceID() == DEV_ID_SW) \|\| (deviceID() == DEV_ID_BTN)); //Return true if the device ID matches either the button or the switch`
`57`		`- return (deviceID() == DEV_ID); //Return true if the device ID matches`
	`56`	`+ return (deviceID() == SFE_QWIIC_BUTTON_DEV_ID); //Return true if the device ID matches`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`uint8_t QwiicButton::getDeviceType()`
`61`	`60`	`{`
`62`	`61`	`if (isConnected())`
`63`	`62`	`{ //only try to get the device ID if the device will acknowledge`
`64`	`63`	`uint8_t id = deviceID();`
`65`		`- if (id == DEV_ID)`
	`64`	`+ if (id == SFE_QWIIC_BUTTON_DEV_ID)`
`66`	`65`	`return 1;`
`67`		`- // if (id == DEV_ID_SW)`
`68`		`- // return 2;`
`69`	`66`	`}`
`70`	`67`	`return 0;`
`71`	`68`	`}`
`72`	`69`
`73`	`70`	`uint16_t QwiicButton::getFirmwareVersion()`
`74`	`71`	`{`
`75`		`- uint16_t version = (readSingleRegister(FIRMWARE_MAJOR)) << 8;`
`76`		`- version \|= readSingleRegister(FIRMWARE_MINOR);`
	`72`	`+ uint16_t version = (readSingleRegister(SFE_QWIIC_BUTTON_FIRMWARE_MAJOR)) << 8;`
	`73`	`+ version \|= readSingleRegister(SFE_QWIIC_BUTTON_FIRMWARE_MINOR);`
`77`	`74`	`return version;`
`78`	`75`	`}`
`79`	`76`
`@@ -85,7 +82,7 @@ bool QwiicButton::setI2Caddress(uint8_t address)`
`85`	`82`	`return 1; //error immediately if the address is out of legal range`
`86`	`83`	`}`
`87`	`84`
`88`		`- bool success = writeSingleRegister(I2C_ADDRESS, address);`
	`85`	`+ bool success = writeSingleRegister(SFE_QWIIC_BUTTON_I2C_ADDRESS, address);`
`89`	`86`
`90`	`87`	`if (success == true)`
`91`	`88`	`{`
`@@ -109,122 +106,122 @@ uint8_t QwiicButton::getI2Caddress()`
`109`	`106`	`bool QwiicButton::isPressed()`
`110`	`107`	`{`
`111`	`108`	`statusRegisterBitField statusRegister;`
`112`		`- statusRegister.byteWrapped = readSingleRegister(BUTTON_STATUS);`
	`109`	`+ statusRegister.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);`
`113`	`110`	`return statusRegister.isPressed;`
`114`	`111`	`}`
`115`	`112`
`116`	`113`	`bool QwiicButton::hasBeenClicked()`
`117`	`114`	`{`
`118`	`115`	`statusRegisterBitField statusRegister;`
`119`		`- statusRegister.byteWrapped = readSingleRegister(BUTTON_STATUS);`
	`116`	`+ statusRegister.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);`
`120`	`117`	`return statusRegister.hasBeenClicked;`
`121`	`118`	`}`
`122`	`119`
`123`	`120`	`uint16_t QwiicButton::getDebounceTime()`
`124`	`121`	`{`
`125`		`- return readDoubleRegister(BUTTON_DEBOUNCE_TIME);`
	`122`	`+ return readDoubleRegister(SFE_QWIIC_BUTTON_BUTTON_DEBOUNCE_TIME);`
`126`	`123`	`}`
`127`	`124`
`128`	`125`	`uint8_t QwiicButton::setDebounceTime(uint16_t time)`
`129`	`126`	`{`
`130`		`- return writeDoubleRegisterWithReadback(BUTTON_DEBOUNCE_TIME, time);`
	`127`	`+ return writeDoubleRegisterWithReadback(SFE_QWIIC_BUTTON_BUTTON_DEBOUNCE_TIME, time);`
`131`	`128`	`}`
`132`	`129`
`133`	`130`	`/------------------- Interrupt Status/Configuration ---------------- /`
`134`	`131`	`uint8_t QwiicButton::enablePressedInterrupt()`
`135`	`132`	`{`
`136`	`133`	`interruptConfigBitField interruptConfigure;`
`137`		`- interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);`
	`134`	`+ interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);`
`138`	`135`	`interruptConfigure.pressedEnable = 1;`
`139`		`- return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
	`136`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
`140`	`137`	`}`
`141`	`138`
`142`	`139`	`uint8_t QwiicButton::disablePressedInterrupt()`
`143`	`140`	`{`
`144`	`141`	`interruptConfigBitField interruptConfigure;`
`145`		`- interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);`
	`142`	`+ interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);`
`146`	`143`	`interruptConfigure.pressedEnable = 0;`
`147`		`- return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
	`144`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
`148`	`145`	`}`
`149`	`146`
`150`	`147`	`uint8_t QwiicButton::enableClickedInterrupt()`
`151`	`148`	`{`
`152`	`149`	`interruptConfigBitField interruptConfigure;`
`153`		`- interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);`
	`150`	`+ interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);`
`154`	`151`	`interruptConfigure.clickedEnable = 1;`
`155`		`- return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
	`152`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
`156`	`153`	`}`
`157`	`154`
`158`	`155`	`uint8_t QwiicButton::disableClickedInterrupt()`
`159`	`156`	`{`
`160`	`157`	`interruptConfigBitField interruptConfigure;`
`161`		`- interruptConfigure.byteWrapped = readSingleRegister(INTERRUPT_CONFIG);`
	`158`	`+ interruptConfigure.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG);`
`162`	`159`	`interruptConfigure.clickedEnable = 0;`
`163`		`- return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
	`160`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
`164`	`161`	`}`
`165`	`162`
`166`	`163`	`bool QwiicButton::available()`
`167`	`164`	`{`
`168`	`165`	`statusRegisterBitField buttonStatus;`
`169`		`- buttonStatus.byteWrapped = readSingleRegister(BUTTON_STATUS);`
	`166`	`+ buttonStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);`
`170`	`167`	`return buttonStatus.eventAvailable;`
`171`	`168`	`}`
`172`	`169`
`173`	`170`	`uint8_t QwiicButton::clearEventBits()`
`174`	`171`	`{`
`175`	`172`	`statusRegisterBitField buttonStatus;`
`176`		`- buttonStatus.byteWrapped = readSingleRegister(BUTTON_STATUS);`
	`173`	`+ buttonStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_BUTTON_STATUS);`
`177`	`174`	`buttonStatus.isPressed = 0;`
`178`	`175`	`buttonStatus.hasBeenClicked = 0;`
`179`	`176`	`buttonStatus.eventAvailable = 0;`
`180`		`- return writeSingleRegisterWithReadback(BUTTON_STATUS, buttonStatus.byteWrapped);`
	`177`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_BUTTON_STATUS, buttonStatus.byteWrapped);`
`181`	`178`	`}`
`182`	`179`
`183`	`180`	`uint8_t QwiicButton::resetInterruptConfig()`
`184`	`181`	`{`
`185`	`182`	`interruptConfigBitField interruptConfigure;`
`186`	`183`	`interruptConfigure.pressedEnable = 1;`
`187`	`184`	`interruptConfigure.clickedEnable = 1;`
`188`		`- return writeSingleRegisterWithReadback(INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
	`185`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_INTERRUPT_CONFIG, interruptConfigure.byteWrapped);`
`189`	`186`	`statusRegisterBitField buttonStatus;`
`190`	`187`	`buttonStatus.eventAvailable = 0;`
`191`		`- return writeSingleRegisterWithReadback(BUTTON_STATUS, buttonStatus.byteWrapped);`
	`188`	`+ return writeSingleRegisterWithReadback(SFE_QWIIC_BUTTON_BUTTON_STATUS, buttonStatus.byteWrapped);`
`192`	`189`	`}`
`193`	`190`
`194`	`191`	`/------------------------- Queue Manipulation ---------------------- /`
`195`	`192`	`//pressed queue manipulation`
`196`	`193`	`bool QwiicButton::isPressedQueueFull()`
`197`	`194`	`{`
`198`	`195`	`queueStatusBitField pressedQueueStatus;`
`199`		`- pressedQueueStatus.byteWrapped = readSingleRegister(PRESSED_QUEUE_STATUS);`
	`196`	`+ pressedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS);`
`200`	`197`	`return pressedQueueStatus.isFull;`
`201`	`198`	`}`
`202`	`199`
`203`	`200`	`bool QwiicButton::isPressedQueueEmpty()`
`204`	`201`	`{`
`205`	`202`	`queueStatusBitField pressedQueueStatus;`
`206`		`- pressedQueueStatus.byteWrapped = readSingleRegister(PRESSED_QUEUE_STATUS);`
	`203`	`+ pressedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS);`
`207`	`204`	`return pressedQueueStatus.isEmpty;`
`208`	`205`	`}`
`209`	`206`
`210`	`207`	`unsigned long QwiicButton::timeSinceLastPress()`
`211`	`208`	`{`
`212`		`- return readQuadRegister(PRESSED_QUEUE_FRONT);`
	`209`	`+ return readQuadRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_FRONT);`
`213`	`210`	`}`
`214`	`211`
`215`	`212`	`unsigned long QwiicButton::timeSinceFirstPress()`
`216`	`213`	`{`
`217`		`- return readQuadRegister(PRESSED_QUEUE_BACK);`
	`214`	`+ return readQuadRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_BACK);`
`218`	`215`	`}`
`219`	`216`
`220`	`217`	`unsigned long QwiicButton::popPressedQueue()`
`221`	`218`	`{`
`222`	`219`	`unsigned long tempData = timeSinceFirstPress(); //grab the oldest value on the queue`
`223`	`220`
`224`	`221`	`queueStatusBitField pressedQueueStatus;`
`225`		`- pressedQueueStatus.byteWrapped = readSingleRegister(PRESSED_QUEUE_STATUS);`
	`222`	`+ pressedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS);`
`226`	`223`	`pressedQueueStatus.popRequest = 1;`
`227`		`- writeSingleRegister(PRESSED_QUEUE_STATUS, pressedQueueStatus.byteWrapped); //remove the oldest value from the queue`
	`224`	`+ writeSingleRegister(SFE_QWIIC_BUTTON_PRESSED_QUEUE_STATUS, pressedQueueStatus.byteWrapped); //remove the oldest value from the queue`
`228`	`225`
`229`	`226`	`return tempData; //return the value we popped`
`230`	`227`	`}`
`@@ -233,44 +230,44 @@ unsigned long QwiicButton::popPressedQueue()`
`233`	`230`	`bool QwiicButton::isClickedQueueFull()`
`234`	`231`	`{`
`235`	`232`	`queueStatusBitField clickedQueueStatus;`
`236`		`- clickedQueueStatus.byteWrapped = readSingleRegister(CLICKED_QUEUE_STATUS);`
	`233`	`+ clickedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS);`
`237`	`234`	`return clickedQueueStatus.isFull;`
`238`	`235`	`}`
`239`	`236`
`240`	`237`	`bool QwiicButton::isClickedQueueEmpty()`
`241`	`238`	`{`
`242`	`239`	`queueStatusBitField clickedQueueStatus;`
`243`		`- clickedQueueStatus.byteWrapped = readSingleRegister(CLICKED_QUEUE_STATUS);`
	`240`	`+ clickedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS);`
`244`	`241`	`return clickedQueueStatus.isEmpty;`
`245`	`242`	`}`
`246`	`243`
`247`	`244`	`unsigned long QwiicButton::timeSinceLastClick()`
`248`	`245`	`{`
`249`		`- return readQuadRegister(CLICKED_QUEUE_FRONT);`
	`246`	`+ return readQuadRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_FRONT);`
`250`	`247`	`}`
`251`	`248`
`252`	`249`	`unsigned long QwiicButton::timeSinceFirstClick()`
`253`	`250`	`{`
`254`		`- return readQuadRegister(CLICKED_QUEUE_BACK);`
	`251`	`+ return readQuadRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_BACK);`
`255`	`252`	`}`
`256`	`253`
`257`	`254`	`unsigned long QwiicButton::popClickedQueue()`
`258`	`255`	`{`
`259`	`256`	`unsigned long tempData = timeSinceFirstClick();`
`260`	`257`	`queueStatusBitField clickedQueueStatus;`
`261`		`- clickedQueueStatus.byteWrapped = readSingleRegister(CLICKED_QUEUE_STATUS);`
	`258`	`+ clickedQueueStatus.byteWrapped = readSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS);`
`262`	`259`	`clickedQueueStatus.popRequest = 1;`
`263`		`- writeSingleRegister(CLICKED_QUEUE_STATUS, clickedQueueStatus.byteWrapped);`
	`260`	`+ writeSingleRegister(SFE_QWIIC_BUTTON_CLICKED_QUEUE_STATUS, clickedQueueStatus.byteWrapped);`
`264`	`261`	`return tempData;`
`265`	`262`	`}`
`266`	`263`
`267`	`264`	`/------------------------ LED Configuration ------------------------ /`
`268`	`265`	`bool QwiicButton::LEDconfig(uint8_t brightness, uint16_t cycleTime, uint16_t offTime, uint8_t granularity)`
`269`	`266`	`{`
`270`		`- bool success = writeSingleRegister(LED_BRIGHTNESS, brightness);`
`271`		`- success &= writeSingleRegister(LED_PULSE_GRANULARITY, granularity);`
`272`		`- success &= writeDoubleRegister(LED_PULSE_CYCLE_TIME, cycleTime);`
`273`		`- success &= writeDoubleRegister(LED_PULSE_OFF_TIME, offTime);`
	`267`	`+ bool success = writeSingleRegister(SFE_QWIIC_BUTTON_LED_BRIGHTNESS, brightness);`
	`268`	`+ success &= writeSingleRegister(SFE_QWIIC_BUTTON_LED_PULSE_GRANULARITY, granularity);`
	`269`	`+ success &= writeDoubleRegister(SFE_QWIIC_BUTTON_LED_PULSE_CYCLE_TIME, cycleTime);`
	`270`	`+ success &= writeDoubleRegister(SFE_QWIIC_BUTTON_LED_PULSE_OFF_TIME, offTime);`
`274`	`271`	`return success;`
`275`	`272`	`}`
`276`	`273`