CN102112061A - 测量颅内弹性的方法 - Google Patents

Abstract

本发明公开了一种用于无创伤地测量颅内压力(ICP)，更一般地，测量大脑弹性的新方法。使用结合到模拟的人工神经网络(SANN)的算法来确定ICP，所述算法基于一组从多个超声脉冲中产生的相互作用的超声信号(IUS)的确定来计算ICP。本发明的方法和系统能够迅速确定ICP而不需要技术人员人工查看EPG波。

Description

测量颅内弹性的方法

技术领域

本发明涉及无创伤地测量颅内压力的方法。

发明背景

一般来讲，诸如人类的哺乳动物的颅内的血液体积是恒定的，因此，具有恒定的颅内压力(“ICP”)。然而，各种正常的和病态的状况能够使颅内压力产生变化。升高的颅内压力能够减小到大脑的血流，并且在某些情况下能够导致大脑被机械地压缩并最终破裂；。升高的颅内压力最常见的后果是头部创伤。升高的颅内压力的其他后果包括但不限于摇晃婴儿综合症、硬脑膜外血肿、硬脑膜下血肿、脑溢血、脑膜炎、脑炎、铅中毒、雷氏综合症、维生素A过多症、糖尿病酮酸症、水中毒、脑肿瘤、颅腔内的其他包块或血块、脑脓疮、中风、ADEM(“急性弥散性脑脊髓炎”)、新陈代谢紊乱、脑积水、硬膜窦和静脉血栓。因为颅内压力的变化需要持续的监视和可能的手术介入，监视颅内压力的技术的发展在医学界仍是一个重要的目标。美国专利号6875176。

传统的颅内压力监视设备包括：硬膜外导管；蛛网膜下腔栓/螺钉；脑室切开术导管和光纤维导管。所有这些方法和系统均为有创伤性的，且需要由受过良好训练的神经外科医生进行有创伤性的手术过程。此外，所有这些技术都不适于迅速或常规的颅内压力的监视。此外，所有这些传统的技术都局部地测量ICP，且假设局部的ICP反映整个大脑的ICP。美国专利号6875176的教导示出了现有方法的局限性。

目前还没有被广泛接受的无创伤性测量ICP的方法。然而，临床上，测量ICP的有效方法的发展非常重要，因为ICP能够预测临床结果，且可以导致改变的、更有效的治疗。例如，在脑部受到外伤后，颅内压力趋于升高，需要马上确认和处理。Zanier等人，Critical Care 11：R7(“2007”)。测量ICP的现有标准要求直接的、有创伤性的测量，包括放置硬脑膜外传感器或脑室内或薄壁组织内导管。Frank等人，Zentralbl Neurochir 61(“4”)：177-80(“2000”)。有创伤性的方法的使用增大了由于感染、流血或手术事故而受伤的风险。Czosnyka等人，J.Neurol.Neurosurg.Psychiatry75：813-821(“2004”)。

