diff --git a/.vscode/launch.json b/.vscode/launch.json index 01d967f..f351788 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -1,28 +1,26 @@ - +{ + "version": "0.2.0", + "configurations": [ { - "version": "0.2.0", - "configurations": [ - { - "name": "Debug C++", - "type": "cppdbg", - "request": "launch", - "program": "${workspaceFolder}/main", - "args": [], - "stopAtEntry": false, - "cwd": "${workspaceFolder}", - "environment": [], - "externalConsole": true, - "MIMode": "gdb", - "setupCommands": [ - { - "description": "Enable pretty-printing for gdb", - "text": "-enable-pretty-printing", - "ignoreFailures": true - } - ], - "preLaunchTask": "build", - "miDebuggerPath": "/usr/bin/gdb" // ou chemin vers gdb sous Windows - } - ] - } - + "name": "Debug C++", + "type": "cppdbg", + "request": "launch", + "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", + "text": "-enable-pretty-printing", + "ignoreFailures": true + } + ], + "preLaunchTask": "C/C++: g++.exe build active file" + } + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json index 53b0dab..678b745 100644 --- a/.vscode/settings.json +++ b/.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" } \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..82ad581 --- /dev/null +++ b/.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" + } + ] +} \ No newline at end of file diff --git a/README.md b/README.md index f0886e3..0e97cf8 100644 --- a/README.md +++ b/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 \ No newline at end of file diff --git a/main.cpp b/main.cpp index b7d1300..d5a1c83 100644 --- a/main.cpp +++ b/main.cpp @@ -2,19 +2,42 @@ #include #include #include +#include +#include +#include // 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 "<& 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 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; diff --git a/main2.cpp b/main2.cpp new file mode 100644 index 0000000..a701e6d --- /dev/null +++ b/main2.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include // Pour rand() +#include // Pour srand() +#include // 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(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(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; +} diff --git a/main3 b/main3 new file mode 100644 index 0000000..25cea36 --- /dev/null +++ b/main3 @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include // rand() +#include // time() +#include // 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(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(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; +} diff --git a/main3.cpp b/main3.cpp new file mode 100644 index 0000000..31042dd --- /dev/null +++ b/main3.cpp @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include // rand() +#include // time() +#include // 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(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(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; +} diff --git a/main4.cpp b/main4.cpp new file mode 100644 index 0000000..e322fd8 --- /dev/null +++ b/main4.cpp @@ -0,0 +1,95 @@ +#include +#include +#include +#include // rand() +#include // time() +#include + +// === 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(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; +} diff --git a/main5.cpp b/main5.cpp new file mode 100644 index 0000000..61655ef --- /dev/null +++ b/main5.cpp @@ -0,0 +1,141 @@ +#include +#include +#include +#include +#include // rand() +#include // time() +#include // 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(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(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(maintenant - dernierBattement).count(); + if (tempsDepuisDernierBattement > 1000) { + if (!enArret) { + std::cout << "Aucune activite cardiaque detectee." << std::endl; + enArret = true; + } + + auto tempsDepuisDernierMessage = std::chrono::duration_cast(maintenant - dernierMessageArret).count(); + if (tempsDepuisDernierMessage >= 1000) { + envoyerMessageBluetooth(true); // Emergency + dernierMessageArret = maintenant; + } + } + + usleep(SAMPLE_INTERVAL_MS * 1000); + } + + return 0; +} diff --git a/main6.cpp b/main6.cpp new file mode 100644 index 0000000..615f5a9 --- /dev/null +++ b/main6.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#include +#include + +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 changeDist(-0.25, 0.25); +std::uniform_real_distribution driftDist(-0.05, 0.05); +std::uniform_real_distribution heartAttackChance(0.0, 1.0); +std::uniform_int_distribution 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 bpmHistory; + double bpm = startBpmDist(rng); + double drift = driftDist(rng); + int outOfRangeSeconds = 0; + bool emergency = false; + bool emergencyNotified = false; + bool cardiacArrestInjected = false; + + std::vector 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(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(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; +} diff --git a/main7.cpp b/main7.cpp new file mode 100644 index 0000000..4bae44b --- /dev/null +++ b/main7.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#include +#include + +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 changeDist(-0.25, 0.25); +std::uniform_real_distribution driftDist(-0.05, 0.05); +std::uniform_real_distribution heartAttackChance(0.0, 1.0); +std::uniform_int_distribution 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 bpmHistory; + double bpm = startBpmDist(rng); + double drift = driftDist(rng); + int outOfRangeSeconds = 0; + bool emergency = false; + bool emergencyNotified = false; + bool cardiacArrestInjected = false; + + std::vector 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(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(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; +} \ No newline at end of file diff --git a/main8.cpp b/main8.cpp new file mode 100644 index 0000000..aeca474 --- /dev/null +++ b/main8.cpp @@ -0,0 +1,139 @@ +#include +#include +#include +#include // rand() +#include // time() +#include + +// === 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" < 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(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: "<(lastTime + 60)){ + for (j = lastTime; j +#include +#include +#include + +// État du rythme cardiaque +enum class HeartRateState { + NORMAL, + BRADYCARDIA, + TACHYCARDIA +}; + +// Fonction pour générer un signal de battement cardiaque +std::vector 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 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::high_resolution_clock::now() - start).count() < ms) { + // boucle vide + } +} + +// Affichage du signal +void printSignal(const std::vector& 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 signal = generateHeartbeatSignal(state, 5, 100); // 5 secondes, 100 Hz + printSignal(signal, 100); + + return 0; +} \ No newline at end of file