MKR 1000 + Pulse Sensor to calculate BPM without visualization

tldr; what is an easy/logical way (for a beginner) to calculate BPM using pulse sensor and mkr1000? I don't want any visualizations or processing sketch, but just print BPM values

Please bear with me, I am a newbie at this and i've tried my best to understand this and fix this issue, but in vain.

I am using the pulse sensor (SEN-11574) with Arduino mkr1000 to calculate the BPM and print it in serial monitor. I was able to get raw readings using their starter code

   //  Variables
    int PulseSensorPurplePin = 0;        // Pulse Sensor PURPLE WIRE connected to ANALOG PIN 0
    int LED13 = 13;   //  The on-board Arduion LED
    
    
    int Signal;                // holds the incoming raw data. Signal value can range from 0-1024
    int Threshold = 550;            // Determine which Signal to "count as a beat", and which to ingore. 
    
    
    // The SetUp Function:
    void setup() {
      pinMode(LED13,OUTPUT);         // pin that will blink to your heartbeat!
       Serial.begin(9600);         // Set's up Serial Communication at certain speed. 
       
    }
    
    // The Main Loop Function
    void loop() {
    
      Signal = analogRead(PulseSensorPurplePin);  // Read the PulseSensor's value. 
                                                  // Assign this value to the "Signal" variable.
    
       Serial.println(Signal);                    // Send the Signal value to Serial Plotter.
    
       
       if(Signal > Threshold){                          // If the signal is above "550", then "turn-on" Arduino's on-Board LED.  
         digitalWrite(LED13,HIGH);          
       } else {
         digitalWrite(LED13,LOW);                //  Else, the sigal must be below "550", so "turn-off" this LED.
       }
    
    
    delay(10); 
    }

However, the real problem is that I am unable to calculate the BPM using their example code available [on their website here]
From what I understand, the interrupt timer function in the Interrupt.ino file is not compatible with mkr1000. Attached is this code for your reference.

    // THIS IS THE TIMER 2 INTERRUPT SERVICE ROUTINE.
    // Timer 2 makes sure that we take a reading every 2 miliseconds
    ISR(TIMER2_COMPA_vect){                         // triggered when Timer2 counts to 124
      cli();                                      // disable interrupts while we do this
      Signal = analogRead(pulsePin);              // read the Pulse Sensor
      sampleCounter += 2;                         // keep track of the time in mS with this variable
      int N = sampleCounter - lastBeatTime;       // monitor the time since the last beat to avoid noise
    
        //  find the peak and trough of the pulse wave
      if(Signal < thresh && N > (IBI/5)*3){       // avoid dichrotic noise by waiting 3/5 of last IBI
        if (Signal < T){                        // T is the trough
          T = Signal;                         // keep track of lowest point in pulse wave
        }
      }
    
      if(Signal > thresh && Signal > P){          // thresh condition helps avoid noise
        P = Signal;                             // P is the peak
      }                                        // keep track of highest point in pulse wave
    
      //  NOW IT'S TIME TO LOOK FOR THE HEART BEAT
      // signal surges up in value every time there is a pulse
      if (N > 250){                                   // avoid high frequency noise
        if ( (Signal > thresh) && (Pulse == false) && (N > (IBI/5)*3) ){
          Pulse = true;                               // set the Pulse flag when we think there is a pulse
          digitalWrite(blinkPin,HIGH);                // turn on pin 13 LED
          IBI = sampleCounter - lastBeatTime;         // measure time between beats in mS
          lastBeatTime = sampleCounter;               // keep track of time for next pulse
    
          if(secondBeat){                        // if this is the second beat, if secondBeat == TRUE
            secondBeat = false;                  // clear secondBeat flag
            for(int i=0; i<=9; i++){             // seed the running total to get a realisitic BPM at startup
              rate[i] = IBI;
            }
          }
    
          if(firstBeat){                         // if it's the first time we found a beat, if firstBeat == TRUE
            firstBeat = false;                   // clear firstBeat flag
            secondBeat = true;                   // set the second beat flag
            sei();                               // enable interrupts again
            return;                              // IBI value is unreliable so discard it
          }
    
    
          // keep a running total of the last 10 IBI values
          word runningTotal = 0;                  // clear the runningTotal variable
    
          for(int i=0; i<=8; i++){                // shift data in the rate array
            rate[i] = rate[i+1];                  // and drop the oldest IBI value
            runningTotal += rate[i];              // add up the 9 oldest IBI values
          }
    
          rate[9] = IBI;                          // add the latest IBI to the rate array
          runningTotal += rate[9];                // add the latest IBI to runningTotal
          runningTotal /= 10;                     // average the last 10 IBI values
          BPM = 60000/runningTotal;               // how many beats can fit into a minute? that's BPM!
          QS = true;                              // set Quantified Self flag
          // QS FLAG IS NOT CLEARED INSIDE THIS ISR
        }
      }
    
      if (Signal < thresh && Pulse == true){   // when the values are going down, the beat is over
        digitalWrite(blinkPin,LOW);            // turn off pin 13 LED
        Pulse = false;                         // reset the Pulse flag so we can do it again
        amp = P - T;                           // get amplitude of the pulse wave
        thresh = amp/2 + T;                    // set thresh at 50% of the amplitude
        P = thresh;                            // reset these for next time
        T = thresh;
      }
    
      if (N > 2500){                           // if 2.5 seconds go by without a beat
        thresh = 530;                          // set thresh default
        P = 512;                               // set P default
        T = 512;                               // set T default
        lastBeatTime = sampleCounter;          // bring the lastBeatTime up to date
        firstBeat = true;                      // set these to avoid noise
        secondBeat = false;                    // when we get the heartbeat back
      }
    
      sei();                                   // enable interrupts when youre done!
    }// end isr

On the interrupt-notes file they mention another work-around for processors that are not compatible with this code, but even after hours of following the intructions, the code didn't work, again with errors with timer interrupt functions.

Next, I used [this guide] but again, it didn't work either and just prints raw signal value that constantly changes (S1023). The code is in this link (can't paste coz char limit)

Serial monitor only displays these numbers that are constantly changing:

S797
S813
S798
S811
S822
S802
S821
S819
S818
S806
S797
S797
S812
S816
S794
S820
S821
S808
S816
S820
S803
S810
S811
S806
S822
S817
S811
S822
S800
S820
S799
S800
S815
S809
S820
S822
S821
S809
S796
S821
S816
S798
S820

All in all, I was hoping if someone could help me with the code to calculate BPM in a more basic/ easy manner without having to deal with visualization of the BPM.

Sorry for the long post, thanks!

That ISR is rather tightly-linked to the architecture of the AVR Arduinos. Using it on the MKR1000 is going to either require some deep understanding of the architecture, or a bit of brute force.

I don't have an MKR1000 so I can't test this idea, but I'd go the brute-force method first.

Step 1: Rename the ISR to make it a regular function. Call it checkForPulse() or something.

Step 2: Call this function as close as possible to once every 2 milliseconds.

void loop() {
  static unsigned long previousPulseCheck = millis();
  if(millis() - previousPulseCheck >= 2) {
    checkForPulse();
    previousPulseCheck += 2;
  }
  //other code here...
}

Just make sure that your other code can't take more than 2-3 milliseconds to run each time. No delay() or gigantically long serial prints.