目前已开发了各种不同的用于无创伤性测量ICP的技术，包括：测量耳声发射(“Frank等人，Zentralbl Neurochir 61(“4”)：177-80(“2000”)”)，及使用经颅的多普勒的超声(Ragauskas等人，Innovative non-invasive me thod for absolute intracranial pressure measurement[在线的]，[于2008年7月30号获取].获取自互联网<URL：http://www.neurosonology.org/bern2002/abs_12.html>).

例如，美国专利号6702743(“‘743专利”)公开了一种测量ICP的无创伤性方法。超声探针放置在病人的头部，然后用其产生穿过病人的颅骨和大脑进行传播的超声脉冲。超声脉冲从位于与超声探针垂直的路径的颅骨和软组织反射回来。然后选取生成的回波EG信号的一部分，并将回波EG信号结合到选取的部分上以产生回波脉冲图(“EPG”)信号。然而，为了使用’743专利的方法确定ICP，操作员必须手动选择，或“筛选”(gate)EPG的一部分并在每一筛选处查看EPG波形以确定哪一个为大脑中的所关注的部位提供了最优的EPG波形。

我们已经开发了用于无创伤性测量ICP，更一般地，测量大脑弹性的新方法，其不需要技术人员手动查看EPG波形。使用结合到模拟的人工神经网络(“SANN”)的算法(其基于从多个超声脉冲生成的一组相互作用的超声信号(“IUS”)的确定来计算ICP)来确定ICP。本发明的方法和系统能够迅速确定ICP而不需要手动查看EPG波形。

发明内容

本发明的一个目的是提供一种用于测量ICP的无创伤性技术，其基于对用回波脉冲图(“EPG”)形式表示的反射的超声信号的分析来测量ICP。

通过首先发射约至少1MHz的超声脉冲到病人的头颅内来测量ICP。然后该超声脉冲被头颅内的包括第三脑室的壁的各种结构反射回来。该反射信号被传感器接收，并生成一信息包。

本发明获取病人的多个超声信号。由于流进和流出大脑的血流(“心脏收缩和舒张”)，第三脑室的壁的状态不断地改变，计算机能够比较各信号以基于对应的波形的偏离来定位第三脑室的区域。

一旦定位了第三脑室，沿着第三脑室内的波的部分的数据点将用于计算ICP值。由将采样值与从具有已知的ICP值的病人获取的ICP数据相关联的算法计算ICP值。一旦参考已知的ICP值比较或训练了系统，计算机将自动完成计算。

附图说明

图1示出了用于发射和接收超声波及训练人工神经网络的优选装置的框图。

图2示出了颅内压力监视系统的流程图。

图3示出了一个完整的超声反射信号(“USRS”)。

图4示出了USRS的部分和大脑的部分之间的相关性。

图5示出了将USRS数据点输入到神经网络和算法以获得ICP值的流程图。

图6示出了用作输入的具体的EPG点的实例。

图7是QRS波群(complex)与超声信号的并排比较。

图8示出了在训练过程中使用的反向传播方法的流程图。

图9示出了训练过程是如何创建可测量的ICP值的范围的实例。

图10示出了用于训练过程的硬件的一个实施方式。

具体描述

本发明的目的是提供一种用于无创伤性测量ICP，更一般地，测量体内的各种器官或腔室的内部或附近的组织的弹性的方法。在一个实施方式中，通过使用穿颅的多普勒信号使颅骨腔受超高频声波的作用来确定ICP。首先，识别第三脑室的前壁和后壁的位置并建立ICP波形图。然后使用神经网络从ICP波计算ICP。更一般地，本发明的方法和系统可用于测量各种不同的组织的组织弹性。

在本发明的一个实施方式中，本发明的方法和系统使用超声探针。这种探针可由一个或多个通过电极激发的压电元件构造，例如，由锆钛酸铅(“PZT”)、聚乙二烯二氟化物(“PVDF”)、PZT陶瓷/聚合体合成物等。电极连接到电压源，施加电压波形，压电元件的大小以对应于施加的电压的频率的频率变化。当施加电压波形时，压电元件以激励波形中含有的频率发射超声波到其耦合的介质中。反过来，当超声波射到压电元件时，元件在电极两端产生相应的电压。可以使用本领域内公知的各种超声探针中的任意一种来实施本发明。

图2提供了本发明的方法的概览。超声探针1发射超声波到颅骨腔内。超声探针放置在病人的头部，然后用其生成穿过病人的头骨和大脑进行传播的超声脉冲。超声脉冲被颅骨9的枕骨部分及在穿过大脑组织8的过程中遇到的其他半刚性或刚性结构反射。在穿过过程中超声脉冲遇到的一个这样的结构是第三脑室，包括脑室的前壁和后壁。超声脉冲被反射回超声探针1并反射回超声获取系统7。任何可从市场上购买到的超声装置可用于本发明的方法和系统(见，Advanced Transducer Services，Inc.[在线的]，[于2008年7月30日获取].获取自互联网<URL：www.atsultrasound.com/>)。该信号可由具有加载的算法6的微处理器系统解译，加载的算法6识别第三脑室壁的位置并将EPG点和ICP值相关联。

图1表示能够用于测量ICP的系统的一个实施方式。该系统包括任何的中央处理单元(“CPU”)或微处理器系统，诸如膝上计算机6、通用串行总线(“USB”)接口5、数字信号处理器(“DSP”)4、放大器、模拟到数字转换器(“ADC”)3、超声电路2和超声探针1(其具有发射器、接收器和用于生成超声脉冲的探针)。该系统与测量心跳的装置相结合。应该理解图1所示的实施方式仅表示具有CPU 6、模拟到数字转换器(“ADC”)3和超声探针1的本发明的系统的一个示例性的配置。所有这些组件都可以从标准的电子供应商那购买到。

标准的、可购买到的组件可用于本发明的系统。以下对具体组件的描述仅为示例性的，且本发明的系统不限于这些组件。例如，DSP 4可以为德州仪器公司的C2000DSC和TMS320C20x，堪培拉公司的2060型号、CEVA-X1641、CEVA-X1622、CEVA-X1620、或CEVA-TeakLite-III。DSP4负责经由探针1生成频率为至少1MHz的电脉冲或信号，通过探针1检测反射回来的波形和回波，并处理检测到的数字信号。根据研究的数字信号可以改变DSP 4的硬件的范围。

当DSP 4接收到来自计算机6的启动信号时，测量周期开始。作为反应，DSP 4指示探针1生成一系列超声脉冲。可商业购买到的超声探针可用于本发明的方法和系统(见：Advanced Transducer Services，Inc.[在线的]，[获取于2008年7月30日].获取自互联网<URL：www.atsultrasound.com/>)。超声探针1应该能够发射频率为至少1MHz且上限为约10MHz的超声波。

可在发射模式、或各种反射或散射模式(包括检查由压力波转变为横波或由横波转变为压力波的模式)中采用超声源和检测器。超声检测技术也可用于监视来自声穿透的组织的声发射。检测技术包括测量诸如反向散射的声散射中的变化，或声发射中的变化。与组织特性相关的声散射或发射数据的实例包括声信号的幅值变化、声信号的相位变化、声信号的频率变化、与问诊信号相关的散射或发射信号的长度变化、在一个心动周期和/或呼吸周期内的声信号的初始和/或其他最大和/或最小幅值的变化；在一个心动周期内最大和/或最小幅值与后续振荡的平均值和/或变化和/或分布的比值，在同一位置的不同时间和/或不同位置的同一时间散射或发射信号的时间或空间差异(variance)的变化，所有可能的内生的大脑组织移位或松弛的变化速率，诸如移位的速度或加速度等。可以采用多个具有相同或不同的频率、脉冲长度、脉冲重复频率、强度的声问诊信号，且多个声问诊信号可以同时和/或顺序地从同一位置或多个位置发送。可以以单一的或多个频率、在同一或多个时间、及在单个或多个位置检测来自一个或多个问诊信号的散射或发射。

图3示出了单个超声反射信号(“USRS”)。图示中，该超声信号指回波脉冲图或EPG 10。它是指示前后颅顶的组织位置和超声脉冲的路径中的颅内内容的交互信号。声穿透包括第三脑室的大脑的超声信号具有一定的频率特性。如果返回的信号没有变化，EPG仅测量解剖结构并反射回同样的波形。然而，如果声穿透的超声信号与其路径中的每一样东西尤其与第三脑室动态相互作用，最终的波形或EPG是交互的，并可进行过滤以得到一组反射信号以计算ICP。例如，图4是有标记的交互的EPG。波形的可识别的部分对应于探针11内的反射信号(“a”)、前颅顶的(“b”)、硬脑膜和脑膜12、大脑13的(“c”)、第三脑室14的(“d”)、及硬脑膜和后颅顶15的反射信号(“e”)。

在任一心动周期(“收缩”和“舒张”)中，可以进行多个EPG测量；图7是EPG和QRS波群的并排比较，其示出了心动周期和大脑的关系。在所述心动周期(“收缩”和“舒张”)中，第三脑室的壁伸展和缩小。因此，在心动周期中第三脑室的壁的位置相对于超声探针变化。

在本发明的一个实施方式中，进行至少10个EPG测量。在另一个实施方式中，进行了至少25个EPG测量。在第三个实施方式中，进行了至少50个EPG测量。在第四实施方式中，进行了至少100个EPG测量。EPG信号均被数字化并在显示屏上显示为强度和时间的函数。如图5所示，所有的EPG 16-19中创建的来自第三脑室区的点被输入算法以计算ICP值。这些点在图6中表示得更为清晰，其示出了EPG的第三脑室区是如何在时间(“t”)上被划分为孤立的点21-35的。

这些点表示来自EPG的孤立部分的数字化的数据点的离散包，然后其被用于基于等式计算ICP：

ICP＝∑tanh(“∑I×W+b”)W+b

其中，I表示来自回波脉冲图21-35的选取部分的所有数据点的输入矩阵，W是通过训练(training)过程得到的权重矩阵，及b是由计算机6分配的随机偏差常数。

输入矩阵是(“n×k”)的数学矩阵，其中n行等于样本数；在本发明的一个实施方式中，该值至少为10。k列等于沿着在脑室壁之间发现的对应的EPG的数据点。经由已知的数学方法计算该矩阵。

通过必须进行一次的训练或相关过程获得W值或权重矩阵。在V.D.De Viterbo和J.C.Belchior，Artificial Neural Networks Applied for Studying Metallic Complexes，Journal of Computational Chemistry，vol.22，no.14，1691-1701(“2001”)中描述了训练SANN的方法。该训练过程是一反向传递算法，该算法由将输入集合和期望的输出集合提供给网络组成。权重被逐渐校正直到在网络中实现期望的误差。在图8中图示了该方法。在本发明的一个实施方式中，根据下式执行反向传递算法：

$\mathrm{\&Delta;}{W}_{\mathrm{ji}}^l={\mathrm{\&eta;\&delta;}}_j^l{\mathrm{out}}_i^{l-1}+\mathrm{\&mu;\&Delta;}{W}_{\mathrm{ji}}^{l\left(\mathrm{previous}\right)}---\left(1\right)$

其中

表示第l层第j个元素和前一层的第i个元素之间的权重的相关性。量

含有第l-1层的输出结果。参数η和μ分别被命名为学习速率和动量(momentum)常数。这些常数确定训练步骤中的收敛速率。通常，动态地调整这些参数以获得最好的收敛速率。将在训练期间引入的误差计算为

${\mathrm{\&delta;}}_j^{\mathrm{last}}=(y_j-{\mathrm{out}}_j^{\mathrm{last}}){\mathrm{out}}_j^{\mathrm{last}}(1-{\mathrm{out}}_j^{\mathrm{last}})---\left(2\right)$

和

${\mathrm{\&delta;}}_j^l=\left(\underset{k=1}{\overset{r}{\mathrm{\&Sigma;}}}{\mathrm{\&delta;}}_k^{l+1}{W}_{\mathrm{kj}}^{l+1}\right){\mathrm{out}}_j^l(1-{\mathrm{out}}_j^l)---\left(3\right)$

其中y_j是与第l层的

的输出结果相比的输出目标。然后可以将网络误差计算为

${\mathrm{\&epsiv;}}^l=\underset{j=1}{\overset{n}{\mathrm{\&Sigma;}}}{(y_j-{\mathrm{out}}_j^l)}^2---\left(4\right)$

对于学习步骤，通过中间层的S形函数和输出层的线性函数计算神经元行为。

对于求极小值函数，本发明的一个实施方式使用由Levenberg提出并由Marquardt实现(Marquardt等人，J SocInd Appl Math 11：431(“1963”))的稳健方法。它通过最速下降法和牛顿法的动态调整来工作。其优点在于在寻找最小值过程中其快很多。根据Levenberg-Marquardt方法(LMM)，更新的权重矩阵可以被计算为

W_n+1＝W_n-(H+βI)^-1▽ε^l(W_n)                  (5)

其中H是海赛矩阵，β是可变参数，通常它从β＝0.01开始。根据局部误差的估计，后者在最小化搜索的过程中发生改变，I是单位矩阵。当使用LMM时，可以将最困难的任务归于H的计算，其通过下式实现

H＝J^TJ                                       (6)

其中J是雅可比矩阵，并由下式给出

$J=\frac{{\&PartialD;\mathrm{\&epsiv;}}^l}{{\&PartialD;\mathrm{out}}_j^l}---\left(7\right)$

其中，l是所有权重的相关误差[式4]。解海赛矩阵的近似法将避免计算二阶导数，这简化了计算。将上述方法带入式(5)，得到

W_n+1＝W_n-[J^T(W_n)J W_n)+βI]^-1J^T(W_n)ε^l(W_n)   (8)

如果β→0，式(8)将接近纯理论的高斯-牛顿法或者当β→∞，式(8)将接近最速下降法。

根据本发明，这意味着，最初，通过具有随机地分配的W值的等式计算ICP值。作为结果的ICP值是测试值。通过一种已知的测量ICP的有创性方法确定参考ICP值。然后，训练包括将测试的ICP值与从已知的有创性方法得到的参考ICP值进行比较。如果ICP值之间的差大于可接受的误差，将调整随机的W值。一经调整W值，使用等式计算新的测试ICP值，该值又将与参考ICP值进行比较。重复调整权重值、计算新的ICP值并将其与参考点比较的训练过程，直到从该过程计算的ICP值与参考值的误差在可接受的范围内。当该情形出现时，由计算机6存储W值并将其与具体的ICP值(作为测试ICP值获取)自动相关联。在本发明的一个实施方式中，训练神经网络的算法如下：

