merge

.vscode/launch.json

@@ -1,18 +1,18 @@
-
+{
-    {
   "version": "0.2.0",
   "configurations": [
     {
       "name": "Debug C++",
       "type": "cppdbg",
       "request": "launch",
-            "program": "${workspaceFolder}/main",
+      "program": "${workspaceFolder}/main3.cpp",
       "args": [],
       "stopAtEntry": false,
       "cwd": "${workspaceFolder}",
       "environment": [],
       "externalConsole": true,
       "MIMode": "gdb",
+      "miDebuggerPath": "C:/MinGW/bin/gdb.exe", // <- adjust this path to your Windows gdb
       "setupCommands": [
         {
           "description": "Enable pretty-printing for gdb",
@@ -20,9 +20,7 @@
           "ignoreFailures": true
         }
       ],
-            "preLaunchTask": "build",
+      "preLaunchTask": "C/C++: g++.exe build active file"
-            "miDebuggerPath": "/usr/bin/gdb" // ou chemin vers gdb sous Windows
     }
   ]
-      }
+}
-      

.vscode/settings.json

@@ -1,3 +1,54 @@
 {
-    "C_Cpp.default.compilerPath": "C:/MinGW/bin/g++.exe"
+    "C_Cpp.default.compilerPath": "C:/MinGW/bin/g++.exe",
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "typeinfo": "cpp",
+        "main3": "cpp",
+        "cstring": "cpp",
+        "iomanip": "cpp"
+    },
+    "C_Cpp.errorSquiggles": "disabled"
 }

.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"type": "cppbuild",
+			"label": "C/C++: g++.exe build active file",
+			"command": "C:/MinGW/bin/g++.exe",
+			"args": [
+				"-fdiagnostics-color=always",
+				"-g",
+				"${file}",
+				"-o",
+				"${fileDirname}\\${fileBasenameNoExtension}.exe"
+			],
+			"options": {
+				"cwd": "C:/MinGW/bin"
+			},
+			"problemMatcher": [
+				"$gcc"
+			],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"detail": "compiler: C:/MinGW/bin/g++.exe"
+		}
+	]
+}

README.md

@@ -1,2 +1,6 @@
 # IP_HeartBand
 
+To launch the code main8.cpp which is the final code, write this on the terminal:
+
+g++ main8.cpp -o main8.exe 
+./main8.exe

main.cpp

@@ -2,19 +2,42 @@
 #include <vector>
 #include <chrono>
 #include <thread>
+#include <windows.h>
+#include <cstdlib>
+#include <unistd.h>
 
 // Seuils de BPM
 const int BPM_MIN = 50;
 const int BPM_MAX = 120;
+int fakeBPM = 60;
+const int secondsBetweenMeasures = 10;
+const int bufferSize = 60480; // une semaine à 1 mesure/10s
+int historique[bufferSize];
+int index = 0;
+
+const int SAMPLE_RATE_MS = 10; // 100 Hz -> une mesure chaque 10 ms
+const int THRESHOLD = 500; // seuil pour détecter un battement (à ajuster selon notre capteur)
 
 // === Simule la récupération de données du capteur ===
 int acquerirDonnees() {
     // Ici tu brancherais ton ADC ou capteur réel
     // Simulation d'une fréquence cardiaque variable
-    static int fakeBPM = 70 + rand() % 60 - 30;
+    fakeBPM = fakeBPM - 5 + rand() % 11 ;
+    std::cout << "Le random BPM est "<<fakeBPM << std::endl;
+    historique[index % bufferSize] = fakeBPM;
+    index++;
     return fakeBPM;
 }
 
