Simulateur de l’ECG (24 / 27 étapes)

Etape 24: ECG Simulator - Sketch Arduino

// ***************************************************************************************************
SIMULATEUR DE L’ECG
//
Objectif : simuler le signal d’ECG : rythme sinusal normal (3-fils RA, Louisiane, RL)
//
Rappel des faits :
//
En normal pour l’électrocardiographie (ECG ou EKG si vous êtes allemand), trois fils composent le
Triangle de Einthoven. Deux fils sont collées sur le côté droit et gauche de la poitrine ci-dessus
cœur (RA = bras droit, LA = bras gauche) et un conducteur est collé sur le bas de la poitrine, en général
sur la hanche droite (RL = jambe droite).
//
Il est important de savoir que ces signaux ECG est millivolts en amplitude. Ceci peut être réalisé par
l’alimentation du convertisseur N/A par un diviseur de tension pour obtenir les niveaux de millivolt.
//
//
Le signal ECG :
//
J’ai trouvé une forme d’onde ECG approprié de l’internet. Voici comment j’ai converti une photo de mon
écran de contrôle pour un tableau de langage C de A/D valeurs, chaque 1.00 espacés msec apart.
//
Capture d’écran d’a. de forme d’onde en utilisant l’écran gratuit programme MWSNAP de capture
http://www.mirekw.com/winfreeware/mwsnap.html
//
B. numériser la forme d’onde de jpeg en utilisant le programme de numérisation gratuit ENGAUGE
http://Digitizer.sourceforge.net/
//
//
C: J’ai écrit un programme en Python pour convertir les échantillons plutôt irréguliers ENGAUGE
pour un tableau de valeurs espacées de 1,0 millisecondes dehors en utilisant une interpolation linéaire.
Ensuite, j’ai créé un fichier texte où ces points de données faisaient partie d’un tableau de langage C
construire ; autrement dit, les points de données sont les initialiseurs de C.
//
D: couper-coller du texte du fichier le tableau de données C avec initialiseurs dans le
Arduino croquis ci-dessous.
//
//
Ressources de l’Arduino :
//
Numérique sortie # 9 - puce sélectionnez le port SPI afficheur 7 segments (faible à sélectionner)
Digital Output # 10 - puce choisir pour convertisseur D/A (faible pour sélectionner)
Données numériques de sortie # 11 - SDI au convertisseur D/A (interface SPI)
Horloge numérique de sortie # 13 - SCK au convertisseur D/A (interface SPI)
//
Analog Input # 0 - essuie-glace goupille de centrage du pot d’ohm 5 k (réglage de la fréquence cardiaque)
//
J’ai suivi le programme d’installation du Timer2 tels que décrits par Sebastian Wallin
http://popdevelop.com/2010/04/Mastering-Timer-interrupts-on-the-Arduino/
//
J’ai mis en place l’interface SPI conformément aux instructions excellentes de l’Australien John Boxall,
dont le merveilleux site a de nombreux excellents tutoriels Arduino :
http://tronixstuff.wordpress.com/
//
Programmateur : James P Lynch
lynch007
//
// ***************************************************************************************************

#include « SPI.h » / / prend en charge l’interface SPI au convertisseur D/A et afficheur 7 segments
#include < Wire.h > / / besoin de la bibliothèque de fils

diverses constantes utilisées par le générateur de signaux
#define INIT 0
#define IDLE 1
#define QRS 2
#define quatre 4
#define trois 3
#define deux 2
#define un 1