●  BEGIN

      ○  WHILE START＝ON

           ■  GET SAMPLES OF DIGITALIZED ECHO FROM ADC

           ■  STORE THE SAMPLES IN A FILE

           ■  PLOT THE SAMPLES

           ■  CHOOSE THE VALID WAVES(MANUAL PROCESS)

           ■  IF WAVES AREVALID

                 ●  START＝OFF(MANUAL)

           ■  END IF

      ○  END WHILE

      ○  NUMBERS OF INPUT OF THE NEURAL NETWORK＝306

      ○  NUMBERS OF HIDDEN NEURONS＝2

      ○  W1(2X306)＝RANDOM NUMBERS

      ○  W2(1X2)＝RANDOM NUMBERS

      ○

           ■  WHILE(ERROR＞0.001)

                 ●  ICP_NON_INVASIVE＝

                     W2*(TANH(W1*DIGITALIZED_ECHO))

                 ●  ERROR＝ICP_INVASIVE-ICP_NON_INVASIVE

                 ●  CALCULATE THE NEW W1AND W2USING THE

                     LEVENBERG MARQUARDT METHOD

                 ●  W1＝W1+DW1

                 ●  W2＝W2+DW2

           ■  END WHILE

  ●END BEGIN

为了计算机创建权重值和对应的ICP值的索引或数据库，必须为每一可能的ICP值完成该训练过程。在训练后，通过为每组输入和ICP值对应适当的W值，计算机6能够自动计算ICP值而不需要有创性的过程。图9示出了该训练过程是如何扩展可能测量的ICP值的范围的。获得9个病人(3个一组共3组，具有3个不同的ICP值)的ICP值，并将他们的超声数据输入本发明作为初始情况，这为本发明提供了用于比较的基线。本发明的操作范围也将等于已知的其用于训练的ICP值。

因此，神经网络是用于头部的动态特性的相关性的算法(“ACDPH”)20。它使用输入数据创建ICP波形。然后将沿着EPG波在时间(“t”)的各点对多个EPG波作图。如能够理解地，从单个EPG波能够进行最多(“n”)个采样。然后对于各时间(“t”)绘制示出多个EPG波在各时间(“t”)的EPG波的幅值的图。对于诸如颅骨的枕骨部分的结构，其在心动周期内不发生变化，所以示出了来自多个EPG波在时间(“t”)的采样的图为一直线。这对于沿着第三脑室的点不适用。在图表上，这通过EPG波的幅值在所述周期内的变化反映出来。更具体地，将这种变化表示为具有正弦波形式的ICP波，其反映了该壁在心动周期内的扩张和收缩。ACDPH 20获取输入点的上下边界，并通过训练将数据与从有创性设备获得的病人的ICP值相关联。在训练后，ACDPH能够自动计算病人的ICP而不需使用有创性方法。在本发明的一个实施方式中，获取ICP值的算法如下：

●  BEGIN

      ○  WHILE START＝ON

           ■  LOAD TRAINED NEURAL NETWORK W1 AND W2

           ■  GET SAMPLES OF DIGITALIZED ECHO FROM ADC

           ■  STORE THE SAMLPLES IN A FILE

           ■  PLOT THE SAMPLES

           ■  CHOOSE THE VALID WAVES(MANUAL PROCESS)

           ■  IF WAVES ARE VALID(MANUAL PROCESS)

                  ●  ICP_NON_INVASIVE＝

                      W2*(TANH(W1*DIGITALIZED_ECHO))

           ■  END IF

           ■  END WHILE

●  END BEGIN

图10示出了用于迅速的训练过程的硬件的一个实施方式。将来自有创性ICP监视硬件的数据、来自无创性ICP监视硬件的数据、和心电图(EKG)数据输入DSP，其通过USB接口连接到膝上计算机。对于数据输出，在本发明的一个实施方式中，膝上计算机在其监视器上显示EPG、EKG和计算出的无创性ICP值。

与’743专利相比，本发明提供了更为准确的ICP测量，因为它考虑了第三脑室随时间的变化。’743专利依赖于通过大脑组织的血流主要从大脑流出的时间点。此外，在从回波EG信号和ECG生成EPG后，现有技术的专利依赖于操作员选取对应于ICP值的EPG的部分。在本发明中，计算机程序识别图的相关部分，即第三脑室。最后，’743专利基于等式ICP＝ρ(″t/T″)*[t/T]-β来计算ICP，其依赖4个不同的等式来限定p(“t/T”)。

本发明的范围不限于以上具体示出和描述的内容。在本发明的描述中引用和讨论了各种参考文献，包括专利和各种出版物。提供这些参考文献的引用和讨论仅仅是为了清楚地描述本发明，并不是承认任何参考文献是这里描述的本发明的现有技术。在本说明书中引用和讨论的所有参考文献都全文包括在此以作参考。只要不背离本发明的精神和范围，对本领域普通技术人员来说，会发生对本文描述内容的变化、修改和其他实现。虽然示出和描述了本发明的某些实施方式，显然对本领域的技术人员来说，只要不背离本发明的精神和范围，可以做出各种改变和修改。在前面的描述和附图中提出的问题仅通过例证提供，且不作为限制。本发明的实际范围意在被下面的权利要求限定。

//使用sixca daq到USB接口的ipc代码

//从板和神经网络获取数据到监视器icp

//SIXCA DAQ实例

//个人和商业使用免费

//www.sixca.com

//协议(ASCII模式)

//指令              PC发送        PIC发送

//设置数字输出位    *ANS#13       -

//读数字输入端口    *B#13         *BXX#13

//读模拟通道        *CN#13        *CNXXX#13

//When :*＝Header

//      X＝Ascii hex(′0′-′9′，′A′-′F′)

//      N＝Bit or channel(′0′-′7′)

//    #13＝End of protocol

//

//---------------------------------------------------------

unit main3；

interface

uses

  Windows，Messages，SysUtils，Variants，Classes，Graphics，Controls，Forms，

  Dialogs，StdCtrls，CPort，ExtCtrls，Buttons，CPortCtl，A3nalogGauge，FmtBcd，

  TeeProcs，TeEngine，Chart，IdBaseComponent，IdComponent，IdTCPConnection，

  IdSimpleServer，Series，ComCtrls，Mask，DBCtrls，math，DbChart，Z_timer；

type

  TForm1＝class(TForm)

    ComPort1:TComPort；

    GroupBox1:TGroupBox；

    GroupBox2:TGroupBox；

    out8:TCheckBox；

    out7:TCheckBox；

    out6:TCheckBox；

    out5:TCheckBox；

    out4:TCheckBox；

    out3:TCheckBox；

    out2:TCheckBox；

    out1:TCheckBox；

    CheckBox8:TCheckBox；

    CheckBox9:TCheckBox；

    CheckBox10:TCheckBox；

    CheckBox11:TCheckBox；

    CheckBox12:TCheckBox；

    CheckBox13:TCheckBox；

CheckBox14:TCheckBox；

CheckBox15:TCheckBox；

Label1:TLabel；

Label2:TLabel；

Label3:TLabel；

Label4:TLabel；

Label5:TLabel；

Label6:TLabel；

Label7:TLabel；

Label8:TLabel；

Label10:TLabel；

Label11:TLabel；

Label12:TLabel；

Label13:TLabel；

Label14:TLabel；

Label15:TLabel；

Label16:TLabel；

Label9:TLabel；

BitBtn1:TBitBtn；

BitBtn2:TBitBtn；

BitBtn3:TBitBtn；

BitBtn4:TBitBtn；

Edit1:TEdit；

GroupBox3:TGroupBox；

Label17:TLabel；

Label18:TLabel；

Label19:TLabel；

Label20:TLabel；

Label21:TLabel；

Label22:TLabel；

Label23:TLabel；

Label24:TLabel；

Label25:TLabel；

Label26:TLabel；

Label27:TLabel；

Label28:TLabel；

Label29:TLabel；

Label30:TLabel；

Label31:TLabel；

Label32:TLabel；

BitBtn5:TBitBtn；

Label33:TLabel；

Label35:TLabel；

Buttonl:TButton；

Chart1:TChart；

Label34:TLabel；

Edit3:TEdit；

Label37:TLabel；

Series3:TLineSeries；

Label38:TLabel；

Label39:TLabel；

Edit5:TEdit；

Edit6:TEdit；

Splitter2:TSplitter；

TrackBar1:TTrackBar；

Edit7:TEdit；

TrackBar2:TTrackBar；

Label36:TLabel；

Edit2:TEdit；

CheckBox1:TCheckBox；

Edit4:TEdit；

Edit8:TEdit；

Edit9:TEdit；

Edit10:TEdit；

Edit11:TEdit；

RadioButton1:TRadioButton；

CheckBox2:TCheckBox；

CheckBox3:TCheckBox；

Label40:TLabel；

Memo1:TMemo；

CheckBox4:TCheckBox；

CheckBox5:TCheckBox；

CheckBox6:TCheckBox；

CheckBox7:TCheckBox；

Edit13:TEdit；

Label41:TLabel；

Button2:TButton；

Series1:TLineSeries；

BitBtn6:TBitBtn；

DBEdit1:TDBEdit；

DBEdit2:TDBEdit；

DBEdit3:TDBEdit；

Label42:TLabel；

Label43:TLabel；

Label44:TLabel；

Label45:TLabel；

DBEdit4:TDBEdit；

DBEdit5:TDBEdit；

Label46:TLabel；

BitBtn7:TBitBtn；

Label47:TLabel；

DBEdit6:TDBEdit；

Label48:TLabel；

Label49:TLabel；

Label50:TLabel；

DBEdit7:TDBEdit；