+// Vrai fonction qui marcherait avec le capteur
+int acquerirSignal() {
+    // Simulation d'un signal : bruit + pics
+    static int t = 0;
+    t++;
+    if (t % 100 == 0) return 700; // simulate un pic toutes les 1 seconde
+    return 300 + rand() % 100; // bruit autour de 300-400
+}
+
 // === Calcule le BPM à partir d'une série de battements ===
 int calculerBPM(const std::vector<int>& battements) {
     // Moyenne simple des valeurs simulées
@@ -34,7 +57,7 @@ bool verifierAnomalie(int bpm) {
 
 // === Déclenche une alerte ===
 void alerter(int bpm) {
-    std::cout << "⚠ Alerte : rythme cardiaque anormal (" << bpm << " BPM) !" << std::endl;
+    std::cout << " Alerte : rythme cardiaque anormal (" << bpm << " BPM) !" << std::endl;
     // Tu peux ici allumer une LED, déclencher un buzzer, etc.
 }
 
@@ -51,6 +74,7 @@ void afficher(int bpm, bool anomalie) {
 int main() {
     std::vector<int> bufferBPM;
     const int tailleBuffer = 5;
+    std::srand(std::time(0));
 
     while (true) {
         int mesure = acquerirDonnees();
@@ -68,7 +92,7 @@ int main() {
             alerter(bpm);
         }
 
-        std::this_thread::sleep_for(std::chrono::seconds(1)); // simulation de délai entre mesures
+        usleep(2); // simulation de délai entre mesures: 500 mesures par seconde
     }
 
     return 0;

main2.cpp

@@ -0,0 +1,80 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <thread>
+#include <cstdlib> // Pour rand()
+#include <ctime>   // Pour srand()
+#include <unistd.h> // pour usleep()
+
+// === Paramètres ===
+const int BPM_MIN = 50;
+const int BPM_MAX = 120;
+const int SAMPLE_INTERVAL_MS = 10; // Prendre une mesure toutes les 10 ms
+const int THRESHOLD = 550;         // Seuil pour détecter un battement
+const int NOISE_LEVEL = 100;        // Niveau de bruit du signal
+
+// === Initialiser le générateur de nombres aléatoires ===
+void initialiserRandom() {
+    srand(static_cast<unsigned int>(time(0)));
+}
+
+// === Simule les données reçues du capteur cardiaque ===
+int simulerSignalCardiaque() {
+    static int t = 0;
+    t++;
+
+    // Créer un pic toutes les 800 ms environ (~75 BPM)
+    if (t % 80 == 0) {
+        return 700 + rand() % 50; // Pic entre 700-750
+    }
+    else {
+        return 300 + rand() % NOISE_LEVEL; // Bruit entre 300 et 400
+    }
+}
+
+// === Fonction principale ===
+int main() {
+    initialiserRandom();
+
+    bool battementDetecte = false;
+    auto dernierBattement = std::chrono::steady_clock::now();
+
+    std::cout << "Démarrage de la simulation du capteur cardiaque...\n";
+
+    while (true) {
+        int signal = simulerSignalCardiaque();
+
+        // Afficher la valeur brute du signal simulé (optionnel pour debug)
+        // std::cout << "Signal: " << signal << std::endl;
+
+        // Détection de battement
+        if (signal > THRESHOLD && !battementDetecte) {
+            auto maintenant = std::chrono::steady_clock::now();
+            auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+
+            if (intervalle > 300) { // Filtrer les battements trop proches (<300 ms = >200 BPM)
+                int bpm = 60000 / intervalle;
+                std::cout << " BPM mesure : " << bpm;
+
+                if (bpm < BPM_MIN || bpm > BPM_MAX) {
+                    std::cout << " [Anomalie]";
+                }
+                std::cout << std::endl;
+
+                dernierBattement = maintenant;
+            }
+
+            battementDetecte = true;
+        }
+
+        // Prêt pour détecter un prochain battement
+        if (signal < THRESHOLD) {
+            battementDetecte = false;
+        }
+
+        // Pause entre deux lectures du capteur
+        usleep(SAMPLE_INTERVAL_MS);
+    }
+
+    return 0;
+}

main3

@@ -0,0 +1,96 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <thread>
+#include <cstdlib> // rand()
+#include <ctime>   // time()
+#include <unistd.h> // pour usleep()
+
+// === Parameters ===
+const int BPM_MIN = 50;
+const int BPM_MAX = 120;
+const int SAMPLE_INTERVAL_MS = 100; // Sampling every 10 ms
+const int THRESHOLD = 550;         // Threshold for heartbeat detection
+const int NOISE_LEVEL = 100;       // Simulated noise level
+
+// === Initialize random generator ===
+void initialiserRandom() {
+    srand(static_cast<unsigned int>(time(0)));
+}
+
+// === Simulate heart signal from sensor ===
+int simulerSignalCardiaque() {
+    static int t = 0;
+    t++;
+
+    // Simulate a peak every ~800 ms (≈75 BPM)
+    if (t % 80 == 0) {
+        return 700 + rand() % 50; // Simulated peak
+    } else {
+        return 300 + rand() % NOISE_LEVEL; // Background noise
+    }
+}
+
+// === Simulate buzzer activation ===
+void activerBuzzer() {
+    std::cout << "🔊 Buzzer activé (ALERTE CARDIAQUE)!" << std::endl;
+}
+
+// === Simulate vibration motor activation ===
+void activerVibreur() {
+    std::cout << " Vibreur activé (ALERTE CARDIAQUE)!" << std::endl;
+}
+
+// === Simulate Bluetooth transmission ===
+void envoyerMessageBluetooth(bool urgence) {
+    std::cout << " Message Bluetooth envoyé: " << (urgence ? "TRUE (urgence)" : "FALSE (normal)") << std::endl;
+}
+
+// === Main program ===
+int main() {
+    initialiserRandom();
+
+    bool battementDetecte = false;
+    auto dernierBattement = std::chrono::steady_clock::now();
+
+    std::cout << " Démarrage de la simulation du capteur cardiaque...\n";
+
+    while (true) {
+        int signal = simulerSignalCardiaque();
+
+        // Détection de battement
+        if (signal > THRESHOLD && !battementDetecte) {
+            auto maintenant = std::chrono::steady_clock::now();
+            auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+
+            if (intervalle > 300) { // BPM > 200 => ignore
+                int bpm = 60000 / intervalle;
+                std::cout << " BPM mesuré : " << bpm;
+
+                bool anomalie = (bpm < BPM_MIN || bpm > BPM_MAX);
+                if (anomalie) {
+                    std::cout << " [ANOMALIE]";
+                    activerBuzzer();
+                    activerVibreur();
+                    envoyerMessageBluetooth(true);
+                } else {
+                    envoyerMessageBluetooth(false);
+                }
+                std::cout << std::endl;
+
+                dernierBattement = maintenant;
+            }
+
+            battementDetecte = true;
+        }
+
+        // Prêt pour détecter le prochain battement
+        if (signal < THRESHOLD) {
+            battementDetecte = false;
+        }
+
+       usleep(SAMPLE_INTERVAL_MS);
+    }
+
+    return 0;
+}

main3.cpp

@@ -0,0 +1,96 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <thread>
+#include <cstdlib> // rand()
+#include <ctime>   // time()
+#include <unistd.h> // pour usleep()
+
+// === Parameters ===
+const int BPM_MIN = 50;
+const int BPM_MAX = 120;
+const int SAMPLE_INTERVAL_MS = 100; // Sampling every 10 ms
+const int THRESHOLD = 550;         // Threshold for heartbeat detection
+const int NOISE_LEVEL = 100;       // Simulated noise level
+
+// === Initialize random generator ===
+void initialiserRandom() {
+    srand(static_cast<unsigned int>(time(0)));
+}
+
+// === Simulate heart signal from sensor ===
+int simulerSignalCardiaque() {
+    static int t = 0;
+    t++;
+
+    // Simulate a peak every ~800 ms (≈75 BPM)
+    if (t % 80 == 0) {
+        return 700 + rand() % 50; // Simulated peak
+    } else {
+        return 300 + rand() % NOISE_LEVEL; // Background noise
+    }
+}
+
+// === Simulate buzzer activation ===
+void activerBuzzer() {
+    std::cout << " Buzzer active (ALERTE CARDIAQUE)!" << std::endl;
+}
+
+// === Simulate vibration motor activation ===
+void activerVibreur() {
+    std::cout << " Vibreur active (ALERTE CARDIAQUE)!" << std::endl;
+}
+
+// === Simulate Bluetooth transmission ===
+void envoyerMessageBluetooth(bool urgence) {
+    std::cout << " Message Bluetooth envoye: " << (urgence ? "TRUE (urgence)" : "FALSE (normal)") << std::endl;
+}
+
+// === Main program ===
+int main() {
+    initialiserRandom();
+
+    bool battementDetecte = false;
+    auto dernierBattement = std::chrono::steady_clock::now();
+
+    std::cout << " Demarrage de la simulation du capteur cardiaque...\n";
+
+    while (true) {
+        int signal = simulerSignalCardiaque();
+
+        // Détection de battement
+        if (signal > THRESHOLD && !battementDetecte) {
+            auto maintenant = std::chrono::steady_clock::now();
+            auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+
+            if (intervalle > 300) { // BPM > 200 => ignore
+                int bpm = 60000 / intervalle;
+                std::cout << " BPM mesure : " << bpm;
+
+                bool anomalie = (bpm < BPM_MIN || bpm > BPM_MAX);
+                if (anomalie) {
+                    std::cout << " [ANOMALIE]";
+                    activerBuzzer();
+                    activerVibreur();
+                    envoyerMessageBluetooth(true);
+                } else {
+                    envoyerMessageBluetooth(false);
+                }
+                std::cout << std::endl;
+
+                dernierBattement = maintenant;
+            }
+
+            battementDetecte = true;
+        }
+
+        // Prêt pour détecter le prochain battement
+        if (signal < THRESHOLD) {
+            battementDetecte = false;
+        }
+
+       usleep(SAMPLE_INTERVAL_MS);
+    }
+
+    return 0;
+}

main4.cpp

@@ -0,0 +1,95 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <cstdlib> // rand()
+#include <ctime>   // time()
+#include <windows.h>
+
+// === Parameters ===
+//const int BPM_MIN = 50;
+//const int BPM_MAX = 120;
+const int SAMPLE_INTERVAL_MS = 1000; // Sampling every 10 ms
+const int THRESHOLD_CARDIAC_ARREST = 2;         
+//const int NOISE_LEVEL = 100;       // Simulated noise level
+
+
+// === Initialize random generator ===// === Simulate heart signal from sensor ===
+int generateRandomHeartRate() {
+    //int bpm = 30 + rand() % 111; // génère un BPM entre 30 et 140
+    int bpm = rand() % 141;  //  génère un BPM entre 0 et 140
+    return bpm;
+}
+
+// === Simulate buzzer activation ===
+void activerBuzzer() {
+    std::cout << " Buzzer active (ALERTE CARDIAQUE)!" << std::endl;
+}
+
+// === Simulate vibration motor activation ===
+void activerVibreur() {
+    std::cout << " Vibreur active (ALERTE CARDIAQUE)!" << std::endl;
+}
+
+// === Simulate Bluetooth transmission ===
+void envoyerMessageBluetooth(bool urgence) {
+    std::cout << " Message Bluetooth envoye: " << (urgence ? "TRUE (urgence)" : "FALSE (normal)") << std::endl;
+}
+
+// === Main program ===
+int main() {
+
+    bool battementDetecte = false;
+    auto dernierBattement = std::chrono::steady_clock::now();
+
+    std::cout << " Demarrage de la simulation du capteur cardiaque...\n";
+    int i=0;
+    int lastBPM;
+
+    while (true) {
+        //int signal = simulerSignalCardiaque();
+        //std::cout << "Signal: " << signal << std::endl; // verify the signal detected
+
+        // Détection de battement
+        if (!battementDetecte) { //signal > THRESHOLD &&
+            auto maintenant = std::chrono::steady_clock::now();
+            auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+            
+            int bpm = generateRandomHeartRate();
+            std::cout << " BPM mesure : " << bpm;
+
+            if (bpm < 55 && bpm > 40){
+                std::cout << " [BRADYCARDIA]"  << std::endl;
+                activerVibreur();
+            } else if(bpm < 140 && bpm > 110) {
+                std::cout << " [TACHYCARDIA]"  << std::endl;
+                activerVibreur();
+            }else if(bpm < 110 && bpm > 55){
+                std::cout << " [NORMAL]" << std::endl;
+                envoyerMessageBluetooth(false);
+            } else if (bpm < 40){
+                if (i>THRESHOLD_CARDIAC_ARREST && lastBPM < 40){
+                    i=0;
+                    std::cout << " [CARDIAC ARREST]" << std::endl;
+                    activerBuzzer();
+                    activerVibreur();
+                    envoyerMessageBluetooth(true);
+                }else{
+                    i+=1;
+                }  
+            }   
+            std::cout << std::endl;
+
+            dernierBattement = maintenant;
+            battementDetecte = true;
+            lastBPM =bpm;
+            std::cout << lastBPM << std::endl;
+
+        }else {
+            battementDetecte = false;// Prêt pour détecter le prochain battement
+        }
+
+        Sleep(SAMPLE_INTERVAL_MS);  // expects milliseconds
+    }
+
+    return 0;
+}

main5.cpp

@@ -0,0 +1,141 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <thread>
+#include <cstdlib> // rand()
+#include <ctime>   // time()
+#include <unistd.h> // usleep()
+
+// === Parameters ===
+const int BPM_MIN = 50;
+const int BPM_MAX = 120;
+const int SAMPLE_INTERVAL_MS = 20; // Sampling every 100 ms
+const int THRESHOLD = 550;          // Threshold for heartbeat detection
+const int NOISE_LEVEL = 100;        // Simulated noise level
+
+// === Initialize random generator ===
+void initialiserRandom() {
+    srand(static_cast<unsigned int>(time(0)));
+}
+
+// === Simulate buzzer activation ===
+void activerBuzzer() {
+    std::cout << "Buzzer active (ALERTE CARDIAQUE)" << std::endl;
+}
+
+// === Simulate vibration motor activation ===
+void activerVibreur() {
+    std::cout << "Vibreur active (ALERTE CARDIAQUE)" << std::endl;
+}
+
+// === Simulate Bluetooth transmission ===
+void envoyerMessageBluetooth(bool urgence) {
+    std::cout << "Message Bluetooth envoye: " << (urgence ? "TRUE (urgence)" : "FALSE (normal)") << std::endl;
+}
+
+// === Simulate heart signal from sensor with variable BPM and 0-BPM possibility ===
+int simulerSignalCardiaque() {
+    static int t = 0;
+    static int nextPeakInterval = 0;
+
+    static int targetBPM = 75;
+    static int cyclesPerPeak = 800 / SAMPLE_INTERVAL_MS;
+    static bool enArretCardiaque = false;
+
+    t++;
+
+    if (t == 1 || t % nextPeakInterval == 0) {
+        if (rand() % 100 < 5) {
+            targetBPM = 0;
+            enArretCardiaque = true;
+            std::cout << "[Simulating cardiac arrest: BPM = 0]" << std::endl;
+        } else {
+            int variation = (rand() % 21) - 10;
+            targetBPM += variation;
+            if (targetBPM < 30) targetBPM = 30;
+            if (targetBPM > 210) targetBPM = 210;
+            enArretCardiaque = false;
+            std::cout << "[Target BPM = " << targetBPM << "]" << std::endl;
+        }
+
+        if (targetBPM == 0) {
+            nextPeakInterval = 10; // Keep short interval to simulate repeated 0 BPM checks
+        } else {
+            int interval_ms = 60000 / targetBPM;
+            cyclesPerPeak = interval_ms / SAMPLE_INTERVAL_MS;
+            nextPeakInterval = cyclesPerPeak;
+        }
+
+        return (targetBPM == 0) ? 300
+                                : 700 + rand() % 50;
+    } else {
+        return 300;
+    }
+}
+
+// === Main program ===
+int main() {
+    initialiserRandom();
+
+    bool battementDetecte = false;
+    auto dernierBattement = std::chrono::steady_clock::now();
+    auto dernierMessageArret = std::chrono::steady_clock::now();
+    bool enArret = false;
+
+    std::cout << "Demarrage de la simulation du capteur cardiaque..." << std::endl;
+
+    while (true) {
+        int signal = simulerSignalCardiaque();
+        auto maintenant = std::chrono::steady_clock::now();
+
+        // Heartbeat detected
+        if (signal > THRESHOLD && !battementDetecte) {
+            auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+
+            if (intervalle > 300) {
+                int bpm = 60000 / intervalle;
+                std::cout << "BPM mesure : " << bpm;
+
+                bool anomalie = (bpm < BPM_MIN || bpm > BPM_MAX);
+                if (anomalie) {
+                    std::cout << " [ANOMALIE]";
+                    activerBuzzer();
+                    activerVibreur();
+                    envoyerMessageBluetooth(true);
+                } else {
+                    envoyerMessageBluetooth(false);
+                }
+
+                enArret = false;
+                std::cout << std::endl;
+                dernierBattement = maintenant;
+            }
+
+            battementDetecte = true;
+        }
+
+        // Ready for next detection
+        if (signal < THRESHOLD) {
+            battementDetecte = false;
+        }
+
+        // Handle 0 BPM condition (no heartbeat detected for > 1 sec)
+        auto tempsDepuisDernierBattement = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+        if (tempsDepuisDernierBattement > 1000) {
+            if (!enArret) {
+                std::cout << "Aucune activite cardiaque detectee." << std::endl;
+                enArret = true;
+            }
+
+            auto tempsDepuisDernierMessage = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierMessageArret).count();
+            if (tempsDepuisDernierMessage >= 1000) {
+                envoyerMessageBluetooth(true); // Emergency
+                dernierMessageArret = maintenant;
+            }
+        }
+
+        usleep(SAMPLE_INTERVAL_MS * 1000);
+    }
+
+    return 0;
+}

main6.cpp

@@ -0,0 +1,103 @@
+#include <iostream>
+#include <vector>
+#include <random>
+#include <thread>
+#include <chrono>
+#include <cmath>
+#include <iomanip>
+
+const int SAMPLE_RATE_MS = 20;
+const int SAMPLES_PER_SECOND = 1000 / SAMPLE_RATE_MS;
+const int TOTAL_SECONDS = 60;
+
+std::default_random_engine rng(std::random_device{}());
+std::uniform_real_distribution<double> changeDist(-0.25, 0.25);
+std::uniform_real_distribution<double> driftDist(-0.05, 0.05);
+std::uniform_real_distribution<double> heartAttackChance(0.0, 1.0);
+std::uniform_int_distribution<int> startBpmDist(30, 210);
+
+double clampBPM(double bpm) {
+    if (bpm == 0.0) return 0.0;
+    if (bpm < 30.0) return 30.0;
+    if (bpm > 210.0) return 210.0;
+    return bpm;
+}
+
+int main() {
+    std::vector<int> bpmHistory;
+    double bpm = startBpmDist(rng);
+    double drift = driftDist(rng);
+    int outOfRangeSeconds = 0;
+    bool emergency = false;
+    bool emergencyNotified = false;
+    bool cardiacArrestInjected = false;
+
+    std::vector<double> currentSecondSamples;
+    int secondCounter = 0;
+
+    std::cout << "Starting real-time heart rate monitoring...\n" << std::endl;
+
+    while (secondCounter < TOTAL_SECONDS) {
+        double sum = 0.0;
+
+        for (int i = 0; i < SAMPLES_PER_SECOND; ++i) {
+            // Inject cardiac arrest
+            if (!cardiacArrestInjected && secondCounter >= 20 && secondCounter < 40 && heartAttackChance(rng) < 0.005) {
+                bpm = 0.0;
+                cardiacArrestInjected = true;
+            } else if (bpm != 0.0) {
+                bpm += changeDist(rng) + drift;
+                bpm = clampBPM(bpm);
+            }
+
+            currentSecondSamples.push_back(bpm);
+            std::this_thread::sleep_for(std::chrono::milliseconds(SAMPLE_RATE_MS));
+        }
+
+        drift = driftDist(rng);
+
+        // Calculate 1-second average
+        double sumSecond = 0.0;
+        for (double val : currentSecondSamples) sumSecond += val;
+        int avgBPM = static_cast<int>(std::round(sumSecond / currentSecondSamples.size()));
+        bpmHistory.push_back(avgBPM);
+        currentSecondSamples.clear();
+
+        // Print real-time 1-second BPM
+        std::cout << "Second " << secondCounter + 1 << " - Calculated Avg BPM: " << avgBPM << std::endl;
+
+        // Emergency check
+        if (avgBPM < 40 || avgBPM > 200) {
+            outOfRangeSeconds++;
+        } else {
+            outOfRangeSeconds = 0;
+        }
+
+        if (!emergency && outOfRangeSeconds >= 3) {
+            emergency = true;
+            emergencyNotified = false;
+        }
+
+        if (emergency) {
+            if (!emergencyNotified) {
+                std::cout << "[buzzer active]" << std::endl;
+                std::cout << "[vibrator active]" << std::endl;
+                emergencyNotified = true;
+            }
+            std::cout << "[Bluetooth message sent: urgency = TRUE]" << std::endl;
+        } else if ((secondCounter + 1) % 10 == 0) {
+            int count = std::min(60, static_cast<int>(bpmHistory.size()));
+            int sumLast = 0;
+            for (int i = bpmHistory.size() - count; i < bpmHistory.size(); ++i) {
+                sumLast += bpmHistory[i];
+            }
+            int avgLast = sumLast / count;
+            std::cout << "[Bluetooth message sent: urgency = FALSE, avg BPM = " << avgLast << "]" << std::endl;
+        }
+
+        secondCounter++;
+    }
+
+    std::cout << "\nMonitoring session ended.\n";
+    return 0;
+}

main7.cpp

@@ -0,0 +1,103 @@
+#include <iostream>
+#include <vector>
+#include <random>
+#include <thread>
+#include <chrono>
+#include <cmath>
+#include <iomanip>
+
+const int SAMPLE_RATE_MS = 20;
+const int SAMPLES_PER_SECOND = 1000 / SAMPLE_RATE_MS;
+const int TOTAL_SECONDS = 60;
+
+std::default_random_engine rng(std::random_device{}());
+std::uniform_real_distribution<double> changeDist(-0.25, 0.25);
+std::uniform_real_distribution<double> driftDist(-0.05, 0.05);
+std::uniform_real_distribution<double> heartAttackChance(0.0, 1.0);
+std::uniform_int_distribution<int> startBpmDist(30, 210);
+
+double clampBPM(double bpm) {
+    if (bpm == 0.0) return 0.0;
+    if (bpm < 30.0) return 30.0;
+    if (bpm > 210.0) return 210.0;
+    return bpm;
+}
+
+int main() {
+    std::vector<int> bpmHistory;
+    double bpm = startBpmDist(rng);
+    double drift = driftDist(rng);
+    int outOfRangeSeconds = 0;
+    bool emergency = false;
+    bool emergencyNotified = false;
+    bool cardiacArrestInjected = false;
+
+    std::vector<double> currentSecondSamples;
+    int secondCounter = 0;
+
+    std::cout << "Starting real-time heart rate monitoring...\n" << std::endl;
+
+    while (secondCounter < TOTAL_SECONDS) {
+        double sum = 0.0;
+
+        for (int i = 0; i < SAMPLES_PER_SECOND; ++i) {
+            // Inject cardiac arrest
+            if (!cardiacArrestInjected && secondCounter >= 20 && secondCounter < 40 && heartAttackChance(rng) < 0.005) {
+                bpm = 0.0;
+                cardiacArrestInjected = true;
+            } else if (bpm != 0.0) {
+                bpm += changeDist(rng) + drift;
+                bpm = clampBPM(bpm);
+            }
+
+            currentSecondSamples.push_back(bpm);
+            std::this_thread::sleep_for(std::chrono::milliseconds(SAMPLE_RATE_MS));
+        }
+
+        drift = driftDist(rng);
+
+        // Calculate 1-second average
+        double sumSecond = 0.0;
+        for (double val : currentSecondSamples) sumSecond += val;
+        int avgBPM = static_cast<int>(std::round(sumSecond / currentSecondSamples.size()));
+        bpmHistory.push_back(avgBPM);
+        currentSecondSamples.clear();
+
+        // Print real-time 1-second BPM
+        std::cout << "Second " << secondCounter + 1 << " - Calculated Avg BPM: " << avgBPM << std::endl;
+
+        // Emergency check
+        if (avgBPM < 40 || avgBPM > 200) {
+            outOfRangeSeconds++;
+        } else {
+            outOfRangeSeconds = 0;
+        }
+
+        if (!emergency && outOfRangeSeconds >= 3) {
+            emergency = true;
+            emergencyNotified = false;
+        }
+
+        if (emergency) {
+            if (!emergencyNotified) {
+                std::cout << "[buzzer active]" << std::endl;
+                std::cout << "[vibrator active]" << std::endl;
+                emergencyNotified = true;
+            }
+            std::cout << "[Bluetooth message sent: urgency = TRUE]" << std::endl;
+        } else if ((secondCounter + 1) % 10 == 0) {
+            int count = std::min(60, static_cast<int>(bpmHistory.size()));
+            int sumLast = 0;
+            for (int i = bpmHistory.size() - count; i < bpmHistory.size(); ++i) {
+                sumLast += bpmHistory[i];
+            }
+            int avgLast = sumLast / count;
+            std::cout << "[Bluetooth message sent: urgency = FALSE, avg BPM = " << avgLast << "]" << std::endl;
+        }
+
+        secondCounter++;
+    }
+
+    std::cout << "\nMonitoring session ended.\n";
+    return 0;
+}

main8.cpp

@@ -0,0 +1,139 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <cstdlib> // rand()
+#include <ctime>   // time()
+#include <windows.h>
+
+// === Parameters ===
+const int BPM_MIN = 55; // Minimum Normal BPM 
+const int BPM_MAX = 110; // Maximum Normal BPM 
+const int BPM_TACHYCARDIA = 40; // Minimum BPM for Tachycardia
+const int BPM_BRADYCARDIA = 140; // Maximum BPM for Bradycardia
+const int SAMPLE_INTERVAL_MS = 1000; // Sampling every 1s
+const int THRESHOLD_CARDIAC_ARREST = 2;
+
+
+// === Initialize random generator ===// === Simulate heart signal from sensor ===
+int generateRandomHeartRate() {
+    int bpm = rand() % BPM_BRADYCARDIA + 1;  //  génère un BPM entre 0 et 140
+    return bpm;
+}
+
+// === Simulate buzzer activation ===
+void activateBuzzer(bool activationBuz) {
+    if (activationBuz) {
+        std::cout << " Buzzer activated (CARDIAC ALERT)!" << std::endl;
+    } else {
+        std::cout << " Buzzer desactivated" << std::endl;
+    }
+}
+
+
+// === Simulate vibration motor activation ===
+void activateVibration(bool activationVib) {
+    if (activationVib) {
+        std::cout << " Vibration activated (CARDIAC ALERT)!" << std::endl;
+    } else {
+        std::cout << " Vibration desactivated" << std::endl;
+    }
+}
+
+// === Simulate Bluetooth transmission ===
+void sendMessageBluetooth(bool urgence) {
+    if (urgence) {
+        std::cout << " Message Bluetooth send : TRUE (urgence)" << std::endl;
+    } else {
+        std::cout << " Message Bluetooth send : FALSE (normal)" << std::endl;
+    }
+}
+
+// send avg bvpm of the last minute
+void sendAvgBPM(int avg){
+    std::cout << " \n [BLUETOOTH MESSAGE] Average BPM over the last minute : " << avg;
+    std::cout << "\n\n" <<std::endl;
+}
+
+// === Main program ===
+int main() {
+
+    bool pulseDetected = false;
+    auto lastPulse = std::chrono::steady_clock::now();
+
+    std::cout << " \n STARTING OF CARDIAC SIMULATION ...\n";
+    int i=0;
+    int lastBPM;
+    int j = 0;
+    int time = 0;
+    int lastTime = 0;
+    std::vector<int> heartRateHistory;
+    heartRateHistory.reserve(1728000); //20*24*60*60 secondes de data (20 days)
+    int avgBPM = 0;
+
+    while (true) {
+
+
+        // DHeartrate detection
+        if (!pulseDetected) { 
+            auto now = std::chrono::steady_clock::now();
+            auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastPulse).count();
+            
+            int bpm = generateRandomHeartRate();
+            time++;
+            std::cout << " \n -------------- \n Time since device turned ON (in seconds) " << time;
+            std::cout << " \n BPM measured : " << bpm;
+
+            if (bpm < BPM_MIN && bpm > BPM_TACHYCARDIA){
+                std::cout << " [BRADYCARDIA]"  << std::endl;
+                activateVibration(true);
+                i=0;
+
+            } else if(bpm < BPM_BRADYCARDIA && bpm > BPM_MAX) {
+                std::cout << " [TACHYCARDIA]"  << std::endl;
+                activateVibration(true);
+                i=0;
+
+            }else if(bpm < BPM_MAX && bpm > BPM_MIN){
+                std::cout << " [NORMAL]" << std::endl;
+                activateBuzzer(false);
+                activateVibration(false);
+                sendMessageBluetooth(false);
+                i=0;
+
+            } else if (bpm < BPM_TACHYCARDIA){
+                if (i=THRESHOLD_CARDIAC_ARREST && lastBPM < BPM_TACHYCARDIA){
+                    i=0;
+                    std::cout << " \n !! Number = 2 [HEART ATTACK]" << std::endl;
+                    activateBuzzer(true);
+                    activateVibration(true);
+                    sendMessageBluetooth(true);
+                }else{
+                    i+=1;
+                    std::cout << " \n !! Low BPM, emergency alert if number gets to 2:  "<<i << std::endl;
+                }  
+            }   
+
+            std::cout << std::endl;
+
+            lastPulse = now;
+            pulseDetected = true;
+            heartRateHistory.push_back(bpm);
+            lastBPM =bpm;
+        }else {
+            pulseDetected = false; // Ready to detect new pulse
+        }
+        
+
+        if (time>(lastTime + 60)){
+            for (j = lastTime; j<time; j++){
+                avgBPM = avgBPM + heartRateHistory[j];
+            }
+            avgBPM = avgBPM/j;
+            sendAvgBPM(avgBPM);
+            lastTime = time;
+        }
+        Sleep(SAMPLE_INTERVAL_MS);  // expects milliseconds
+    }
+
+    return 0;
+}

test.cpp

@@ -0,0 +1,70 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <random>
+
+// État du rythme cardiaque
+enum class HeartRateState {
+    NORMAL,
+    BRADYCARDIA,
+    TACHYCARDIA
+};
+
+// Fonction pour générer un signal de battement cardiaque
+std::vector<float> generateHeartbeatSignal(HeartRateState state, int durationSeconds = 10, int sampleRate = 1000) {
+    int bpm;
+    switch (state) {
+        case HeartRateState::BRADYCARDIA:
+            bpm = 40 + rand() % 15; // 40-55 BPM
+            break;
+        case HeartRateState::TACHYCARDIA:
+            bpm = 110 + rand() % 30; // 110-140 BPM
+            break;
+        default:
+            bpm = 60 + rand() % 40; // 60-100 BPM
+            break;
+    }
+
+    int totalSamples = durationSeconds * sampleRate;
+    int samplesPerBeat = (60.0 / bpm) * sampleRate;
+
+    std::vector<float> signal(totalSamples, 0.0f);
+
+    for (int i = 0; i < totalSamples; i += samplesPerBeat) {
+        if (i < totalSamples) signal[i] = 1.0f;       // Pic R
+        if (i + 1 < totalSamples) signal[i + 1] = 0.5f;
+        if (i + 2 < totalSamples) signal[i + 2] = 0.2f;
+    }
+
+    return signal;
+}
+
+// Pause active sans utiliser thread
+void waitMilliseconds(int ms) {
+    auto start = std::chrono::high_resolution_clock::now();
+    while (std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::high_resolution_clock::now() - start).count() < ms) {
+        // boucle vide
+    }
+}
+
+// Affichage du signal
+void printSignal(const std::vector<float>& signal, int sampleRate) {
+    for (size_t i = 0; i < signal.size(); ++i) {
+        std::cout << signal[i] << "\n";
+        waitMilliseconds(1000 / sampleRate);
+    }
+}
+
+// ----------- FONCTION PRINCIPALE ------------
+int main() {
+    std::cout << "Simulation d’un signal de battement cardiaque\n";
+
+    // Tu peux changer ici : NORMAL / BRADYCARDIA / TACHYCARDIA
+    HeartRateState state = HeartRateState::TACHYCARDIA;
+
+    std::vector<float> signal = generateHeartbeatSignal(state, 5, 100); // 5 secondes, 100 Hz
+    printSignal(signal, 100);
+
+    return 0;
+}