// *******************************************************************************************
forme d’onde de ecg y_data [543] - numérisés, échantillonnée à 1,0 msec
//
Forme d’onde est mise à l’échelle pour un convertisseur de D/A 12 bits (0.. 4096)
//
Un battement/min 60 ECG exigerait cette forme d’onde (543 échantillons) plus de 457 échantillons
la première valeur d’y_data [0] de 939.
//
// *********************************************************************************************
const y_data court [] = {}
939, 940, 941, 942, 944, 945, 946, 947, 951, 956,
962, 967, 973, 978, 983, 989, 994, 1000, 1005, 1015,
1024, 1034, 1043, 1053, 1062, 1075, 1087, 1100, 1112, 1121,
1126, 1131, 1136, 1141, 1146, 1151, 1156, 1164, 1172, 1179,
1187, 1194, 1202, 1209, 1216, 1222, 1229, 1235, 1241, 1248,
1254, 1260, 1264, 1268, 1271, 1275, 1279, 1283, 1287, 1286,
1284, 1281, 1279, 1276, 1274, 1271, 1268, 1266, 1263, 1261,
1258, 1256, 1253, 1251, 1246, 1242, 1237, 1232, 1227, 1222,
1218, 1215, 1211, 1207, 1203, 1199, 1195, 1191, 1184, 1178,
1171, 1165, 1159, 1152, 1146, 1141, 1136, 1130, 1125, 1120,
1115, 1110, 1103, 1096, 1088, 1080, 1073, 1065, 1057, 1049,
1040, 1030, 1021, 1012, 1004, 987, 982, 978, 995, 974,
970, 966, 963, 959, 955, 952, 949, 945, 942, 939,
938, 939, 940, 941, 943, 944, 945, 946, 946, 946,
946, 946, 946, 946, 946, 947, 950, 952, 954, 956,
958, 960, 962, 964, 965, 965, 965, 965, 965, 965,
963, 960, 957, 954, 951, 947, 944, 941, 938, 932,
926, 920, 913, 907, 901, 894, 885, 865, 820, 733,
606, 555, 507, 632, 697, 752, 807, 896, 977, 1023,
1069, 1127, 1237, 1347, 1457, 2085, 2246, 2474, 2549, 2595,
2641, 2695, 3083, 3135, 3187, 3217, 3315, 3403, 3492, 3581,
3804, 3847, 3890, 3798, 3443, 3453, 3297, 3053, 2819, 2810,
2225, 2258, 1892, 1734, 1625, 998, 903, 355, 376, 203,
30, 33, 61, 90, 119, 160, 238, 275, 292, 309,
325, 343, 371, 399, 429, 484, 542, 602, 652, 703,
758, 802, 838, 856, 875, 895, 917, 938, 967, 1016,
1035, 1041, 1047, 1054, 1060, 1066, 1066, 1064, 1061, 1058,
1056, 1053, 1051, 1048, 1046, 1043, 1041, 1038, 1035, 1033,
1030, 1028, 1025, 1022, 1019, 1017, 1014, 1011, 1008, 1006,
1003, 1001, 999, 998, 996, 994, 993, 991, 990, 988,
986 985, 983, 981, 978, 976, 973, 971, 968, 966,
963 963 963, 963, 963, 963, 963, 963, 963, 963,
963 963 963, 963, 963, 963, 963, 963, 963, 963,
964, 965, 966, 967, 968, 969, 970, 971, 972, 974,
976, 978, 980, 983, 985, 987, 989, 991, 993, 995,
997, 999, 1002, 1006, 1011, 1015, 1019, 1023, 1028, 1032,
1036, 1040, 1045, 1050, 1055, 1059, 1064, 1069, 1076, 1082,
1088, 1095, 1101, 1107, 1114, 1120, 1126, 1132, 1141, 1149,
1158, 1166, 1173, 1178, 1183, 1188, 1193, 1198, 1203, 1208,
1214, 1221, 1227, 1233, 1240, 1246, 1250, 1254, 1259, 1263,
1269, 1278, 1286, 1294, 1303, 1309, 1315, 1322, 1328, 1334,
1341, 1343, 1345, 1347, 1349, 1351, 1353, 1355, 1357, 1359,
1359, 1359, 1359, 1359, 1358, 1356, 1354, 1352, 1350, 1347,
1345, 1343, 1341, 1339, 1336, 1334, 1332, 1329, 1327, 1324,
1322, 1320, 1317, 1315, 1312, 1307, 1301, 1294, 1288, 1281,
1275, 1270, 1265, 1260, 1256, 1251, 1246, 1240, 1233, 1227,
1221, 1214, 1208, 1201, 1194, 1186, 1178, 1170, 1162, 1154,
1148, 1144, 1140, 1136, 1131, 1127, 1123, 1118, 1114, 1107,
1099, 1090, 1082, 1074, 1069, 1064, 1058, 1053, 1048, 1043,
1038, 1034, 1029, 1025, 1021, 1017, 1013, 1009, 1005, 1001,
997, 994, 990, 991, 992, 994, 996, 997, 999, 998,
997 996, 995, 994, 993, 991, 990, 989, 989, 989,
989 989, 989, 989, 988, 986, 984, 983, 981, 980,
982, 984, 986, 988, 990, 993, 995, 997, 999, 1002,
1005, 1008, 1012} ;