DBEdit8:TDBEdit；

Label51:TLabel；

DBEdit9:TDBEdit；

DBComboBox1:TDBComboBox；

Button3:TButton；

Label52:TLabel；

DBEdit10:TDBEdit；

CheckBox16:TCheckBox；

CheckBox17:TCheckBox；

CheckBox18:TCheckBox；

CheckBox19:TCheckBox；

CheckBox20:TCheckBox；

CheckBox21:TCheckBox；

Label53:TLabel；

Label54:TLabel；

Label55:TLabel；

CheckBox22:TCheckBox；

CheckBox23:TCheckBox；

Series2:TLineSeries；

Button4:TButton；

Button5:TButton；

Button6:TButton；

Edit12:TEdit；

Edit14:TEdit；

Edit15:TEdit；

Label56:TLabel；

Edit16:TEdit；

Label57:TLabel；

Label58:TLabel；

Label59:TLabel；

Label60:TLabel；

Edit17:TEdit；

DBChart1:TDBChart；

Timer1:TTimer；

Series4:TLineSeries；

Series5:TLineSeries；

Series6:TLineSeries；

Series7:TLineSeries；

Series8:TLineSeries；

Series9:TLineSeries；

Series10:TLineSeries；

Series11:TLineSeries；

Series12:TLineSeries；

Series13:TLineSeries；

Series14:TLineSeries；

Series15:TLineSeries；

Series16:TLineSeries；

Series17:TLineSeries；

Series18:TLineSeries；

Series19:TLineSeries；

Series20:TLineSeries；

Series21:TLineSeries；

Series22:TLineSeries；

CheckBox24:TCheckBox；

CheckBox25:TCheckBox；

Edit18:TEdit；

Edit19:TEdit；

CheckBox26:TCheckBox；

Edit20:TEdit；

procedure ZTimer1Timer(Sender:TObject)；

procedure Timer3Timer(Sender:TObject)；

procedure Timer2Timer(Sender:TObject)；

procedure Timer4Timer(Sender:TObject)；

    procedure Timer5Timer(Sender:TObject)；

        procedure Timer6Timer(Sender:TObject)；

            procedure Timer7Timer(Sender:TObject)；

                procedure Timer8Timer(Sender:TObject)；

                    procedure Timer9Timer(Sender:TObject)；

                        procedure Timer10Timer(Sender:TObject)；

procedure Button6Click(Sender:TObject)；

procedure Button5Click(Sender:TObject)；

    procedure Button4Click(Sender:TObject)；

    procedure FormCreate(Sender:TObject)；

    procedure CheckBox2Click(Sender:TObject)；

    procedure Button1Click(Sender:TObject)；

    procedure FormClose(Sender:TObject；var Action:TCloseAction)；

    {procedure out8Click(Sender:TObject)；

    procedure out7Click(Sender:TObject)；

    procedure out6Click(Sender:TObject)；

    procedure out5Click(Sender:TObject)；

    procedure out4Click(Sender:TObject)；

    procedure out3Click(Sender:TObject)；

    procedure out2Click(Sender:TObject)；}

    procedure out1Click(Sender:TObject)；

    procedure ComPort1RxChar(Sender:TObject；Count:Integer)；

    procedure Timer1Timer(Sender:TObject)；

    procedure BitBtn1Click(Sender:TObject)；

    procedure BitBtn3Click(Sender:TObject)；

    procedure BitBtn4Click(Sender:TObject)；

    procedure BitBtn2Click(Sender:TObject)；

    procedure BitBtn5Click(Sender:TObject)；

  private

  Input_buffer:array[0..128]of byte；

  //DigitalInp2:array[0..1100]of byte；

  icp，erro，correction:real；

DigitalInp2，A，B，C，D，save，tmSt，tempo，sample，tempo3，nent，noculto，amostra，ns

aida，samplewave，ecgend:integer；

  DigitalInp，ADCch:byte；

  Ctrpic，calibra，sampledsp，All，nsamples:integer；

  A1:array[1..4，1..10000]of integer；

    w1:array[1..50，1..200]of real；

    w2:array[1..1，1..50]of real；

    b1:array[1..50]of real；

    b2:array[1..50]of real；

    entest:array[1..1000]of real；

  procedure ChangeCheckBox；

  procedure CalculateADC(ch:byte)；

  procedure CheckCMD；

    {Private declarations}

  public

    {Public declarations}

  end；

var

  Form1:TForm1；

  k，Diastole，T，Tantes，MediaT，lt，tempo2，ient，echocont:integer；

//ECG : Array[2..100]of real；

  ECG : Array[1..100]of real；

  EPG : Array[1..100]of real；

EPGMIN，EPGMAX1，EPGMIN2，EPGMAX2，ECGAntes，Tmedio，sensibility，sensibility2:real；

    echopg : Array[0..10000，0..30]of integer；

    old:real；

    Entradas:Array[1..1000]of real；

implementation

{$R *.dfm}

procedure TForm1.CheckBox2Click(Sender:TObject)；

begin

//        if (CheckBox2.Checked)then

//        Comport1.WriteStr(′*A01′+#13)

//        else

//        Comport1.WriteStr(′*A00′+#13)；

end；

procedure TForm1.CheckCMD；

var

  LVar:Integer；

  teste，teste1:Real；

  SomeTxtFile :TextFile；

  net1:Array[1..1，1..100]of real；

  net2:Array[1..1，1..1]of real；

    wt1:array[1..400，1..100]of real；

    wt2:array[1..100，1..1]of real；

  ii，iii，iiii，iv，inet1，jnet1，knet1，inet2，jnet2，knet2:Integer；

begin

         case input_buffer[1]of

         ord(′B′):begin

                                  if(((input_buffer[9]shr 0)and $01)＝

0)then

                                  begin

                                  save:＝1；

                                  CheckBox26.Cheeked:＝false；

                                  end；

              if(((input_buffer[9]shr 0)and $01)＝1)then

              begin

              CheckBox26.Checked:＝true；

                      icp:＝0；

          //          A:＝((input_buffer[2]shr 0)and $01)*8192+

((input_buffer[2]shr 1)and $01)*4096+((input_buffer[2]shr 2)and

$01)*2048+((input_buffer[2]shr 3)and $01)*1024；

         //           B:＝((input_buffer[3]shr 0)and $01)*512+

((input_buffer[3]shr 1)and $01)*256+((input_buffer[3]shr 2)and

$01)*128+((input_buffer[3]shr 3)and $01)*64；

          //        C:＝((input_buffer[4]shr 0)and

$01)*32+((input_buffer[4]shr 1)and $01)*16+((input_buffer[4]shr 2)and

$01)*8+((input_buffer[4]shr 3)and $01)*4；

          //        D:＝((input_buffer[5]shr 0)and $01)*2+

((input_buffer[5]shr 1)and $01)*1；

                    ii:＝2；

                    while ii＜6 do

                    begin           // D13 d12 d11 d10

                        A:＝((input_buffer[ii]shr 0)and $01)*8192+

((input_buffer[ii]shr 1)and $01)*4096+((input_buffer[ii]shr 2)and

$01)*2048+((input_buffer[ii]shr 3)and $01)*1024；

                     //  A:＝((input_buffer[ii]shr 0)and $01)*0+

((input_buffer[ii]shr 1)and $01)*4096+((input_buffer[ii]shr 2)and

$01)*2048+((input_buffer[ii]shr 3)and $01)*1024；

                       B:＝((input_buffer[ii+1]shr 0)and $01)*512+

((input_buffer[ii+1]shr 1)and $01)*256+((input_buffer[ii+1]shr 2)and

$01)*128+((input_buffer[ii+1]shr 3)and $01)*64；

                       C:＝((input_buffer[ii+2]shr 0)and

$01)*32+((input_buffer[ii+2]shr 1)and $01)*16+((input_buffer[ii+2]shr 2)

and $01)*8+((input_buffer[ii+2]shr 3)and $01)*4；

                       D:＝((input_buffer[ii+3]shr 0)and $01)*2+

((input_buffer[ii+3]shr 1)and $01)*1；

                             if(((input_buffer[7]shr 0)and $01)＝

1)then

                              begin

                                  if(((input_buffer[8]shr 0)and

$01)＝0)then

                                  begin

                                      Edit19.Text:＝IntToStr(ecgend)；

                                      ecgend:＝tempo；

                                  end；

                              end；

//                                if(((((input_buffer[7]shr 0)and

$01)＝0)and(((input_buffer[7]shr 0)and $01)＝0))＝0)then

//                                begin

//                                CheckBox24.Checked:＝false；

