From 345412c33b4efbb14847e627f1cc2ae4cb7fd637 Mon Sep 17 00:00:00 2001 From: Daniel Kluge Date: Wed, 24 May 2023 14:57:19 +0200 Subject: [PATCH] Initial commit --- .gitignore | 5 ++ .vscode/extensions.json | 10 +++ include/README | 39 ++++++++++ lib/README | 46 ++++++++++++ platformio.ini | 17 +++++ src/main.cpp | 158 ++++++++++++++++++++++++++++++++++++++++ test/README | 11 +++ 7 files changed, 286 insertions(+) create mode 100644 .gitignore create mode 100644 .vscode/extensions.json create mode 100644 include/README create mode 100644 lib/README create mode 100644 platformio.ini create mode 100644 src/main.cpp create mode 100644 test/README 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..194dcd4 --- /dev/null +++ b/include/README @@ -0,0 +1,39 @@ + +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 usual convention is to give header files names that end with `.h'. +It is most portable to use only letters, digits, dashes, and underscores in +header file names, and at most one dot. + +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..6debab1 --- /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 executable file. + +The source code of each library should be placed in a an own separate directory +("lib/your_library_name/[here are source files]"). + +For example, see a structure of the following two libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional, 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 + +and a contents of `src/main.c`: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +PlatformIO Library Dependency Finder will find automatically dependent +libraries 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..111ac9f --- /dev/null +++ b/platformio.ini @@ -0,0 +1,17 @@ +; 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:teensylc] +platform = teensy +board = teensylc +framework = arduino +lib_deps = + thomasfredericks/Bounce2@^2.71 +build_flags = -D USB_MIDI -D TEENSY_OPT_FASTEST \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..1e2c406 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,158 @@ +#include +#include + +#define MIDI_NAME {'P', 'i', 'n', 'g', 'b', 'o', 'a', 'r', 'd'} +#define MIDI_NAME_LEN 9 + +#define CHECK_PINS 9 +#define KEY_PINS 6 +#define BOUNCE_TIME 5 +#define POWER_SUPPLY_CHECK_PIN 13 + +#define NUMBER_OF_KEYS 49 +#define SELF_DRIVE_INTERVAL 100 + +Bounce check_pins[CHECK_PINS] { + {14, BOUNCE_TIME}, // not KEYS1..6 + {15, BOUNCE_TIME}, // not KEYS7..12 + {16, BOUNCE_TIME}, // not KEYS13..18 + {17, BOUNCE_TIME}, // not KEYS19..24 + {18, BOUNCE_TIME}, // not KEYS25..30 + {19, BOUNCE_TIME}, // not KEYS31..36 + {20, BOUNCE_TIME}, // not KEYS37..42 + {21, BOUNCE_TIME}, // not KEYS43..48 + {22, BOUNCE_TIME} // not KEYS49 +}; + +// not KEY0%6..not KEY5%6 +const unsigned char key_pins[KEY_PINS] {2, 3, 4, 5, 6, 7}; +// Array of pressed keys (initially all 0) +bool keys_pressed[NUMBER_OF_KEYS]; +// K1, K2, K3, K4, K5, K12, K13, K14, K15 +const unsigned char self_drive_pins[CHECK_PINS] {8, 9, 10, 11, 12, 26, 23, 24, 25}; +volatile unsigned char curr_self_drive_pin = 0; +IntervalTimer self_drive_timer = IntervalTimer(); + +// Map the current array and pressed key to a MIDI note +unsigned char mapToMidi(char curr_arr, char key) { + unsigned char offset = (curr_arr >> 1) * 12; + // TODO: maybe we have to switch the notes and array offsets + // Uneven offset are the upper octave, even the lower + if (curr_arr & 1) { + switch (key) { + case 0: return offset + 42; // F#2 + offset + case 1: return offset + 43; // G2 + offset + case 2: return offset + 44; // G#2 + offset + case 3: return offset + 45; // A2 + offset + case 4: return offset + 46; // A#2 + offset + case 5: return offset + 47; // B2 + offset + } + } else { + switch (key) { + case 0: return offset + 36; // C2 + offset + case 1: return offset + 37; // C#2 + offset + case 2: return offset + 38; // D2 + offset + case 3: return offset + 39; // D#2 + offset + case 4: return offset + 40; // E2 + offset + case 5: return offset + 41; // F2 + offset + } + } + + // We hopefully never get here + return 0; +} + +// Check if any of the array pins fell since last time +char findCurrentArrPin() { + for (unsigned char i = 0; i < CHECK_PINS; i++) { + // Update status + check_pins[i].update(); + // Check if the pin fell or is low + // ! inverted + if (check_pins[i].fell()) return i; + } + + // If none fell we should have enough time to see which one is low + for (unsigned char i = 0; i < CHECK_PINS; i++) { + if (check_pins[i].read() == LOW) return i; + } + + // Default return + return -1; +} + +// Set the next self drive pin +void nextSelfDrivePin() { + // Set the current pin to high + digitalWriteFast(self_drive_pins[curr_self_drive_pin], HIGH); + // Set the next pin + curr_self_drive_pin = (curr_self_drive_pin + 1) % CHECK_PINS; +} + +// Interrupt for power supply check +void powerStateChanged() { + unsigned char state = digitalReadFast(POWER_SUPPLY_CHECK_PIN); + // ! inverted + if (state == LOW) { + curr_self_drive_pin = 0; + self_drive_timer.begin(nextSelfDrivePin, SELF_DRIVE_INTERVAL); + } else { + self_drive_timer.end(); + } +} + +// Initial start function +void setup() { + // Set all in- and outputs + for (unsigned char i = 0; i < CHECK_PINS; i++) { + pinMode(check_pins[i].getPin(), INPUT); + pinMode(self_drive_pins[i], INPUT); + } + for (unsigned char i = 0; i < KEY_PINS; i++) { + pinMode(key_pins[i], INPUT); + } + pinMode(POWER_SUPPLY_CHECK_PIN, INPUT); + // Manual call, so we can set the initial state + powerStateChanged(); + // Setup interrupt for power supply + attachInterrupt(POWER_SUPPLY_CHECK_PIN, []() { while (true); }, CHANGE); +} + +// Main loop +void loop() { + // Find active arr pin + char curr_arr = findCurrentArrPin(); + + // If none is active, we do nothing, else we check the keys + if (curr_arr >= 0) { + // Get all the key values ans send the MIDI message if needed + unsigned char value; + + for (unsigned char i = 0; i < KEY_PINS; i++) { + value = digitalReadFast(key_pins[i]); + // If the key is pressed, we send a MIDI message and set the entry in the array + // ! inverted + if (value == LOW) { + // Check if the key is not already pressed + if (keys_pressed[curr_arr * 6 + i] == 0) { + // Send MIDI message + usbMIDI.sendNoteOn(mapToMidi(curr_arr, i), 127, 1); + // Set the entry in the array + keys_pressed[curr_arr * 6 + i] = 1; + } + } else { + // Check if the key is not already released + if (keys_pressed[curr_arr * 6 + i] == 1) { + // Send MIDI message + usbMIDI.sendNoteOff(mapToMidi(curr_arr, i), 0, 1); + // Set the entry in the array + keys_pressed[curr_arr * 6 + i] = 0; + } + } + } + } + + // MIDI Controllers should discard incoming MIDI messages. + while (usbMIDI.read()) { + } +} \ No newline at end of file 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