variables globales utilisées par le programme
unsigned int NumSamples = sizeof(y_data) / 2 ;              nombre d’éléments dans y_data [] ci-dessus
unsigned int QRSCount = 0 ;                                                nombre de période ms course QRS
unsigned int IdleCount = 0 ;                                                  comte de la marche ralenti période ms
unsigned long IdlePeriod = 0 ;                                              période de ralenti est réglé par pot pour définir la fréquence cardiaque
unsigned int Etat = INIT ;                                                     les États sont INIT, QRS et IDLE
unsigned int DisplayCount = 0 ;                                           comtes 50 msec pour mettre à jour l’affichage 7 segments
unsigned int tcnt2 ;                                                                 Valeur de rechargement TIMER2, disponible dans le monde
float BeatsPerMinute ;                                                     représentation de point flottant de la fréquence cardiaque
unsigned int puls/min ;                                                                 version de nombre entier de la fréquence cardiaque (multiplié par 10)
unsigned int BpmLow ;                                                          le plus bas taux de coeur a permis (x10)
unsigned int BpmHigh ;                                                         plus haute fréquence cardiaque a permis (x10)
int valeur ;                                                                         espace réservé pour les 0 d’entrée analogique
unsigned long BpmValues [32] = {0, 0, 0, 0, 0, 0, 0, 0, / / contient les 32 dernières lectures de pot analogiques
0, 0, 0, 0, 0, 0, 0, 0, / / devant servir à filtrer les Visualisez une gigue
0, 0, 0, 0, 0, 0, 0, 0, / / devant servir à filtrer les Visualisez une gigue
0, 0, 0, 0, 0, 0, 0, 0} ;    devant servir à filtrer le scintillement de l’écran
unsigned long BpmAverage = 0 ;                                          utilisé dans un simple filtre moyenneur
unsigned char Index = 0 ;                                                       utilisé dans un simple filtre moyenneur
unsigned int DisplayValue = 0 ;                                           filtrée battements par Minute envoyé à afficher

void setup() {}

Configurer les ports de sortie (1 indicateur d’intrerrupt ms et le soutien de SPI de d/a)
pinMode (sortie 9) ;                     afficheur 7 segments chip select (bas pour sélectionner la puce)
pinMode (sortie 10,) ;                    Puce D/A convertisseur sélectionnez (bas pour sélectionner la puce)
pinMode (sortie 11) ;                    Données de SDI
pinMode (13, sortie) ;                    Horloge de la SCK

état initial de l’interface SPI
SPI.begin() ;                                                          Réveillez-vous avec le bus SPI.
SPI.setDataMode(0) ;                                          mode : l’ACSP = 0, les données captées sur front montant de l’horloge (faible à élevé)
SPI.setClockDivider(SPI_CLOCK_DIV64) ;    horloge système / 64
SPI.setBitOrder(MSBFIRST) ;                            bit 7 horloges en premier

la plage de fréquence cardiaque a permis de mettre en place
BpmLow = 300 (30 bpm x 10)
BpmHigh = (60,0 / (NumSamples * 0,001)) * 10 = (60,0 /.543) * 10 = 1104 (110.49 x 10)
BpmLow = 300 ;
BpmHigh = (60,0 / ((float) NumSamples * 0,001)) * 10 ;