//                                end；

                                 if(((input_buffer[7]shr 0)and $01)＝

1)then

                                 begin

                                 CheckBox24.Checked:＝true；

                                 end；

                                 if(((input_buffer[7]shr 0)and $01)＝

0)then

                                 begin

                                 CheckBox24.Checked:＝false；

                                 end；

                                    if(((input_buffer[8]shr 0)and $01)＝

1)then

                                    begin

                                    CheckBox25.Checked:＝true

                                    end；

                                    if(((input_buffer[8]shr 0)and $01)＝

0)then

                                    begin

                                    CheckBox25.Checked:＝false；

                                    end；

           {         A:＝((input_buffer[2]shr 0)and $01)*8192+

((input_buffer[2]shr 1)and $01)*4096+((input_buffer[2]shr 2)and

$01)*2048+((input_buffer[2]shr 3)and $01)*1024；

                     B:＝((input_buffer[3]shr 0)and $01)*512+

((input_buffer[3]shr 1)and $01)*256+((input_buffer[3]shr 2)and

$01)*128+((input_buffer[3]shr 3)and $01)*64；

                     C:＝((input_buffer[4]shr 0)and

$01)*32+((input_buffer[4]shr 1)and $01)*16+((input_buffer[4]shr 2)and

$01)*8+((input_buffer[4]shr 3)and $01)*4；

                     D:＝((input_buffer[5]shr 0)and $01)*2+

((input_buffer[5]shr 1)and $01)*1；

            }

                                      DigitalInp2:＝A+B+C+D；

                       if DigitalInp2＞14724 then

                       begin

                    //DigitalInp2:＝DigitalInp2+TrackBar2.Position；

                       end；

                       Edit8.Text:＝IntToStr(A)；

                       Edit9.Text:＝IntToStr(B)；

                       Edit10.Text:＝IntToStr(C)；

                       Edit11.Text:＝IntToStr(D)；

                       Edit5.Text:＝IntToStr(TrackBar1.Position)；

            //           A1[1][A11]:＝DigitalInp2；

            //           A11:＝A11+1；

                       echopg[tempo][0]:＝DigitalInp2；

                       Edit13.Text:＝IntToStr(tempo)；

                       ii:＝ii+4；

                       if(DigitalInp2＝1)then

                               begin

                               sampledsp:＝1；

                               end；

                               AssignFile(SomeTxtFile，′echo.dat′)；

                               Append(SomeTxtFile)；

                                WriteLn(SomeTxtFile，′    ′，samplewave，′

′，tempo，′         ′，DigitalInp2)；

                               CloseFile(SomeTxtFile)；

             //            if(tempo＝0)then

             //            begin

             //            end；

                Series21.AddXY(tempo，DigitalInp2，′′，clRed)；

                            tempo:＝tempo+1；

                            Edit2.Text:＝IntToStr(A+B+C+D)；

                         end；

  //

ADCRes:＝StrToInt(chr(Input_buffer[6])+chr(Input_buffer[5])+chr(Input_buff

er[4])+chr(Input_buffer[3]))；

  //              Volt:＝(ADCRes/2)；

              //    echopg[tempo+1]:＝1；

             //          Series4.AddXY(tempo，DigitalInp2，′′，clGreen)；

//                     if (((input_buffer[6]shr 0)and $01)＝1)and

(tempo＞50)then

                      if (save＝1)then

    //    if (1＝1)then

                   begin

                   save:＝0；

    //        CheckBox1.Checked:＝true；

                          samplewave:＝samplewave+1；

                          if(tempo＞TrackBar1.Position)then

                                begin

                                Series1.Clear；

                                Series2.Clear；

                                Series3.Clear；

                                Series4.Clear；

                                Series5.Clear；

                                Series6.Clear；

                                Series7.Clear；

                                Series8.Clear；

             Series9.Clear；

             Series10.Clear；

             Series11.Clear；

             Series12.Clear；

             Series13.Clear；

             Series14.Clear；

             Series15.Clear；

             Series16.Clear；

             Series17.Clear；

             Series18.Clear；

             Series19.Clear；

             Series20.Clear；

             Series21.Clear；

             Series22.Clear；

                AssignFile(SomeTxtFile，′echotrain.dat′

)；

    //     Rewrite(SomeTxtFile)；

                Append(SomeTxtFile)；

            for iii:＝0to nsamples-1do

                begin

                  if(nsamples＝120)then

                  begin

        {         echopg[iii][10]:＝echopg[iii][9]；

                  echopg[iii][9]:＝echopg[iii][8]；

                  echopg[iii][8]:＝echopg[iii][7]；

                  echopg[iii][7]:＝echopg[iii][6]；

                  echopg[iii][6]:＝echopg[iii][5]；

                  echopg[iii][5]:＝echopg[iii][4]；

                  echopg[iii][4]:＝echopg[iii][3]；

                  echopg[iii][3]:＝echopg[iii][2]；

                  echopg[iii][2]:＝echopg[iii][1]；

            }

                  echopg[iii][20]:＝echopg[iii+2470][0]

        ；

                  echopg[iii][19]:＝echopg[iii+2340][0]

        ；

                  echopg[iii][18]:＝echopg[iii+2210][0]

        ；

                  echopg[iii][17]:＝echopg[iii+2080][0]

        ；

                  echopg[iii][16]:＝echopg[iii+1950][0]

        ；

                  echopg[iii][15]:＝echopg[iii+1820][0]

        ；

                  echopg[iii][14]:＝echopg[iii+1690][0]

        ；

                  echopg[iii][13]:＝echopg[iii+1560][0]

        ；

                  echopg[iii][12]:＝echopg[iii+1430][0]

        ；

                  echopg[iii][11]:＝echopg[iii+1300][0]

        ；

                                           echopg[iii][10]:＝echopg[iii+1170][0]

；

                                           echopg[iii][9]:＝echopg[iii+1040][0]

；

                                           echopg[iii][8]:＝echopg[iii+910][0]；

                                           echopg[iii][7]:＝echopg[iii+780][0]；

                                           echopg[iii][6]:＝echopg[iii+650][0]；

                                           echopg[iii][5]:＝echopg[iii+520][0]；

                                           echopg[iii][4]:＝echopg[iii+389][0]；

                                           echopg[iii][3]:＝echopg[iii+258][0]；

                                           echopg[iii][2]:＝echopg[iii+130][0]；

                                           echopg[iii][1]:＝echopg[iii][0]；

                                         end；

//                                         echopg[iii][1]:＝echopg[iii][0]；

                                         if(nsamples＝3000)then

                                         begin

                                       //echopg[iii][1]:＝echopg[iii][0]；

Seriesl.AddXY(iii，echopg[iii][0]，′′，clGreen)；

                                         end；

                                         if(nsamples＝120)then

                                           begin

Series1.AddXY(iii，echopg[iii][1]，′′，clGreen)；

                                           Series2.AddXY(iii，300+

echopg[iii][2]，′′)；

                                           Series3.AddXY(iii，600+

echopg[iii][3]，′′)；

                                           Series4.AddXY(iii，900+

echopg[iii][4]，′′)；

                                           Series5.AddXY(iii，1200+

echopg[iii][5]，′′)；

                                           Series6.AddXY(iii，1500+

echopg[iii][6]，′′)；

                                           Series7.AddXY(iii，1800+

echopg[iii][7]，′′)；

                                           Series8.AddXY(iii，2100+

echopg[iii][8]，′′)；

                                           Series9.AddXY(iii，2400+

echopg[iii][9]，′′)；

                                           Series10.AddXY(iii，2700+

echopg[iii][10]，′′)；

                                           Series11.AddXY(iii，3000+

echopg[iii][11]，′′)；

                                           Series12.AddXY(iii，3300+

echopg[iii][12]，′′)；

                                           Series13.AddXY(iii，3600+

echopg[iii][13]，′′)；

                                           Series14.AddXY(iii，3900+

echopg[iii][14]，′′)；

                                           Series15.AddXY(iii，4200+

echopg[iii][15]，′′)；

                                     Series16.AddXY(iii，4500+

echopg[iii][16]，′′)；

                                     Series17.AddXY(iii，4800+

echopg[iii][17]，′′)；

                                     Series18.AddXY(iii，5100+

echopg[iii][18]，′′)；

                                     Series19.AddXY(iii，5400+

echopg[iii][19]，′′)；

                                     Series20.AddXY(iii，5700+

echopg[iii][20]，′′)；

//WriteLn(SomeTxtFile，samplewave，′  ′，iii，′       ′，ecgend，′

′，echopg [iii][1]，′        ′，echopg[iii][2]，′    ′，echopg[iii][3]，′

′，echopg[iii][4]，′         ′，echopg[iii][5]，′    ′，echopg[iii][6]，′

′，echopg [iii][7]，′        ′，echopg[iii][8]，′    ′，echopg[iii][9]，′

′，echopg[iii][10]，′        ′，echopg[iii][11]，′   ′，echopg[iii][12]，′

′，echopg[iii][13]，′        ′，echopg[iii][14]，′   ′，echopg[iii][15]，′

′，echopg[iii][16]，′        ′，echopg[iii][17]，′   ′，echopg[iii][18]，′

′，echopg[iii][19]，′        ′，echopg[iii][20])；

                                          end；

                                   end；

                                      tempo:＝0；

              //

AssignFile(SomeTxtFile，′echotrain.dat′)；

             //            Rewrite (SomeTxtFile)；

             //                         Append(SomeTxtFile)；

    //    for iii:＝1 to 58 do

    //         begin

    //                 WriteLn(SomeTxtFile，iii，′

