laure.bel
/
IP_HeartBand
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

merge

This commit is contained in:
Laure BEL 2025-05-12 20:45:01 +02:00
parent c184231763 44dff6bfef
commit c12b944187
14 changed files with 1059 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
.vscode/launch.json vendored
View File

@ -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"
}
]
}

53
.vscode/settings.json vendored
View File

@ -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"
}

28
.vscode/tasks.json vendored Normal file
View File

@ -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"
}
]
}

4
README.md
View File

@ -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

30
main.cpp
View File

@ -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;

80
main2.cpp Normal file
View File

@ -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;
}

96
main3 Normal file
View File

@ -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;
}

96
main3.cpp Normal file
View File

@ -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;
}

95
main4.cpp Normal file
View File

@ -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;
}

141
main5.cpp Normal file
View File

@ -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;
}

103
main6.cpp Normal file
View File

@ -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;
}

103
main7.cpp Normal file
View File

@ -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;
}

139
main8.cpp Normal file
View File

@ -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;
}

70
test.cpp Normal file
View File

@ -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;
}