Pendant que nous sommes configure d’abord désactiver l’interruption de débordement du timer
TIMSK2 & = ~ (1 << TOIE2) ;

Configurer le timer2 en mode normal (pur en comptant, pas PWM, etc..)
TCCR2A & = ~ ((1 << WGM21) | (1 << WGM20)) ;
TCCR2B & = ~ (1 << WGM22) ;

Source sélectionnez horloge : horloge interne de I/O
ASSR & = ~ (1 << AS2) ;

Comparer les désactiver activer interruption de match de football A (débordement de vouloir seulement)
TIMSK2 & = ~ (1 << OCIE2A) ;

Maintenant configurer le diviseur d’horloge du processeur divisé par 128
TCCR2B | = (1 << CS22) | (1 << CS20) ; Ensemble de bits
TCCR2B & = ~ (1 << CS21) ;             Peu clair

Nous avons besoin calculer une valeur correcte pour charger le compteur de la minuterie.
Ce qui suit en charge la valeur 131 dans le registre de compteur Timer 2
Les maths derrière ce sont :
(Fréquence du processeur) / (valeur de diviseur) = 125000 Hz = 8us.
(période désirée) / 8us = 125.
Max(UInt8) + 1-125 = 131 ;
//
Enregistrez la valeur dans le monde pour recharger plus tard en ISR /
tcnt2 = 131 ;

Enfin la fin de charge activer la minuterie
TCNT2 = tcnt2 ;
TIMSK2 | = (1 << TOIE2) ;
}

void loop() {}

lire sur le pot de la fréquence cardiaque (entrée analogique 0)
Valeur = analogRead(0) ;

carte de la gamme d’entrée analogique 0 (0.. 1023) à la gamme de Bpm (300.. 1104)
BPM = carte (valeur, 0, 1023, BpmLow, BpmHigh) ;

Afin de diminuer la gigue ou rebondir au chiffre le moins significatif de l’écran,
un filtre de moyens mobile (32 valeurs) il va lisser.
BpmValues [Index ++] = puls/min ;                       Ajouter le dernier échantillon à tableau de huit
Si (indice == 32) {/ / poignée enveloppante
Index = 0 ;
}
BpmAverage = 0 ;
pour (int i = 0 ;  J’ai < 32 ; i ++) {/ / sommation de toutes les valeurs dans le tableau
BpmAverage += BpmValues [i] ;
}
BpmAverage >> = 5 ;                                      Diviser par 32 pour obtenir la moyenne

maintenant mettre à jour l’affichage à 4 chiffres - format : XXX. X
mise à jour étant un transfert de plusieurs octets, désactiver les interruptions jusqu'à ce que c’est fait
noInterrupts() ;
DisplayValue = BpmAverage ;
interrupts() ;

compte tenu de la valeur du pot (battements / minute) lue dans, calculer le IdlePeriod (MS)
Cette valeur est utilisée par la Timer2 1.0 msec interrupt service routine
BeatsPerMinute = (float) Bpm / 10.0 ;
noInterrupts() ;
IdlePeriod = (unsigned int) ((float) 60000.0 / BeatsPerMinute)-(float) NumSamples ;
interrupts() ;

Delay(20) ;
}