′，echopg [iii][0])；

                 //    Series2.AddXY(tempo，DigitalInp2，′′，clGreen)；

              //   Entradas [iiii]:＝echopg[iii]/8000；

                //  Edit3.Text:＝FloatToStr (tanh (Entradas [10]))；

             //    iiii:＝iiii+1；

        //     end；

               CloseFile(SomeTxtFile)；

                                         AssignFile(SomeTxtFile，′lixo .dat ′

)；

            //            Rewrite(SomeTxtFile)；

                                   Append(SomeTxtFile)；

         //  calculate icp para 1 echo

         iiii:＝2；iv:＝2；inet1:＝1；

  //                            AssignFile(SomeTxtFile，′echoNormal.dat′

)；

  //

Append(SomeTxtFile)；

   //          for iii:＝2 to 2400 do

   //          begin

                while iiii＜＝2400 do

                begin

                 Entradas[inet1]:＝echopg[iiii][0]/8000；；///8000；

                 if(sample＞2)and(echopg[iiii][0]<>0)then

                   begin

                   Entradas[inet1]:＝echopg[iiii][0]/8000；///8000；

                   end；

              //   Edit3.Text:＝FloatToStr(tanh(Entradas[10]))；

                 WriteLn(SomeTxtFile，′         ′，iiii，′

′，Entradas[inet1]，′          ′，echopg[iiii][0])；

      //            WriteLn(SomeTxtFile，iv，′  ′，iiii，′        ′，

Entradas[iiii])；

                    iiii:＝iiii+30；iv:＝iv+30；inet1:＝inet1+1；

           //       amostra:＝iiii-1；

                  end；

       end；

//                calibra:＝calibra+1；

//                if(calibra＞10)then

//                begin

//                  calibra:＝5；

//                end；

                for inet1:＝1 to amostra do

                   begin

                         for jnet1:＝1 to noculto do

                          begin

                          net1[inet1][jnet1]:＝0.0；

                          end；

                   end；

               for inet2:＝1 to amostra do

                 begin

                       for jnet2:＝1 to nsaida do

                         begin

                       net2[inet2][jnet2]:＝0.0；

                        end；

                 end；

              // tranpostas

                 for knet1:＝1 to noculto do

                 begin

                      for jnet1:＝1 to nent do

                        begin

                        wt1[jnet1][knet1]:＝w1[knet1][jnet1]；

                        end；

                 end；

               for knet2:＝1 to nsaida do

                 begin

                       for jnet2:＝1 to noculto do

                         begin

                        wt2[jnet2][knet2]:＝w2[knet2][jnet2]；

   //                     WriteLn(SomeTxtFile，inet1，′′，knet1，′′，

net1[inet1][knet1])；

                         end；

                end；

//  fim transp

              for knet1:＝1 to noculto do

                begin

                  for inet1:＝1 to amostra do

                    begin

                      for jnet1:＝1 to nent do

                        begin

net1[inet1][knet1]:＝net1[inet1][knet1]+Entradas[jnet1]*wt1[jnet1][knet1]；

                             WriteLn(SomeTxtFile，jnet1，′   ′，knet1，′

′，Entradas[jnet1]，′      ′，net1[inet1][knet1])；

                         end；

                     end；

                 end；

                        CloseFile(SomeTxtFile)；

               for knet1:＝1 to noculto do

                begin

                  for inet1:＝1 to amostra do

                    begin

net1[inet1][knet1]:＝tanh((net1[inet1][knet1]+b1[knet1]))；

//                               WriteLn(SomeTxtFile，inet1，′

′，knet1，′        ′，net1[inet1][knet1]，′     ′，b1[knet1])；

       //                    WriteLn(SomeTxtFile，inet1，′  ′，knet1，′

′，net1[inet1][knet1])；

                    end；

                end；

              for knet2:＝1 to nsaida do

                begin

                  for inet2:＝1 to amostra do

                    begin

                      for jnet2:＝1 to noculto do

                         begin

net2[inet2][knet2]:＝net2[inet2][knet2]+net1[inet2][jnet2]*wt2[jnet2][knet

2]；

                         end；

                     end；

                 end；

               for knet2:＝1 to nsaida do

                 begin

                   for inet2:＝1 to amostra do

                     begin

                  net2[inet2][knet2]:＝((net2[inet2][knet2]+b2[knet2]))；

//                         WriteLn(SomeTxtFile，inet2，′   ′，knet2，′

′，net2[inet2][knet2])；

                     end；

                  end；

Edit3.Text:＝FloatToStr(net2[1][1])；

                      if(net2[1][1]＜＝0.0)then

                                         //    net2[1][1]:＝0；

                         Edit3.Text:＝FloatToStr(0.0)

                      else

                           //         Edit3.Text:＝′----′；

                                   Edit20.Text:＝FloatToStr(net2[1][1])；

//                      if(net2[1][1]＞11.0)then

//                      begin

//                        if(net2[1][1]＜13.0)then

//                        begin

                     //     old:＝net2[1][1]；

//                          end

//                          else

//                          begin

//                          Edit3.Text:＝FloatToStr(old)；

//                          if(net2[1][1]＜11.0)then

//                          begin

//                              Edit3.Text:＝FloatToStr(0.0)；

//                            end；

//                          end；

//                        end；

               //   Edit3.Text:＝FloatToStr(tanh(10))；

             // calculate para 1 wave

             sample:＝sample+1；

             //    Series1.Clear；

            //    Series2.Clear；

            //    Series4.Clear；

        //  Series3.Clear；

//         Series1.AddXY(0，0，′′，c1Green)；

//        Series1.AddXY(0，40，′′，c1Green)；

//        Series1.AddXY(TrackBar1.Position，40，′′，c1Green)；

//        Series1.AddXY(TrackBar1.Position，0，′′，c1Green)；

        Edit5.Text:＝IntToStr(TrackBar1.Position)；

               end

               else

               begin

               CheckBox1.Checked:＝false；

         end；

       if(((input_buffer[2]shr 0)and $01)＝1)then

          CheckBox8.Checked:＝true

       else

          CheckBox8.Checked:＝false；

          if(((input_buffer[2]shr 1)and $01)＝1)then

          CheckBox9.Checked:＝true

       else

          CheckBox9.Checked:＝false；

                if(((input_buffer[2]shr 2)and $01)＝1)then

          CheckBox10.Checked:＝true

       else

          CheckBox10.Checked:＝false；

                if(((input_buffer[2]shr 3)and $01)＝1)then

          CheckBox11.Checked:＝true

       else

          CheckBox11.Checked:＝false；

                if(((input_buffer[3]shr 0)and $01)＝1)then

          CheckBox12.Checked:＝true

    else

        CheckBox12.Checked:＝false；

              if(((input_buffer[3]shr 1)and $01)＝1)then

        CheckBox13.Checked:＝true

    else

        CheckBox13.Checked:＝false；

              if(((input_buffer[3]shr 2)and $01)＝1)then

        CheckBox14.Checked:＝true

    else

        CheckBox14.Checked:＝false；

              if(((input_buffer[3]shr 3)and $01)＝1)then

        CheckBox15.Checked:＝true

    else

        CheckBox15.Checked:＝false；

              if(((input_buffer[4]shr 0)and $01)＝1)then

        CheckBox16.Checked:＝true

    else

        CheckBox16.Checked:＝false；

              if(((input_buffer[4]shr 1)and $01)＝1)then

        CheckBox17.Checked:＝true

    else

        CheckBox17.Checked:＝false；

              if(((input_buffer[4]shr 2)and $01)＝1)then

        CheckBox18.Checked:＝true

    else

        CheckBox18.Checked:＝false；

              if(((input_buffer[4]shr 3)and $01)＝1)then

        CheckBox19.Checked:＝true

    else

        CheckBox19.Checked:＝false；

              if(((input_buffer[5]shr 0)and $01)＝1)then

        CheckBox20.Checked:＝true

    else

        CheckBox20.Checked:＝false；

    if(((input_buffer[5]shr 1)and $01)＝1)then

        CheckBox21.Checked:＝true

    else

        CheckBox21.Checked:＝false；

