diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..89cc49c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 0000000..080e70d
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,10 @@
+{
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
+    "recommendations": [
+        "platformio.platformio-ide"
+    ],
+    "unwantedRecommendations": [
+        "ms-vscode.cpptools-extension-pack"
+    ]
+}
diff --git a/include/README b/include/README
new file mode 100644
index 0000000..49819c0
--- /dev/null
+++ b/include/README
@@ -0,0 +1,37 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the convention is to give header files names that end with `.h'.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html
diff --git a/lib/README b/lib/README
new file mode 100644
index 0000000..9379397
--- /dev/null
+++ b/lib/README
@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into the executable file.
+
+The source code of each library should be placed in a separate directory
+("lib/your_library_name/[Code]").
+
+For example, see the structure of the following example libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional. for custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+Example contents of `src/main.c` using Foo and Bar:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+The PlatformIO Library Dependency Finder will find automatically dependent
+libraries by scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html
diff --git a/platformio.ini b/platformio.ini
new file mode 100644
index 0000000..17d0d10
--- /dev/null
+++ b/platformio.ini
@@ -0,0 +1,26 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:nano_r4]
+platform = https://github.com/platformio/platform-renesas-ra
+board = nano_r4
+framework = arduino
+
+monitor_speed = 115200
+
+lib_ldf_mode = deep+
+
+lib_deps = 
+    adafruit/Adafruit GFX Library@^1.12.4
+    adafruit/Adafruit SSD1351 library@^1.3.3
+    arduinogetstarted/ezButton@^1.0.6
+    nrf24/RF24@^1.5.0
+
+
diff --git a/src/Bitmaps.cpp b/src/Bitmaps.cpp
new file mode 100644
index 0000000..a0d6e43
--- /dev/null
+++ b/src/Bitmaps.cpp
@@ -0,0 +1,134 @@
+#include "Bitmaps.h"
+#include <SPI.h>
+
+const unsigned char spash_screen_BMP[] = {
+// 'SplashScreen, 128x128px Memory usage: 2kb so... easy tiger! Dont get carried away
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0xf0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x03, 0x18, 0x00, 0x1f, 0x00, 0x00, 0xe0, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x06, 0x0c, 0x00, 0x31, 0x80, 0x03, 0xf0, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x06, 0x00, 0x40, 0xc0, 0x07, 0x30, 0x01, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x18, 0x03, 0x01, 0xc0, 0x40, 0x0c, 0x18, 0x01, 0x8c, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x18, 0x03, 0x03, 0x80, 0x60, 0x78, 0x08, 0x06, 0x06, 0x00, 0x7c, 0x00, 0x10, 0x00, 0x00, 
+	0x00, 0x30, 0x01, 0x8e, 0x00, 0x30, 0xe0, 0x0c, 0x0c, 0x06, 0x00, 0xe6, 0x00, 0x78, 0x00, 0x00, 
+	0x00, 0x60, 0x00, 0xf8, 0x00, 0x37, 0x80, 0x06, 0x38, 0x03, 0x0f, 0x86, 0x00, 0xc8, 0x00, 0x00, 
+	0x00, 0x40, 0x00, 0x70, 0x00, 0x0f, 0x00, 0x02, 0x60, 0x03, 0x1e, 0x03, 0x03, 0x8c, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0xc0, 0x01, 0xf0, 0x03, 0x0e, 0x06, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0xe0, 0x01, 0x9c, 0x03, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xb0, 0x03, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xe0, 0x01, 0x80, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0xe0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x18, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0xef, 0xff, 0xf0, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x7c, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x01, 0x80, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x60, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x30, 0x00, 0x04, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x1c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0xc0, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc0, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
\ No newline at end of file
diff --git a/src/Bitmaps.h b/src/Bitmaps.h
new file mode 100644
index 0000000..b53b69b
--- /dev/null
+++ b/src/Bitmaps.h
@@ -0,0 +1,4 @@
+#pragma once
+
+extern const unsigned char spash_screen_BMP[];
+
diff --git a/src/Menu.cpp b/src/Menu.cpp
new file mode 100644
index 0000000..ba5670e
--- /dev/null
+++ b/src/Menu.cpp
@@ -0,0 +1,92 @@
+#include "Menu.h"
+#include "Programs/Snake/Snake.h"
+#include "Programs/Settings/Settings.h"
+#include "Programs/Asteroids/Asteroids.h"
+#include "Programs/Calculator/Calculator.h"
+
+// ... include headers for your other programs here
+void requestProgramChange(Program* program);
+
+namespace Menu {
+ 
+    // --- 1. Define the MenuItem struct ---
+    struct MenuItem {
+        const char* text;
+        Program* program;
+    };
+
+    // --- 2. Create the menuItems array ---
+    MenuItem menuItems[] = {
+        {"Snake", new Snake::Snake()},
+        {"Settings", new Settings::Settings()},
+        {"Asteroids", new Asteroids::Asteroids()},
+        {"Calculator", new Calculator::Calculator()}
+    };
+
+    const int TOTAL_MENU_ITEMS = sizeof(menuItems) / sizeof(menuItems[0]);
+    const int MAX_VISIBLE_ITEMS = 6;
+    const int FONT_HEIGHT = 8;
+
+    // --- 3. Implement the Menu class methods ---
+
+    int selectedIndex = 0;
+    int viewOffset = 0;
+
+    void Menu::setup() {
+        // Not needed for the menu
+    }
+
+    void Menu::onEnter(Adafruit_SSD1351 *tft) {
+        // Reset the menu state when we enter it
+        selectedIndex = 0;
+        viewOffset = 0;
+        Menu::disableInfoBar = false;
+        tft->fillRect(0, 0, 128, 128, BLACK);
+    }
+
+    void Menu::onExit() {
+        // Not needed for the menu
+    }
+
+    void Menu::loop(Adafruit_SSD1351 *tft, inputData *userInputs) {
+        // --- Input Handling ---
+        static int previousJoystickCommand = COMMAND_NO;
+        int currentJoystickCommand = userInputs->joystickCommand;
+
+        if ((currentJoystickCommand & COMMAND_DOWN) && !(previousJoystickCommand & COMMAND_DOWN)) {
+            selectedIndex++;
+            if (selectedIndex >= TOTAL_MENU_ITEMS) {
+                selectedIndex = 0;
+            }
+        }
+        if ((currentJoystickCommand & COMMAND_UP) && !(previousJoystickCommand & COMMAND_UP)) {
+            selectedIndex--;
+            if (selectedIndex < 0) {
+                selectedIndex = TOTAL_MENU_ITEMS - 1;
+            }
+        }
+
+        previousJoystickCommand = currentJoystickCommand;
+
+        // --- Drawing ---
+        for (int i = 0; i < MAX_VISIBLE_ITEMS; i++) {
+            int itemIndex = i + viewOffset;
+            if (itemIndex < TOTAL_MENU_ITEMS) {
+                int yPos = 20 + i * (FONT_HEIGHT + 2);
+                tft->setCursor(10, yPos);
+                if (itemIndex == selectedIndex) {
+                    tft->setTextColor(BLACK, WHITE);
+                } else {
+                    tft->setTextColor(WHITE, BLACK);
+                }
+                tft->println(menuItems[itemIndex].text);
+            }
+        }
+
+        // --- Program Switching ---
+        if (userInputs->buttonTop.isReleased()) {
+            requestProgramChange(menuItems[selectedIndex].program);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/Menu.h b/src/Menu.h
new file mode 100644
index 0000000..bb8c181
--- /dev/null
+++ b/src/Menu.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <Adafruit_SSD1351.h>
+
+#include "utility.h"
+
+namespace Menu{
+
+    class Menu : public Program {
+      public:
+        void setup() override;
+        void loop(Adafruit_SSD1351 *tft, inputData *userInputs) override;
+        void onEnter(Adafruit_SSD1351 *tft) override;
+        void onExit()override;
+    };
+}
diff --git a/src/Programs/Asteroids/Asteroids.cpp b/src/Programs/Asteroids/Asteroids.cpp
new file mode 100644
index 0000000..eb496da
--- /dev/null
+++ b/src/Programs/Asteroids/Asteroids.cpp
@@ -0,0 +1,22 @@
+
+#include "Asteroids.h"
+
+namespace Asteroids{
+    void Asteroids::setup(){
+        // start method
+        Serial.println("Starting Asteroids");
+        return;
+    }
+    void Asteroids::loop(Adafruit_SSD1351 *tft, inputData *userInput){
+        // update method
+        Serial.println("Running Asteroids");
+        return;
+    }
+    void Asteroids::onEnter(Adafruit_SSD1351 *tft){
+
+    }
+
+    void Asteroids::onExit(){
+
+    }
+};
\ No newline at end of file
diff --git a/src/Programs/Asteroids/Asteroids.h b/src/Programs/Asteroids/Asteroids.h
new file mode 100644
index 0000000..5936399
--- /dev/null
+++ b/src/Programs/Asteroids/Asteroids.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <Adafruit_SSD1351.h>
+
+#include "../../utility.h"
+
+
+namespace Asteroids{
+    class Asteroids : public Program {
+        public:
+          void setup() override;
+          void loop(Adafruit_SSD1351 *tft, inputData *userInput) override;
+          void onEnter(Adafruit_SSD1351 *tft) override;
+          void onExit()override;
+    };
+}
diff --git a/src/Programs/Calculator/Calculator.cpp b/src/Programs/Calculator/Calculator.cpp
new file mode 100644
index 0000000..93122da
--- /dev/null
+++ b/src/Programs/Calculator/Calculator.cpp
@@ -0,0 +1,119 @@
+#include <Arduino.h>
+#include "Calculator.h"
+
+namespace Calculator{
+    void Calculator::setup(){
+        // Code for setup
+    }
+    void Calculator::loop(Adafruit_SSD1351 *tft, inputData *userInput){
+
+        static int previousJoystickCommand = COMMAND_NO;
+        int currentJoystickCommand = userInput->joystickCommand;
+
+        if ((currentJoystickCommand & COMMAND_UP) && !(previousJoystickCommand & COMMAND_UP)) {
+            cursorY--;
+            if (cursorY < 0) cursorY = 3;
+        }
+        if ((currentJoystickCommand & COMMAND_DOWN) && !(previousJoystickCommand & COMMAND_DOWN)) {
+            cursorY++;
+            if (cursorY > 3) cursorY = 0;
+        }
+        if ((currentJoystickCommand & COMMAND_LEFT) && !(previousJoystickCommand & COMMAND_LEFT)) {
+            cursorX--;
+            if (cursorX < 0) cursorX = 3;
+        }
+        if ((currentJoystickCommand & COMMAND_RIGHT) && !(previousJoystickCommand & COMMAND_RIGHT)) {
+            cursorX++;
+            if (cursorX > 3) cursorX = 0;
+        }
+
+        if (userInput->joyStickButton.isReleased()) {
+            const char* selectedButton = buttonGrid[cursorY][cursorX];
+            handleButtonPress(selectedButton);
+        }
+
+        previousJoystickCommand = currentJoystickCommand;
+
+        drawCalculator(tft);
+    }
+
+    void Calculator::handleButtonPress(const char* button) {
+        char buttonChar = button[0];
+
+        if (buttonChar >= '0' && buttonChar <= '9') {
+            if (strcmp(display, "0") == 0 || newNumber) {
+                strcpy(display, button);
+                newNumber = false;
+            } else if (strlen(display) < 15) {
+                strcat(display, button);
+            }
+        } else if (buttonChar == 'C') {
+            strcpy(display, "0");
+            storedValue = 0;
+            operation = ' ';
+            newNumber = true;
+        } else if (buttonChar == '+' || buttonChar == '-' || buttonChar == '*' || buttonChar == '/') {
+            storedValue = atof(display);
+            operation = buttonChar;
+            newNumber = true;
+        } else if (buttonChar == '=') {
+            if (operation != ' ') {
+                double secondValue = atof(display);
+                double result = 0;
+                switch (operation) {
+                    case '+': result = storedValue + secondValue; break;
+                    case '-': result = storedValue - secondValue; break;
+                    case '*': result = storedValue * secondValue; break;
+                    case '/': result = storedValue / secondValue; break;
+                }
+                dtostrf(result, 0, 2, display);
+                operation = ' ';
+                newNumber = true;
+            }
+        }
+    }
+
+    void Calculator::onEnter(Adafruit_SSD1351 *tft){
+        // Code to run when program is entered
+        Calculator::disableInfoBar = true;
+        // clear the screen
+        tft->fillRect(0, 0, 128, 128, BLACK);
+    }
+
+    void Calculator::onExit(){
+        // Code to run when program is exited
+    }
+    void Calculator::drawCalculator(Adafruit_SSD1351 *tft) {
+        // Clear only the top display area to reduce flicker
+        tft->fillRect(0, 0, 128, 30, BLACK);
+        tft->setTextSize(2);
+        tft->setCursor(10, 10);
+        tft->println(display);
+
+        int buttonWidth = 32;
+        int buttonHeight = 24;
+        int startX = 0;
+        int startY = 30;
+
+        for (int y = 0; y < 4; y++) {
+            for (int x = 0; x < 4; x++) {
+                int buttonX = startX + x * buttonWidth;
+                int buttonY = startY + y * buttonHeight;
+
+                if (x == cursorX && y == cursorY) {
+                    // draw selected Item
+                    tft->fillRect(buttonX, buttonY, buttonWidth, buttonHeight, WHITE);
+                    tft->setTextColor(BLACK);
+                } else {
+                    // Fill the button background black to "un-highlight" it
+                    tft->fillRect(buttonX, buttonY, buttonWidth, buttonHeight, BLACK);
+                    //tft->drawRect(buttonX, buttonY, buttonWidth, buttonHeight, WHITE);
+                    tft->setTextColor(WHITE);
+                }
+                
+                tft->setCursor(buttonX + 10, buttonY + 5);
+                tft->print(buttonGrid[y][x]);
+            }
+        }
+    }
+};
\ No newline at end of file
diff --git a/src/Programs/Calculator/Calculator.h b/src/Programs/Calculator/Calculator.h
new file mode 100644
index 0000000..1958d82
--- /dev/null
+++ b/src/Programs/Calculator/Calculator.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Adafruit_SSD1351.h>
+
+#include "../../utility.h"
+
+
+namespace Calculator{
+    
+    class Calculator : public Program {
+        public:
+          void setup() override;
+          void loop(Adafruit_SSD1351 *tft, inputData *userInput) override;
+          void onEnter(Adafruit_SSD1351 *tft) override;
+          void onExit()override;
+        
+        private:
+          void drawCalculator(Adafruit_SSD1351 *tft);
+          void handleButtonPress(const char* button);
+
+          int cursorX = 0;
+          int cursorY = 0;
+
+          char display[16] = "0";
+          double storedValue = 0;
+          char operation = ' ';
+          bool newNumber = true;
+
+          const char* buttonGrid[4][4] = {
+            {"1", "2", "3", "+"},
+            {"4", "5", "6", "-"},
+            {"7", "8", "9", "*"},
+            {"C", "0", "=", "/"}
+          };
+    };
+}
+
diff --git a/src/Programs/Keyboard.cpp b/src/Programs/Keyboard.cpp
new file mode 100644
index 0000000..a0e3102
--- /dev/null
+++ b/src/Programs/Keyboard.cpp
@@ -0,0 +1,41 @@
+
+#include "Keyboard.h"
+
+namespace Keyboard{
+    void Keyboard::render(Adafruit_SSD1351 *tft){
+        // Clear the keyboard area (e.g., bottom half of screen)
+        tft->fillRect(0, 64, 128, 64, BLACK);
+
+        // Draw the typed text at the top of the keyboard area
+        tft->setTextSize(1);
+        tft->setCursor(5, 70);
+        tft->setTextColor(WHITE);
+        tft->println(typedText);
+
+        // Draw the keyboard grid
+        int buttonWidth = 21;
+        int buttonHeight = 10; // Adjusted for 5 rows in the remaining space
+        int startX = 0;
+        int startY = 85;
+
+        for (int y = 0; y < 5; y++) {
+            for (int x = 0; x < 6; x++) {
+                int buttonX = startX + x * buttonWidth;
+                int buttonY = startY + y * buttonHeight;
+
+                if (x == cursorX && y == cursorY) {
+                    tft->fillRect(buttonX, buttonY, buttonWidth, buttonHeight, WHITE);
+                    tft->setTextColor(BLACK);
+                } else {
+                    tft->fillRect(buttonX, buttonY, buttonWidth, buttonHeight, BLACK);
+                    tft->drawRect(buttonX, buttonY, buttonWidth, buttonHeight, WHITE);
+                    tft->setTextColor(WHITE);
+                }
+                
+                // Simple centering for text
+                tft->setCursor(buttonX + (buttonWidth/2) - 3, buttonY + (buttonHeight/2) - 4);
+                tft->print(keyboardLayout[y][x]);
+            }
+        }
+    }
+}
diff --git a/src/Programs/Keyboard.h b/src/Programs/Keyboard.h
new file mode 100644
index 0000000..9b50a18
--- /dev/null
+++ b/src/Programs/Keyboard.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <Adafruit_SSD1351.h>
+
+#include "../utility.h"
+
+
+namespace Keyboard{
+    
+    class Keyboard {
+        public:
+          void render(Adafruit_SSD1351 *tft);
+        
+        private:
+          int cursorX = 0;
+          int cursorY = 0;
+
+          char typedText[32] = "";
+
+          const char* keyboardLayout[5][6] = {
+            {"A", "B", "C", "D", "E", "F"},
+            {"G", "H", "I", "J", "K", "L"},
+            {"M", "N", "O", "P", "Q", "R"},
+            {"S", "T", "U", "V", "W", "X"},
+            {"Y", "Z", ".", "<", "_", "ENT"}
+          };
+    };
+}
diff --git a/src/Programs/Messaging/Messaging.cpp b/src/Programs/Messaging/Messaging.cpp
new file mode 100644
index 0000000..8c9c4b3
--- /dev/null
+++ b/src/Programs/Messaging/Messaging.cpp
@@ -0,0 +1,21 @@
+#include "Messaging.h"
+
+namespace Messaging{
+    void Messaging::setup(){
+        // start method
+        Serial.println("Starting Messaging");
+        return;
+    }
+    void Messaging::loop(Adafruit_SSD1351 *tft, inputData *userInput){
+        // update method
+        Serial.println("Running Messaging");
+        return;
+    }
+    void Messaging::onEnter(Adafruit_SSD1351 *tft){
+
+    }
+
+    void Messaging::onExit(){
+
+    }
+};
\ No newline at end of file
diff --git a/src/Programs/Messaging/Messaging.h b/src/Programs/Messaging/Messaging.h
new file mode 100644
index 0000000..06d66e5
--- /dev/null
+++ b/src/Programs/Messaging/Messaging.h
@@ -0,0 +1,17 @@
+#pragma once
+
+
+#include <Adafruit_SSD1351.h>
+
+#include "../../utility.h"
+
+
+namespace Messaging{
+    class Messaging : public Program {
+        public:
+          void setup() override;
+          void loop(Adafruit_SSD1351 *tft, inputData *userInput) override;
+          void onEnter(Adafruit_SSD1351 *tft) override;
+          void onExit()override;
+    };
+}
diff --git a/src/Programs/Settings/Settings.cpp b/src/Programs/Settings/Settings.cpp
new file mode 100644
index 0000000..1ad5afd
--- /dev/null
+++ b/src/Programs/Settings/Settings.cpp
@@ -0,0 +1,21 @@
+#include "Settings.h"
+
+namespace Settings{
+    void Settings::setup(){
+        // start method
+        Serial.println("Starting Settings");
+        return;
+    }
+    void Settings::loop(Adafruit_SSD1351 *tft, inputData *userInput){
+        // update method
+        Serial.println("Running Settings");
+        return;
+    }
+    void Settings::onEnter(Adafruit_SSD1351 *tft){
+
+    }
+
+    void Settings::onExit(){
+
+    }
+};
\ No newline at end of file
diff --git a/src/Programs/Settings/Settings.h b/src/Programs/Settings/Settings.h
new file mode 100644
index 0000000..de5a416
--- /dev/null
+++ b/src/Programs/Settings/Settings.h
@@ -0,0 +1,18 @@
+#pragma once
+
+
+#include <Adafruit_SSD1351.h>
+
+#include "../../utility.h"
+
+
+namespace Settings{
+    class Settings : public Program {
+        public:
+          void setup() override;
+          void loop(Adafruit_SSD1351 *tft, inputData *userInput) override;
+          void onEnter(Adafruit_SSD1351 *tft) override;
+          void onExit()override;
+    };
+}
+
diff --git a/src/Programs/Snake/Snake.cpp b/src/Programs/Snake/Snake.cpp
new file mode 100644
index 0000000..2005289
--- /dev/null
+++ b/src/Programs/Snake/Snake.cpp
@@ -0,0 +1,22 @@
+#include "Snake.h"
+
+namespace Snake{
+    void Snake::setup(){
+        // start method
+        Serial.println("Starting Snake");
+        return;
+    }
+    void Snake::loop(Adafruit_SSD1351 *tft, inputData *userInput){
+        // update method
+        Serial.println("Running Snake");
+        return;
+    }
+    void Snake::onEnter(Adafruit_SSD1351 *tft){
+        // Show Snake game logo for a second or two
+        // could make the 7 seg do like a little snake impression by having the led's move around
+    }
+
+    void Snake::onExit(){
+
+    }
+};
\ No newline at end of file
diff --git a/src/Programs/Snake/Snake.h b/src/Programs/Snake/Snake.h
new file mode 100644
index 0000000..983c7ec
--- /dev/null
+++ b/src/Programs/Snake/Snake.h
@@ -0,0 +1,18 @@
+#pragma once
+
+
+#include <Adafruit_SSD1351.h>
+
+#include "../../utility.h"
+
+
+namespace Snake{
+    
+    class Snake : public Program {
+        public:
+          void setup() override;
+          void loop(Adafruit_SSD1351 *tft, inputData *userInput) override;
+          void onEnter(Adafruit_SSD1351 *tft) override;
+          void onExit()override;
+    };
+}
diff --git a/src/Resources/Adafruit_GFX.h b/src/Resources/Adafruit_GFX.h
new file mode 100644
index 0000000..032d8ea
--- /dev/null
+++ b/src/Resources/Adafruit_GFX.h
@@ -0,0 +1,401 @@
+#ifndef _ADAFRUIT_GFX_H
+#define _ADAFRUIT_GFX_H
+
+#if ARDUINO >= 100
+#include "Arduino.h"
+#include "Print.h"
+#else
+#include "WProgram.h"
+#endif
+#include "gfxfont.h"
+
+#include <Adafruit_I2CDevice.h>
+#include <Adafruit_SPIDevice.h>
+
+/// A generic graphics superclass that can handle all sorts of drawing. At a
+/// minimum you can subclass and provide drawPixel(). At a maximum you can do a
+/// ton of overriding to optimize. Used for any/all Adafruit displays!
+class Adafruit_GFX : public Print {
+
+public:
+  Adafruit_GFX(int16_t w, int16_t h); // Constructor
+
+  /**********************************************************************/
+  /*!
+    @brief  Draw to the screen/framebuffer/etc.
+    Must be overridden in subclass.
+    @param  x    X coordinate in pixels
+    @param  y    Y coordinate in pixels
+    @param color  16-bit pixel color.
+  */
+  /**********************************************************************/
+  virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
+
+  // TRANSACTION API / CORE DRAW API
+  // These MAY be overridden by the subclass to provide device-specific
+  // optimized code.  Otherwise 'generic' versions are used.
+  virtual void startWrite(void);
+  virtual void writePixel(int16_t x, int16_t y, uint16_t color);
+  virtual void writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h,
+                             uint16_t color);
+  virtual void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  virtual void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  virtual void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+                         uint16_t color);
+  virtual void endWrite(void);
+
+  // CONTROL API
+  // These MAY be overridden by the subclass to provide device-specific
+  // optimized code.  Otherwise 'generic' versions are used.
+  virtual void setRotation(uint8_t r);
+  virtual void invertDisplay(bool i);
+
+  // BASIC DRAW API
+  // These MAY be overridden by the subclass to provide device-specific
+  // optimized code.  Otherwise 'generic' versions are used.
+
+  // It's good to implement those, even if using transaction API
+  virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  virtual void fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
+                        uint16_t color);
+  virtual void fillScreen(uint16_t color);
+  // Optional and probably not necessary to change
+  virtual void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+                        uint16_t color);
+  virtual void drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
+                        uint16_t color);
+
+  // These exist only with Adafruit_GFX (no subclass overrides)
+  void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
+  void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
+                        uint16_t color);
+  void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
+  void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
+                        int16_t delta, uint16_t color);
+  void drawEllipse(int16_t x0, int16_t y0, int16_t rw, int16_t rh,
+                   uint16_t color);
+  void fillEllipse(int16_t x0, int16_t y0, int16_t rw, int16_t rh,
+                   uint16_t color);
+  void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2,
+                    int16_t y2, uint16_t color);
+  void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2,
+                    int16_t y2, uint16_t color);
+  void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
+                     int16_t radius, uint16_t color);
+  void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
+                     int16_t radius, uint16_t color);
+  void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w,
+                  int16_t h, uint16_t color);
+  void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w,
+                  int16_t h, uint16_t color, uint16_t bg);
+  void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h,
+                  uint16_t color);
+  void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h,
+                  uint16_t color, uint16_t bg);
+  void drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w,
+                   int16_t h, uint16_t color);
+  void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
+                           int16_t w, int16_t h);
+  void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w,
+                           int16_t h);
+  void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
+                           const uint8_t mask[], int16_t w, int16_t h);
+  void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint8_t *mask,
+                           int16_t w, int16_t h);
+  void drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w,
+                     int16_t h);
+  void drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w,
+                     int16_t h);
+  void drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[],
+                     const uint8_t mask[], int16_t w, int16_t h);
+  void drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask,
+                     int16_t w, int16_t h);
+  void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
+                uint16_t bg, uint8_t size);
+  void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
+                uint16_t bg, uint8_t size_x, uint8_t size_y);
+  void getTextBounds(const char *string, int16_t x, int16_t y, int16_t *x1,
+                     int16_t *y1, uint16_t *w, uint16_t *h);
+  void getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
+                     int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
+  void getTextBounds(const String &str, int16_t x, int16_t y, int16_t *x1,
+                     int16_t *y1, uint16_t *w, uint16_t *h);
+  void setTextSize(uint8_t s);
+  void setTextSize(uint8_t sx, uint8_t sy);
+  void setFont(const GFXfont *f = NULL);
+
+  /**********************************************************************/
+  /*!
+    @brief  Set text cursor location
+    @param  x    X coordinate in pixels
+    @param  y    Y coordinate in pixels
+  */
+  /**********************************************************************/
+  void setCursor(int16_t x, int16_t y) {
+    cursor_x = x;
+    cursor_y = y;
+  }
+
+  /**********************************************************************/
+  /*!
+    @brief   Set text font color with transparant background
+    @param   c   16-bit 5-6-5 Color to draw text with
+    @note    For 'transparent' background, background and foreground
+             are set to same color rather than using a separate flag.
+  */
+  /**********************************************************************/
+  void setTextColor(uint16_t c) { textcolor = textbgcolor = c; }
+
+  /**********************************************************************/
+  /*!
+    @brief   Set text font color with custom background color
+    @param   c   16-bit 5-6-5 Color to draw text with
+    @param   bg  16-bit 5-6-5 Color to draw background/fill with
+  */
+  /**********************************************************************/
+  void setTextColor(uint16_t c, uint16_t bg) {
+    textcolor = c;
+    textbgcolor = bg;
+  }
+
+  /**********************************************************************/
+  /*!
+  @brief  Set whether text that is too long for the screen width should
+          automatically wrap around to the next line (else clip right).
+  @param  w  true for wrapping, false for clipping
+  */
+  /**********************************************************************/
+  void setTextWrap(bool w) { wrap = w; }
+
+  /**********************************************************************/
+  /*!
+    @brief  Enable (or disable) Code Page 437-compatible charset.
+            There was an error in glcdfont.c for the longest time -- one
+            character (#176, the 'light shade' block) was missing -- this
+            threw off the index of every character that followed it.
+            But a TON of code has been written with the erroneous
+            character indices. By default, the library uses the original
+            'wrong' behavior and old sketches will still work. Pass
+            'true' to this function to use correct CP437 character values
+            in your code.
+    @param  x  true = enable (new behavior), false = disable (old behavior)
+  */
+  /**********************************************************************/
+  void cp437(bool x = true) { _cp437 = x; }
+
+  using Print::write;
+#if ARDUINO >= 100
+  virtual size_t write(uint8_t);
+#else
+  virtual void write(uint8_t);
+#endif
+
+  /************************************************************************/
+  /*!
+    @brief      Get width of the display, accounting for current rotation
+    @returns    Width in pixels
+  */
+  /************************************************************************/
+  int16_t width(void) const { return _width; };
+
+  /************************************************************************/
+  /*!
+    @brief      Get height of the display, accounting for current rotation
+    @returns    Height in pixels
+  */
+  /************************************************************************/
+  int16_t height(void) const { return _height; }
+
+  /************************************************************************/
+  /*!
+    @brief      Get rotation setting for display
+    @returns    0 thru 3 corresponding to 4 cardinal rotations
+  */
+  /************************************************************************/
+  uint8_t getRotation(void) const { return rotation; }
+
+  // get current cursor position (get rotation safe maximum values,
+  // using: width() for x, height() for y)
+  /************************************************************************/
+  /*!
+    @brief  Get text cursor X location
+    @returns    X coordinate in pixels
+  */
+  /************************************************************************/
+  int16_t getCursorX(void) const { return cursor_x; }
+
+  /************************************************************************/
+  /*!
+    @brief      Get text cursor Y location
+    @returns    Y coordinate in pixels
+  */
+  /************************************************************************/
+  int16_t getCursorY(void) const { return cursor_y; };
+
+protected:
+  void charBounds(unsigned char c, int16_t *x, int16_t *y, int16_t *minx,
+                  int16_t *miny, int16_t *maxx, int16_t *maxy);
+  int16_t WIDTH;        ///< This is the 'raw' display width - never changes
+  int16_t HEIGHT;       ///< This is the 'raw' display height - never changes
+  int16_t _width;       ///< Display width as modified by current rotation
+  int16_t _height;      ///< Display height as modified by current rotation
+  int16_t cursor_x;     ///< x location to start print()ing text
+  int16_t cursor_y;     ///< y location to start print()ing text
+  uint16_t textcolor;   ///< 16-bit background color for print()
+  uint16_t textbgcolor; ///< 16-bit text color for print()
+  uint8_t textsize_x;   ///< Desired magnification in X-axis of text to print()
+  uint8_t textsize_y;   ///< Desired magnification in Y-axis of text to print()
+  uint8_t rotation;     ///< Display rotation (0 thru 3)
+  bool wrap;            ///< If set, 'wrap' text at right edge of display
+  bool _cp437;          ///< If set, use correct CP437 charset (default is off)
+  GFXfont *gfxFont;     ///< Pointer to special font
+};
+
+/// A simple drawn button UI element
+class Adafruit_GFX_Button {
+
+public:
+  Adafruit_GFX_Button(void);
+  // "Classic" initButton() uses center & size
+  void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w,
+                  uint16_t h, uint16_t outline, uint16_t fill,
+                  uint16_t textcolor, char *label, uint8_t textsize);
+  void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w,
+                  uint16_t h, uint16_t outline, uint16_t fill,
+                  uint16_t textcolor, char *label, uint8_t textsize_x,
+                  uint8_t textsize_y);
+  // New/alt initButton() uses upper-left corner & size
+  void initButtonUL(Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w,
+                    uint16_t h, uint16_t outline, uint16_t fill,
+                    uint16_t textcolor, char *label, uint8_t textsize);
+  void initButtonUL(Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w,
+                    uint16_t h, uint16_t outline, uint16_t fill,
+                    uint16_t textcolor, char *label, uint8_t textsize_x,
+                    uint8_t textsize_y);
+  void drawButton(bool inverted = false);
+  bool contains(int16_t x, int16_t y);
+
+  /**********************************************************************/
+  /*!
+    @brief    Sets button state, should be done by some touch function
+    @param    p  True for pressed, false for not.
+  */
+  /**********************************************************************/
+  void press(bool p) {
+    laststate = currstate;
+    currstate = p;
+  }
+
+  bool justPressed();
+  bool justReleased();
+
+  /**********************************************************************/
+  /*!
+    @brief    Query whether the button is currently pressed
+    @returns  True if pressed
+  */
+  /**********************************************************************/
+  bool isPressed(void) { return currstate; };
+
+private:
+  Adafruit_GFX *_gfx;
+  int16_t _x1, _y1; // Coordinates of top-left corner
+  uint16_t _w, _h;
+  uint8_t _textsize_x;
+  uint8_t _textsize_y;
+  uint16_t _outlinecolor, _fillcolor, _textcolor;
+  char _label[10];
+
+  bool currstate, laststate;
+};
+
+/// A GFX 1-bit canvas context for graphics
+class GFXcanvas1 : public Adafruit_GFX {
+public:
+  GFXcanvas1(uint16_t w, uint16_t h, bool allocate_buffer = true);
+  ~GFXcanvas1(void);
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+  void fillScreen(uint16_t color);
+  void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  bool getPixel(int16_t x, int16_t y) const;
+  /**********************************************************************/
+  /*!
+    @brief    Get a pointer to the internal buffer memory
+    @returns  A pointer to the allocated buffer
+  */
+  /**********************************************************************/
+  uint8_t *getBuffer(void) const { return buffer; }
+
+protected:
+  bool getRawPixel(int16_t x, int16_t y) const;
+  void drawFastRawVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  void drawFastRawHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  uint8_t *buffer;   ///< Raster data: no longer private, allow subclass access
+  bool buffer_owned; ///< If true, destructor will free buffer, else it will do
+                     ///< nothing
+
+private:
+#ifdef __AVR__
+  // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
+  static const uint8_t PROGMEM GFXsetBit[], GFXclrBit[];
+#endif
+};
+
+/// A GFX 8-bit canvas context for graphics
+class GFXcanvas8 : public Adafruit_GFX {
+public:
+  GFXcanvas8(uint16_t w, uint16_t h, bool allocate_buffer = true);
+  ~GFXcanvas8(void);
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+  void fillScreen(uint16_t color);
+  void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  uint8_t getPixel(int16_t x, int16_t y) const;
+  /**********************************************************************/
+  /*!
+   @brief    Get a pointer to the internal buffer memory
+   @returns  A pointer to the allocated buffer
+  */
+  /**********************************************************************/
+  uint8_t *getBuffer(void) const { return buffer; }
+
+protected:
+  uint8_t getRawPixel(int16_t x, int16_t y) const;
+  void drawFastRawVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  void drawFastRawHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  uint8_t *buffer;   ///< Raster data: no longer private, allow subclass access
+  bool buffer_owned; ///< If true, destructor will free buffer, else it will do
+                     ///< nothing
+};
+
+///  A GFX 16-bit canvas context for graphics
+class GFXcanvas16 : public Adafruit_GFX {
+public:
+  GFXcanvas16(uint16_t w, uint16_t h, bool allocate_buffer = true);
+  ~GFXcanvas16(void);
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+  void fillScreen(uint16_t color);
+  void byteSwap(void);
+  void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  uint16_t getPixel(int16_t x, int16_t y) const;
+  /**********************************************************************/
+  /*!
+    @brief    Get a pointer to the internal buffer memory
+    @returns  A pointer to the allocated buffer
+  */
+  /**********************************************************************/
+  uint16_t *getBuffer(void) const { return buffer; }
+
+protected:
+  uint16_t getRawPixel(int16_t x, int16_t y) const;
+  void drawFastRawVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  void drawFastRawHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  uint16_t *buffer;  ///< Raster data: no longer private, allow subclass access
+  bool buffer_owned; ///< If true, destructor will free buffer, else it will do
+                     ///< nothing
+};
+
+#endif // _ADAFRUIT_GFX_H
diff --git a/src/Resources/EEPROM.txt b/src/Resources/EEPROM.txt
new file mode 100644
index 0000000..3591b2b
--- /dev/null
+++ b/src/Resources/EEPROM.txt
@@ -0,0 +1,56 @@
+// --- EEPROM --- //
+
+// EEPROM is a static class. it does not need to be initiated or created
+// Each adress is 1 bytes in size. so if you store an int in adress 0, the first half will be in 0 and the second half will be stored in 1;
+// Also note, EEPROM has a limited life span. each adress can only be updates around 100k times. this sould like a lot, until you realise that the CPU clock speed is 
+
+EEPROM.length() -> returns number of unique adresses
+
+EEPROM.get(INT address, ANY_OBJECT variableToBeAsigned)
+
+EEPROM.read(INT address) -> reads a single byte
+
+EEPROM.put(INT address, ANY_OBJECT variableToStore) -> Used to save multi-byte data to EEPROM. also works like .update
+
+EEPROM.update(INT address, ANY_OBJECT variableToStore) -> check if the value in EEPROM address is different to
+                                                          "variableToStore", if so, update the value. This is
+                                                           to help maintain the life of EEPROM and mitiage un-nessersary ware
+
+EEPROM.write() -> writes a single byte of data to said adress
+
+
+
+
+// --- Arduino --- //
+
+// does not need any kind of class, is available from the getgo
+
+tone(pin, frequency, duration) -> play a tone for "duration" miliseconds
+tone(pin, frequency) -> plays a tone indefinitly
+noTone(pin) -> stops the buzzer
+
+
+
+
+// --- GFX Library --- //
+
+// needs to be created through constructor. input the width, height etc...
+
+Adafruit_SSD1351 tft = Adafruit_SSD1351(SCREEN_WIDTH, SCREEN_HEIGHT, &SPI, CS_PIN, DC_PIN, RST_PIN);
+
+
+
+
+
+// --- RF24 --- //
+
+// needs to be created through constructor
+
+RF24 radio(RF_ENABLE_PIN, CSN_PIN) -> create a radio object
+
+radio.begin() -> init the radio. returns false if it fails to start 
+
+radio.setPALevel(RF24_PA_LOW) -> able to set the volume ()
+
+
+radio.startListening();  // put radio in RX mode
\ No newline at end of file
diff --git a/src/Resources/RF24.h b/src/Resources/RF24.h
new file mode 100644
index 0000000..1fd4d54
--- /dev/null
+++ b/src/Resources/RF24.h
@@ -0,0 +1,2563 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ version 2 as published by the Free Software Foundation.
+ */
+
+/**
+ * @file RF24.h
+ *
+ * Class declaration for RF24 and helper enums
+ */
+
+#ifndef RF24_H_
+#define RF24_H_
+
+#include "RF24_config.h"
+
+#if defined(RF24_LINUX) || defined(LITTLEWIRE)
+    #include "utility/includes.h"
+#elif defined SOFTSPI
+    #include <DigitalIO.h>
+#endif
+
+/**
+ * @defgroup PALevel Power Amplifier level
+ * Power Amplifier level. The units dBm (decibel-milliwatts or dB<sub>mW</sub>)
+ * represents a logarithmic signal loss.
+ * @see
+ * - RF24::setPALevel()
+ * - RF24::getPALevel()
+ * @{
+ */
+typedef enum
+{
+    /**
+     * (0) represents:
+     * nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
+     * :-------:|:-----------------------------:|:----------------------------:
+     *  -18 dBm | -6 dBm | -12 dBm
+     */
+    RF24_PA_MIN = 0,
+    /**
+     * (1) represents:
+     * nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
+     * :-------:|:-----------------------------:|:----------------------------:
+     *  -12 dBm | 0 dBm | -4 dBm
+     */
+    RF24_PA_LOW,
+    /**
+     * (2) represents:
+     * nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
+     * :-------:|:-----------------------------:|:----------------------------:
+     *  -6 dBm | 3 dBm | 1 dBm
+     */
+    RF24_PA_HIGH,
+    /**
+     * (3) represents:
+     * nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
+     * :-------:|:-----------------------------:|:----------------------------:
+     *  0 dBm | 7 dBm | 4 dBm
+     */
+    RF24_PA_MAX,
+    /**
+     * (4) This should not be used and remains for backward compatibility.
+     */
+    RF24_PA_ERROR
+} rf24_pa_dbm_e;
+
+/**
+ * @}
+ * @defgroup Datarate datarate
+ * How fast data moves through the air. Units are in bits per second (bps).
+ * @see
+ * - RF24::setDataRate()
+ * - RF24::getDataRate()
+ * @{
+ */
+typedef enum
+{
+    /** (0) represents 1 Mbps */
+    RF24_1MBPS = 0,
+    /** (1) represents 2 Mbps */
+    RF24_2MBPS,
+    /** (2) represents 250 kbps */
+    RF24_250KBPS
+} rf24_datarate_e;
+
+/**
+ * @}
+ * @defgroup CRCLength CRC length
+ * The length of a CRC checksum that is used (if any). Cyclical Redundancy
+ * Checking (CRC) is commonly used to ensure data integrity.
+ * @see
+ * - RF24::setCRCLength()
+ * - RF24::getCRCLength()
+ * - RF24::disableCRC()
+ * @{
+ */
+typedef enum
+{
+    /** (0) represents no CRC checksum is used */
+    RF24_CRC_DISABLED = 0,
+    /** (1) represents CRC 8 bit checksum is used */
+    RF24_CRC_8,
+    /** (2) represents CRC 16 bit checksum is used */
+    RF24_CRC_16
+} rf24_crclength_e;
+
+/**
+ * @}
+ * @defgroup fifoState FIFO state
+ * The state of a single FIFO (RX or TX).
+ * Remember, each FIFO has a maximum occupancy of 3 payloads.
+ * @see RF24::isFifo()
+ * @{
+ */
+typedef enum
+{
+    /// @brief The FIFO is not full nor empty, but it is occupied with 1 or 2 payloads.
+    RF24_FIFO_OCCUPIED,
+    /// @brief The FIFO is empty.
+    RF24_FIFO_EMPTY,
+    /// @brief The FIFO is full.
+    RF24_FIFO_FULL,
+    /// @brief Represents corruption of data over SPI (when observed).
+    RF24_FIFO_INVALID,
+} rf24_fifo_state_e;
+
+/**
+ * @}
+ * @defgroup StatusFlags Status flags
+ * @{
+ */
+
+/**
+ * @brief An enumeration of constants used to configure @ref StatusFlags
+ */
+typedef enum
+{
+#include "nRF24L01.h"
+    /// An alias of `0` to describe no IRQ events enabled.
+    RF24_IRQ_NONE = 0,
+    /// Represents an event where TX Data Failed to send.
+    RF24_TX_DF = 1 << MASK_MAX_RT,
+    /// Represents an event where TX Data Sent successfully.
+    RF24_TX_DS = 1 << TX_DS,
+    /// Represents an event where RX Data is Ready to `RF24::read()`.
+    RF24_RX_DR = 1 << RX_DR,
+    /// Equivalent to `RF24_RX_DR | RF24_TX_DS | RF24_TX_DF`.
+    RF24_IRQ_ALL = (1 << MASK_MAX_RT) | (1 << TX_DS) | (1 << RX_DR),
+} rf24_irq_flags_e;
+
+/**
+ * @}
+ * @brief Driver class for nRF24L01(+) 2.4GHz Wireless Transceiver
+ */
+class RF24
+{
+private:
+#ifdef SOFTSPI
+    SoftSPI<SOFT_SPI_MISO_PIN, SOFT_SPI_MOSI_PIN, SOFT_SPI_SCK_PIN, SPI_MODE> spi;
+#elif defined(SPI_UART)
+    SPIUARTClass uspi;
+#endif
+
+#if defined(RF24_LINUX) || defined(XMEGA_D3) /* XMEGA can use SPI class */
+    SPI spi;
+#endif // defined (RF24_LINUX) || defined (XMEGA_D3)
+#if defined(RF24_SPI_PTR)
+    _SPI* _spi;
+#endif // defined (RF24_SPI_PTR)
+
+    rf24_gpio_pin_t ce_pin;  /* "Chip Enable" pin, activates the RX or TX role */
+    rf24_gpio_pin_t csn_pin; /* SPI Chip select */
+    uint32_t spi_speed;      /* SPI Bus Speed */
+#if defined(RF24_LINUX) || defined(XMEGA_D3) || defined(RF24_RP2)
+    uint8_t spi_rxbuff[32 + 1]; //SPI receive buffer (payload max 32 bytes)
+    uint8_t spi_txbuff[32 + 1]; //SPI transmit buffer (payload max 32 bytes + 1 byte for the command)
+#endif
+    uint8_t status;                   /* The status byte returned from every SPI transaction */
+    uint8_t payload_size;             /* Fixed size of payloads */
+    uint8_t pipe0_reading_address[5]; /* Last address set on pipe 0 for reading. */
+    uint8_t pipe0_writing_address[5]; /* Last address set on pipe 0 for writing. */
+    uint8_t config_reg;               /* For storing the value of the NRF_CONFIG register */
+    bool _is_p_variant;               /* For storing the result of testing the toggleFeatures() affect */
+    bool _is_p0_rx;                   /* For keeping track of pipe 0's usage in user-triggered RX mode. */
+
+protected:
+    /**
+     * SPI transactions
+     *
+     * Common code for SPI transactions including CSN toggle
+     *
+     */
+    inline void beginTransaction();
+
+    inline void endTransaction();
+
+    /** Whether ack payloads are enabled. */
+    bool ack_payloads_enabled;
+    /** The address width to use (3, 4 or 5 bytes). */
+    uint8_t addr_width;
+    /** Whether dynamic payloads are enabled. */
+    bool dynamic_payloads_enabled;
+
+    /**
+     * Read a chunk of data in from a register
+     *
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @param[out] buf Where to put the data
+     * @param len How many bytes of data to transfer
+     * @note This returns nothing. Older versions of this function returned the status
+     * byte, but that it now saved to a private member on all SPI transactions.
+     */
+    void read_register(uint8_t reg, uint8_t* buf, uint8_t len);
+
+    /**
+     * Read single byte from a register
+     *
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @return Current value of register @p reg
+     */
+    uint8_t read_register(uint8_t reg);
+
+public:
+    /**
+     * @name Primary public interface
+     *
+     *  These are the main methods you need to operate the chip
+     */
+    /**@{*/
+
+    /**
+     * RF24 Constructor
+     *
+     * Creates a new instance of this driver.  Before using, you create an instance
+     * and send in the unique pins that this chip is connected to.
+     *
+     * See [Related Pages](pages.html) for device specific information
+     *
+     * @param _cepin The pin attached to Chip Enable on the RF module.
+     * Review our [Linux general](rpi_general.md) doc for details about selecting pin numbers on Linux systems.
+     * @param _cspin The pin attached to Chip Select (often labeled CSN) on the radio module.
+     * - For the Arduino Due board, the [Arduino Due extended SPI feature](https://www.arduino.cc/en/Reference/DueExtendedSPI)
+     * is not supported. This means that the Due's pins 4, 10, or 52 are not mandated options (can use any digital output pin) for
+     * the radio's CSN pin.
+     * @param _spi_speed The SPI speed in Hz ie: 1000000 == 1Mhz
+     * - Users can specify default SPI speed by modifying @ref RF24_SPI_SPEED in @ref RF24_config.h
+     *     - For Arduino, the default SPI speed will only be properly configured this way on devices supporting SPI TRANSACTIONS
+     *     - Older/Unsupported Arduino devices will use a default clock divider & settings configuration
+     *     - For Linux: The old way of setting SPI speeds using BCM2835 driver enums has been removed as of v1.3.7
+     */
+    RF24(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin, uint32_t _spi_speed = RF24_SPI_SPEED);
+
+    /**
+     * A constructor for initializing the radio's hardware dynamically
+     * @warning You MUST use begin(rf24_gpio_pin_t, rf24_gpio_pin_t) or begin(_SPI*, rf24_gpio_pin_t, rf24_gpio_pin_t) to pass both the
+     * digital output pin numbers connected to the radio's CE and CSN pins.
+     * @param _spi_speed The SPI speed in Hz ie: 1000000 == 1Mhz
+     * - Users can specify default SPI speed by modifying @ref RF24_SPI_SPEED in @ref RF24_config.h
+     *     - For Arduino, the default SPI speed will only be properly configured this way on devices supporting SPI TRANSACTIONS
+     *     - Older/Unsupported Arduino devices will use a default clock divider & settings configuration
+     *     - For Linux: The old way of setting SPI speeds using BCM2835 driver enums has been removed as of v1.3.7
+     */
+    RF24(uint32_t _spi_speed = RF24_SPI_SPEED);
+
+#if defined(RF24_LINUX)
+    virtual ~RF24() {};
+#endif
+
+    /**
+     * Begin operation of the chip
+     *
+     * Call this in setup(), before calling any other methods.
+     * @code
+     * if (!radio.begin()) {
+     *   Serial.println(F("radio hardware not responding!"));
+     *   while (1) {} // hold program in infinite loop to prevent subsequent errors
+     * }
+     * @endcode
+     * @return
+     * - `true` if the radio was successfully initialized
+     * - `false` if the MCU failed to communicate with the radio hardware
+     */
+    bool begin(void);
+
+#if defined(RF24_SPI_PTR) || defined(DOXYGEN_FORCED)
+    /**
+     * Same as begin(), but allows specifying a non-default SPI bus to use.
+     *
+     * @note This function assumes the `SPI::begin()` method was called before to
+     * calling this function.
+     *
+     * @warning This function is for the Arduino platforms only
+     *
+     * @param spiBus A pointer or reference to an instantiated SPI bus object.
+     * The `_SPI` datatype is a "wrapped" definition that will represent
+     * various SPI implementations based on the specified platform.
+     * @see Review the [Arduino support page](arduino.md).
+     *
+     * @return same result as begin()
+     */
+    bool begin(_SPI* spiBus);
+
+    /**
+     * Same as begin(), but allows dynamically specifying a SPI bus, CE pin,
+     * and CSN pin to use.
+     *
+     * @note This function assumes the `SPI::begin()` method was called before to
+     * calling this function.
+     *
+     * @warning This function is for the Arduino platforms only
+     *
+     * @param spiBus A pointer or reference to an instantiated SPI bus object.
+     * The `_SPI` datatype is a "wrapped" definition that will represent
+     * various SPI implementations based on the specified platform.
+     * @param _cepin The pin attached to Chip Enable on the RF module.
+     * Review our [Linux general](rpi_general.md) doc for details about selecting pin numbers on Linux systems.
+     * @param _cspin The pin attached to Chip Select (often labeled CSN) on the radio module.
+     * - For the Arduino Due board, the [Arduino Due extended SPI feature](https://www.arduino.cc/en/Reference/DueExtendedSPI)
+     * is not supported. This means that the Due's pins 4, 10, or 52 are not mandated options (can use any digital output pin) for the radio's CSN pin.
+     *
+     * @see Review the [Arduino support page](arduino.md).
+     *
+     * @return same result as begin()
+     */
+    bool begin(_SPI* spiBus, rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin);
+#endif // defined (RF24_SPI_PTR) || defined (DOXYGEN_FORCED)
+
+    /**
+     * Same as begin(), but allows dynamically specifying a CE pin
+     * and CSN pin to use.
+     * @param _cepin The pin attached to Chip Enable on the RF module
+     * @param _cspin The pin attached to Chip Select (often labeled CSN) on the radio module.
+     * - For the Arduino Due board, the [Arduino Due extended SPI feature](https://www.arduino.cc/en/Reference/DueExtendedSPI)
+     * is not supported. This means that the Due's pins 4, 10, or 52 are not mandated options (can use any digital output pin) for the radio's CSN pin.
+     * @return same result as begin()
+     */
+    bool begin(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin);
+
+    /**
+     * Checks if the chip is connected to the SPI bus
+     */
+    bool isChipConnected();
+
+    /**
+     * Start listening on the pipes opened for reading.
+     *
+     * 1. Be sure to call openReadingPipe() first.
+     * 2. Do not call write() while in this mode, without first calling stopListening().
+     * 3. Call available() to check for incoming traffic, and read() to get it.
+     *
+     * Open reading pipe 1 using address `0xCCCECCCECC`
+     * @code
+     * byte address[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
+     * radio.openReadingPipe(1,address);
+     * radio.startListening();
+     * @endcode
+     *
+     * @note If there was a call to openReadingPipe() about pipe 0 prior to
+     * calling this function, then this function will re-write the address
+     * that was last set to reading pipe 0. This is because openWritingPipe()
+     * will overwrite the address to reading pipe 0 for proper auto-ack
+     * functionality.
+     */
+    void startListening(void);
+
+    /**
+     * Stop listening for incoming messages, and switch to transmit mode.
+     *
+     * Do this before calling write().
+     * @code
+     * radio.stopListening();
+     * radio.write(&data, sizeof(data));
+     * @endcode
+     *
+     * @warning When the ACK payloads feature is enabled, the TX FIFO buffers are
+     * flushed when calling this function. This is meant to discard any ACK
+     * payloads that were not appended to acknowledgment packets.
+     */
+    void stopListening(void);
+
+    /**
+     * @brief Similar to startListening(void) but changes the TX address.
+     * @param txAddress The new TX address.
+     * This value will be cached for auto-ack purposes.
+     */
+    void stopListening(const uint8_t* txAddress);
+
+    /**
+     * Check whether there are bytes available to be read
+     * @code
+     * if(radio.available()){
+     *   radio.read(&data,sizeof(data));
+     * }
+     * @endcode
+     *
+     * @see available(uint8_t*)
+     *
+     * @return True if there is a payload available, false if none is
+     *
+     * @warning This function relies on the information about the pipe number
+     * that received the next available payload. According to the datasheet,
+     * the data about the pipe number that received the next available payload
+     * is "unreliable" during a FALLING transition on the IRQ pin. This means
+     * you should call clearStatusFlags() before calling this function
+     * during an ISR (Interrupt Service Routine). For example:
+     * @code
+     * void isrCallbackFunction() {
+     *   bool tx_ds, tx_df, rx_dr;
+     *   uint8_t flags = radio.clearStatusFlags(); // resets the IRQ pin to HIGH
+     *   radio.available();                        // returned data should now be reliable
+     * }
+     *
+     * void setup() {
+     *   pinMode(IRQ_PIN, INPUT);
+     *   attachInterrupt(digitalPinToInterrupt(IRQ_PIN), isrCallbackFunction, FALLING);
+     * }
+     * @endcode
+     */
+    bool available(void);
+
+    /**
+     * Read payload data from the RX FIFO buffer(s).
+     *
+     * The length of data read is usually the next available payload's length
+     * @see
+     * - getPayloadSize()
+     * - getDynamicPayloadSize()
+     *
+     * @note I specifically chose `void*` as a data type to make it easier
+     * for beginners to use.  No casting needed.
+     *
+     * @param buf Pointer to a buffer where the data should be written
+     * @param len Maximum number of bytes to read into the buffer. This
+     * value should match the length of the object referenced using the
+     * `buf` parameter. The absolute maximum number of bytes that can be read
+     * in one call is 32 (for dynamic payload lengths) or whatever number was
+     * previously passed to setPayloadSize() (for static payload lengths).
+     * @remark
+     * @parblock
+     * Remember that each call to read() fetches data from the
+     * RX FIFO beginning with the first byte from the first available
+     * payload. A payload is not removed from the RX FIFO until it's
+     * entire length (or more) is fetched using read().
+     *
+     * - If `len` parameter's value is less than the available payload's
+     *   length, then the payload remains in the RX FIFO.
+     * - If `len` parameter's value is greater than the first of multiple
+     *   available payloads, then the data saved to the `buf`
+     *   parameter's object will be supplemented with data from the next
+     *   available payload.
+     * - If `len` parameter's value is greater than the last available
+     *   payload's length, then the last byte in the payload is used as
+     *   padding for the data saved to the `buf` parameter's object.
+     *   The nRF24L01 will repeatedly use the last byte from the last
+     *   payload even when read() is called with an empty RX FIFO.
+     * @endparblock
+     * @note To use this function in the python wrapper, remember that
+     * only the `len` parameter is required because this function (in the
+     * python wrapper) returns the payload data as a buffer protocol object
+     * (bytearray object).
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * if radio.available():
+     *     length = radio.getDynamicPayloadSize()  # or radio.getPayloadSize() for static payload sizes
+     *     received_payload = radio.read(length)
+     * @endcode
+     *
+     * @note This function no longer returns a boolean. Use available to
+     * determine if packets are available. The `RX_DR` Interrupt flag is now
+     * cleared with this function instead of when calling available().
+     * @code
+     * if(radio.available()) {
+     *   radio.read(&data, sizeof(data));
+     * }
+     * @endcode
+     */
+    void read(void* buf, uint8_t len);
+
+    /**
+     * Be sure to call openWritingPipe() first to set the destination
+     * of where to write to.
+     *
+     * This blocks until the message is successfully acknowledged by
+     * the receiver or the timeout/retransmit maxima are reached.  In
+     * the current configuration, the max delay here is 60-70ms.
+     *
+     * The maximum size of data written is the fixed payload size, see
+     * getPayloadSize().  However, you can write less, and the remainder
+     * will just be filled with zeroes.
+     *
+     * TX/RX/RT interrupt flags will be cleared every time write is called
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     *
+     * @code
+     * radio.stopListening();
+     * radio.write(&data,sizeof(data));
+     * @endcode
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.write(buffer)
+     * @endcode
+     *
+     * @return
+     * - `true` if the payload was delivered successfully and an acknowledgement
+     *   (ACK packet) was received. If auto-ack is disabled, then any attempt
+     *   to transmit will also return true (even if the payload was not
+     *   received).
+     * - `false` if the payload was sent but was not acknowledged with an ACK
+     *   packet. This condition can only be reported if the auto-ack feature
+     *   is on.
+     */
+    bool write(const void* buf, uint8_t len);
+
+    /**
+     * New: Open a pipe for writing via byte array. Old addressing format retained
+     * for compatibility.
+     *
+     * @deprecated Use `RF24::stopListening(uint8_t*)` instead.
+     *
+     * Only one writing pipe can be opened at once, but this function changes
+     * the address that is used to transmit (ACK payloads/packets do not apply
+     * here). Be sure to call stopListening() prior to calling this function.
+     *
+     * Addresses are assigned via a byte array, default is 5 byte address length
+     *
+     * @code
+     * uint8_t addresses[][6] = {"1Node", "2Node"};
+     * radio.openWritingPipe(addresses[0]);
+     * @endcode
+     * @code
+     * uint8_t address[] = { 0xCC, 0xCE, 0xCC, 0xCE, 0xCC };
+     * radio.openWritingPipe(address);
+     * address[0] = 0x33;
+     * radio.openReadingPipe(1, address);
+     * @endcode
+     *
+     * @warning This function will overwrite the address set to reading pipe 0
+     * as stipulated by the datasheet for proper auto-ack functionality in TX
+     * mode. Use this function to ensure proper transmission acknowledgement
+     * when the address set to reading pipe 0 (via openReadingPipe()) does not
+     * match the address passed to this function. If the auto-ack feature is
+     * disabled, then this function will still overwrite the address for
+     * reading pipe 0 regardless.
+     *
+     * @see
+     * - setAddressWidth()
+     * - startListening()
+     * - stopListening()
+     *
+     * @param address The address to be used for outgoing transmissions (uses
+     * pipe 0). Coordinate this address amongst other receiving nodes (the
+     * pipe numbers don't need to match). This address is cached to ensure proper
+     * auto-ack behavior; stopListening() will always restore the latest cached TX
+     * address.
+     *
+     * @remark There is no address length parameter because this function will
+     * always write the number of bytes that the radio addresses are configured
+     * to use (set with setAddressWidth()).
+     */
+
+    void openWritingPipe(const uint8_t* address);
+
+    /**
+     * Open a pipe for reading
+     *
+     * Up to 6 pipes can be open for reading at once.  Open all the required
+     * reading pipes, and then call startListening().
+     *
+     * @see
+     * - openWritingPipe()
+     * - setAddressWidth()
+     *
+     * @note Pipes 0 and 1 will store a full 5-byte address. Pipes 2-5 will technically
+     * only store a single byte, borrowing up to 4 additional bytes from pipe 1 per the
+     * assigned address width.
+     * Pipes 1-5 should share the same address, except the first byte.
+     * Only the first byte in the array should be unique, e.g.
+     * @code
+     * uint8_t addresses[][6] = {"Prime", "2Node", "3xxxx", "4xxxx"};
+     * openReadingPipe(0, addresses[0]); // address used is "Prime"
+     * openReadingPipe(1, addresses[1]); // address used is "2Node"
+     * openReadingPipe(2, addresses[2]); // address used is "3Node"
+     * openReadingPipe(3, addresses[3]); // address used is "4Node"
+     * @endcode
+     *
+     * @warning
+     * @parblock
+     * If the reading pipe 0 is opened by this function, the address
+     * passed to this function (for pipe 0) will be restored at every call to
+     * startListening().
+     *
+     * Read
+     * http://maniacalbits.blogspot.com/2013/04/rf24-addressing-nrf24l01-radios-require.html
+     * to understand how to avoid using malformed addresses. This address
+     * restoration is implemented because of the underlying necessary
+     * functionality of openWritingPipe().
+     * @endparblock
+     *
+     * @param number Which pipe to open. Only pipe numbers 0-5 are available,
+     * an address assigned to any pipe number not in that range will be ignored.
+     * @param address The 24, 32 or 40 bit address of the pipe to open.
+     *
+     * There is no address length parameter because this function will
+     * always write the number of bytes (for pipes 0 and 1) that the radio
+     * addresses are configured to use (set with setAddressWidth()).
+     */
+    void openReadingPipe(uint8_t number, const uint8_t* address);
+
+    /**@}*/
+    /**
+     * @name Advanced Operation
+     *
+     * Methods you can use to drive the chip in more advanced ways
+     */
+    /**@{*/
+
+    /**
+     * Set radio's CE (Chip Enable) pin state.
+     *
+     * @warning Please see the datasheet for a much more detailed description of this pin.
+     *
+     * @note This is only publicly exposed for advanced use cases such as complex networking or
+     * streaming consecutive payloads without robust error handling.
+     * Typical uses are satisfied by simply using `startListening()` for RX mode or
+     * `stopListening()` and `write()` for TX mode.
+     *
+     * @param level In RX mode, `HIGH` causes the radio to begin actively listening.
+     * In TX mode, `HIGH` (+ 130 microsecond delay) causes the radio to begin transmitting.
+     * Setting this to `LOW` will cause the radio to stop transmitting or receiving in any mode.
+     */
+    void ce(bool level);
+
+    /**
+     * Print a giant block of debugging information to stdout
+     *
+     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+     * The printf.h file is included with the library for Arduino.
+     * @code
+     * #include <printf.h>
+     * setup() {
+     *   Serial.begin(115200);
+     *   printf_begin();
+     *   // ...
+     * }
+     * @endcode
+     */
+    void printDetails(void);
+
+    /**
+     * Decode and print the given STATUS byte to stdout.
+     *
+     * @param flags The STATUS byte to print.
+     * This value is fetched with update() or getStatusFlags().
+     *
+     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+     */
+    void printStatus(uint8_t flags);
+
+    /**
+     * Print a giant block of debugging information to stdout. This function
+     * differs from printDetails() because it makes the information more
+     * understandable without having to look up the datasheet or convert
+     * hexadecimal to binary. Only use this function if your application can
+     * spare extra bytes of memory.
+     *
+     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+     * The printf.h file is included with the library for Arduino.
+     * @code
+     * #include <printf.h>
+     * setup() {
+     *   Serial.begin(115200);
+     *   printf_begin();
+     *   // ...
+     * }
+     * @endcode
+     *
+     * @note If the automatic acknowledgements feature is configured differently
+     * for each pipe, then a binary representation is used in which bits 0-5
+     * represent pipes 0-5 respectively. A `0` means the feature is disabled, and
+     * a `1` means the feature is enabled.
+     */
+    void printPrettyDetails(void);
+
+    /**
+     * Put a giant block of debugging information in a char array. This function
+     * differs from printPrettyDetails() because it uses `sprintf()` and does not use
+     * a predefined output stream (like `Serial` or stdout). Only use this function if
+     * your application can spare extra bytes of memory. This can also be used for boards that
+     * do not support `printf()` (which is required for printDetails() and printPrettyDetails()).
+     *
+     * @remark
+     * The C standard function [sprintf()](http://www.cplusplus.com/reference/cstdio/sprintf)
+     * formats a C-string in the exact same way as `printf()` but outputs (by reference)
+     * into a char array. The formatted string literal for sprintf() is stored
+     * in nonvolatile program memory.
+     *
+     * @warning Use a buffer of sufficient size for the `debugging_information`. Start
+     * with a char array that has at least 870 elements. There is no overflow protection when using
+     * sprintf(), so the output buffer must be sized correctly or the resulting behavior will
+     * be undefined.
+     * @code
+     * char buffer[870] = {'\0'};
+     * uint16_t used_chars = radio.sprintfPrettyDetails(buffer);
+     * Serial.println(buffer);
+     * Serial.print(F("strlen = "));
+     * Serial.println(used_chars + 1); // +1 for c-strings' null terminating byte
+     * @endcode
+     *
+     * @param debugging_information The c-string buffer that the debugging
+     * information is stored to. This must be allocated to a minimum of 870 bytes of memory.
+     * @returns The number of characters altered in the given buffer. Remember that,
+     * like `sprintf()`, this returned number does not include the null terminating byte.
+     *
+     * This function is available in the python wrapper, but it accepts no parameters and
+     * returns a string. It does not return the number of characters in the string.
+     * @code{.py}
+     * debug_info = radio.sprintfPrettyDetails()
+     * print(debug_info)
+     * print("str_len =", len(debug_info))
+     * @endcode
+     *
+     * @note If the automatic acknowledgements feature is configured differently
+     * for each pipe, then a binary representation is used in which bits 0-5
+     * represent pipes 0-5 respectively. A `0` means the feature is disabled, and
+     * a `1` means the feature is enabled.
+     */
+    uint16_t sprintfPrettyDetails(char* debugging_information);
+
+    /**
+     * Encode radio debugging information into an array of uint8_t. This function
+     * differs from other debug output methods because the debug information can
+     * be decoded by an external program.
+     *
+     * This function is not available in the python wrapper because it is intended for
+     * use on processors with very limited available resources.
+     *
+     * @remark
+     * This function uses much less ram than other `*print*Details()` methods.
+     *
+     * @code
+     * uint8_t encoded_details[43] = {0};
+     * radio.encodeRadioDetails(encoded_details);
+     * @endcode
+     *
+     * @param encoded_status The uint8_t array that RF24 radio details are
+     * encoded into. This array must be at least 43 bytes in length; any less would surely
+     * cause undefined behavior.
+     *
+     * Registers names and/or data corresponding to the index of the `encoded_details` array:
+     * | index | register/data |
+     * |------:|:--------------|
+     * | 0 |     NRF_CONFIG |
+     * | 1 |     EN_AA |
+     * | 2 |     EN_RXADDR |
+     * | 3 |     SETUP_AW |
+     * | 4 |     SETUP_RETR |
+     * | 5 |     RF_CH |
+     * | 6 |     RF_SETUP |
+     * | 7 |     NRF_STATUS |
+     * | 8 |     OBSERVE_TX |
+     * | 9 |     CD (aka RPD) |
+     * | 10-14 | RX_ADDR_P0 |
+     * | 15-19 | RX_ADDR_P1 |
+     * | 20 |    RX_ADDR_P2 |
+     * | 21 |    RX_ADDR_P3 |
+     * | 22 |    RX_ADDR_P4 |
+     * | 23 |    RX_ADDR_P5 |
+     * | 24-28 | TX_ADDR |
+     * | 29 |    RX_PW_P0 |
+     * | 30 |    RX_PW_P1 |
+     * | 31 |    RX_PW_P2 |
+     * | 32 |    RX_PW_P3 |
+     * | 33 |    RX_PW_P4 |
+     * | 34 |    RX_PW_P5 |
+     * | 35 |    FIFO_STATUS |
+     * | 36 |    DYNPD |
+     * | 37 |    FEATURE |
+     * | 38-39 | ce_pin |
+     * | 40-41 | csn_pin |
+     * | 42 |    SPI speed (in MHz) or'd with (isPlusVariant << 4) |
+     */
+    void encodeRadioDetails(uint8_t* encoded_status);
+
+    /**
+     * Test whether there are bytes available to be read from the
+     * FIFO buffers.
+     *
+     * @note This function is named `available_pipe()` in the python wrapper.
+     * @parblock
+     * Additionally, the `available_pipe()` function (which
+     * takes no arguments) returns a 2 item tuple containing (ordered by
+     * tuple's indices):
+     * - A boolean describing if there is a payload available to read from
+     *   the RX FIFO buffers.
+     * - The pipe number that received the next available payload in the RX
+     *   FIFO buffers. If the item at the tuple's index 0 is `False`, then
+     *   this pipe number is invalid.
+     *
+     * To use this function in python:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * has_payload, pipe_number = radio.available_pipe()  # expand the tuple to 2 variables
+     * if has_payload:
+     *     print("Received a payload with pipe", pipe_number)
+     * @endcode
+     * @endparblock
+     *
+     * @param[out] pipe_num Which pipe has the payload available
+     * @code
+     * uint8_t pipeNum;
+     * if(radio.available(&pipeNum)){
+     *   radio.read(&data, sizeof(data));
+     *   Serial.print("Received data on pipe ");
+     *   Serial.println(pipeNum);
+     * }
+     * @endcode
+     *
+     * @warning According to the datasheet, the data saved to `pipe_num` is
+     * "unreliable" during a FALLING transition on the IRQ pin. This means you
+     * should call clearStatusFlags() before calling this function during
+     * an ISR (Interrupt Service Routine). For example:
+     * @code
+     * void isrCallbackFunction() {
+     *   radio.clearStatusFlags(); // resets the IRQ pin to inactive HIGH
+     *   uint8_t pipe = 7;         // initialize pipe data
+     *   radio.available(&pipe);   // pipe data should now be reliable
+     * }
+     *
+     * void setup() {
+     *   pinMode(IRQ_PIN, INPUT);
+     *   attachInterrupt(digitalPinToInterrupt(IRQ_PIN), isrCallbackFunction, FALLING);
+     * }
+     * @endcode
+     *
+     * @return
+     * - `true` if there is a payload available in the top (first out)
+     *   level RX FIFO.
+     * - `false` if there is nothing available in the RX FIFO because it is
+     *   empty.
+     */
+    bool available(uint8_t* pipe_num);
+
+    /**
+     * Use this function to check if the radio's RX FIFO levels are all
+     * occupied. This can be used to prevent data loss because any incoming
+     * transmissions are rejected if there is no unoccupied levels in the RX
+     * FIFO to store the incoming payload. Remember that each level can hold
+     * up to a maximum of 32 bytes.
+     * @return
+     * - `true` if all three 3 levels of the RX FIFO buffers are occupied.
+     * - `false` if there is one or more levels available in the RX FIFO
+     *   buffers. Remember that this does not always mean that the RX FIFO
+     *   buffers are empty; use available() to see if the RX FIFO buffers are
+     *   empty or not.
+     */
+    bool rxFifoFull();
+
+    /**
+     * @param about_tx `true` focuses on the TX FIFO, `false` focuses on the RX FIFO
+     * @return
+     * - @ref RF24_FIFO_OCCUPIED (`0`) if the specified FIFO is neither full nor empty.
+     * - @ref RF24_FIFO_EMPTY (`1`) if the specified FIFO is empty.
+     * - @ref RF24_FIFO_FULL (`2`) if the specified FIFO is full.
+     * - @ref RF24_FIFO_INVALID (`3`) if the data fetched over SPI was malformed.
+     */
+    rf24_fifo_state_e isFifo(bool about_tx);
+
+    /**
+     * @deprecated Use RF24::isFifo(bool about_tx) instead.
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * @param about_tx `true` focuses on the TX FIFO, `false` focuses on the RX FIFO
+     * @param check_empty
+     * - `true` checks if the specified FIFO is empty
+     * - `false` checks is the specified FIFO is full.
+     * @return A boolean answer to the question "is the [TX/RX] FIFO [empty/full]?"
+     */
+    bool isFifo(bool about_tx, bool check_empty);
+
+    /**
+     * Enter low-power mode
+     *
+     * To return to normal power mode, call powerUp().
+     *
+     * @note After calling startListening(), a basic radio will consume about 13.5mA
+     * at max PA level.
+     * During active transmission, the radio will consume about 11.5mA, but this will
+     * be reduced to 26uA (.026mA) between sending.
+     * In full powerDown mode, the radio will consume approximately 900nA (.0009mA)
+     *
+     * @code
+     * radio.powerDown();
+     * avr_enter_sleep_mode(); // Custom function to sleep the device
+     * radio.powerUp();
+     * @endcode
+     */
+    void powerDown(void);
+
+    /**
+     * Leave low-power mode - required for normal radio operation after calling powerDown()
+     *
+     * To return to low power mode, call powerDown().
+     * @note This will take up to 5ms for maximum compatibility
+     */
+    void powerUp(void);
+
+    /**
+     * Write for single NOACK writes. Optionally disable
+     * acknowledgements/auto-retries for a single payload using the
+     * multicast parameter set to true.
+     *
+     * Can be used with enableAckPayload() to request a response
+     * @see
+     * - setAutoAck()
+     * - write()
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     * @param multicast Request ACK response (false), or no ACK response
+     * (true). Be sure to have called enableDynamicAck() at least once before
+     * setting this parameter.
+     * @return
+     * - `true` if the payload was delivered successfully and an acknowledgement
+     *   (ACK packet) was received. If auto-ack is disabled, then any attempt
+     *   to transmit will also return true (even if the payload was not
+     *   received).
+     * - `false` if the payload was sent but was not acknowledged with an ACK
+     *   packet. This condition can only be reported if the auto-ack feature
+     *   is on.
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.write(buffer, False)  # False = the multicast parameter
+     * @endcode
+     */
+    bool write(const void* buf, uint8_t len, const bool multicast);
+
+    /**
+     * This will not block until the 3 FIFO buffers are filled with data.
+     * Once the FIFOs are full, writeFast() will simply wait for a buffer to
+     * become available or a transmission failure (returning `true` or `false`
+     * respectively).
+     *
+     * @warning
+     * @parblock
+     * It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
+     * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
+     * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
+     *
+     * Use txStandBy() when this function returns `false`.
+     *
+     * Example (Partial blocking):
+     * @code
+     * radio.writeFast(&buf,32);  // Writes 1 payload to the buffers
+     * txStandBy();     		   // Returns 0 if failed. 1 if success. Blocks only until MAX_RT timeout or success. Data flushed on fail.
+     *
+     * radio.writeFast(&buf,32);  // Writes 1 payload to the buffers
+     * txStandBy(1000);		   // Using extended timeouts, returns 1 if success. Retries failed payloads for 1 seconds before returning 0.
+     * @endcode
+     * @endparblock
+     *
+     * @see
+     * - setAutoAck()
+     * - txStandBy()
+     * - write()
+     * - writeBlocking()
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     * @return
+     * - `true` if the payload passed to `buf` was loaded in the TX FIFO.
+     * - `false` if the payload passed to `buf` was not loaded in the TX FIFO
+     *   because a previous payload already in the TX FIFO failed to
+     *   transmit. This condition can only be reported if the auto-ack feature
+     *   is on.
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.writeFast(buffer)
+     * @endcode
+     */
+    bool writeFast(const void* buf, uint8_t len);
+
+    /**
+     * Similar to writeFast(const void*, uint8_t) but allows for single NOACK writes.
+     * Optionally disable acknowledgements/auto-retries for a single payload using the
+     * multicast parameter set to `true`.
+     *
+     * @warning If the auto-ack feature is enabled, then it is strongly encouraged to call
+     * txStandBy() when this function returns `false`.
+     *
+     * @see
+     * - setAutoAck()
+     * - txStandBy()
+     * - write()
+     * - writeBlocking()
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     * @param multicast Request ACK response (false), or no ACK response
+     * (true). Be sure to have called enableDynamicAck() at least once before
+     * setting this parameter.
+     * @return
+     * - `true` if the payload passed to `buf` was loaded in the TX FIFO.
+     * - `false` if the payload passed to `buf` was not loaded in the TX FIFO
+     *   because a previous payload already in the TX FIFO failed to
+     *   transmit. This condition can only be reported if the auto-ack feature
+     *   is on (and the multicast parameter is set to false).
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.writeFast(buffer, False)  # False = the multicast parameter
+     * @endcode
+     */
+    bool writeFast(const void* buf, uint8_t len, const bool multicast);
+
+    /**
+     * This function extends the auto-retry mechanism to any specified duration.
+     * It will not block until the 3 FIFO buffers are filled with data.
+     * If so the library will auto retry until a new payload is written
+     * or the user specified timeout period is reached.
+     * @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
+     * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
+     * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
+     *
+     * Example (Full blocking):
+     * @code
+     * radio.writeBlocking(&buf, sizeof(buf), 1000); // Wait up to 1 second to write 1 payload to the buffers
+     * radio.txStandBy(1000);                        // Wait up to 1 second for the payload to send. Return 1 if ok, 0 if failed.
+     *                                               // Blocks only until user timeout or success. Data flushed on fail.
+     * @endcode
+     * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
+     * @see
+     * - txStandBy()
+     * - write()
+     * - writeFast()
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     * @param timeout User defined timeout in milliseconds.
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.writeBlocking(buffer, 1000)  # 1000 means wait at most 1 second
+     * @endcode
+     *
+     * @return
+     * - `true` if the payload passed to `buf` was loaded in the TX FIFO.
+     * - `false` if the payload passed to `buf` was not loaded in the TX FIFO
+     *   because a previous payload already in the TX FIFO failed to
+     *   transmit. This condition can only be reported if the auto-ack feature
+     *   is on.
+     */
+    bool writeBlocking(const void* buf, uint8_t len, uint32_t timeout);
+
+    /**
+     * This function should be called as soon as transmission is finished to
+     * drop the radio back to STANDBY-I mode. If not issued, the radio will
+     * remain in STANDBY-II mode which, per the data sheet, is not a recommended
+     * operating mode.
+     *
+     * @note When transmitting data in rapid succession, it is still recommended by
+     * the manufacturer to drop the radio out of TX or STANDBY-II mode if there is
+     * time enough between sends for the FIFOs to empty. This is not required if auto-ack
+     * is enabled.
+     *
+     * Relies on built-in auto retry functionality.
+     *
+     * Example (Partial blocking):
+     * @code
+     * radio.writeFast(&buf, 32);
+     * radio.writeFast(&buf, 32);
+     * radio.writeFast(&buf, 32);   //Fills the FIFO buffers up
+     * bool ok = radio.txStandBy(); //Returns 0 if failed. 1 if success.
+     *                              //Blocks only until MAX_RT timeout or success. Data flushed on fail.
+     * @endcode
+     * @see txStandBy(uint32_t timeout, bool startTx)
+     * @return
+     * - `true` if all payloads in the TX FIFO were delivered successfully and
+     *   an acknowledgement (ACK packet) was received for each. If auto-ack is
+     *   disabled, then any attempt to transmit will also return true (even if
+     *   the payload was not received).
+     * - `false` if a payload was sent but was not acknowledged with an ACK
+     *   packet. This condition can only be reported if the auto-ack feature
+     *   is on.
+     */
+    bool txStandBy();
+
+    /**
+     * This function allows extended blocking and auto-retries per a user defined timeout
+     *
+     * Fully Blocking Example:
+     * @code
+     * radio.writeFast(&buf, 32);
+     * radio.writeFast(&buf, 32);
+     * radio.writeFast(&buf, 32);       //Fills the FIFO buffers up
+     * bool ok = radio.txStandBy(1000); //Returns 0 if failed after 1 second of retries. 1 if success.
+     *                                  //Blocks only until user defined timeout or success. Data flushed on fail.
+     * @endcode
+     * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
+     * @param timeout Number of milliseconds to retry failed payloads
+     * @param startTx If this is set to `true`, then this function puts the nRF24L01
+     * in TX Mode. `false` leaves the primary mode (TX or RX) as it is, which can
+     * prevent the mandatory wait time to change modes.
+     * @return
+     * - `true` if all payloads in the TX FIFO were delivered successfully and
+     *   an acknowledgement (ACK packet) was received for each. If auto-ack is
+     *   disabled, then any attempt to transmit will also return true (even if
+     *   the payload was not received).
+     * - `false` if a payload was sent but was not acknowledged with an ACK
+     *   packet. This condition can only be reported if the auto-ack feature
+     *   is on.
+     */
+    bool txStandBy(uint32_t timeout, bool startTx = 0);
+
+    /**
+     * Write an acknowledgement (ACK) payload for the specified pipe
+     *
+     * The next time a message is received on a specified `pipe`, the data in
+     * `buf` will be sent back in the ACK payload.
+     *
+     * @see
+     * - enableAckPayload()
+     * - enableDynamicPayloads()
+     *
+     * @note ACK payloads are handled automatically by the radio chip when a
+     * regular payload is received. It is important to discard regular payloads
+     * in the TX FIFO (using flush_tx()) before loading the first ACK payload
+     * into the TX FIFO. This function can be called before and after calling
+     * startListening().
+     *
+     * @warning Only three of these can be pending at any time as there are
+     * only 3 FIFO buffers. Dynamic payloads must be enabled.
+     *
+     * @note ACK payloads are dynamic payloads. Calling enableAckPayload()
+     * will automatically enable dynamic payloads on pipe 0 (required for TX
+     * mode when expecting ACK payloads) & pipe 1. To use ACK payloads on any other
+     * pipe in RX mode, call enableDynamicPayloads().
+     *
+     * @param pipe Which pipe# (typically 1-5) will get this response.
+     * @param buf Pointer to data that is sent
+     * @param len Length of the data to send, up to 32 bytes max.  Not affected
+     * by the static payload size set by setPayloadSize().
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.writeAckPayload(1, buffer)  # load an ACK payload for response on pipe 1
+     * @endcode
+     *
+     * @return
+     * - `true` if the payload was loaded into the TX FIFO.
+     * - `false` if the payload wasn't loaded into the TX FIFO because it is
+     *   already full or the ACK payload feature is not enabled using
+     *   enableAckPayload().
+     */
+    bool writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
+
+    /**
+     * Clear the Status flags that caused an interrupt event.
+     *
+     * @remark This function is similar to `whatHappened()` because it also returns the
+     * Status flags that caused the interrupt event. However, this function returns
+     * a STATUS byte instead of bit-banging into 3 1-byte booleans
+     * passed by reference.
+     *
+     * @note When used in an ISR (Interrupt Service routine), there is a chance that the
+     * returned bits 0b1110 (rx_pipe number) is inaccurate. See available(uint8_t*) (or the
+     * datasheet) for more detail.
+     *
+     * @param flags The IRQ flags to clear. Default value is all of them (`RF24_IRQ_ALL`).
+     * Multiple flags can be cleared by OR-ing rf24_irq_flags_e values together.
+     *
+     * @returns The STATUS byte from the radio's register before it was modified. Use
+     * enumerations of rf24_irq_flags_e as masks to interpret the STATUS byte's meaning(s).
+     *
+     * @ingroup StatusFlags
+     */
+    uint8_t clearStatusFlags(uint8_t flags = RF24_IRQ_ALL);
+
+    /**
+     * Set which flags shall be reflected on the radio's IRQ pin.
+     *
+     * @remarks This function is similar to maskIRQ() but with less confusing parameters.
+     *
+     * @param flags A value of rf24_irq_flags_e to influence the radio's IRQ pin.
+     * The default value (`RF24_IRQ_NONE`) will disable the radio's IRQ pin.
+     * Multiple events can be enabled by OR-ing rf24_irq_flags_e values together.
+     * ```cpp
+     * radio.setStatusFlags(RF24_IRQ_ALL);
+     * // is equivalent to
+     * radio.setStatusFlags(RF24_RX_DR | RF24_TX_DS | RF24_TX_DF);
+     * ```
+     *
+     * @ingroup StatusFlags
+     */
+    void setStatusFlags(uint8_t flags = RF24_IRQ_NONE);
+
+    /**
+     * Get the latest STATUS byte returned from the last SPI transaction.
+     *
+     * @note This does not actually perform any SPI transaction with the radio.
+     * Use `RF24::update()` instead to get a fresh copy of the Status flags at
+     * the slight cost of performance.
+     *
+     * @returns The STATUS byte from the radio's register as the latest SPI transaction. Use
+     * enumerations of rf24_irq_flags_e as masks to interpret the STATUS byte's meaning(s).
+     *
+     * @ingroup StatusFlags
+     */
+    uint8_t getStatusFlags();
+
+    /**
+     * Get an updated STATUS byte from the radio.
+     *
+     * @returns The STATUS byte fetched from the radio's register. Use enumerations of
+     * rf24_irq_flags_e as masks to interpret the STATUS byte's meaning(s).
+     *
+     * @ingroup StatusFlags
+     */
+    uint8_t update();
+
+    /**
+     * Non-blocking write to the open writing pipe used for buffered writes
+     *
+     * @note Optimization: This function now leaves the CE pin high, so the radio
+     * will remain in TX or STANDBY-II Mode until a txStandBy() command is issued. Can be used as an alternative to startWrite()
+     * if writing multiple payloads at once.
+     * @warning It is important to never keep the nRF24L01 in TX mode with FIFO full for more than 4ms at a time. If the auto
+     * retransmit/autoAck is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
+     * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
+     *
+     * @see
+     * - write()
+     * - writeFast()
+     * - startWrite()
+     * - writeBlocking()
+     * - setAutoAck() (for single noAck writes)
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     * @param multicast Request ACK response (false), or no ACK response
+     * (true). Be sure to have called enableDynamicAck() at least once before
+     * setting this parameter.
+     * @param startTx If this is set to `true`, then this function sets the
+     * nRF24L01's CE pin to active (enabling TX transmissions). `false` has no
+     * effect on the nRF24L01's CE pin and simply loads the payload into the
+     * TX FIFO.
+     *
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.startFastWrite(buffer, False, True)  # 3rd parameter is optional
+     * #     False means expecting ACK response (multicast parameter)
+     * #     True means initiate transmission (startTx parameter)
+     * @endcode
+     */
+    void startFastWrite(const void* buf, uint8_t len, const bool multicast, bool startTx = 1);
+
+    /**
+     * Non-blocking write to the open writing pipe
+     *
+     * Just like write(), but it returns immediately. To find out what happened
+     * to the send, catch the IRQ and then call clearStatusFlags() or update().
+     *
+     * @see
+     * - write()
+     * - writeFast()
+     * - startFastWrite()
+     * - clearStatusFlags()
+     * - setAutoAck() (for single noAck writes)
+     *
+     * @param buf Pointer to the data to be sent
+     * @param len Number of bytes to be sent
+     * @param multicast Request ACK response (false), or no ACK response
+     * (true). Be sure to have called enableDynamicAck() at least once before
+     * setting this parameter.
+     *
+     * @return
+     * - `true` if payload was written to the TX FIFO buffers and the
+     *   transmission was started.
+     * - `false` if the TX FIFO is full and the payload could not be written. In
+     *   this condition, the transmission process is restarted.
+     * @note The `len` parameter must be omitted when using the python
+     * wrapper because the length of the payload is determined automatically.
+     * To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * buffer = b"Hello World"  # a `bytes` object
+     * radio.startWrite(buffer, False)  # False = the multicast parameter
+     * @endcode
+     */
+    bool startWrite(const void* buf, uint8_t len, const bool multicast);
+
+    /**
+     * The function will instruct the radio to re-use the payload in the
+     * top level (first out) of the TX FIFO buffers. This is used internally
+     * by writeBlocking() to initiate retries when a TX failure
+     * occurs. Retries are automatically initiated except with the standard
+     * write(). This way, data is not flushed from the buffer until calling
+     * flush_tx(). If the TX FIFO has only the one payload (in the top level),
+     * the re-used payload can be overwritten by using write(), writeFast(),
+     * writeBlocking(), startWrite(), or startFastWrite(). If the TX FIFO has
+     * other payloads enqueued, then the aforementioned functions will attempt
+     * to enqueue the a new payload in the TX FIFO (does not overwrite the top
+     * level of the TX FIFO). Currently, stopListening() also calls flush_tx()
+     * when ACK payloads are enabled (via enableAckPayload()).
+     *
+     * Upon exiting, this function will set the CE pin HIGH to initiate the
+     * re-transmission process. If only 1 re-transmission is desired, then the
+     * CE pin should be set to LOW after the mandatory minumum pulse duration
+     * of 10 microseconds.
+     *
+     * @remark This function only applies when taking advantage of the
+     * auto-retry feature. See setAutoAck() and setRetries() to configure the
+     * auto-retry feature.
+     *
+     * @note This is to be used AFTER auto-retry fails if wanting to resend
+     * using the built-in payload reuse feature. After issuing reUseTX(), it
+     * will keep resending the same payload until a transmission failure
+     * occurs or the CE pin is set to LOW (whichever comes first). In the
+     * event of a re-transmission failure, simply call this function again to
+     * resume re-transmission of the same payload.
+     */
+    void reUseTX();
+
+    /**
+     * Empty all 3 of the TX (transmit) FIFO buffers. This is automatically
+     * called by stopListening() if ACK payloads are enabled. However,
+     * startListening() does not call this function.
+     *
+     * @return Current value of status register
+     */
+    uint8_t flush_tx(void);
+
+    /**
+     * Empty all 3 of the RX (receive) FIFO buffers.
+     *
+     * @return Current value of status register
+     */
+    uint8_t flush_rx(void);
+
+    /**
+     * Test whether there was a carrier on the line for the
+     * previous listening period.
+     *
+     * Useful to check for interference on the current channel.
+     *
+     * @return true if was carrier, false if not
+     */
+    bool testCarrier(void);
+
+    /**
+     * Test whether a signal (carrier or otherwise) greater than
+     * or equal to -64dBm is present on the channel. Valid only
+     * on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
+     *
+     * Useful to check for interference on the current channel and
+     * channel hopping strategies.
+     *
+     * @code
+     * bool goodSignal = radio.testRPD();
+     * if(radio.available()){
+     *    Serial.println(goodSignal ? "Strong signal > -64dBm" : "Weak signal < -64dBm" );
+     *    radio.read(&payload,sizeof(payload));
+     * }
+     * @endcode
+     * @return true if a signal greater than or equal to -64dBm was detected,
+     * false if not.
+     */
+    bool testRPD(void);
+
+    /**
+     * Test whether this is a real radio, or a mock shim for
+     * debugging.  Setting either pin to 0xff is the way to
+     * indicate that this is not a real radio.
+     *
+     * @return true if this is a legitimate radio
+     */
+    bool isValid();
+
+    /**
+     * Close a pipe after it has been previously opened.
+     * Can be safely called without having previously opened a pipe.
+     * @param pipe Which pipe number to close, any integer not in range [0, 5]
+     * is ignored.
+     */
+    void closeReadingPipe(uint8_t pipe);
+
+#if defined(FAILURE_HANDLING)
+    /**
+     *
+     * If a failure has been detected, it usually indicates a hardware issue. By default the library
+     * will cease operation when a failure is detected.
+     * This should allow advanced users to detect and resolve intermittent hardware issues.
+     *
+     * In most cases, the radio must be re-enabled via radio.begin(); and the appropriate settings
+     * applied after a failure occurs, if wanting to re-enable the device immediately.
+     *
+     * The three main failure modes of the radio include:
+     *
+     * 1. Writing to radio: Radio unresponsive
+     *     - Fixed internally by adding a timeout to the internal write functions in RF24 (failure handling)
+     * 2. Reading from radio: Available returns true always
+     *     - Fixed by adding a timeout to available functions by the user. This is implemented internally in  RF24Network.
+     * 3. Radio configuration settings are lost
+     *     - Fixed by monitoring a value that is different from the default, and re-configuring the radio if this setting reverts to the default.
+     *
+     * See the included example, GettingStarted_HandlingFailures
+     *
+     * @code
+     * if(radio.failureDetected) {
+     *   radio.begin();                          // Attempt to re-configure the radio with defaults
+     *   radio.failureDetected = 0;              // Reset the detection value
+     *   radio.openWritingPipe(addresses[1]);    // Re-configure pipe addresses
+     *   radio.openReadingPipe(1, addresses[0]);
+     *   report_failure();                       // Blink LEDs, send a message, etc. to indicate failure
+     * }
+     * @endcode
+     */
+    bool failureDetected;
+#endif // defined (FAILURE_HANDLING)
+
+    /**@}*/
+    /**
+     * @name Optional Configurators
+     *
+     *  Methods you can use to get or set the configuration of the chip.
+     *  None are required.  Calling begin() sets up a reasonable set of
+     *  defaults.
+     */
+    /**@{*/
+
+    /**
+     * Set the address width from 3 to 5 bytes (24, 32 or 40 bit)
+     *
+     * @param a_width The address width (in bytes) to use; this can be 3, 4 or
+     * 5.
+     */
+    void setAddressWidth(uint8_t a_width);
+
+    /**
+     * Set the number of retry attempts and delay between retry attempts when
+     * transmitting a payload. The radio is waiting for an acknowledgement
+     * (ACK) packet during the delay between retry attempts.
+     *
+     * @param delay How long to wait between each retry, in multiples of
+     * 250 us. The minimum of 0 means 250 us, and the maximum of 15 means
+     * 4000 us. The default value of 5 means 1500us (5 * 250 + 250).
+     * @param count How many retries before giving up. The default/maximum is 15. Use
+     * 0 to disable the auto-retry feature all together.
+     *
+     * @note Disable the auto-retry feature on a transmitter still uses the
+     * auto-ack feature (if enabled), except it will not retry to transmit if
+     * the payload was not acknowledged on the first attempt.
+     */
+    void setRetries(uint8_t delay, uint8_t count);
+
+    /**
+     * Set RF communication channel. The frequency used by a channel is
+     * calculated as:
+     * @verbatim 2400 MHz + <channel number> @endverbatim
+     * Meaning the default channel of 76 uses the approximate frequency of
+     * 2476 MHz.
+     *
+     * @note In the python wrapper, this function is the setter of the
+     * `channel` attribute.To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * radio.channel = 2  # set the channel to 2 (2402 MHz)
+     * @endcode
+     *
+     * @param channel Which RF channel to communicate on, 0-125
+     */
+    void setChannel(uint8_t channel);
+
+    /**
+     * Get RF communication channel
+     *
+     * @note In the python wrapper, this function is the getter of the
+     * `channel` attribute.To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * chn = radio.channel  # get the channel
+     * @endcode
+     *
+     * @return The currently configured RF Channel
+     */
+    uint8_t getChannel(void);
+
+    /**
+     * Set Static Payload Size
+     *
+     * This implementation uses a pre-established fixed payload size for all
+     * transmissions.  If this method is never called, the driver will always
+     * transmit the maximum payload size (32 bytes), no matter how much
+     * was sent to write().
+     *
+     * @note In the python wrapper, this function is the setter of the
+     * `payloadSize` attribute.To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * radio.payloadSize = 16  # set the static payload size to 16 bytes
+     * @endcode
+     *
+     * @param size The number of bytes in the payload
+     */
+    void setPayloadSize(uint8_t size);
+
+    /**
+     * Get Static Payload Size
+     *
+     * @note In the python wrapper, this function is the getter of the
+     * `payloadSize` attribute.To use this function in the python wrapper:
+     * @code{.py}
+     * # let `radio` be the instantiated RF24 object
+     * pl_size = radio.payloadSize  # get the static payload size
+     * @endcode
+     *
+     * @see setPayloadSize()
+     *
+     * @return The number of bytes in the payload
+     */
+    uint8_t getPayloadSize(void);
+
+    /**
+     * Get Dynamic Payload Size
+     *
+     * For dynamic payloads, this pulls the size of the payload off
+     * the chip
+     *
+     * @note Corrupt packets are now detected and flushed per the
+     * manufacturer.
+     * @code
+     * if(radio.available()){
+     *   if(radio.getDynamicPayloadSize() < 1){
+     *     // Corrupt payload has been flushed
+     *     return;
+     *   }
+     *   radio.read(&data,sizeof(data));
+     * }
+     * @endcode
+     *
+     * @return Payload length of last-received dynamic payload
+     */
+    uint8_t getDynamicPayloadSize(void);
+
+    /**
+     * Enable custom payloads in the acknowledge packets
+     *
+     * ACK payloads are a handy way to return data back to senders without
+     * manually changing the radio modes on both units.
+     *
+     * @remarks The ACK payload feature requires the auto-ack feature to be
+     * enabled for any pipe using ACK payloads. This function does not
+     * automatically enable the auto-ack feature on pipe 0 since the auto-ack
+     * feature is enabled for all pipes by default.
+     *
+     * @see setAutoAck()
+     *
+     * @note ACK payloads are dynamic payloads. This function automatically
+     * enables dynamic payloads on pipes 0 & 1 by default. Call
+     * enableDynamicPayloads() to enable on all pipes (especially for RX nodes
+     * that use pipes other than pipe 0 to receive transmissions expecting
+     * responses with ACK payloads).
+     */
+    void enableAckPayload(void);
+
+    /**
+     * Disable custom payloads on the acknowledge packets
+     *
+     * @see enableAckPayload()
+     */
+    void disableAckPayload(void);
+
+    /**
+     * Enable dynamically-sized payloads
+     *
+     * This way you don't always have to send large packets just to send them
+     * once in a while. This enables dynamic payloads on ALL pipes.
+     *
+     */
+    void enableDynamicPayloads(void);
+
+    /**
+     * Disable dynamically-sized payloads
+     *
+     * This disables dynamic payloads on ALL pipes. Since Ack Payloads
+     * requires Dynamic Payloads, Ack Payloads are also disabled.
+     * If dynamic payloads are later re-enabled and ack payloads are desired
+     * then enableAckPayload() must be called again as well.
+     *
+     */
+    void disableDynamicPayloads(void);
+
+    /**
+     * Enable dynamic ACKs (single write multicast or unicast) for chosen
+     * messages.
+     *
+     * @note This function must be called once before using the multicast
+     * parameter for any functions that offer it. To use multicast behavior
+     * about all outgoing payloads (using pipe 0) or incoming payloads
+     * (concerning all RX pipes), use setAutoAck()
+     *
+     * @see
+     * - setAutoAck() for all pipes
+     * - setAutoAck(uint8_t, bool) for individual pipes
+     *
+     * @code
+     * radio.write(&data, 32, 1); // Sends a payload with no acknowledgement requested
+     * radio.write(&data, 32, 0); // Sends a payload using auto-retry/autoACK
+     * @endcode
+     */
+    void enableDynamicAck();
+
+    /**
+     * Determine whether the hardware is an nRF24L01+ or not.
+     *
+     * @return true if the hardware is nRF24L01+ (or compatible) and false
+     * if its not.
+     */
+    bool isPVariant(void);
+
+    /**
+     * Enable or disable the auto-acknowledgement feature for all pipes. This
+     * feature is enabled by default. Auto-acknowledgement responds to every
+     * received payload with an empty ACK packet. These ACK packets get sent
+     * from the receiving radio back to the transmitting radio. To attach an
+     * ACK payload to a ACK packet, use writeAckPayload().
+     *
+     * If this feature is disabled on a transmitting radio, then the
+     * transmitting radio will always report that the payload was received
+     * (even if it was not). Please remember that this feature's configuration
+     * needs to match for transmitting and receiving radios.
+     *
+     * @warning When using the `multicast` parameter to write(), this feature
+     * can be disabled for an individual payload. However, if this feature is
+     * disabled, then the `multicast` parameter will have no effect.
+     *
+     * @note If disabling auto-acknowledgment packets, the ACK payloads
+     * feature is also disabled as this feature is required to send ACK
+     * payloads.
+     *
+     * @see
+     * - write()
+     * - writeFast()
+     * - startFastWrite()
+     * - startWrite()
+     * - writeAckPayload()
+     *
+     * @param enable Whether to enable (true) or disable (false) the
+     * auto-acknowledgment feature for all pipes
+     */
+    void setAutoAck(bool enable);
+
+    /**
+     * Enable or disable the auto-acknowledgement feature for a specific pipe.
+     * This feature is enabled by default for all pipes. Auto-acknowledgement
+     * responds to every received payload with an empty ACK packet. These ACK
+     * packets get sent from the receiving radio back to the transmitting
+     * radio. To attach an ACK payload to a ACK packet, use writeAckPayload().
+     *
+     * Pipe 0 is used for TX operations, which include sending ACK packets. If
+     * using this feature on both TX & RX nodes, then pipe 0 must have this
+     * feature enabled for the RX & TX operations. If this feature is disabled
+     * on a transmitting radio's pipe 0, then the transmitting radio will
+     * always report that the payload was received (even if it was not).
+     * Remember to also enable this feature for any pipe that is openly
+     * listening to a transmitting radio with this feature enabled.
+     *
+     * @warning If this feature is enabled for pipe 0, then the `multicast`
+     * parameter to write() can be used to disable this feature for an
+     * individual payload. However, if this feature is disabled for pipe 0,
+     * then the `multicast` parameter will have no effect.
+     *
+     * @note If disabling auto-acknowledgment packets on pipe 0, the ACK
+     * payloads feature is also disabled as this feature is required on pipe 0
+     * to send ACK payloads.
+     *
+     * @see
+     * - write()
+     * - writeFast()
+     * - startFastWrite()
+     * - startWrite()
+     * - writeAckPayload()
+     * - enableAckPayload()
+     * - disableAckPayload()
+     *
+     * @param pipe Which pipe to configure. This number should be in range
+     * [0, 5].
+     * @param enable Whether to enable (true) or disable (false) the
+     * auto-acknowledgment feature for the specified pipe
+     */
+    void setAutoAck(uint8_t pipe, bool enable);
+
+    /**
+     * Set Power Amplifier (PA) level and Low Noise Amplifier (LNA) state
+     *
+     * @param level The desired @ref PALevel as defined by @ref rf24_pa_dbm_e.
+     * @param lnaEnable Enable or Disable the LNA (Low Noise Amplifier) Gain.
+     * See table for Si24R1 modules below. @p lnaEnable only affects
+     * nRF24L01 modules with an LNA chip.
+     *
+     * | @p level (enum value) | nRF24L01<br>description | Si24R1<br>description when<br> @p lnaEnable = 1 | Si24R1<br>description when<br> @p lnaEnable = 0 |
+     * |:---------------------:|:-------:|:--------:|:-------:|
+     * | @ref RF24_PA_MIN (0)  | -18 dBm |  -6 dBm  | -12 dBm |
+     * | @ref RF24_PA_LOW (1)  | -12 dBm |  -0 dBm  | -4 dBm  |
+     * | @ref RF24_PA_HIGH (2) | -6 dBm  |  3 dBm   | 1 dBm   |
+     * | @ref RF24_PA_MAX (3)  |  0 dBm  |  7 dBm   | 4 dBm   |
+     *
+     * @note The getPALevel() function does not care what was passed @p lnaEnable parameter.
+     */
+    void setPALevel(uint8_t level, bool lnaEnable = 1);
+
+    /**
+     * Fetches the current @ref PALevel.
+     *
+     * @return One of the values defined by @ref rf24_pa_dbm_e.
+     * See tables in @ref rf24_pa_dbm_e or setPALevel()
+     */
+    uint8_t getPALevel(void);
+
+    /**
+     * Returns automatic retransmission count (ARC_CNT)
+     *
+     * Value resets with each new transmission. Allows roughly estimating signal strength.
+     *
+     * @return Returns values from 0 to 15.
+     */
+    uint8_t getARC(void);
+
+    /**
+     * Set the transmission @ref Datarate
+     *
+     * @warning setting @ref RF24_250KBPS will fail for non-plus modules (when
+     * isPVariant() returns false).
+     *
+     * @param speed Specify one of the following values (as defined by
+     * @ref rf24_datarate_e):
+     * | @p speed (enum value) | description  |
+     * |:---------------------:|:------------:|
+     * | @ref RF24_1MBPS (0)   | for 1 Mbps   |
+     * | @ref RF24_2MBPS (1)   | for 2 Mbps   |
+     * | @ref RF24_250KBPS (2) | for 250 kbps |
+     *
+     * @return true if the change was successful
+     */
+    bool setDataRate(rf24_datarate_e speed);
+
+    /**
+     * Fetches the currently configured transmission @ref Datarate
+     *
+     * @return One of the values defined by @ref rf24_datarate_e.
+     * See table in @ref rf24_datarate_e or setDataRate()
+     */
+    rf24_datarate_e getDataRate(void);
+
+    /**
+     * Set the @ref CRCLength (in bits)
+     *
+     * CRC cannot be disabled if auto-ack is enabled
+     * @param length Specify one of the values (as defined by @ref rf24_crclength_e)
+     * | @p length (enum value)     | description                    |
+     * |:--------------------------:|:------------------------------:|
+     * | @ref RF24_CRC_DISABLED (0) | to disable using CRC checksums |
+     * | @ref RF24_CRC_8 (1)        | to use 8-bit checksums         |
+     * | @ref RF24_CRC_16 (2)       | to use 16-bit checksums        |
+     */
+    void setCRCLength(rf24_crclength_e length);
+
+    /**
+     * Get the @ref CRCLength (in bits)
+     *
+     * CRC checking cannot be disabled if auto-ack is enabled
+     * @return One of the values defined by @ref rf24_crclength_e.
+     * See table in @ref rf24_crclength_e or setCRCLength()
+     */
+    rf24_crclength_e getCRCLength(void);
+
+    /**
+     * Disable CRC validation
+     *
+     * @warning CRC cannot be disabled if auto-ack/ESB is enabled.
+     */
+    void disableCRC(void);
+
+    /**
+     *
+     * The driver will delay for this duration when stopListening() is called
+     *
+     * When responding to payloads, faster devices like ARM(RPi) are much faster than Arduino:
+     * 1. Arduino sends data to RPi, switches to RX mode
+     * 2. The RPi receives the data, switches to TX mode and sends before the Arduino radio is in RX mode
+     * 3. If AutoACK is disabled, this can be set as low as 0. If AA/ESB enabled, set to 100uS minimum on RPi
+     *
+     * @warning If set to 0, ensure 130uS delay after stopListening() and before any sends
+     */
+    uint32_t txDelay;
+
+    /**
+     *
+     * On all devices but Linux and ATTiny, a small delay is added to the CSN toggling function
+     *
+     * This is intended to minimize the speed of SPI polling due to radio commands
+     *
+     * If using interrupts or timed requests, this can be set to 0 Default:5
+     */
+    uint32_t csDelay;
+
+    /**
+     * Transmission of constant carrier wave with defined frequency and output power
+     *
+     * @param level Output power to use
+     * @param channel The channel to use
+     *
+     * @warning If isPVariant() returns true, then this function takes extra
+     * measures that alter some settings. These settings alterations include:
+     * - setAutoAck() to false (for all pipes)
+     * - setRetries() to retry `0` times with a delay of 250 microseconds
+     * - set the TX address to 5 bytes of `0xFF`
+     * - flush_tx()
+     * - load a 32 byte payload of `0xFF` into the TX FIFO's top level
+     * - disableCRC()
+     */
+    void startConstCarrier(rf24_pa_dbm_e level, uint8_t channel);
+
+    /**
+     * Stop transmission of constant wave and reset PLL and CONT registers
+     *
+     * @warning this function will powerDown() the radio per recommendation of
+     * datasheet.
+     * @note If isPVariant() returns true, please remember to re-configure the radio's settings
+     * @code
+     * // re-establish default settings
+     * setCRCLength(RF24_CRC_16);
+     * setAutoAck(true);
+     * setRetries(5, 15);
+     * @endcode
+     * @see startConstCarrier()
+     */
+    void stopConstCarrier(void);
+
+    /**
+     * @brief Open or close all data pipes.
+     *
+     * This function does not alter the addresses assigned to pipes. It is simply a
+     * convenience function that allows controlling all pipes at once.
+     * @param isEnabled `true` opens all pipes; `false` closes all pipes.
+     */
+    void toggleAllPipes(bool isEnabled);
+
+    /**
+     * @brief configure the RF_SETUP register in 1 transaction
+     * @param level This parameter is the same input as setPALevel()'s `level` parameter.
+     * See @ref rf24_pa_dbm_e enum for accepted values.
+     * @param speed This parameter is the same input as setDataRate()'s `speed` parameter.
+     * See @ref rf24_datarate_e enum for accepted values.
+     * @param lnaEnable This optional parameter is the same as setPALevel()'s `lnaEnable`
+     * optional parameter. Defaults to `true` (meaning LNA feature is enabled) when not specified.
+     */
+    void setRadiation(uint8_t level, rf24_datarate_e speed, bool lnaEnable = true);
+
+    /**@}*/
+    /**
+     * @name Deprecated
+     *
+     *  Methods provided for backwards compatibility.
+     */
+    /**@{*/
+
+    /**
+     * Open a pipe for reading
+     * @deprecated For compatibility with old code only, see newer function
+     * openReadingPipe().
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * @note Pipes 1-5 should share the first 32 bits.
+     * Only the least significant byte should be unique, e.g.
+     * @code
+     * openReadingPipe(1, 0xF0F0F0F0AA);
+     * openReadingPipe(2, 0xF0F0F0F066);
+     * @endcode
+     *
+     * @warning
+     * @parblock
+     * Pipe 0 is also used by the writing pipe so should typically be avoided as a reading pipe.
+     * If used, the reading pipe 0 address needs to be restored at every call to startListening().
+     *
+     * See http://maniacalbits.blogspot.com/2013/04/rf24-addressing-nrf24l01-radios-require.html
+     * @endparblock
+     *
+     * @param number Which pipe# to open, 0-5.
+     * @param address The 40-bit address of the pipe to open.
+     */
+    void openReadingPipe(uint8_t number, uint64_t address);
+
+    /**
+     * Open a pipe for writing
+     * @deprecated For compatibility with old code only, see newer function
+     * openWritingPipe().
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * Addresses are 40-bit hex values, e.g.:
+     *
+     * @code
+     * openWritingPipe(0xF0F0F0F0F0);
+     * @endcode
+     *
+     * @param address The 40-bit address of the pipe to open.
+     */
+    void openWritingPipe(uint64_t address);
+
+    /**
+     * Determine if an ack payload was received in the most recent call to
+     * write(). The regular available() can also be used.
+     *
+     * @deprecated For compatibility with old code only, see synonymous function available().
+     * Use read() to retrieve the ack payload and getDynamicPayloadSize() to get the ACK payload size.
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * @return True if an ack payload is available.
+     */
+    bool isAckPayloadAvailable(void);
+
+    /**
+     * This function is used to configure what events will trigger the Interrupt
+     * Request (IRQ) pin active LOW.
+     *
+     * @deprecated Use setStatusFlags() instead.
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * The following events can be configured:
+     * 1. "data sent": This does not mean that the data transmitted was
+     * received, only that the attempt to send it was complete.
+     * 2. "data failed": This means the data being sent was not received. This
+     * event is only triggered when the auto-ack feature is enabled.
+     * 3. "data received": This means that data from a receiving payload has
+     * been loaded into the RX FIFO buffers. Remember that there are only 3
+     * levels available in the RX FIFO buffers.
+     *
+     * By default, all events are configured to trigger the IRQ pin active LOW.
+     * When the IRQ pin is active, use clearStatusFlags() or getStatusFlags() to
+     * determine what events triggered it.
+     * Remember that calling clearStatusFlags() also clears these
+     * events' status, and the IRQ pin will then be reset to inactive HIGH.
+     *
+     * The following code configures the IRQ pin to only reflect the "data received"
+     * event:
+     * @code
+     * radio.maskIRQ(1, 1, 0);
+     * @endcode
+     *
+     * @param tx_ok  `true` ignores the "data sent" event, `false` reflects the
+     * "data sent" event on the IRQ pin.
+     * @param tx_fail  `true` ignores the "data failed" event, `false` reflects the
+     * "data failed" event on the IRQ pin.
+     * @param rx_ready `true` ignores the "data received" event, `false` reflects the
+     * "data received" event on the IRQ pin.
+     */
+    void maskIRQ(bool tx_ok, bool tx_fail, bool rx_ready);
+
+    /**
+     * Call this when you get an Interrupt Request (IRQ) to find out why
+     *
+     * This function describes what event triggered the IRQ pin to go active
+     * LOW and clears the status of all events.
+     *
+     * @deprecated Use clearStatusFlags() instead.
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * @see setStatusFlags()
+     *
+     * @param[out] tx_ok The transmission attempt completed (TX_DS). This does
+     * not imply that the transmitted data was received by another radio, rather
+     * this only reports if the attempt to send was completed. This will
+     * always be `true` when the auto-ack feature is disabled.
+     * @param[out] tx_fail The transmission failed to be acknowledged, meaning
+     * too many retries (MAX_RT) were made while expecting an ACK packet. This
+     * event is only triggered when auto-ack feature is enabled.
+     * @param[out] rx_ready There is a newly received payload (RX_DR) saved to
+     * RX FIFO buffers. Remember that the RX FIFO can only hold up to 3
+     * payloads. Once the RX FIFO is full, all further received transmissions
+     * are rejected until there is space to save new data in the RX FIFO
+     * buffers.
+     *
+     * @note This function expects no parameters in the python wrapper.
+     * Instead, this function returns a 3 item tuple describing the IRQ
+     * events' status. To use this function in the python wrapper:
+     * @code{.py}
+     * # let`radio` be the instantiated RF24 object
+     * tx_ds, tx_df, rx_dr = radio.whatHappened()  # get IRQ status flags
+     * print("tx_ds: {}, tx_df: {}, rx_dr: {}".format(tx_ds, tx_df, rx_dr))
+     * @endcode
+     */
+    void whatHappened(bool& tx_ok, bool& tx_fail, bool& rx_ready);
+
+    /**
+     * Similar to startListening(void) but changes the TX address.
+     *
+     * @deprecated Use stopListening(const uint8_t*) instead.
+     * See our [migration guide](migration.md) to understand what you should update in your code.
+     *
+     * @param txAddress The new TX address.
+     * This value will be cached for auto-ack purposes.
+     */
+    void stopListening(const uint64_t txAddress);
+
+private:
+    /**@}*/
+    /**
+     * @name Low-level internal interface.
+     *
+     *  Protected methods that address the chip directly.  Regular users cannot
+     *  ever call these.  They are documented for completeness and for developers who
+     *  may want to extend this class.
+     */
+    /**@{*/
+
+    /**
+     * initializing function specific to all constructors
+     * (regardless of constructor parameters)
+     */
+    void _init_obj();
+
+    /**
+     * initialize radio by performing a soft reset.
+     * @warning This function assumes the SPI bus object's begin() method has been
+     * previously called.
+     */
+    bool _init_radio();
+
+    /**
+     * initialize the GPIO pins
+     */
+    bool _init_pins();
+
+    /**
+     * Set chip select pin
+     *
+     * Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data
+     * and best of all, we make use of the radio's FIFO buffers. A lower speed
+     * means we're less likely to effectively leverage our FIFOs and pay a higher
+     * AVR runtime cost as toll.
+     *
+     * @param mode HIGH to take this unit off the SPI bus, LOW to put it on
+     */
+    void csn(bool mode);
+
+    /**
+     * Write a chunk of data to a register
+     *
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @param buf Where to get the data
+     * @param len How many bytes of data to transfer
+     * @return Nothing. Older versions of this function returned the status
+     * byte, but that it now saved to a private member on all SPI transactions.
+     */
+    void write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
+
+    /**
+     * Write a single byte to a register
+     *
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @param value The new value to write
+     * @return Nothing. Older versions of this function returned the status
+     * byte, but that it now saved to a private member on all SPI transactions.
+     */
+    void write_register(uint8_t reg, uint8_t value);
+
+    /**
+     * Write the transmit payload
+     *
+     * The size of data written is the fixed payload size, see getPayloadSize()
+     *
+     * @param buf Where to get the data
+     * @param len Number of bytes to be sent
+     * @param writeType Specify if individual payload should be acknowledged
+     * @return Nothing. Older versions of this function returned the status
+     * byte, but that it now saved to a private member on all SPI transactions.
+     */
+    void write_payload(const void* buf, uint8_t len, const uint8_t writeType);
+
+    /**
+     * Read the receive payload
+     *
+     * The size of data read is the fixed payload size, see getPayloadSize()
+     *
+     * @param buf Where to put the data
+     * @param len Maximum number of bytes to read
+     * @return Nothing. Older versions of this function returned the status
+     * byte, but that it now saved to a private member on all SPI transactions.
+     */
+    void read_payload(void* buf, uint8_t len);
+
+#if !defined(MINIMAL)
+
+    /**
+     * Decode and print the given 'observe_tx' value to stdout
+     *
+     * @param value The observe_tx value to print
+     *
+     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+     */
+    void print_observe_tx(uint8_t value);
+
+    /**
+     * Print the name and value of an 8-bit register to stdout
+     *
+     * Optionally it can print some quantity of successive
+     * registers on the same line.  This is useful for printing a group
+     * of related registers on one line.
+     *
+     * @param name Name of the register
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @param qty How many successive registers to print
+     */
+    void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
+
+    /**
+     * Print the name and value of a 40-bit address register to stdout
+     *
+     * Optionally it can print some quantity of successive
+     * registers on the same line.  This is useful for printing a group
+     * of related registers on one line.
+     *
+     * @param name Name of the register
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @param qty How many successive registers to print
+     */
+    void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
+
+    /**
+     * Put the value of a 40-bit address register into a char array
+     *
+     * Optionally it can print some quantity of successive
+     * registers on the same line.  This is useful for printing a group
+     * of related registers on one line.
+     *
+     * @param out_buffer Output buffer, char array
+     * @param reg Which register. Use constants from nRF24L01.h
+     * @param qty How many successive registers to print
+     * @return The total number of characters written to the given buffer.
+     */
+    uint8_t sprintf_address_register(char* out_buffer, uint8_t reg, uint8_t qty = 1);
+#endif
+
+    /**
+     * Turn on or off the special features of the chip
+     *
+     * The chip has certain 'features' which are only available when the 'features'
+     * are enabled.  See the datasheet for details.
+     */
+    void toggle_features(void);
+
+#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
+
+    void errNotify(void);
+
+#endif
+
+    /**
+     * @brief Manipulate the @ref Datarate and txDelay
+     *
+     * This is a helper function to setRadiation() and setDataRate()
+     * @param speed The desired data rate.
+     */
+    inline uint8_t _data_rate_reg_value(rf24_datarate_e speed);
+
+    /**
+     * @brief Manipulate the @ref PALevel
+     *
+     * This is a helper function to setRadiation() and setPALevel()
+     * @param level The desired @ref PALevel.
+     * @param lnaEnable Toggle the LNA feature.
+     */
+    inline uint8_t _pa_level_reg_value(uint8_t level, bool lnaEnable);
+
+    /**@}*/
+};
+
+/**
+ * @example{lineno} examples/GettingStarted/GettingStarted.ino
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use the Serial Monitor to change each node's behavior.
+ */
+
+/**
+ * @example{lineno} examples/AcknowledgementPayloads/AcknowledgementPayloads.ino
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another
+ * with Acknowledgement (ACK) payloads attached to ACK packets.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use the Serial Monitor to change each node's behavior.
+ */
+
+/**
+ * @example{lineno} examples/ManualAcknowledgements/ManualAcknowledgements.ino
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another
+ * with manually transmitted (non-automatic) Acknowledgement (ACK) payloads.
+ * This example still uses ACK packets, but they have no payloads. Instead the
+ * acknowledging response is sent with `write()`. This tactic allows for more
+ * updated acknowledgement payload data, where actual ACK payloads' data are
+ * outdated by 1 transmission because they have to loaded before receiving a
+ * transmission.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use the Serial Monitor to change each node's behavior.
+ */
+
+/**
+ * @example{lineno} examples/StreamingData/StreamingData.ino
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of streaming data from 1 nRF24L01 transceiver to another.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use the Serial Monitor to change each node's behavior.
+ */
+
+/**
+ * @example{lineno} examples/MulticeiverDemo/MulticeiverDemo.ino
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from as many as 6 nRF24L01 transceivers to
+ * 1 receiving transceiver. This technique is trademarked by
+ * Nordic Semiconductors as "MultiCeiver".
+ *
+ * This example was written to be used on up to 6 devices acting as TX nodes &
+ * only 1 device acting as the RX node (that's a maximum of 7 devices).
+ * Use the Serial Monitor to change each node's behavior.
+ */
+
+/**
+ * @example{lineno} examples/InterruptConfigure/InterruptConfigure.ino
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This example uses Acknowledgement (ACK) payloads attached to ACK packets to
+ * demonstrate how the nRF24L01's IRQ (Interrupt Request) pin can be
+ * configured to detect when data is received, or when data has transmitted
+ * successfully, or when data has failed to transmit.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use the Serial Monitor to change each node's behavior.
+ */
+
+/**
+ * @example{lineno} examples/old_backups/GettingStarted_HandlingFailures/GettingStarted_HandlingFailures.ino
+ * Written by [TMRh20](http://github.com/TMRh20) in 2019
+ *
+ * This example demonstrates the basic getting started functionality, but with
+ * failure handling for the radio chip. Addresses random radio failures etc,
+ * potentially due to loose wiring on breadboards etc.
+ */
+
+/**
+ * @example{lineno} examples/old_backups/TransferTimeouts/TransferTimeouts.ino
+ * Written by [TMRh20](https://github.com/TMRh20)
+ *
+ * This example demonstrates the use of and extended timeout period and
+ * auto-retries/auto-reUse to increase reliability in noisy or low signal scenarios.
+ *
+ * Write this sketch to two different nodes.  Put one of the nodes into 'transmit'
+ * mode by connecting with the serial monitor and sending a 'T'.  The data <br>
+ * transfer will begin, with the receiver displaying the payload count and the
+ * data transfer rate.
+ */
+
+/**
+ * @example{lineno} examples/old_backups/pingpair_irq/pingpair_irq.ino
+ * Updated by [TMRh20](https://github.com/TMRh20)
+ *
+ * This is an example of how to user interrupts to interact with the radio, and a demonstration
+ * of how to use them to sleep when receiving, and not miss any payloads.<br>
+ * The pingpair_sleepy example expands on sleep functionality with a timed sleep option for the transmitter.
+ * Sleep functionality is built directly into my fork of the RF24Network library<br>
+ */
+
+/**
+ * @example{lineno} examples/old_backups/pingpair_sleepy/pingpair_sleepy.ino
+ * Updated by [TMRh20](https://github.com/TMRh20)
+ *
+ * This is an example of how to use the RF24 class to create a battery-
+ * efficient system.  It is just like the GettingStarted_CallResponse example, but the<br>
+ * ping node powers down the radio and sleeps the MCU after every
+ * ping/pong cycle, and the receiver sleeps between payloads. <br>
+ */
+
+/**
+ * @example{lineno} examples/rf24_ATTiny/rf24ping85/rf24ping85.ino
+ * <b>2014 Contribution by [tong67](https://github.com/tong67)</b><br>
+ * Updated 2020 by [2bndy5](http://github.com/2bndy5) for the
+ * [SpenceKonde ATTinyCore](https://github.com/SpenceKonde/ATTinyCore)<br>
+ * The RF24 library uses the [ATTinyCore by
+ * SpenceKonde](https://github.com/SpenceKonde/ATTinyCore)
+ *
+ * This sketch is a duplicate of the ManualAcknowledgements.ino example
+ * (without all the Serial input/output code), and it demonstrates
+ * a ATTiny25/45/85 or ATTiny24/44/84 driving the nRF24L01 transceiver using
+ * the RF24 class to communicate with another node.
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another
+ * with manually transmitted (non-automatic) Acknowledgement (ACK) payloads.
+ * This example still uses ACK packets, but they have no payloads. Instead the
+ * acknowledging response is sent with `write()`. This tactic allows for more
+ * updated acknowledgement payload data, where actual ACK payloads' data are
+ * outdated by 1 transmission because they have to loaded before receiving a
+ * transmission.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ */
+
+/**
+ * @example{lineno} examples/rf24_ATTiny/timingSearch3pin/timingSearch3pin.ino
+ * <b>2014 Contribution by [tong67](https://github.com/tong67)</b><br>
+ * Updated 2020 by [2bndy5](http://github.com/2bndy5) for the
+ * [SpenceKonde ATTinyCore](https://github.com/SpenceKonde/ATTinyCore)<br>
+ * The RF24 library uses the [ATTinyCore by
+ * SpenceKonde](https://github.com/SpenceKonde/ATTinyCore)
+ *
+ * This sketch can be used to determine the best settle time values to use for
+ * RF24::csDelay in RF24::csn() (private function).
+ * @see RF24::csDelay
+ *
+ * The settle time values used here are 100/20. However, these values depend
+ * on the actual used RC combination and voltage drop by LED. The
+ * intermediate results are written to TX (PB3, pin 2 -- using Serial).
+ *
+ * For schematic details, see introductory comment block in the rf24ping85.ino sketch.
+ */
+
+/**
+ * @example{lineno} examples/old_backups/pingpair_dyn/pingpair_dyn.ino
+ *
+ * This is an example of how to use payloads of a varying (dynamic) size on Arduino.
+ */
+
+/**
+ * @example{lineno} examples_linux/getting_started.py
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This is a simple example of using the RF24 class on a Raspberry Pi.
+ *
+ * Remember to install the [Python wrapper](python_wrapper.md), then
+ * navigate to the "RF24/examples_linux" folder.
+ * <br>To run this example, enter
+ * @code{.sh}python3 getting_started.py @endcode and follow the prompts.
+ *
+ * @note this example requires python v3.7 or newer because it measures
+ * transmission time with `time.monotonic_ns()`.
+ */
+
+/**
+ * @example{lineno} examples_linux/acknowledgement_payloads.py
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This is a simple example of using the RF24 class on a Raspberry Pi to
+ * transmit and retrieve custom automatic acknowledgment payloads.
+ *
+ * Remember to install the [Python wrapper](python_wrapper.md), then
+ * navigate to the "RF24/examples_linux" folder.
+ * <br>To run this example, enter
+ * @code{.sh}python3 acknowledgement_payloads.py @endcode and follow the prompts.
+ *
+ * @note this example requires python v3.7 or newer because it measures
+ * transmission time with `time.monotonic_ns()`.
+ */
+
+/**
+ * @example{lineno} examples_linux/manual_acknowledgements.py
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This is a simple example of using the RF24 class on a Raspberry Pi to
+ * transmit and respond with acknowledgment (ACK) transmissions. Notice that
+ * the auto-ack feature is enabled, but this example doesn't use automatic ACK
+ * payloads because automatic ACK payloads' data will always be outdated by 1
+ * transmission. Instead, this example uses a call and response paradigm.
+ *
+ * Remember to install the [Python wrapper](python_wrapper.md), then
+ * navigate to the "RF24/examples_linux" folder.
+ * <br>To run this example, enter
+ * @code{.sh}python3 manual_acknowledgements.py @endcode and follow the prompts.
+ *
+ * @note this example requires python v3.7 or newer because it measures
+ * transmission time with `time.monotonic_ns()`.
+ */
+
+/**
+ * @example{lineno} examples_linux/streaming_data.py
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This is a simple example of using the RF24 class on a Raspberry Pi for
+ * streaming multiple payloads.
+ *
+ * Remember to install the [Python wrapper](python_wrapper.md), then
+ * navigate to the "RF24/examples_linux" folder.
+ * <br>To run this example, enter
+ * @code{.sh}python3 streaming_data.py @endcode and follow the prompts.
+ *
+ * @note this example requires python v3.7 or newer because it measures
+ * transmission time with `time.monotonic_ns()`.
+ */
+
+/**
+ * @example{lineno} examples_linux/interrupt_configure.py
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This is a simple example of using the RF24 class on a Raspberry Pi to
+ * detecting (and verifying) the IRQ (interrupt) pin on the nRF24L01.
+ *
+ * Remember to install the [Python wrapper](python_wrapper.md), then
+ * navigate to the "RF24/examples_linux" folder.
+ * <br>To run this example, enter
+ * @code{.sh}python3 interrupt_configure.py @endcode and follow the prompts.
+ *
+ * @note this example requires python v3.7 or newer because it measures
+ * transmission time with `time.monotonic_ns()`.
+ */
+
+/**
+ * @example{lineno} examples_linux/multiceiver_demo.py
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * This is a simple example of using the RF24 class on a Raspberry Pi for
+ * using 1 nRF24L01 to receive data from up to 6 other transceivers. This
+ * technique is called "multiceiver" in the datasheet.
+ *
+ * Remember to install the [Python wrapper](python_wrapper.md), then
+ * navigate to the "RF24/examples_linux" folder.
+ * <br>To run this example, enter
+ * @code{.sh}python3 multiceiver_demo.py @endcode and follow the prompts.
+ *
+ * @note this example requires python v3.7 or newer because it measures
+ * transmission time with `time.monotonic_ns()`.
+ */
+
+/**
+ * @example{lineno} examples_linux/scanner.cpp
+ *
+ * Example to detect interference on the various channels available.
+ * This is a good diagnostic tool to check whether you're picking a
+ * good channel for your application.
+ *
+ * Inspired by cpixip.
+ * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ *
+ * Use ctrl+C to exit
+ */
+
+/**
+ * @example{lineno} examples/scanner/scanner.ino
+ *
+ * Example to detect interference on the various channels available.
+ * This is a good diagnostic tool to check whether you're picking a
+ * good channel for your application.
+ *
+ * Inspired by cpixip.
+ * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ */
+
+/**
+ * @example{lineno} examples_linux/gettingstarted.cpp
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another.
+ *
+ * This example was written  * This example was written to be used on up to 6 devices acting as TX nodes &
+ * only 1 device acting as the RX node (that's a maximum of 7 devices).
+ acting as "nodes".
+ * Use `ctrl+c` to quit at any time.
+ */
+
+/**
+ * @example{lineno} examples_linux/acknowledgementPayloads.cpp
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another
+ * with Acknowledgement (ACK) payloads attached to ACK packets.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use `ctrl+c` to quit at any time.
+ */
+
+/**
+ * @example{lineno} examples_linux/manualAcknowledgements.cpp
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another
+ * with manually transmitted (non-automatic) Acknowledgement (ACK) payloads.
+ * This example still uses ACK packets, but they have no payloads. Instead the
+ * acknowledging response is sent with `write()`. This tactic allows for more
+ * updated acknowledgement payload data, where actual ACK payloads' data are
+ * outdated by 1 transmission because they have to loaded before receiving a
+ * transmission.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use `ctrl+c` to quit at any time.
+ */
+
+/**
+ * @example{lineno} examples_linux/streamingData.cpp
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from 1 nRF24L01 transceiver to another.
+ *
+ * This example was written to be used on 2 devices acting as "nodes".
+ * Use `ctrl+c` to quit at any time.
+ */
+
+/**
+ * @example{lineno} examples_linux/multiceiverDemo.cpp
+ * Written by [2bndy5](http://github.com/2bndy5) in 2020
+ *
+ * A simple example of sending data from as many as 6 nRF24L01 transceivers to
+ * 1 receiving transceiver. This technique is trademarked by
+ * Nordic Semiconductors as "MultiCeiver".
+ *
+ * This example was written to be used on up to 6 devices acting as TX nodes &
+ * only 1 device acting as the RX node (that's a maximum of 7 devices).
+ * Use `ctrl+c` to quit at any time.
+ */
+
+#endif // RF24_H_
diff --git a/src/Resources/ezButton.h b/src/Resources/ezButton.h
new file mode 100644
index 0000000..8e4eeee
--- /dev/null
+++ b/src/Resources/ezButton.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2019, ArduinoGetStarted.com. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the ArduinoGetStarted.com nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ARDUINOGETSTARTED.COM "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ARDUINOGETSTARTED.COM BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ezButton_h
+#define ezButton_h
+
+#include <Arduino.h>
+
+#define COUNT_FALLING 0
+#define COUNT_RISING  1
+#define COUNT_BOTH    2
+
+// Constants for button modes
+#define INTERNAL_PULLUP  INPUT_PULLUP
+#ifdef INPUT_PULLDOWN
+#define INTERNAL_PULLDOWN INPUT_PULLDOWN
+#else
+#define INTERNAL_PULLDOWN INPUT
+#endif
+
+#define EXTERNAL_PULLUP   0xFE
+#define EXTERNAL_PULLDOWN 0xFF
+
+class ezButton
+{
+	private:
+		int btnPin;
+		unsigned long debounceTime;
+		unsigned long count;
+		int countMode;
+		int pressedState;     // the state when the button is considered pressed
+		int unpressedState;   // the state when the button is considered unpressed
+
+		int previousSteadyState;  // the previous steady state from the input pin, used to detect pressed and released event
+		int lastSteadyState;      // the last steady state from the input pin
+		int lastFlickerableState; // the last flickerable state from the input pin
+
+		unsigned long lastDebounceTime; // the last time the output pin was toggled
+
+	public:
+		ezButton(int pin);
+		ezButton(int pin, int mode);
+		void setDebounceTime(unsigned long time);
+		int getState(void);
+		int getStateRaw(void);
+		bool isPressed(void);
+		bool isReleased(void);
+		void setCountMode(int mode);
+		unsigned long getCount(void);
+		void resetCount(void);
+		void loop(void);
+};
+
+#endif
diff --git a/src/conversation_history.md b/src/conversation_history.md
new file mode 100644
index 0000000..359ccbe
--- /dev/null
+++ b/src/conversation_history.md
@@ -0,0 +1,127 @@
+# Conversation History
+
+**User:** Is there a way I can view our conversation history?
+
+**Gemini:** I do not have a command to view the conversation history. You should be able to scroll up in your terminal to see our previous messages.
+
+**User:** Ah I'm looking for a conversation from yesterday. No worries
+
+**Gemini:** Got it. Terminal scrollback usually doesn't persist between sessions.
+
+I can save our conversations to a file for you to review later. Would you like me to set that up?
+
+**User:** That's not a bad idea. what file type would you use?
+
+**Gemini:** I would use a Markdown (`.md`) file.
+
+This format is easy to read and is great for preserving the formatting of any code snippets we might discuss. I can name it `conversation_history.md`.
+
+Does that sound good?
+
+**User:** yeah that sounds good! also for a quick overview of the project, you can read "info.txt".
+
+**Gemini:** Sounds good. I'll create `conversation_history.md` and start logging our conversation.
+
+Thanks for the tip, I'll read `info.txt` now to get an overview of the project.
+
+**User:** Please continue.
+
+**Gemini:** Of course. Based on the `info.txt` file, I see that a "Calculator" program is on the list of required programs, but I don't see any corresponding files for it in the project structure.
+
+I can start by creating the basic files for the calculator program:
+1.  Create a `Programs/Calculator` directory.
+2.  Create `Calculator.h` and `Calculator.cpp` inside the new directory.
+3.  Add a basic class structure to these files.
+
+After that, I can work on integrating it into the main menu.
+
+Would you like me to proceed with creating these files?
+
+**User:** yeah go for it!
+
+**Gemini:** Great. I'll create the directory and the basic files for the calculator program.
+
+**User:** sure
+
+**Gemini:** Okay, I will now read `Menu.h` and `Menu.cpp`.
+
+**User:** yeah looks good
+
+**Gemini:** Alright, I'll start by updating the header file (`Calculator.h`) with the necessary variables for the UI and a private function to handle drawing. Then, I'll implement the initial drawing logic in `Calculator.cpp`.
+
+This first step will just render the static UI on the screen. We'll handle input and logic next.
+
+**User:** yeah sure
+
+**Gemini:** Okay, I will now add the joystick handling logic to the `loop` function in `Calculator.cpp` to enable cursor movement. I'll use the same input detection method as the main menu to ensure consistent behavior.
+
+**User:** I just had to quickly correct a typo. you put "Adafruit_SSD1151" in Calculator.cpp instead off 1351. easily done! other than that, the code succsesfully compiles! well done! Yes, you can proceed
+
+**Gemini:** Thank you for catching that typo! I appreciate you fixing it and letting me know the code compiles. That's great news.
+
+I will now proceed with implementing the button press logic as we discussed. I'll add the code to detect when the joystick button is released and print the selected grid item to the serial port for verification.
+
+**User:** ok. I will test your implementation now
+
+**Gemini:** Sounds good. I'll wait for your feedback.
+
+**User:** that works suprising well. However, there are a couple of issues. the main one is that the screen is flickering a lot. also, The controls with the joystick are a bit inconsistent. for example I my push the joystick in one direction, but the computer may read multiple inputs in the wrong direction. This may be hardware limitaion and I may need to invest in a d-pad
+
+**Gemini:** You've found some excellent points. Your analysis is spot on.
+
+1.  **Screen Flickering:** You are right, this is the main issue. It's happening because the code is clearing and redrawing the entire screen on every single frame. This is inefficient and a classic cause of flickering.
+2.  **Joystick Input:** The input detection logic is quite simple. If the joystick hardware is a bit "noisy," it can definitely produce ghost inputs like you're seeing.
+
+Let's tackle the flickering first, as that's a definite software bug I can fix.
+
+I will modify the drawing code to only clear the top part of the screen where the numbers are displayed, rather than the whole screen. The rest of the UI will just be drawn over itself. This should eliminate the most noticeable flickering.
+
+Shall I apply this fix?
+
+**User:** yes please
+
+**Gemini:** Okay, I'm applying the fix to reduce screen flickering now.
+
+**User:** yes please
+
+**Gemini:** The rendering fix has been applied. The button backgrounds should now correctly revert to black when the cursor moves away.
+
+Please give it a test when you have a moment. Once you confirm it's working as expected, we can proceed with implementing the calculator's operator and equals logic.
+
+**User:** Please continue.
+
+**Gemini:** Understood. I will proceed with implementing the final piece of the calculator's functionality: the operator and equals buttons.
+
+I will now modify the `handleButtonPress` function to perform the calculations.
+
+**User:** no it's ok. One thing you could do that would be great is implement a draw keyboard method in the keyboard.cpp file
+
+**Gemini:** Okay, I can definitely work on that.
+
+I see the file `Programs/Keyboard.h`, but I don't see a corresponding `Keyboard.cpp` file. I'll need to create that file to implement the `drawKeyboard` method.
+
+Before I start, I'll need to read `Keyboard.h` to understand the existing class structure. Shall I proceed with reading the header file?
+
+**User:** ah, check now. I had create a keyboard.cpp but it was lowercase by mistake. there is a method called render in there. if you could implement it in there that would be fantastic
+
+**Gemini:** Ah, I see it now. Thank you for clarifying. I can certainly implement the `render` method in `keyboard.cpp`.
+
+For the keyboard layout, I propose a simple 6x5 grid to fit the screen and make navigation manageable:
+```
+[A][B][C][D][E][F]
+[G][H][I][J][K][L]
+[M][N][O][P][Q][R]
+[S][T][U][V][W][X]
+[Y][Z][.][<][ENT]
+```
+Here, `<` would be backspace and `ENT` would be enter. The `render` method would draw this grid, highlight the currently selected key, and show the composed text at the top of the screen.
+
+Does this approach sound good? If you agree, I'll read the keyboard header and source files to begin the implementation.
+
+**User:** yeah I like it
+
+**Gemini:** Great. I'll read the `Keyboard.h` and `keyboard.cpp` files now to get started.
+
+**User:** yeah I agree with that
+
+**Gemini:** Excellent. I'll start by modifying `Keyboard.h` to update the `render` method and add the necessary variables to manage the keyboard's state, like the cursor position and the grid layout.
diff --git a/src/info.txt b/src/info.txt
new file mode 100644
index 0000000..c664d2e
--- /dev/null
+++ b/src/info.txt
@@ -0,0 +1,27 @@
+--> Project Outline <--
+
+Hardware:
+  I am making a small, handheld 3d printed games console for my 7yo and 5yo cousins
+  the console has a 128x128 colour OLED display, a 7 segment display, a basic speaker,
+  two buttons and a joystick (with a built-in button). I also plan to make it battery powered too.
+  The console will also have wireless capabilites by using the NFR24L01 radio transceiver module. this
+  will the consoles to communicate and open the door to multiplayer games
+
+  The main board is a arduino nano R4. this has 256kb of programable memory, 32kb or ram and 8kb or EEPROM
+  for storing save states. 
+
+Software:
+  The computer needs to have a centeral "OS" that everything is based around. It need a menu to navigate 
+  and needs settings to the user can customise things.
+  The OS will also have a top bar to give the user information about the deice such as battery level and time
+
+  Current List of Required Programs:
+  -  Calculator
+  -  Snake (single player and multiplayer, selected from within the game)
+  -  2D puzzle maze (a 2d generated maze with a procedually generated puzzles to solve)
+  -  asteroids (single player and multiplayer. In multiplayer you can shoot eachother)
+  -  messenger (a way to send a text message to the other device. more for fun as it is short range)
+  -  chess (single player and multiplayer. You can also play against a basic AI)
+  -  3D maze (may be out of the scope of this project)
+  -  more to come!
+
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..7462cc3
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,194 @@
+#include <Arduino.h>
+#include <Adafruit_GFX.h>
+#include <Adafruit_SSD1351.h>
+#include <SPI.h>
+#include <ezButton.h>
+#include <EEPROM.h>
+#include "RF24.h"
+
+// Screen dimensions
+#define SCREEN_WIDTH  128
+#define SCREEN_HEIGHT 128 // Change this to 96 for 1.27" OLED.
+
+// You can use any (4 or) 5 pins 
+#define SCLK_PIN 13
+#define MOSI_PIN 11
+#define MISO_PIN 12
+#define DC_PIN   9 // was pin 4
+#define CS_PIN   10 // was pin 5
+#define RST_PIN  8 // was pin 6
+
+#define RF_CE_PIN 7 // (chicp enable)
+#define RF_CSN_PIN 6 // (SPI select)
+
+// Control Data
+#define BUTTON_TOP 0
+#define BUTTON_BOTTOM 1 
+#define JOYSTICK_BUTTON A4
+#define JOYSTICK_X A6
+#define JOYSTICK_Y A5
+
+#include "Programs/Calculator/Calculator.h"
+#include "Programs/Snake/Snake.h"
+#include "Programs/Settings/Settings.h"
+#include "Programs/Asteroids/Asteroids.h"
+
+#include "Bitmaps.h"
+#include "Menu.h"
+#include "utility.h"
+
+Adafruit_SSD1351 tft = Adafruit_SSD1351(SCREEN_WIDTH, SCREEN_HEIGHT, &SPI, CS_PIN, DC_PIN, RST_PIN);
+RF24 radio(RF_CE_PIN, RF_CSN_PIN);
+inputData userInputs(BUTTON_TOP, BUTTON_BOTTOM, JOYSTICK_BUTTON);
+//programID currentProgram = NO_PROGRAM;
+
+unsigned long interval=1000; // the time we need to wait
+unsigned long previousMillis=0; // millis() returns an unsigned long.
+
+Program* currentProgram = nullptr; // will be renamed to currentProgram when fully implemented
+Program* nextProgram = nullptr;
+
+struct state {
+  bool SoundEnabled = true;
+  bool RunningProgram = false;
+  bool InMenu = false;
+  bool RadioEnabled = true;
+} MachineState;
+
+
+void displaySplashScreen(int duration);
+void getUserInput(inputData* inputs);
+void requestProgramChange(Program* program);
+void drawInfoBar();
+float normalizeJoystick(int analogValue);
+
+
+
+void requestProgramChange(Program* program){
+  nextProgram = program;
+}
+
+// --- STARTUP -- //
+void setup(void) {
+  Serial.begin(9600);
+  Serial.println("Starting up...");
+  userInputs.buttonTop.setDebounceTime(25);
+  userInputs.buttonBottom.setDebounceTime(25);
+  userInputs.joyStickButton.setDebounceTime(25);
+
+  tft.begin();
+
+  // spash screen goes here!
+  displaySplashScreen(2000); // show spash for 2 seconds
+  MachineState.InMenu = true;
+  currentProgram = new Menu::Menu();
+  currentProgram->onEnter(&tft);
+  Serial.println("Start sucsessful");
+}
+
+// --- PROGRAM LOOP --- //
+void loop() {
+    // need to loop as fast a possible to maintain framerate and responce time
+    unsigned long currentMillis = millis(); // grab current time
+
+    // handle program transistion
+    if (nextProgram != nullptr) {
+      if (currentProgram != nullptr) {
+        currentProgram->onExit();
+        delete currentProgram;
+      }
+      currentProgram = nextProgram;
+      nextProgram = nullptr;
+      if (currentProgram != nullptr){
+        currentProgram->onEnter(&tft);
+      }
+    }
+
+    // update current program
+    if (currentProgram != nullptr){
+      getUserInput(&userInputs);
+      currentProgram->loop(&tft, &userInputs);
+      if (!currentProgram->disableInfoBar){ drawInfoBar(); }
+    }
+
+	// check if "interval" time has passed (1000 milliseconds)
+	if ((unsigned long)(currentMillis - previousMillis) >= interval) {
+		// do task
+		previousMillis = millis();
+	}
+}
+
+
+void getUserInput(inputData *inputs){
+  // Call the loop() function for each button. This is required by ezButton.
+  inputs->buttonTop.loop();
+  inputs->buttonBottom.loop();
+  inputs->joyStickButton.loop();
+
+  // The rest of the code can now get button states directly, e.g.:
+  // if (inputs->buttonTop.isPressed()) { ... }
+
+  // For now, let's keep joystick values simple
+  int rawX = analogRead(JOYSTICK_X);
+  int rawY = analogRead(JOYSTICK_Y);
+  inputs->joyX = normalizeJoystick(rawX);
+  inputs->joyY = normalizeJoystick(rawY);
+
+
+  inputs->joystickCommand = COMMAND_NO;
+
+  // check left/right commands
+  if (rawX < LEFT_THRESHOLD){
+    inputs->joystickCommand = inputs->joystickCommand | COMMAND_LEFT;
+  }
+  else if (rawX > RIGHT_THRESHOLD){
+    inputs->joystickCommand = inputs->joystickCommand | COMMAND_RIGHT;
+  }
+
+  // check up/down commands
+  if (rawY < UP_THRESHOLD){
+    inputs->joystickCommand = inputs->joystickCommand | COMMAND_UP;
+  }
+  else if (rawY > DOWN_THRESHOLD){
+    inputs->joystickCommand = inputs->joystickCommand | COMMAND_DOWN;
+  }
+}
+
+
+void displaySplashScreen(int duration){
+  // - could play a tune and also show off the capability of the display with some
+  //   stylish graphics! maybe even 3d graphics if build a library for it
+  tft.fillScreen(BLACK);
+  tft.drawBitmap(0, 0, spash_screen_BMP, 128, 128, WHITE);
+  tft.setCursor(10, 10);
+  tft.setTextColor(GREEN);
+  tft.println(F("B-TEK Advanced"));
+  tft.setCursor(30, 10);
+  tft.println(F("Booting in progress..."));
+  delay(duration);
+  tft.fillScreen(BLACK);
+}
+
+
+void drawInfoBar(){
+  // a bar on the time with data like battery life and current time and wifi status... maybe more (:
+  tft.drawRect(0, 0, 128, 12, RED);
+  tft.setCursor(5, 2);
+  tft.setTextSize(1);
+  tft.setTextColor(WHITE);
+  tft.println(F("20:34"));
+  tft.setCursor(90, 2);
+  tft.println(F("[-->]"));
+}
+
+
+float normalizeJoystick(int analogValue) {
+  // Account for the dead zone
+  if (abs(analogValue - 512) < JOY_DEAD_ZONE) {
+    return 0.0;
+  }
+  // Shift the range so the center is 0
+  float shiftedValue = analogValue - 512;
+
+  return shiftedValue / 512.0;
+}
diff --git a/src/main.cpp.bak b/src/main.cpp.bak
new file mode 100644
index 0000000..579796a
--- /dev/null
+++ b/src/main.cpp.bak
@@ -0,0 +1,20 @@
+#include <Arduino.h>
+#include <Adafruit_GFX.h> 
+#include <Adafruit_SSD1351.h>
+#include <SPI.h>
+#include <ezButton.h>
+#include <EEPROM.h>
+#include "RF24.h"
+
+void setup() {
+  // put your setup code here, to run once:
+  pinMode(LED_BUILTIN, OUTPUT);
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+  digitalWrite(LED_BUILTIN, HIGH);
+  delay(1000);
+  digitalWrite(LED_BUILTIN, LOW);
+  delay(1000);
+}
\ No newline at end of file
diff --git a/src/utility.cpp b/src/utility.cpp
new file mode 100644
index 0000000..bb84edf
--- /dev/null
+++ b/src/utility.cpp
@@ -0,0 +1,2 @@
+#include "utility.h"
+
diff --git a/src/utility.h b/src/utility.h
new file mode 100644
index 0000000..2437be0
--- /dev/null
+++ b/src/utility.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#define LEFT_THRESHOLD  400
+#define RIGHT_THRESHOLD 800
+#define UP_THRESHOLD    400
+#define DOWN_THRESHOLD  800
+
+#define COMMAND_NO     0x00
+#define COMMAND_LEFT   0x01
+#define COMMAND_RIGHT  0x02
+#define COMMAND_UP     0x04
+#define COMMAND_DOWN   0x08
+
+#include <ezButton.h>
+#include <Adafruit_SSD1351.h>
+
+
+// Color definitions
+static const int BLACK   = 0x0000;
+static const int BLUE    = 0x001F;
+static const int RED     = 0xF800;
+static const int GREEN   = 0x07E0;
+static const int CYAN    = 0x07FF;
+static const int MAGENTA = 0xF81F;
+static const int YELLOW  = 0xFFE0;  
+static const int WHITE   = 0xFFFF;
+
+
+static const int NOTE_A = 250; // hz
+static const int NOTE_B = 250; // hz
+static const int NOTE_C = 250; // hz
+static const int NOTE_D = 250; // hz
+static const int NOTE_E = 250; // hz
+static const int NOTE_F = 250; // hz
+static const int NOTE_G = 250; // hz
+
+struct inputData {
+  ezButton buttonTop;
+  ezButton buttonBottom;
+  ezButton joyStickButton;
+
+  float joyX = 0; // between -1 and 1
+  float joyY = 0; // between -1 and 1
+
+  int joystickCommand = 0x00;
+
+  // Constructor
+  inputData(int topPin, int bottomPin, int stickPin)
+    : buttonTop(topPin), 
+      buttonBottom(bottomPin), 
+      joyStickButton(stickPin){
+  }
+};
+
+enum programID{
+  NO_PROGRAM,
+  PROGRAM_SNAKE,
+  PROGRAM_MUSIC_MAKER,
+  PROGRAM_SETTINGS,
+  PROGRAM_ABOUT,
+  PROGRAM_INFO,
+  PROGRAM_WIRELESS,
+  PROGRAM_MENU
+};
+
+class Program {
+  public:
+    virtual void setup();
+    virtual void loop(Adafruit_SSD1351 *tft, inputData *userInput);
+    virtual void onEnter(Adafruit_SSD1351 *tft);
+    virtual void onExit();
+
+    bool disableInfoBar = false;
+    int framerate = 30;
+
+    // need to be able to set a framerate
+    // need to be able to input comuncation data
+};
+
+static const int JOY_DEAD_ZONE = 20;
+
diff --git a/test/README b/test/README
new file mode 100644
index 0000000..9b1e87b
--- /dev/null
+++ b/test/README
@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html