// ********************************************************************************
TIMER2 Interrupt Service Routine
//
Interrupt Service Routine (ISR) Timer2 dépassement à 1.000 msec.
//
//
La fonction d’interruption Timer2 est utilisée pour envoyer le point de forme d’onde de 16-bit
à la micropuce MCP4921 au convertisseur à l’aide de l’interface SPI.
//
La fonction d’interruption Timer2 est également utilisée pour envoyer le rythme cardiaque actuel
comme lire le potentiomètre chaque 50 interruptions Timer2 pour l’afficheur 7 segments.
//
Le pot est lu et la fréquence cardiaque est calculée dans la boucle de fond.
En exécutant les deux périphériques SPI au niveau d’interruption, nous « sérialiser » eux et éviter
corruption en un seul envoi de SPI étant interrompu par l’autre.
//
Un État machime est mis en œuvre pour y parvenir. C' est les États sont :
//
INIT - fondamentalement efface les compteurs et définit l’état de QRS.
//
QRS - affiche les données du signal ECG prochaines point chaque 1.0 msec
Il y a 543 de ces points de données complexes QRS.
//
IDLE - période variable après la partie QRS.
N/A détient la première valeur ECG (939) pour l’ensemble de la période de ralenti.
Période de ralenti varie pour permettre l’ajustement de la fréquence cardiaque base ;
une valeur de zéro msec pour la période de ralenti donne 110,4 battements par min
tandis que la durée maximale d’inactivité de 457 msec donne 30,0 bpm.
//
Noter que la période de ralenti est calculée dans l’arrière-plan principal
une boucle en lisant un pot et la conversion de son aire de répartition à un approprié
pour la période de l’arrière-plan. La routine d’interruption lit ce
valeur pour déterminer le moment d’arrêter la période d’inactivité.
//
La transmission du prochain point données au convertisseur D/A via SPI se
environ 63 microsecondes (y compris les deux transmissions d’octet SPI).
//
La transmission des chiffres de l’afficheur 7 segments de Sparkfun fréquence cardiaque
prend environ 350 usec (c’est seulement transmis chaque 50 interruptions Timer2)
//
// ********************************************************************************
{ISR(TIMER2_OVF_vect)}

Recharger la minuterie
TCNT2 = tcnt2 ;

machine d’État
interrupteur (État) {}

cas INIT :

Zero le QRS et compteurs de ralenti
QRSCount = 0 ;
IdleCount = 0 ;
DisplayCount = 0 ;

la valeur état suivant QRS
État = QRS ;
rupture ;

cas complexe QRS :

sortie de l’échantillon suivant la forme d’onde QRS au convertisseur D/A
DTOA_Send(y_data[QRSCount]) ;

faire avancer l’exemple de compteur et de vérification pour fin
QRSCount ++ ;
Si (QRSCount > = NumSamples) {}
commencer la période de ralenti et sortie premier échantillon à DTOA
QRSCount = 0 ;
DTOA_Send(y_data[0]) ;
État = inactif ;
}
rupture ;

cas IDLE :

puisque le convertisseur D/A tiendra la valeur précédente écrite, tout ce que nous ont
pour ce faire est de déterminer combien de temps la période de ralenti doit être.

faire avancer le compteur inactif et recherchez de fin
IdleCount ++ ;

le IdlePeriod est calculée dans la boucle principale (dans un pot)
Si (IdleCount > = IdlePeriod) {}
IdleCount = 0 ;
État = QRS ;
}
rupture ;

par défaut :
rupture ;
}

sortie vers le segment 7 afficher toutes les 50 ms
DisplayCount ++ ;
Si (DisplayCount > = 50) {}
DisplayCount = 0 ;
Display7Seg_Send(DisplayValue) ;
}
}