{

     if((Ctrpic and $01)＝1)then

        begin

                    Comport1.WriteStr(′*A01′+#13)；

                    Comport1.WriteStr(′*A00′+#13)；

                    Comport1.WriteStr(′*A01′+#13)

        end；}

                  ChangeCheckBox；

        end；//END OF ′B′

      end；

        ord(′C′):begin

                   ADCCh:＝input_buffer[2]and $0F；

                   CalculateADC(ADCCh)；

                 end；

        end；

end；

procedure TForm1.CalculateADC(ch:byte)；

var ADCRes:word；

    Volt:Double；

begin

                if(k＝0)then

                begin

//                Series1.AddXY(0，0，′′，c1Green)；

//                Series1.AddXY(0，40，′′，c1Green)；

//                Series1.AddXY(TrackBar1.Position，40，′′，c1Green)；

//                Series1.AddXY(TrackBar1.Position，0，′′，c1Green)；

                Edit5.Text:＝IntToStr(TrackBar1.Position)；

                 k:＝1；

                end；

//                Series1.Delete()；

  {              if(tempo＝TrackBar1.Position)then

                begin

                Series2.Clear；

               // Series4.Clear；

                Series3.Clear；

                tempo:＝1；

                tempo2:＝1；

                T:＝0；

                end；

}

                if(ch＝1)then

                begin

                 sensibility:＝(TrackBar1.Position)/100；

                 correction:＝80*sensibility；

                 Edit7.Text:＝FloatToStr(TrackBar1.Position/100)；

                 Volt:＝10000；///correction；

                                  //Volt:＝tempo；

         Label25.caption:＝FloatToStrF(Volt，ffFixed，3，2)+′V′；

        end；

         if(ch＝0)then

         begin

ADCRes:＝StrToInt(chr(Input_buffer[6])+chr(Input_buffer[5])+chr(Input_buff

er[4])+chr(Input_buffer[3]))；

        Volt:＝(ADCRes/2)；

                Series22.AddXY(tempo，Volt，′′，c1Red)；

      end；

    end；

procedure TForm1.ChangeCheckBox；

begin

      if((Ctrpic and $01)＝1)then

          CheckBox2.Checked:＝true

      else

          CheckBox2.Checked:＝false；

end；

procedure TForm1.FormClose(Sender:TObject；var Action:TCloseAction)；

begin

          comport1.Close；

end；

procedure TForm1.FormCreate(Sender:TObject)；

var

SomeTxtFile:TextFile；

  echoi:Integer；

begin

         samplewave:＝0；

         nsamples:＝1；

         echocont:＝0；

tempo:＝0；

tempo3:＝0；

sample:＝0；

calibra:＝1；

A11:＝1；

for echoi:＝1 to 1000 do

  begin

    echopg[echoi][0]:＝1；

  end；

            AssignFile(SomeTxtFile，′lixo.dat′)；

                      Rewrite(SomeTxtFile)；

            CloseFile(SomeTxtFile)；

  AssignFile(SomeTxtFile，′echotrain.dat′)；

                      Rewrite(SomeTxtFile)；

            CloseFile(SomeTxtFile)；

AssignFile(SomeTxtFile，′graphic.dat′)；

                    Rewrite(SomeTxtFile)；

          CloseFile(SomeTxtFile)；

                  AssignFile(SomeTxtFile，′echo.dat′)；

                 Rewrite(SomeTxtFile)；

                 CloseFile(SomeTxtFile)；

//                  WriteLn(SomeTxtFile，DigitalInp2)；

AssignFile(SomeTxtFile，′echoNormal.dat′)；

                                               Rewrite(SomeTxtFile)；

CloseFile(SomeTxtFile)；

end；

procedure TForm1.out1Click(Sender:TObject)；

begin

             if(out1.Checked)then

              Comport1.WriteStr(′*A01′+#13)

             else

              Comport1.WriteStr(′*A00′+#13)；

              if(out1.Checked)then

              nsamples:＝120

              else

              nsamples:＝3000；

end；

procedure TForm1.ComPort1RxChar(Sender:TObject；Count:Integer)；

begin

              Comport1.Read(Input_buffer，count)；

              if((Input_buffer[0]＝ord(′*′))and(Input_buffer[count-

1]＝ord(#13)))then

              begin

              checkCMD；

              end；

        end；

procedure TForm1.Timer1Timer(Sender:TObject)；

var St:string；

begin

//         if((tmSt＝0)or(tmSt＜8))then

         if(tmSt＝0)then

         begin

            St:＝′*C′+inttostr(tmSt)+#13；

            Comport1.WriteStr(St)；

            tmSt:＝tmSt+1；

         end

         else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer2Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer3Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer4Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer5Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer6Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer7Timer(Sender:TObject)；

var St:string；

begin

//            if((tmSt＝0)or(tmSt＜8))then

            if(tmSt＝0)then

            begin

               St:＝′*C′+inttostr(tmSt)+#13；

               Comport1.WriteStr(St)；

               tmSt:＝tmSt+1；

            end

            else

            begin

               Comport1.WriteStr(′*B′+#13)；

               tmSt:＝0；

            end；

end；

procedure TForm1.Timer8Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer9Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.ZTimer1Timer(Sender:TObject)；

var St:string；

begin

//        if((tmSt＝0)or(tmSt＜8))then

        if(tmSt＝0)then

        begin

           St:＝′*C′+inttostr(tmSt)+#13；

           Comport1.WriteStr(St)；

           tmSt:＝tmSt+1；

        end

        else

        begin

           Comport1.WriteStr(′*B′+#13)；

           tmSt:＝0；

        end；

end；

procedure TForm1.Timer10Timer(Sender:TObject)；

var St:string；

begin

//      if((tmSt＝0)or(tmSt＜8))then

       if(tmSt＝0)then

       begin

          St:＝′*C′+inttostr(tmSt)+#13；

          Comport1.WriteStr(St)；

          tmSt:＝tmSt+1；

       end

       else

       begin

          Comport1.WriteStr(′*B′+#13)；

          tmSt:＝0；

       end；

end；

procedure TForm1.BitBtn1Click(Sender:TObject)；

var Answer:string；

    I:Integer；

begin

Diastole:＝0；

ECGAntes:＝5；

k:＝0；

//tempo:＝1；

Tmedio:＝0；

MediaT:＝1；

EPGMIN:＝5；

EPGMAX1:＝0；

EPGMIN2:＝5；

EPGMAX2:＝0；

//Close()；

        comport1.Open；

        comport1.WriteStr(′*B′+#13)；

        //Sleep(1)；

    //    for I:＝0 to 5 do

    //    begin

   //     end；

       ComPort1.ReadStr(Answer，ComPort1.InputCount)；

       if not(Pos(′*B′，Answer)＞0)then

       begin

           label35.Font.Color:＝clRed；

           label35.caption:＝′Hardware NOT found on:′+ComPort1.Port；

           comport1.Close；

           exit；

       end

       else

       begin

           label35.Font.Color:＝c1Black；

           label35.caption:＝′Hardware connected on:′+ComPort1.Port；

          timer1.Enabled:＝true；

{                  timer2.Enabled:＝true；

                   timer3.Enabled:＝true；

                   timer4.Enabled:＝true；

                   timer5.Enabled:＝true；

                   timer6.Enabled:＝true；

                   timer7.Enabled:＝true；

                   timer8.Enabled:＝true；

                   timer9.Enabled:＝true；

                   timer10.Enabled:＝true；}

           bitbtn1.Enabled:＝false；

           bitbtn5.Enabled:＝false；

           bitbtn2.Enabled:＝true；

       end；

end；

procedure TForm1.BitBtn3Click(Sender:TObject)；

begin

        Comport1.WriteStr(′*A00′+#13)；

   (    Comport1.WriteStr(′*A10′+#13)；

        Comport1.WriteStr(′*A20′+#13)；

        Comport1.WriteStr(′*A30′+#13)；

        Comport1.WriteStr(′*A40′+#13)；

        Comport1.WriteStr(′*A50′+#13)；

        Comport1.WriteStr(′*A60′+#13)；

        Comport1.WriteStr(′*A70′+#13)；)

        out1.Checked:＝false；

   {    out2.Checked:＝false；

        out3.Checked:＝false；

        out4.Checked:＝false；

        out5.Checked:＝false；

        out6.Checked:＝false；

        out7.Checked:＝false；

        out8.Checked:＝false；}

end；

procedure TForm1.BitBtn4Click(Sender:TObject)；

begin

      Comport1.WriteStr(′*A01′+#13)；

  (      Comport1.WriteStr(′*A11′+#13)；

        Comport1.WriteStr(′*A21′+#13)；

        Comport1.WriteStr(′*A31′+#13)；

        Comport1.WriteStr(′*A41′+#13)；

        Comport1.WriteStr(′*A51′+#13)；

        Comport1.WriteStr(′*A61′+#13)；

        Comport1.WriteStr(′*A71′+#13)；)

        out1.Checked:＝true；

{       out2.Checked:＝true；

        out3.Checked:＝true；

        out4.Checked:＝true；

        out5.Checked:＝true；

        out6.Checked:＝true；

        out7.Checked:＝true；

        out8.Checked:＝true；

}end；

procedure TForm1.BitBtn2Click(Sender:TObject)；

begin

        bitbtn1.Enabled:＝true；

        bitbtn2.Enabled:＝false；

        bitbtn5.Enabled:＝true；

        timer1.Enabled:＝false；

end；

procedure TForm1.BitBtn5Click(Sender:TObject)；

begin

        Comport1.ShowSetupDialog；

end；

procedure TForm1.Button1Click(Sender:TObject)；

begin

Close()；

end；

procedure TForm1.Button4Click(Sender:TObject)；

begin

//Series1.Delete(tempo)；

 {  Series1.AddXY(0，0，′′，c1Green)；

    Series1.AddXY(0，40，′′，c1Green)；

    Series1.AddXY(100，40，′′，c1Green)；

    Series1.AddXY(100，0，′′，c1Green)；

  }

    Series1.Clear；

    Series2.Clear；

    Series3.Clear；

    Series4.Clear；

    Series5.Clear；

    Series6.Clear；

    Series7.Clear；

    Series8.Clear；

    Series9.Clear；

    Series10.Clear；

                             Series11.Clear；

                             Series12.Clear；

                                  Series13.Clear；

                                  Series14.Clear；

                                  Series15.Clear；

                                  Series16.Clear；

                                  Series17.Clear；

                                  Series18.Clear；

                                  Series19.Clear；

                                  Series20.Clear；

      Series21.Clear；

      Series22.Clear；

  //    Series1.AddXY(0，0，′′，c1Green)；

  //    Series1.AddXY(0，40，′′，c1Green)；

    //  Series1.AddXY(TrackBar1.Position，40，′′，c1Green)；

    //  Series1.AddXY(TrackBar1.Position，0，′′，c1Green)；

  //    Edit5.Text:＝IntToStr(TrackBar1.Position)；

    //     k:＝1；

//       Series1.Delete()；

//       Series3.AddXY(0，0，′′，c1Green)；

  //     Series3.AddXY(100，0，′′，c1Green)；

  //     for tempo:＝1 to 10 do

  //     begin

  //     Series1.AddXY(tempo，ECG[tempo]，′′，c1Green)；

  //     Series2.AddXY(tempo，EPG[tempo]，′′，c1Red)；

  //     end；

       tempo:＝1；

end；

procedure TForm1.Button5Click(Sender:TObject)；

var

i:Integer；

begin

//

           Comport1.WriteStr(′*B′+#13)；

//           tmSt:＝0；

                  for i:＝0 to 100 do

        begin

           Series2.AddXY(i，echopg[i][0]，′′，c1Green)；

        end；

end；

procedure TForm1.Button6Click(Sender:TObject)；

var

  j，i，k:Integer；

  teste1:Real；

  w11，w12，b11，b12:array[1..10000]of real；

  SomeTxtFile :TextFile；

begin

j:＝1；

nent:＝StrToInt(Edit12.text)；

Edit17.text:＝IntToStr(nent)；

noculto:＝StrToInt(Edit14.text)；

nsaida:＝StrToInt(Edit15.text)；

amostra:＝StrToInt(Edit16.text)；

           for j:＝1 to nent do

             begin

               Entradas[j]:＝0；

             end；

             AssignFile(SomeTxtFile，′entest.dat′)；

             Reset(SomeTxtFile)；

             while not EOF(SomeTxtFile)do

                  begin

                      ReadLn(SomeTxtFile，entest[j])；

                     //  Edit6.Text:＝FloatToStr(w11)；

                      Memo1.Lines.Add(FloatToStr(entest[j]))；

                     //  Memo1.Lines.Add(FloatToStr(teste1))；

                  j:＝j+1；

                  end；

              CloseFile(SomeTxtFile)；

              j:＝1；

              AssignFile(SomeTxtFile，′w11.dat′)；

              Reset(SomeTxtFile)；

              while not EOF(SomeTxtFile)do

                  begin

                      ReadLn(SomeTxtFile，w11[j])；

                     //  Edit6.Text:＝FloatToStr(w11)；

                     Memo1.Lines.Add(FloatToStr(w11[j]))；

                     //  Memo1.Lines.Add(FloatToStr(teste1))；

                  j:＝j+1；

                  end；

              CloseFile(SomeTxtFile)；

              j:＝1；

              AssignFile(SomeTxtFile，′w12.dat′)；

              Reset(SomeTxtFile)；

              while not EOF(SomeTxtFile)do

                  begin

                      ReadLn(SomeTxtFile，w12[j])；

                     //  Edit6.Text:＝FloatToStr(w11)；

                      Memo1.Lines.Add(FloatToStr(w12[j]))；

                     //  Memo1.Lines.Add(FloatToStr(teste1))；

                  j:＝j+1；

                  end；

              CloseFile(SomeTxtFile)；

              j:＝1；

              AssignFile(SomeTxtFile，′b11.dat′)；

              Reset(SomeTxtFile)；

              while not EOF(SomeTxtFile)do

              begin

                      ReadLn(SomeTxtFile，b11[j])；

                      //  Edit6.Text:＝FloatToStr(w11)；

                       Memo1.Lines.Add(FloatToStr(b11[j]))；

                      //  Memo1.Lines.Add(FloatToStr(teste1))；

                  j:＝j+1；

                  end；

              CloseFile(SomeTxtFile)；

              j:＝1；

              AssignFile(SomeTxtFile，′b12.dat′)；

              Reset(SomeTxtFile)；

              while not EOF(SomeTxtFile)do

                   begin

                       ReadLn(SomeTxtFile，b12[j])；

                      //  Edit6.Text:＝FloatToStr(w11)；

                       Memo1.Lines.Add (FloatToStr(b12[j]))；

                      //  Memo1.Lines.Add(FloatToStr(teste1))；

                  j:＝j+1；

                  end；

              CloseFile(SomeTxtFile)；

              j:＝1；

         k:＝1；

         AssignFile(SomeTxtFile，′w1delphi.dat′)；

         Rewrite(SomeTxtFile )；

        for j:＝1 to nent do

         begin

             for i:＝1 to noculto do

                  begin

                      w1[i][j]:＝w11[k]；

                      k:＝1+k；

                    end；

         end；

          for i:＝1 to noculto do

         begin

              for j:＝1 to nent do

                  begin

                    Write(SomeTxtFile，w1[i][j])；

                  end；

                   Writeln(SomeTxtFile)；

         end；

     k:＝1；

              for i:＝1 to noculto do

                   begin

                     b1[i]:＝b11[k]；

                     k:＝1+k；

                   end；

         for i:＝1 to nocu1to do

         begin

                       Write(SomeTxtFile，b1[i])；

                       Writeln(SomeTxtFile)；

       end；

k:＝1；

       for j:＝1 to noculto do

        begin

             for i:＝1 to nsaida do

                  begin

                    w2[i][j]:＝w12[k]；

                    k:＝1+k；

                  end；

         end；

          for i:＝1 to nent do

         begin

               for j:＝1 to noculto do

                   begin

                     Write(SomeTxtFile，w2[i][j])；

                   end；

                    Writeln(SomeTxtFile)；

         end；

k:＝1；

               for i:＝1 to nsaida do

                    begin

                      b2[i]:＝b12[k]；

                      k:＝1+k；

                    end；

            for i:＝1 to nsaida do

               begin

                       Write(SomeTxtFile，b2[i])；

                     end；

                      Writeln(SomeTxtFile)；

         CloseFile(SomeTxtFile)；

end；

end.

Claims (16)

1.一种测量哺乳动物体内组织的弹性的方法，包括以下步骤：

a.发射至少一个超声脉冲到所述体内的靶位以获得一反射信号；

b.绘制随时间(“t”)的所述反射信号(“s”)强度以生成回波脉冲图(“EPG”)；

c.识别所述信号随时间的变化点；

d.对于各EPG绘制在时间(“t”)的所述点；及

e.使用计算机算法计算组织的弹性。

2.根据权利要求1所述的方法，其中所述超声脉冲的频率为至少1MHz。

3.根据权利要求1所述的方法，其中所述超声脉冲的频率为至少5MHz。

4.根据权利要求1所述的方法，其中所述超声脉冲的频率为至少10MHz。

5.根据权利要求1所述的方法，其中至少10个超声脉冲被发射到所述体内。

6.根据权利要求1所述的方法，其中所述超声脉冲具有在0到200伏之间的幅值。

7.根据权利要求1所述的方法，其中所述超声脉冲被超声接收器以在14次心跳中10M样本/秒的速率接收。

8.根据权利要求1所述的方法，其中所述超声脉冲被超声接收器以在14次心跳中1000M样本/秒的速率接收。

9.根据权利要求1所述的方法，其中所述超声脉冲被超声接收器以在14次心跳中10,000M样本/秒的速率接收。

10.根据权利要求1所述的方法，其中所述超声脉冲被超声接收器以在14次心跳中100,000M样本/秒的速率接收。

11.一种测量哺乳动物大脑内的颅内压力(“ICP”)的方法，包括以下步骤：

a.发射至少一个超声脉冲到哺乳动物的颅腔内的靶位以获得一反射信号；

b.绘制随时间(“t”)的所述反射信号(“s”)强度以生成回波脉冲图(“EPG”)；

c.识别所述信号随时间的变化点；

d.对于各EPG绘制在时间(“t”)的所述点；及

e.使用计算机算法计算所述颅内压力。

12.根据权利要求11所述的方法，其中所述靶位是所述颅腔内或邻近所述颅腔的至少一个半刚性或刚性结构。

13.根据权利要求11所述的方法，其中所述靶位包括颅骨的枕骨部分。

14.根据权利要求11所述的方法，其中所述靶位包括第三脑室。

15.根据权利要求11所述的方法，其中所述计算机算法是用于计算颅内压力的头部动态特性的相关性的算法(ACDPH)。

16.一种颅内压力监视系统，包括：

a.一超声探针；

b.一超声获取系统；及

c.一微处理器系统、USB、监视器、存储器和ACDPH波群仪。

Images