Hi there! First post 🙂) Me and my friend are very new to c++ but are trying to code a psychological experiment, using a MIDI-keyboard and the bela mini. We are currently too tired to function, but heres the state of things:

Our experiment is meant to work in such a way that participants are presented with 4 metronome tones (here "cuetones"), and then afterwards they have to keep tapping at that tempo for 24 tones. In the condition that we show here, it is set up so two of the participants have to press together, in order for the bela to generate a sound, while the third participant can play a tone alone. The ‘loner’ and the ‘subgroup’ take turns playing a tone. The timing of each keypress is recorded together with information about the participant, the group, the condition and the trial number.

Our code is currently a wonky combination of code from other scripts, the bela yt channel and AI and we've desperately moved things around – so please don’t pay too much attention to the comments :’)

We have been told that we can solve an issue regarding an underrun warning, and to be certain about our timing, by moving the midi event processing into the “audioFrames loop” that runs every frame, which currently only includes actually generating the sounds. We’ve tried to move the lines 114 to 249 into the loop starting at line 250, but this completely ruined the sound generation and introduced ungodly amounts of distortion.

On top of this, we have the problem that the bela seems to stay silent for too long after the fourth metronome beat, so that pressing in time with the metronome will not generate a tone for the first tap.

We hope a kind soul will show mercy and give us a helping hand - have a nice weekend !

Here's our poor code

#include <Bela.h>
#include <libraries/Midi/Midi.h>
#include <stdlib.h>
#include <cmath>
#include <fstream>
// #include <libraries/WriteFile/WriteFile.h>
#include <chrono>
#include <string>
#include <iomanip>  // for std::fixed and std::setprecision
#include <set> // Include for std::set
#include <algorithm> // For std::includes

std::set<int> activeParticipants; // Set to track currently active participants
const std::set<int> requiredParticipants = {1, 2, 3}; // Define required participants
const std::set<int> lonerParticipants = {3}; // Define required participants
const std::set<int> subgroupParticipants = {1, 2}; // Define required participants

// Global variables
// Replace WriteFile global variables with std::ofstream
std::ofstream gDataFile;
int gCurrentGroup = 0;
const char* gCurrentCondition = "Subgroup";
int gCurrentTrial = 1;

int participant = 0;

// MIDI setup
Midi gMidi;
const char* gMidiPort0 = "hw:1,0,0";

std::string gCurrentPhase;

unsigned long gStartTime;
int gTapCount = 0;
std::vector<float> logs(6); // Create a vector to store the log data

// Oscillator state - generate the tone 
float gPhase = 0; 
float gFrequency = 0;
float gAmplitude = 0;
double freq[6] = {440.0, 493.88, 554.37, 659.26, 739.99, 880.0}; //initializing array of 7 tones from pentatonic a-major scale  
int tone_nr = 0;

// List of active notes
const int kMaxNotes = 16;
int gActiveNotes[kMaxNotes];
int gActiveNoteCount = 0;

// Cue tone variable
int CueTone = 0; 
int cueTonePlayCount = 0;
int cueToneCounter = 0;
bool playingCueTone = true;

int gTotalTaps = 0;
bool gTrialComplete = false;

float audioSampleRate = 0;

bool setup(BelaContext *context, void *userData)
{
	// print statement to check samplerate 
	rt_printf("Audio sample rate: %f\n", context->audioSampleRate);
	audioSampleRate = context->audioSampleRate;
	
    // Initialise the MIDI device
    if(gMidi.readFrom(gMidiPort0) < 0) {
        rt_printf("Unable to read from MIDI port %s\n", gMidiPort0);
        return false;
    }
    gMidi.writeTo(gMidiPort0);
    gMidi.enableParser(true);
    
    // Initialize start time
    gStartTime = std::chrono::duration_cast<std::chrono::milliseconds>
        (std::chrono::system_clock::now().time_since_epoch()).count();
    
    // Read parameters
    std::ifstream params("/root/Bela/projects/Subgroup/current_params");
    if(!params) {
        rt_printf("Warning: Could not read parameters file\n");
        gCurrentGroup = 0;
        gCurrentCondition = "Subgroup";
        gCurrentTrial = 1;
    } else {
        params >> gCurrentGroup >> gCurrentTrial;
        rt_printf("Parameters loaded: group=%d, condition=%s, trial=%d\n", 
                 gCurrentGroup, gCurrentCondition, gCurrentTrial);
    }
    
    // Setup data logging with CSV file
    char filename[100];
    sprintf(filename, "/root/Bela/projects/Subgroup/data/trial_%d_%s_%d.csv", 
            gCurrentGroup, gCurrentCondition, gCurrentTrial);
    
    gDataFile.open(filename);
    if(!gDataFile.is_open()) {
        rt_printf("Error: Could not open data file %s\n", filename);
        return false;
    }
    
    // Write CSV header
    gDataFile << "timestamp,participant,group,condition,trial" << std::endl;
    rt_printf("Data logging setup for file: %s\n", filename);
    
    gTotalTaps = 0;
    gTrialComplete = false;
    
    return true;
}