// ***************************************************************************************************
Sub DTOA_Send(unsigned short)
//
But : envoyer la valeur de D/A 12 bits à micropuce MCP4921 au convertisseur (0.. 4096)
//
//
Entrée : DtoAValue - la valeur de D/A 12 bits (0.. 4096)
//
//
Le DtoAValue est précédé de l’A / B, BUF, GA et SHDN bits avant leur transmission.
//
ÉCRIRE LA COMMANDE
//            |-----------|-----------|-----------|-------------|--------------------------------------------------------------------------------|
//            |  A/B       |   BUF |  GA        | SHDN | D11 D10 D09 D08 D07 D06 D05 D04 D03 D02 D01 D00 |
//            |               |              |               |                  |                                                                                                          |
|Setting : |setting : |setting: | Définition: |                                    DtoAValue (12 bits) |
//            |   0          |   0          |   1        |   1            |                                                                                                           |
//            | DAC-A |unbuffer |   1 x |puissance-compilation on|              (0.. 4096 sortira en volts 0.. 5 volts) |
//            |-----------|------------|----------|-------------|--------------------------------------------------------------------------------|
//                15             14            13            12       11                                                                                                    0
//  To D/A    <======================================================================================
//
Remarque : WriteCommand est cadencé avec bit 15 tout d’abord !
//
//
Retours : rien
//
//
I/O ressources : Digital broche 9 = chip select (bas pour sélectionner la puce)
La broche numérique 13 = SPI horloge
La broche numérique 11 = données SPI
//
Remarque : par mise à la terre la TAAC * broche à accrocher le matériel, les données SPI vont être cadencées dans le
Convertisseur D/A s’enclenche lorsque la puce, sélectionnez s’élève à la fin-de-transfert.
//
Cette routine prend 63 usec utilisant un Adafruit Menta
// ***************************************************************************************************
void DTOA_Send (unsigned short DtoAValue) {}

octet de données = 0 ;

Sélectionnez la puce N/A (faible)
digitalWrite (10, 0) ;    puce sélectionnez faible

Envoyer le 0011xxxx premier octet haut
Données = highByte(DtoAValue) ;
Données = 0b00001111 & données ;
Données = 0b00110000 | Données ;
SPI.transfer(Data) ;

Envoyer le xxxxxxxx prochain octet de poids faible
Données = lowByte(DtoAValue) ;
SPI.transfer(Data) ;

tout ce que fait, désélectionnez l’option la puce (cela met à jour le D/A avec la nouvelle valeur)
digitalWrite (10, 1) ;    puce sélectionnez haute
}

// ***************************************************************************************************
Sub Display7Seg_Send(char *)
//
But : envoyer 4 chiffres pour affichage à 7 segments SparkFun série (nécessite 4 SPI d’écriture)
//
Entrée : valeur - unsignedInt version de BeatsPerMinute
//
Retours : rien
//
I/O ressources : Digital Pin 10 = chip select (bas pour sélectionner la puce)
La broche numérique 13 = SPI horloge
La broche numérique 11 = données SPI
//
Remarque : cette routine prend 350 usec utilisant un Adafruit Menta
// ***************************************************************************************************
void Display7Seg_Send (unsigned int HeartRate) {}
uint8_t digit1, digit2, digit3, digit4 ;
valeur unsigned int ;

convertir à quatre chiffres (set principaux zéros à flans; 0 x 78 est le caractère vide)
valeur = fréquence cardiaque ;
digit1 = valeur / 1000 ;
valeur = digit1 * 1000 ;
Si (digit1 == 0) digit1 = 0 x 78 ;

digit2 = valeur / 100 ;
valeur = digit2 * 100 ;
Si ((digit1 == 0x78) & & (digit2 == 0)) digit2 = 0 x 78 ;

digit3 = valeur / 10 ;
valeur = digit3 * 10 ;
Si ((digit1 == 0x78) & & (digit2 == 0 x 78) & & (digit3 == 0)) digit3 = 0 x 78 ;

digit4 = valeur ;

digitalWrite (9, faible) ;    Sélectionnez l’affichage de 7-seg Sparkfun
SPI.transfer(0x76) ;      réinitialiser l’affichage
SPI.transfer(0x7A) ;      commande de luminosité
SPI.transfer(0x00) ;      0 = brillant, 255 = dim
SPI.transfer(digit1) ;    Des milliers chiffres
SPI.transfer(digit2) ;    Des centaines à chiffres
SPI.transfer(digit3) ;    Chiffre des dizaines
SPI.transfer(digit4) ;    Chiffre
SPI.transfer(0x77) ;      commande de réglage des points décimaux
SPI.transfer(0x04) ;      Allumez dec pt entre les chiffres 3 et 4
digitalWrite (9, HIGH) ;   version affichage 7-seg Sparkfun
}