void render(BelaContext *context, void *userData)
{		
	//loop through audioframes 
	
	// At the beginning of each callback, look for available MIDI
	// messages that have come in since the last block
	while(gMidi.getParser()->numAvailableMessages() > 0) {
		MidiChannelMessage message;
		message = gMidi.getParser()->getNextChannelMessage();
		message.prettyPrint();		// Print the message data
		
		// A MIDI "note on" message type might actually hold a real
		// note onset (e.g. key press), or it might hold a note off (key release).
		// The latter is signified by a velocity of 0.
		if(message.getType() == kmmNoteOn) {
			int noteNumber = message.getDataByte(0);
			int velocity = message.getDataByte(1); 
			
			// Velocity of 0 is really a note off
			if(velocity > 0) {
				if (!gTrialComplete && gActiveNoteCount < kMaxNotes) {
        // Determine participant based on note number
        if (noteNumber == 48) participant = 1;
        else if (noteNumber == 59) participant = 2;
        else if (noteNumber == 71) participant = 3;
        else participant = 0; // Invalid participant key

        if (participant > 0) {
            // Log the keypress immediately
            unsigned long currentTime = std::chrono::duration_cast<std::chrono::milliseconds>
                (std::chrono::system_clock::now().time_since_epoch()).count();
            float timestamp = (currentTime - gStartTime) / 1000.0;

            if (gDataFile.is_open()) {
                gDataFile << std::fixed << std::setprecision(3)
                          << timestamp << "," << participant << ","
                          << gCurrentGroup << "," << gCurrentCondition << ","
                          << gCurrentTrial << std::endl;

                rt_printf("Logged: time=%.3f, participant=%d, group=%d, condition=%s, trial=%d\n",
                          timestamp, participant, gCurrentGroup, gCurrentCondition, gCurrentTrial);
            }

            // Add participant to activeParticipants for synchronization tracking
            activeParticipants.insert(participant);

            // Check if all required participants have pressed their keys
            if (std::includes(activeParticipants.begin(), activeParticipants.end(),
                  subgroupParticipants.begin(), subgroupParticipants.end()) ||
    std::includes(activeParticipants.begin(), activeParticipants.end(),
                  lonerParticipants.begin(), lonerParticipants.end())) {
                
                // All required participants pressed keys simultaneously
                gActiveNotes[gActiveNoteCount] = noteNumber;
                gActiveNoteCount++;
                gFrequency = freq[tone_nr];
                gAmplitude = 0.5;

                // Reset activeParticipants for the next synchronization event
                activeParticipants.clear();

                // Increment total taps only for synchronized events
                gTotalTaps++;
                if (tone_nr < 7) {
                    tone_nr++;
                }
                else {
                	tone_nr = 0;
                }
                
                rt_printf("Tap %d/24: participant=%d\n", gTotalTaps, participant);

                if (gTotalTaps >= 24) {
                    gTrialComplete = true;
                    rt_printf("\nTrial complete! 24 taps recorded.\n");
        			
                }
               
            }
        }
    }
			}
		}
		
		else if(message.getType() == kmmNoteOff) {
			// We can also encounter the "note off" message type which is the same
			// as "note on" with a velocity of 0.
			int noteNumber = message.getDataByte(0);
			
			// When we receive a note off, it might be the most recent note
	// that we played, or it might be an earlier note. We need to figure
	// out which indexes correspond to this note number.
	
		bool activeNoteChanged = false;
	
	// Go through all the active notes and remove any with this number
		for(int i = gActiveNoteCount - 1; i >= 0; i--) {
			if(gActiveNotes[i] == noteNumber) {
			// Found a match: is it the most recent note?
			
			// TODO 1: if the note is the most recent, set the flag
			// that says we will change the active note (activeNoteChanged)
			// But how do we know if this note in the array is the most
			// recent one? (hint: it depends on the value of i)
				if (i == gActiveNoteCount-1) {
					activeNoteChanged = true;
				}
			
			// TODO 2: move all the later notes to be one slot earlier in the
			// array. Hint: you will need another for() loop with a new
			// index, st arting from "i" and counting upward
				for (int j = i; j < gActiveNoteCount-1; j++){
					gActiveNotes[j] = gActiveNotes[j + 1];
			} 
	
			// TODO 3: decrease the number of active notes
			gActiveNoteCount--;
		}
	}

	rt_printf("Note off: %d notes remaining\n", gActiveNoteCount);
	
	if(gActiveNoteCount == 0) {
		// No notes left
		gAmplitude = 0;
	}
	//else if(activeNoteChanged) {
		// Update the frequency but don't retrigger
	//	int mostRecentNote = gActiveNotes[gActiveNoteCount - 1];
		
	//	gFrequency = powf(2.0, (mostRecentNote - 69)/12.0) * 440.0; //convert to frequency
		
	//	rt_printf("Note changed: new frequency %f\n", gFrequency);
	//}
		}

	}
	//Cue Tones 
  for(unsigned int n = 0; n < context->audioFrames; n++) {
  	
        float value = 0;
        // Cue Tone Handling
        if (playingCueTone) {
            if (cueTonePlayCount < 4) {
                // Play cue tone for 0.5 seconds, then silence for 0.5 seconds
                if (cueToneCounter < audioSampleRate / 2 ){ // Play tone
                    gFrequency = 440.0;
                    gAmplitude = 0.5; 
                } else if (cueToneCounter < audioSampleRate) { // Silence
                    gAmplitude = 0.0;
                } else { // Reset cycle
                    cueToneCounter = 0;
                    cueTonePlayCount++;
                }
                cueToneCounter++; // Increment the sample counter
                value = sin(gPhase) * gAmplitude; // Generate cue tone wave

                gPhase += 2.0 * M_PI * gFrequency / audioSampleRate;
                if (gPhase > 2.0 * M_PI) { // Ensure phase wraps correctly
                    gPhase -= 2.0 * M_PI;
                }
            } else {
                // Cue tone finished
                playingCueTone = false; // Disable cue tone mode
                cueToneCounter = 0;     // Reset counter
                gAmplitude = 0.0;       // Ensure silence is cleared
                gPhase = 0.0f;          // Reset phase
            }
        }

        // Normal Note Generation (Outside Cue Tone Block)
        else if (gActiveNoteCount > 0) {
            gPhase += 2.0 * M_PI * gFrequency / audioSampleRate;
            if (gPhase > 2.0 * M_PI) {
                gPhase -= 2.0 * M_PI;
            }
            value = sin(gPhase) * gAmplitude;
        }

        // Write audio output for each channel
        for (unsigned int ch = 0; ch < context->audioOutChannels; ++ch) {
            audioWrite(context, n, ch, value);
        
        }
        
        // Log the keypress immediately
            unsigned long currentTime = std::chrono::duration_cast<std::chrono::milliseconds>
                (std::chrono::system_clock::now().time_since_epoch()).count();
            float timestamp = (currentTime - gStartTime) / 1000.0;

            if (gDataFile.is_open()) {
                gDataFile << std::fixed << std::setprecision(3)
                          << timestamp << "," << participant << ","
                          << gCurrentGroup << "," << gCurrentCondition << ","
                          << gCurrentTrial << std::endl;

                rt_printf("Logged: time=%.3f, participant=%d, group=%d, condition=%s, trial=%d\n",
                          timestamp, participant, gCurrentGroup, gCurrentCondition, gCurrentTrial);
            }
}
}

void cleanup(BelaContext *context, void *userData)
{
    if(gDataFile.is_open()) {
        gDataFile.close();
        rt_printf("Data file closed\n");
    }
}