C# Discussion Boards - CodeProject

Re: Current datagrid row not being selected

Member 1144944710-Dec-15 3:49

10-Dec-15 3:49

That´s exactly the problem I described with other words. It is selecting the previous row, not the one where the mouse is clicked. But this only happens if the cell selected is empty, because if I write in the cell and click the button, that same row is the current row, not the previous one. That´s what the following code is telling:

MessageBox.Show(grid_lic.CurrentCell.ColumnIndex.ToString()); MessageBox.Show(grid_lic.CurrentCell.RowIndex.ToString());

I don't know where is the source of the problem. Any clue?

Re: Current datagrid row not being selected

Richard Deeming10-Dec-15 4:18

Richard Deeming

10-Dec-15 4:18

Sounds like the empty row doesn't become "current" until you start editing it.

Try checking the Selected property of the CurrentRow, which will probably be false. Also, check the SelectedRows collection to see if it contains the empty row.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: Current datagrid row not being selected

Member 1144944710-Dec-15 5:34

Member 11449447

10-Dec-15 5:34

The empty row belongs to the collection of SelectedRows, as this code which I ran selecting an empty row with index #4, confirms:

DataGridViewRow emptyrow = grid_lic.Rows[4];
if (grid_lic.SelectedRows.Contains(emptyrow))
MessageBox.Show("The row is empty!");

The Selected property of the CurrentRow is false:

if (grid_lic.Rows[4].Selected == false)
MessageBox.Show("False");
else
MessageBox.Show("True");

The problem was identified, I just don't know why it happens nor how to solve it. Any ideas?

Thank you.

Re: Current datagrid row not being selected

Richard Deeming10-Dec-15 5:53

Richard Deeming

10-Dec-15 5:53

Try something like this:

var row = grid_lic.CurrentRow;
if (row == null || !row.Selected)
{
    if (grid_lic.SelectedRows.Count == 0)
    {
        MessageBox.Show("Select a row.");
        return;
    }
    
    row = grid_lic.SelectedRows[0];
}

if (string.IsNullOrEmpty(Convert.ToString(row.Cells[1].Value)) 
  || string.IsNullOrEmpty(Convert.ToString(row.Cells[2].Value)) 
  || string.IsNullOrEmpty(Convert.ToString(row.Cells[6].Value)))
{
    MessageBox.Show("Fill the empty cells");
    return;
}

using (OdbcConnection connection = CreateConnection())
using (OdbcCommand command = new OdbcCommand("insert into lojas (NIF, Loja, bloqueado, DataFim, lastupdate, Nome) values (?, ?, ?, ?, ?, ?)", connection))
{
    command.CommandType = CommandType.Text;
    command.Parameters.AddWithValue("@NIF", row.Cells[1].Value);
    command.Parameters.AddWithValue("@Loja", row.Cells[2].Value);
    command.Parameters.AddWithValue("@Bloqueado", checkBox_bloq.Checked);
    command.Parameters.AddWithValue("@DataFim", row.Cells[4].Value);
    command.Parameters.AddWithValue("@lastupdate", row.Cells[5].Value);
    command.Parameters.AddWithValue("@Nome", row.Cells[6].Value);
    
    connection.Open();
    command.ExecuteNonQuery();
}

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: Current datagrid row not being selected

Member 1144944714-Dec-15 6:25

Member 11449447

14-Dec-15 6:25

That code allows me to fill an empty row which is what I don't want, it just doesn't allow to add data when the row is not selected, even if the cells are filled.

Re: Current datagrid row not being selected

Member 1144944714-Dec-15 7:08

Member 11449447

14-Dec-15 7:08

I solved it this way:

if(!row.Selected)
 {
   if (grid_lic.SelectedRows.Count == 0)
     {
       MessageBox.Show("Select the row.");
       return;
      }

  row = grid_lic.SelectedRows[0];
  }

 int i = grid_lic.SelectedRows[0].Index;

  if (string.IsNullOrEmpty(Convert.ToString(grid_lic.Rows[i].Cells[1].Value)) || string.IsNullOrEmpty(Convert.ToString(grid_lic.CurrentRow.Cells[2].Value))
|| string.IsNullOrEmpty(Convert.ToString(grid_lic.CurrentRow.Cells[6].Value)))
 {
    MessageBox.Show("Preencha os campos vazios");
    return;
  }

using (OdbcConnection connection = CreateConnection())
{
    OdbcCommand Command = new OdbcCommand("insert into lojas (NIF, Loja, bloqueado, DataFim,       lastupdate, Nome) values (?, ?, ?, ?, ?, ?)", connection);
   Command.CommandType = CommandType.Text;
   Command.Parameters.AddWithValue("@NIF", grid_lic.CurrentRow.Cells[1].Value);
   Command.Parameters.AddWithValue("@Loja", grid_lic.CurrentRow.Cells[2].Value);
   Command.Parameters.AddWithValue("@Bloqueado", checkBox_bloq.Checked);
   Command.Parameters.AddWithValue("@DataFim", grid_lic.CurrentRow.Cells[4].Value);
   Command.Parameters.AddWithValue("@lastupdate", grid_lic.CurrentRow.Cells[5].Value);
   Command.Parameters.AddWithValue("@Nome", grid_lic.CurrentRow.Cells[6].Value);
             
   connection.Open();
   Command.ExecuteNonQuery();
}

Re: Current datagrid row not being selected

Eddy Vluggen10-Dec-15 4:43

Eddy Vluggen

10-Dec-15 4:43

Richard is right; it is not the currently selected row, but the one you are editing.

Also would like to point out that X.ToString() will fail if X is null. I'd recommend "Convert.ToString(X)".

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

why do not SetFocus row for the GridView when using the Thread ?

Member 24584679-Dec-15 21:20

Member 2458467

9-Dec-15 21:20

I have used Thread Thr = new Thread();
I do not SetFocus gridview1.FocusedRowHandle = i; it will warning: "Cross-thread operation not valid: Control 'gridControl1' accessed from a thread other than the thread it was created on."
you do not know how to fix this ?

Re: why do not SetFocus row for the GridView when using the Thread ?

Simon_Whale9-Dec-15 21:58

Simon_Whale

9-Dec-15 21:58

because the grid is active on another thread so you will need to use a delegate to access the grid.

have a read of this Fill datagridview Column from different thread[^]

Every day, thousands of innocent plants are killed by vegetarians.

Help end the violence EAT BACON

C# ECG Analysis Algorithm

Member 121973799-Dec-15 18:45

Member 12197379

9-Dec-15 18:45

/****************************************************************************
** $Id: arrmain.cpp



//#define	ENABLE_EXTRA_VFIB_DETECTION

ChannelAutoSelInfoType gChannelAutoSelInfo;
ARRANAINFO 	 gArrAnalysisInfo;
QRSANAINFO    gQrsAnaInfo;
//EcgSettingType         gLastEcgSetting;

//MWI value threshold
UINT	MWI_THRESHOLD= 400;

//minimal slope in noise detecting for different gain
INT	MIN_NOISESLOPE= 30;


//define the arr code's name(string), code, and alarm level
ArrInfoType  sArrInfo[MAX_ARR_TYPE + 5 ]={
				{"ASY",0,1},   // asystole
				{"FIB",1,1},   // fibrillation
				{"VTA",2,1},   // ventricular tachycardia
				{"ROT",3,2},   // VPB R on T
				{"RUN",4,2},   // VPB runs of 3 or 4
				{"TPT",5,2},   // VPB triple. important: not use
				{"CPT",6,2},   // VPB couple
				{"VPB",7,2},   // accidental VPB
				{"BGM",8,2},   // VPB bigeminy
				{"TGM",9,2},   // VPB trigeminy
				{"TAC",10,1},  // supraventricular tachycaridia
				{"BRD",11,2},  // supraventricular bradycaridia
				{"MTI",12,2},  // VPB multiform. important: not use
				{"PNC",13,2},  // pace not capture
				{"PNP",14,2},  // pacer not paced
				{"PNF",15,2},  // pacer not function. important: not use
				{"MIS",16,2},  // missed beat
				{"SPB",17,2},  // supraventricular premature beat. important: not use
				{"IPB",18,2},  // insertion premature beat. important: not use
				{"APB",19,2},  // artial premature beat. important: not use

				{"LRN",20,1},  // learning
				{"OFF",21,1},  // off
				{"NOM",22,0},  // normal qrs
				{"PAC",23,0},  // pace rhythmia. important: not used
				{"NOS",24,0},  // noise beat
};


//the following two arrays are used in ArrhythmiaClassify:
static INT sStateTransfer[MAX_STATE+1][MAX_TYPE+1] ={
								 {21,1},  {2,3},   {4,5},  {6,7},  {8,9},   {10,11},
								 {21,1},  {12,13}, {23,1}, {14,3}, {21,16}, {6,7},
								 {21,1},  {17,18}, {19,1}, {6,7},  {10,3},  {0,1},
								 {0,18},  {0,20},  {14,3}, {22,1}, {23,1},  {24,1},
								 {24,1},  {0,1} };

static INT sStateToArrType[MAX_STATE+1][3] ={
				{NML,0,1}, {NON,-1,0}, {NON,-1,0}, {NON,-1,0}, {NON,-1,0}, {NON,-1,0},
				{CPT,2,3}, {NON,-1,0}, {VPB,3,4},  {NON,-1,0}, {BGM,3,4},  {VPB,3,2},
				{RUN,3,4}, {NON,-1,0}, {TGM,4,5},  {VPB,4,3},  {NON,-1,0}, {RUN,4,5},
				{VTA,4,5}, {NON,-1,0}, {NON,-1,0}, {NML,0,1},  {NML,0,1},  {NML,0,1},
				{NML,0,1} };

static INT sContinueAllowed[26] = {
					 1/*asy*/, 1/*fib*/, 1/*vta*/, 0/*RonT*/, 0/*run*/, 0, 0/*cpt*/,
					 0/*vpb*/, 1/*bgm*/, 1/*tgm*/, 1/*tac*/, 1/*brd*/, 0,  0/*pnc*/,
					 0/*pnp*/, 0, 0/*mis*/, 0, 0, 0, 0, 0, 0, 0, 0, 0};



static INT sIsLastArrValid = 0;

#define	 RRINTERVAL_NUM   12

static INT16 sHeartRate;
static INT16 sRrIntervals[RRINTERVAL_NUM];

static INT sHrOfOneSecond;
static INT sInnerHeartRate, sInnerLastHeartRate;
static INT sPreviousMatched;
static INT sOutHR;

typedef struct{ UCHAR type; INT position; INT isSaved;} ARRSELECTED;

static ARRSELECTED sLastArrSelected;

//samples that not found MWI value greater than threshold
static  UINT32  sBlankLength = 0;

// How many seconds past that average R-R interval has not been updated.
static INT sNotUpdatedTime = 0;

/*
 *
 *	FUNCTION:       call arr_anal to do arrhythmia analysis work. if a new
 *									arrhythmia was detected, save 4 seconds wave before and
 *									after the arrhythmia occurred time
 *
 */
void  ArrhythmiaAnalysis( void )
{
   // pace statistic
   PaceStatistic();

   // R wave detection and arrhythmia classify
   arr_anal( );
   if( 0 < gArrAnalysisInfo.ignoreResult )
   {
      gArrAnalysisInfo.arrCode = NML;
      gStates.current = MAX_STATE;
      gRGlobals.counter = 0;
   }
}


/**
 *
 *	1. if auto-select channel is ON, execute channel auto-select function.
 *	2. check whether relearn is needed or not.
 *	3. QRS complex detecting:
 *			1). do ECG filter, differential, integration.
 *			2). check ECG signal: noise or signal too slight
 *			3). check whether process is in learn state, execute proper function.
 *			4). detect QRS complex if not in learn.
 *
 *	4. if Arrhythmia analysis monitor or ST analysis is ON:
 *			1). Ventricular fibrillation or Ventricular tachycardia detecting.
 *			2). Asystole detecting.
 *			3). if Paced is ON, do pace analysis.
 *					else, call Arrhythmia analysis
 *			4). superventricular tachycardia and bradycarida detecting.
 *			5). arrhythmia selection: select the most serious arrhythmia for
 *					saving and display in this second.
 *			6). PVC statistic.
 *
 *	NOTE:
 *		1.		only if ECG lead is connected, 
 *					can this function be called.
 */
void  arr_anal( void )
{
	INT  i, ptr;
    Frame pack;

	//auto select channel
    if ( gEcgStatus.ecg1Exist
        && gEcgStatus.ecg2Exist  )
    {
        i = ChannelAutoSelect(mod( gEcgBuffer.pos - ARR_SAMPLE_RATE , ECG_BUF_LENGTH));
    }
    else
    {
        if ( gEcgStatus.ecg1Exist )
            i = ECG_CHANNEL_1;
        else
            i = ECG_CHANNEL_2;
    }
    if ( i != gArrConfig.arrChannel )
    {
        gArrConfig.arrChannel = i;
        pack.id = ECGCHANNEL;
        pack.data[0] = gArrConfig.arrChannel;
        gProtocol.SendPack( pack );
    }

	gRDetEcgBuf = gEcgBuffer.channel[gArrConfig.arrChannel];

	//check relearn is needed or not
	if( IsRelearnNeeded() == TRUE )
	{
    gArrAnalysisInfo.ignoreResult = 4;

		EcgVarInit();
		gQrsAnaInfo.inLearning = TRUE;

    ResetSTAnalysis( );
    
		sBlankLength = 0;
	}

  // Maybe the gQrsAnaInfo.inLearning has been set to TRUE,
  // but we must clear gLocalArrConfig.arrSelfLearn
  if(TRUE == gArrConfig.arrSelfLearn)
  {
		gQrsAnaInfo.inLearning = TRUE;
        gArrConfig.arrSelfLearn = FALSE;
  }

	//when arrhythmia analysis or ST analysis is ON, set maxTemplate to MAX_TEMPLATE
    gTemplateSet.maxTemplate = MAX_TEMPLATE;

	//gRDetEcgBufPtr is global variable, it's point to the end of ECG data saved.
	gRDetEcgBufPtr = gEcgBuffer.pos;
	ECGProcess( ARR_SAMPLE_RATE );

#ifdef	ENABLE_EXTRA_VFIB_DETECTION
	CopyDiffData( ARR_SAMPLE_RATE );
#endif

	gRGlobals.qrsDetected = 0;

	if( IsNoise( ARR_SAMPLE_RATE ) )
	{
		// ECG analyzing status: current signal is full of noise.
		gArrAnalysisInfo.arrCode = NOS;
		gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_NOISE;

		gQrsAnaInfo.delay = 2;
		gRGlobals.validRRi = 0;
		gRGlobals.resetPeakDetect = 1;
		gRGlobals.timePast = 0;
		gStates.current = MAX_STATE;
		gRGlobals.counter = 0;
		if( gRGlobals.initialized == 0 )
			EcgVarInit();
	}
	else
	if( gQrsAnaInfo.delay > 0 )
	{
		gQrsAnaInfo.delay --;

		// ECG analyzing status: Normal
		gArrAnalysisInfo.arrCode = NML;
	}
	else
	{
		if( IsECGLost( ARR_SAMPLE_RATE ) )
		{
            gArrAnalysisInfo.arrCode = ASY;
			gRGlobals.timePast = 0;
			gQrsAnaInfo.isEcgLost = TRUE;
			gRGlobals.validRRi = 0;
			gRGlobals.resetPeakDetect = 1;
			gStates.current = MAX_STATE;
			gRGlobals.counter = 0;
			if( gRGlobals.initialized == 0 )
				EcgVarInit();
		}
		else
		{
			gQrsAnaInfo.isEcgLost = FALSE;

		}

		if( gRGlobals.initialized == 0 )
		{
			if(	TRUE == gQrsAnaInfo.isEcgLost )
			{
				gRGlobals.initLength = 0;
				gRGlobals.initialized = 0;
				gRGlobals.qrsPtr = 0;
			}
			else
			{
				InitDetect( );
				if( gRGlobals.initialized == 1 )
				{
						gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_ARR_LRN;
                }
                else
                    // ECG analyzing status: QRS detection learning.
					gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_QRS_LEARN;
			}
		}
		else
		{
				if( gQrsAnaInfo.inLearning == TRUE && gTemplateSet.ready == 1 )
				{
					TemplateVarInit();//if relearn, initialize variables

          // ECG analyzing status: arrhythmia analysis learning.
					gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_ARR_LRN;
				}

			if( FALSE == gQrsAnaInfo.isEcgLost)
				QRSDetector( ARR_SAMPLE_RATE );
			else
				gRGlobals.qrsDetected = 0;

				i = gRGlobals.qrsDetected - 1;

				while( i >= 0 )
				{
					ptr = mod( gRGlobals.qrsPtr - i, MAX_QRS_NUM);
					if( gQrsComplex[ptr].coef != INVALID_CORRCOEF )
					{
						break;
					}
					i --;
				}
				ArrhythmiaProcess( i+1 );

      // Moved from the next five line, you can see. LLH.2000.11.1
      if( gQrsAnaInfo.inLearning == TRUE && gArrAnalysisInfo.arrCode != ASY )
      {
        gArrAnalysisInfo.arrCode = ARRLRN;

        // ECG analyzing status: arrhythmia analysis learning.
				gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_ARR_LRN;
      }
		}

        if (   (  gQrsAnaInfo.isEcgLost
            ||( gRGlobals.timePast > _4SECONDS + _200MS) )
         && ASY != gArrAnalysisInfo.arrCode )
			gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_SIGNAL_TOO_SMALL;
	}

	gQrsAnaInfo.heartRate = InnerGetHeartRate();
  gQrsAnaInfo.hrOfCurrSec = sHrOfOneSecond;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		call functions to select channel for arrhythmia analysis

	RETURN:			channel selected.

*/////////////////////////////////////////////////////////////////////////////
UCHAR	ChannelAutoSelect( INT16 beginPos )
{
	INT i;

	for( i = 0; i < ECG_CHANNEL_MAX; i++ )
	{
		 __Ddf1(gEcgBuffer.channel[i], gChannelAutoSelInfo.lpDifEcg[i], beginPos,
            ARR_SAMPLE_RATE, ECG_BUF_LENGTH, ECG_BUF_LENGTH);
		 PulNum( gChannelAutoSelInfo.lpDifEcg[i], i );
	}
	ChSelectNum( ECG_CHANNEL_MAX );

	return gChannelAutoSelInfo.byCurChNum;
}


/**
 */
void ChSelectNum( INT16 iChNum )
{
	INT16  i;
	INT16  pulseNum = 0;

	// if there is only one channel, no other choice.
	if( iChNum == 1 )
		return;

	if( gChannelAutoSelInfo.byTimeDelay > 1 )
		gChannelAutoSelInfo.byTimeDelay--;
	else
		gChannelAutoSelInfo.byTimeDelay = 0;

	for( i = 0; i < iChNum; i++ )
	{
		if( i != gChannelAutoSelInfo.byCurChNum )
		{
			if( gChannelAutoSelInfo.byPulNum[gChannelAutoSelInfo.byCurChNum] != 0 )
			{
				if( gChannelAutoSelInfo.byPulNum[i] != 0 )
					pulseNum = 1;
				else
					pulseNum = 0;
			}

			if(   ( ( gChannelAutoSelInfo.byPulNum[i] < gChannelAutoSelInfo.byPulNum[gChannelAutoSelInfo.byCurChNum] ) && ( pulseNum == 1 ) )
				 || (   ( gChannelAutoSelInfo.byPulNum[i] <= gChannelAutoSelInfo.byPulNum[gChannelAutoSelInfo.byCurChNum] )
							&&( gChannelAutoSelInfo.iMaxDiff[i] > gChannelAutoSelInfo.iMaxDiff[gChannelAutoSelInfo.byCurChNum] )	 )
				 || ( gChannelAutoSelInfo.iMaxDiff[gChannelAutoSelInfo.byCurChNum] == 10 ) )
			{
				gChannelAutoSelInfo.byChgCount[i]++;
				if( ( gChannelAutoSelInfo.byChgCount[i] > 10 ) && ( gChannelAutoSelInfo.byTimeDelay == 0 ) )
				{
					gChannelAutoSelInfo.byCurChNum    = i;
					gChannelAutoSelInfo.byChgCount[i] = 0;
				}
			}
			else
				gChannelAutoSelInfo.byChgCount[i] = 0;
		}
	}
	return;
}


/**
 */
void PulNum( INT16 *lpDifEcg, INT16 iChNo)
{
	INT16    i;         // general loop index.
	INT16    iCutLine;  // cut line to get numbers of pulse.

	gChannelAutoSelInfo.iMaxDiff[iChNo] = *lpDifEcg;
	gChannelAutoSelInfo.byPulNum[iChNo] = 0;

	for( i = 1; i < ARR_SAMPLE_RATE; i++)
	{
		if( *( lpDifEcg + i ) > gChannelAutoSelInfo.iMaxDiff[iChNo] )
			gChannelAutoSelInfo.iMaxDiff[iChNo] = *( lpDifEcg + i );
	}

	iCutLine = gChannelAutoSelInfo.iMaxDiff[iChNo] / 3;
	if( iCutLine < 10 )
		iCutLine = 10;

	for( i = 0; i < ARR_SAMPLE_RATE; i++ )
	{
		if( ( *( lpDifEcg + i ) > iCutLine ) && ( gChannelAutoSelInfo.byPassThdFlag[iChNo]== 0 ) )
		{
			gChannelAutoSelInfo.byPulNum[iChNo] ++;
			gChannelAutoSelInfo.byPassThdFlag[iChNo] = 1;
		}
		else
		{
			if( *( lpDifEcg + i )  <= iCutLine )
				gChannelAutoSelInfo.byPassThdFlag[iChNo] = 0;
		}
	}
	if( gChannelAutoSelInfo.iMaxDiff[iChNo] < 10 )
		gChannelAutoSelInfo.iMaxDiff[iChNo] = 10;
	return;
}

/*///////////////////////////////////////////////////////////////////////////

		FUNCTION:		check whether relearn is needed:
								if Gain or Lead or channel changed, relearn is needed.

		RETURN:			TRUE(1): 	relearn is needed
								FALSE(0): relearn is not needed

*////////////////////////////////////////////////////////////////////////////
INT	IsRelearnNeeded( void )
{
	return FALSE;
}

/*///////////////////////////////////////////////////////////////////////////

		FUNCTION:		call functions to process arrhythmia analysis.
								when call this function, G_ECG.arrmoni or G_ECG.stch1moni
								must be ON.

		INPUT:		  qrsDetected: qrs number that will be analysis
								sample: 		 number of samples that will be analysis, it has
														 nothing to do with qrsDetected, that is, the qrs
														 detected may not in the sample segment.

		OUTPUT:     the arrhythmia's information was saved to gArrAnalysisInfo

*////////////////////////////////////////////////////////////////////////////
void  ArrhythmiaProcess( INT qrsProcessed )
{
	UCHAR  arrCode;
	INT		i, ptr, position, isArrSelectedValid;
	INT		tmp, firstSaved;

	ARRSELECTED arrSelected;

	//qrs classify to normal or PVC, even in PACE ON mode, this process
	//is needed.
	gRGlobals.qrsClassified = 0;
	for( i = qrsProcessed - 1; i >= 0; i -- )
	{
		ptr = mod( gRGlobals.qrsPtr - i, MAX_QRS_NUM);

		tmp = MorphClassify(
                ptr,
                gSysSetting.pace || (0 < gArrAnalysisInfo.ignoreResult)
             );

		if( tmp > 0 )
		{
			gRGlobals.qrsClassified += tmp;
			gRGlobals.classifiedQrsPtr = ptr;
		}
	}

	// if pace monitor is ON, or 0 < gArrAnalysisInfo.ignoreResult,
	// classify all QRS as normal beats
	if( gSysSetting.pace || (0 < gArrAnalysisInfo.ignoreResult) )
	{
		for( i = gRGlobals.qrsClassified - 1; i >= 0; i -- )
		{
			ptr = mod( gRGlobals.classifiedQrsPtr - i, MAX_QRS_NUM);
			gQrsComplex[ptr].type = QT_DOMINANT;
		}
	}

	//arrhythmia classify
  //this variable has been initialized out of this function

	arrSelected.type = gArrAnalysisInfo.lastArrCode;

	arrSelected.isSaved = 1;
	isArrSelectedValid = 0;
	firstSaved = 0;

	for( i = gRGlobals.qrsClassified - 1; i >= 0; i -- )
	{
		ptr = mod( gRGlobals.classifiedQrsPtr - i, MAX_QRS_NUM);

		//pvc number increase
		if( gQrsComplex[ptr].type == QT_ABNORMAL )
			gArrAnalysisInfo.pvcOfCurrentSecond ++;

		//important: type must be normal(0) or PVC(1).
		//classified information saved to gArrAnalysisInfo. gStates is a global variable
		arrCode = ArrhythmiaClassify( &gStates, ptr, &position );

		//if it's a valid type, normal or abnormal
		if( arrCode != NON && position >= 0 )
		{
			//if it's not a new type, continue
			if( gArrAnalysisInfo.lastArrCode == arrCode && sContinueAllowed[arrCode] )
			{
				if( sIsLastArrValid )
				{
					arrSelected.type = sLastArrSelected.type ;
					arrSelected.position = sLastArrSelected.position ;
					arrSelected.isSaved = 0;
					firstSaved = 1;
					sIsLastArrValid = 0;
					isArrSelectedValid = 1;
				}
				else
				if( !firstSaved )
				{
					arrSelected.type = arrCode ;
					arrSelected.position = gQrsComplex[position].peakPos;
					isArrSelectedValid = 1;
				}
				continue;
			}
			else
				gArrAnalysisInfo.lastArrCode = arrCode;

			//select the most serious arrhythmia for warning.
			if( sArrInfo[arrCode].warningLevel >= sArrInfo[arrSelected.type].warningLevel )
			{
				arrSelected.type = arrCode;
				arrSelected.position = gQrsComplex[position].peakPos;
				arrSelected.isSaved = 0;
				firstSaved = 1;
				isArrSelectedValid = 1;
			}
			else
			if( arrCode != NML )
			{
				sLastArrSelected.type = arrCode;
				sLastArrSelected.position = gQrsComplex[position].peakPos;
				sIsLastArrValid = 1;
			}
		}
	}

	//note: even in relearning process, VFIB and ASYSTOLE are detected.
	// if VFIB or ASYSTOLE is detected, does the following process need?
		arrCode = NON;
		//detecting asystole
		if( ASYSTOLEDetect() == 1 )
		{
			arrCode = ASY;
		}
		else
		if( (gArrAnalysisInfo.arrCode == ASY) && (arrSelected.type != ASY) )
		{
			arrSelected.type = NML;
			isArrSelectedValid = 1;
		}

#ifdef	ENABLE_EXTRA_VFIB_DETECTION
		//detecting ventricular fibrillation
		if( VFIBDetect( ) == 1 )
		{
			arrCode = FIB;//because VTA and VFIB are classified as one type.
		}
#endif

#ifdef	ENABLE_EXTRA_VFIB_DETECTION
		if( arrCode == ASY || arrCode == FIB )
#else
		if( arrCode == ASY )
#endif
		{
			arrSelected.type = arrCode;

			//position four seconds before current time as the time of occurring.
			arrSelected.position = mod( gEcgBuffer.pos - 4 * ARR_SAMPLE_RATE, ECG_BUF_LENGTH);
			isArrSelectedValid = 1;
			if( gArrAnalysisInfo.arrCode != arrCode )
			{
				arrSelected.isSaved = 0;
			}
		}
		if( isArrSelectedValid )
		{
			gArrAnalysisInfo.arrCode = arrSelected.type;
			gArrAnalysisInfo.position = arrSelected.position;
			if( arrSelected.isSaved == 0 )
				gArrAnalysisInfo.isSaved = 0;
		}

	//check whether current arrhythmia is valid or not.
	if( gArrAnalysisInfo.arrCode <= 19 && gArrAnalysisInfo.isSaved == 0 )
	{
		 i = mod( gArrAnalysisInfo.position - ARR_RECORD_SECONDS * ARR_SAMPLE_RATE, ECG_BUF_LENGTH);
		 i = mod( gEcgBuffer.pos - i , ECG_BUF_LENGTH );
		 if( i < ARR_RECORD_SECONDS * ARR_SAMPLE_RATE )
		 {
			 gArrAnalysisInfo.arrCode = NML;
		 }
	}
}

/*////////////////////////////////////////////////////////////////////////////

	FUNCTION:		check whether the ECG signal is weak or not.
							it checks the Moving-Window Intergration signal, if in a
							continuous time, and the signal is less than a predefined
							threshold, the signal is too weak.

	INPUT:		  sample: number of samples that will be analysis

	RETURN:     TRUE:	 signal is too weak
							FALSE: signal is not too weak

	GLOBAL VARIABLES:	 gMWIBuf: moving window intergration data buffer
										 gRDetEcgBufPtr: moving window intergration data buffer pointer
*/////////////////////////////////////////////////////////////////////////////
CHAR  IsECGLost( INT sample )
{
	INT i, ptr;

	ptr = mod(gRDetEcgBufPtr - sample, ECG_BUF_LENGTH);
	for( i = 0; i < sample; i ++)
	{
		if( MWI_THRESHOLD >= *(gMWIBuf + ptr) )
		{
			sBlankLength ++;  //value too low, sBlankLength increase
		}
		else
		{
			sBlankLength = 0;//clear flag, reset sBlankLength
		}

		ptr = mod(ptr + 1, ECG_BUF_LENGTH);
	}

	//detect ECGLOST signal
	if( ECGLOST_THRESHOLD < sBlankLength )
		return TRUE;
	else
		return FALSE;
}

/*///////////////////////////////////////////////////////////////////////////

*////////////////////////////////////////////////////////////////////////////
UCHAR  ArrhythmiaClassify( STATES* states, INT qrsPtr, INT* eventQrsIndex )
{
	INT arrCode, qrsIndex;
	INT i, tmp, qrsNumber, ptr0, ptr1;
	UCHAR	type;

	states->last = states->current;

	if( gQrsComplex[qrsPtr].type == QT_ABNORMAL )/* PVC*/
		type = 1;
	else/* gQrsComplex[qrsPtr].type == QT_DOMINANT, normal */
		type = 0;

	//assert that states->current and type are in predefined range
	if( states->current <= MAX_STATE && states->current >= 0 )
	{
		states->current = sStateTransfer[states->current][type];
	}
	else//error occurred, reset state.
	{
		states->current = MAX_STATE;
	}

	//save position and RR interval
	states->ptr = mod( states->ptr + 1, QRS_SAVED );
	states->rri[states->ptr] = gQrsComplex[qrsPtr].rri;
	states->matched[states->ptr] = gQrsComplex[qrsPtr].matched;
	states->qrsPtrs[states->ptr] = qrsPtr;

	//get arrhythmia type code and qrsIndex
	arrCode  = sStateToArrType[states->current][0];
	qrsIndex = sStateToArrType[states->current][1];

	//classify for some unclassified types
	switch( arrCode )
	{
		case VPB:

			//heart rate is less than 100. important: heart rate here
			//is not the same as heart rate in system display
			if( states->averageRRi > _600MS )
			{
				i = mod( states->ptr - qrsIndex , QRS_SAVED );

				//if PVC is premature more than 66% and has a rest interval
				//that greater than 1.25 average interval, the VPB is RonT.
				//subtract 5 for error correction
				if(  ( (states->rri[i] * 10) <= (states->averageRRi * 5 ) )
					 &&(states->rri[mod(i+1,QRS_SAVED)] >= states->averageRRi* 5 / 4 ) )
				{
					arrCode = ROT;
				}
			}
			break;

		case NML:
			if( states->current == 24 )
			{
				arrCode = TachBradyDetect( states );
			}
			break;

		default:
			break;
	}

	//if it has more than three continued normal QRS found, do MISSED beat analysis
	if( states->current >= 22 )
	{
		if( states->last == 8 )
			qrsNumber = 2;
		else
			qrsNumber = 1;

		ptr0 = mod( states->ptr - qrsNumber , QRS_SAVED );
		ptr1 = mod( ptr0 + 1, QRS_SAVED );
		for( i = 0; i < qrsNumber ; i ++ )
		{
			//missed beat: 1) heart rate < 100
      //                and current R-R interval > 1.75 * average R-R interval
			//						    and next R-R interval < 1.5 * average R-R interval
			//        or   2) heart rate >= 100 and current R-R interval > 1000mseconds

			if(  (states->rri[ptr0] < _4SECONDS )
				 &&(states->rri[ptr1] < states->averageRRi * 3 / 2 )
				 &&(    (states->averageRRi > _600MS && states->rri[ptr0] > states->averageRRi * 7 / 4 )
						 || (states->averageRRi < _600MS && states->rri[ptr0] > ( _1000MS - 4 ) )) )// subtract four for error correction
			{
				arrCode = MIS;
				ptr0 = mod( ptr0 - 1, QRS_SAVED ); //save the last QRS complex as the wave
				*eventQrsIndex = states->qrsPtrs[ptr0];

				//if pace monitor is ON, do pace analysis
				if( TRUE == gSysSetting.pace )
				{
					tmp = mod( gEcgBuffer.pos - gQrsComplex[*eventQrsIndex].peakPos, ECG_BUF_LENGTH);
					arrCode = PaceAnalysis( tmp, states->averageRRi );
				}
				break;
			}
			ptr0 = mod( ptr0 + 1, QRS_SAVED );
		}
	}

	qrsNumber = sStateToArrType[states->current][2];
	tmp = mod( states->ptr - qrsIndex, QRS_SAVED );

	//if current arrhythmia type is not missed beat.
	if( arrCode != MIS && arrCode != PNC && arrCode != PNP )
	{
		//if a new arrhythmia or normal state was found, save the QRS complex
		//position to *position, it will be use for saving ecg wave.
		if( qrsNumber > 0 )
		{
			if( arrCode == TAC || arrCode == BRD )
				*eventQrsIndex = states->qrsPtrs[mod(tmp - 5, QRS_SAVED)];
			else
				*eventQrsIndex = states->qrsPtrs[tmp];
		}
		else
			*eventQrsIndex = -1;
	}

	//calculate average RR interval
	for( i = 0; i < qrsNumber; i++)
	{
		if( states->matched[tmp] && states->matched[mod( tmp - 1, QRS_SAVED)] )
			states->averageRRi = UpdateAveRRi( states->rri[tmp], states->averageRRi );
			//states->averageRRi = ( states->rri[tmp] + states->averageRRi * 7 ) / 8;
		tmp = mod( tmp + 1, QRS_SAVED);
	}

	return arrCode;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:	do superventricular tachycardia and bradycardia detection.
						tachycardia: continuous 5 RR intervals less than 500 milliseconds.
						bradycardia: continuous 5 RR intervals greater than 1.5 seconds.

	INPUT:	  global variable (gStates) is used.

	RETURN:	  normal: NML; tachycardia:TAC; bradycardia: BRD

*////////////////////////////////////////////////////////////////////////////
UCHAR TachBradyDetect( STATES* states )
{
	INT 		i, tmp, tmp1, ptr;
	UCHAR  arrCode;

	// added by two for error calibration
	static	INT	TACHY_LIMIT[3] = { ARR_SAMPLE_RATE/2+2, ARR_SAMPLE_RATE*3/8+2, ARR_SAMPLE_RATE*3/8+2 };//500ms and 375ms

	//get number of RRi that less than 500ms and greater 1500ms in
	//latest five RR intervals
	tmp = tmp1 = 0;
	for(i = 0 ; i < 5; i ++)
	{
		ptr = mod( states->ptr - i , QRS_SAVED );
		if( states->rri[ ptr ] <= TACHY_LIMIT[gSysSetting.patientType]  )
		{
			tmp ++;
		}
		else
		if( states->rri[ ptr ] >= (_1500MS - 2) )// subtract by two for error calibration
		{
			tmp1 ++;
		}
	}

	//if number of RRi is equal to or geater than 5, it's TAC or BRD.
	arrCode = NML;
	if( tmp >= 5 )
		arrCode = TAC;
	else
	if( tmp1 >= 5 )
		arrCode = BRD;

	return arrCode;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		update average R-R interval with current R-R interval.
							the function updates average R-R interval only when:

							1).(| currentRRi - averageRRi | < averageRRi / 5)
								 and (currentRRi > 500 ms) and (currentRRi < 1500ms)
							or
							2).averageRRi has not been updated for five seconds.

	INPUT:			currentRRi:	current R-R interval
							averageRRi:	average R-R interval

	RETURN:     updated average R-R interval if updated, else the original
							average R-R interval.

*////////////////////////////////////////////////////////////////////////////
INT	 UpdateAveRRi( INT currentRRi, INT averageRRi )
{
	if(  (  (abs( currentRRi - averageRRi ) < averageRRi / 5)
				&&(currentRRi > ARR_SAMPLE_RATE/2)
				&&(currentRRi < ARR_SAMPLE_RATE*3/2) )
			||( sNotUpdatedTime >= 3 ) )
	{
		averageRRi = (averageRRi * 7 + currentRRi) / 8;
		sNotUpdatedTime = 0;
	}
	else
	{
		sNotUpdatedTime ++;
	}
	return averageRRi;
}


/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		detect asystole

	INPUT:			sample:	sample number for detcting this time

	RETURN:     0: no asystole is detected
							1: asystole is detected

*////////////////////////////////////////////////////////////////////////////
UCHAR	ASYSTOLEDetect( void )
{
    return gQrsAnaInfo.isEcgLost || (gRGlobals.timePast > _4SECONDS + _200MS) ;
}


/*///////////////////////////////////////////////////////////////////////////

 FUNCTIONS:        DdfEcg1
 DESCRIPTIONS:     caculate 4 points deference value of  ECG
 ALGORITHM:        运用四点差分法,求ECG一阶差分值
										Y(n) = [x(n-2) - x(n-1) + 2*x(n-3) - 2*x(n)]/2
 INPUT:
		CHAR far      *Ecg_buf          //ECG buffer
		INT           Proc_begin        //beginning of processing
		INT           Proc_len          //length of processing

 RETURN:            -1              //failure
										 1              //success

*////////////////////////////////////////////////////////////////////////////
INT16 __Ddf1( UCHAR  *Ecg_buf, INT16* dif_buf,    UINT Proc_begin,
							UINT  Proc_len, UINT Ecgbuf_len, UINT Ddfbuf_len )
{
	INT16  i, n0;
	INT16  ecgPos;
	INT16  x0, x1, x2, x3;
	INT16  fib;

	if( (Proc_len > Ecgbuf_len) || (Proc_len > Ddfbuf_len) )
	{
		return(-1);
	}

	n0 = 0;

	//define the start position of ecg,ddf
	ecgPos = (Proc_begin - 4 + Ecgbuf_len)%Ecgbuf_len;

	//4 points deference formula
	for( i = n0; i < (int)Proc_len; i++ )
	{
		x0 = ecgPos;

		x1 = ( ecgPos + 1 ) ;
		if( x1 >= (int)Ecgbuf_len ) x1 = x1 - Ecgbuf_len;

		x2 = ( ecgPos + 3 );
		if( x2 >= (int)Ecgbuf_len ) x2 = x2 - Ecgbuf_len;

		x3 = ( ecgPos + 4 );
		if( x3 >= (int)Ecgbuf_len ) x3 = x3 - Ecgbuf_len;

		fib = ( *(Ecg_buf+x2) - *(Ecg_buf+x1)
					 + 2 * (*(Ecg_buf+x3) - *(Ecg_buf+x0) ) ) >> 1;

		if( Proc_len <= ARR_SAMPLE_RATE )
		{
			*( dif_buf + i ) = fib;
		}

		ecgPos = ( ecgPos + 1 );
		if(ecgPos>=(int)Ecgbuf_len) ecgPos = 0 ;
	}

	return 1;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		calculate number of PVC in a minute

	INPUT:			list:			the array for saving PVC of a second
							listSize: the length of the list, in fact, it will always be 60
							pvcNumber:PVC in the latest second

	RETURN:     number of PVC in the latest minute

*////////////////////////////////////////////////////////////////////////////
INT16  PVCStatistic( UCHAR* list, INT listSize, INT pvcNumber )
{
	INT16 i, total;

	total = pvcNumber;

	for( i = listSize - 1; i > 0 ; i -- )
	{
		*( list + i ) = *( list + i - 1);
		total += *( list + i );
	}

	*( list ) = pvcNumber;

	return total;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		calculate heart rate

	INPUT:      rrInterval: current R-R interval

	OUTPUT:			current heart rate

*////////////////////////////////////////////////////////////////////////////
#define  _1200MS          (ARR_SAMPLE_RATE+ARR_SAMPLE_RATE/5)
INT16	 CalculateHeartRate( INT16 rrInterval )
{
	INT  i, max, min, total, rri, validRRI;

	//update RR intervals
	for( i = RRINTERVAL_NUM	- 1; i > 0; i --)
	{
		sRrIntervals[i] = sRrIntervals[i-1];
	}
	sRrIntervals[0] = rrInterval;

  //if the latest three RR intervals are all greater than 1200MS,
  //calculate heart rate as the average value of latest four RR intervals.
  if(    (_1200MS <= sRrIntervals[0])
      && (_1200MS <= sRrIntervals[1])
      && (_1200MS <= sRrIntervals[2]) )
  {
    rri = 4;
  }
  else
    rri = RRINTERVAL_NUM;

  // calculate how many RRi is greater than 0
  validRRI = 0;
	for( i = 0; i < RRINTERVAL_NUM; i ++)
  {
    if ( 0 < sRrIntervals[i] )
      validRRI ++;
  }

  // return the last HeartRate if there is no more 5 valid RRIs
  if ( 5 > validRRI )
    return sHeartRate;

	// search maximal and minimal RR interval,
	// calculate summary of RR intervals
  total = 0;
  max   = 0;
  min   = 5120;

  if (RRINTERVAL_NUM == rri)
     rri = validRRI;

	for( i = 0; i < rri; i ++)
	{
		if( sRrIntervals[i] > max )
			max = sRrIntervals[i];

		if( sRrIntervals[i] < min )
			min = sRrIntervals[i];

		total += sRrIntervals[i];
	}

  //subtract min and max from total if rri is greater than 4
  if( rri > 4 )
  {
    total -= min + max;
    rri -= 2;
  }

	if( total != 0 )
	{
		sHeartRate = 600 * (INT32)rri * ARR_SAMPLE_RATE / total;
		sHeartRate = ( sHeartRate + 4 ) / 10;//error calibrate
	} else {
		sHeartRate = -100;
	}

	return sHeartRate;
}


/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		get heart rate after detecting QRS complex

	GLOBAL VARIABLES: gQrsAnaInfo.isEcgLost, gRGlobals.qrsDetected,
                    gRGlobals.initialized, gQrsComplex

	RETURN:			if process is in relearn of ECG signal is lost, HR = -100,
							else, return the true heart rate

*////////////////////////////////////////////////////////////////////////////
INT16  InnerGetHeartRate( void )
{
	INT i, ptr;
  INT sum_for_b2b_hr;
  BOOL tmpCondition = FALSE;

    tmpCondition = ( gRGlobals.timePast > _4SECONDS + _200MS );

	if(		 TRUE == gQrsAnaInfo.isEcgLost
	        || tmpCondition
			|| gRGlobals.initialized == 0
			|| gQrsAnaInfo.delay > 0 )
	{
		sInnerHeartRate = -100;
    sHrOfOneSecond  = -100;
	}
	else
	{
    sum_for_b2b_hr = 0;
		for( i = gRGlobals.qrsDetected - 1 ; i >= 0; i -- )
		{
			ptr = mod(gRGlobals.qrsPtr - i, MAX_QRS_NUM);

			if( sPreviousMatched && gQrsComplex[ptr].matched && gRGlobals.validRRi )
      {
				sInnerHeartRate = CalculateHeartRate( gQrsComplex[ptr].rri);
        sum_for_b2b_hr += gQrsComplex[ptr].rri;
      }
			else
				gRGlobals.validRRi = 1;

			sPreviousMatched = gQrsComplex[ptr].matched;
		}
    if (0 < sum_for_b2b_hr)
    {
       sHrOfOneSecond = 600 * (INT32)gRGlobals.qrsDetected * ARR_SAMPLE_RATE / sum_for_b2b_hr;
       sHrOfOneSecond = ( sHrOfOneSecond + 4 ) / 10;//error calibrate
    }
	}
	if( sOutHR == 1 || sInnerLastHeartRate == -100 )
	{
		sInnerLastHeartRate = sInnerHeartRate;
		sOutHR = 0;
	}
	else
	{
		sOutHR = 1;
	}
	return sInnerLastHeartRate;
}


#ifdef	ENABLE_EXTRA_VFIB_DETECTION
///////////////////////////////////////////////////////////////////////////
void CopyDiffData( INT sample )
{
	INT i, ptr, tmp;

	ptr = mod( gRDetEcgBufPtr - sample , ECG_BUF_LENGTH );

	//save differential data to gVFibInfo.noiseDetBuf for VFIB detection.
	for( i = 0; i < sample && i < ARR_SAMPLE_RATE; i ++)
	{
		tmp = *(gDiffBuf + ptr);
		*( gVFibInfo.data + i ) = tmp;

		if( tmp > 0 )
			*( gVFibInfo.noiseDetBuf + i ) = tmp;
		else
			*( gVFibInfo.noiseDetBuf + i ) = 0;

		ptr = mod( ptr + 1, ECG_BUF_LENGTH);
	}
}
#endif
/*//////////////////////////////////////////////////////////////////////////

*////////////////////////////////////////////////////////////////////////////
void ResetFlag( void )
{
	gQrsAnaInfo.inLearning = FALSE;
	gArrStatus.ecgAnalysisStatus = ECG_ANA_STATUS_NORMAL;
	gArrAnalysisInfo.arrCode = NML;
	gArrAnalysisInfo.lastArrCode = NML;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		detect noise in ECG signal

	INPUT:      sample:	data number to be propcessed

	OUTPUT:			0:	no noise detected, 1: noise detected.

*////////////////////////////////////////////////////////////////////////////
#define	 MINIMAL_CROSSPOINT  20
INT	IsNoise( INT sample )
{
	INT  isNoise,crossPoint, slope;

	isNoise = IsSaturation( sample );
    isNoise |= ( PacePulseOfTheSecond() > PACE_NUM_ALLOWED );
	
	if( !isNoise )
	{
		slope = gRGlobals.maxSlope / 4;
		if( slope < MIN_NOISESLOPE )
			slope = MIN_NOISESLOPE;

		crossPoint = CrossPointNum(gLpDiffBuf, mod( gRDetEcgBufPtr - sample, ECG_BUF_LENGTH),
                               sample/2, slope );
		if( crossPoint < MINIMAL_CROSSPOINT )
			crossPoint = CrossPointNum(gLpDiffBuf, mod( gRDetEcgBufPtr - sample/2, ECG_BUF_LENGTH),
                                 sample/2, slope );
		isNoise = ( crossPoint >= MINIMAL_CROSSPOINT );

	}
	/*
	if( !isNoise )
	{
		isNoise = IsBaselineWander( sample );
	}
	*/
	return isNoise;
}

/*///////////////////////////////////////////////////////////////////////////

	FUNCTION:		detect signal saturation in ECG signal

	INPUT:      sample:	data number to be propcessed

	OUTPUT:			0:	no saturation detected, 1: saturation detected.

*////////////////////////////////////////////////////////////////////////////
#define		SATURATION_HI			0xfd
#define		SATURATION_LO			0x2
#define	  FASTCHANGE_TIME 	5
#define	  FASTCHANGING 			5
INT	IsSaturation( INT sample )
{
	INT 		i, ptr, delay, result;
	INT 		numberFF, number00, fastChange;
	UCHAR   data;

	numberFF = number00 = fastChange = 0;
	delay = ARR_SAMPLE_RATE;

	ptr = mod( gRDetEcgBufPtr - sample, ECG_BUF_LENGTH);
	for( i = 0; i < sample; i++ )
	{
		data = *( gRDetEcgBuf + ptr );
		ptr += 1;
		if( ptr >= ECG_BUF_LENGTH )
			ptr = 0;

		if( data > SATURATION_HI )
		{
			numberFF ++;
			if( delay < FASTCHANGING )
			{
				fastChange ++;
			}
		}
		else
		if( data < SATURATION_LO )
		{
			number00 ++;
			delay = 0;
		}
		delay ++;
	}

	//if over 200 ms samples are greater than SATURATIONHI or less than
	//SATURATIONLO or times of fast changing from 0x1 to 0xfe is greater
	//than 5, the ECG signal is saturation
	if(		 number00 > _200MS
			|| numberFF > _200MS
			|| fastChange > FASTCHANGE_TIME  )
	{
		result = 1;
	}
	else
	{
		result = 0;
	}
	return result;
}

////////////////////////////////////////////////////////////////////////////
void InitStatics( void )
{
  INT i;

	sIsLastArrValid = 0;
  
  sHeartRate = -100;

  for (i = 0; i < RRINTERVAL_NUM; i ++)
    sRrIntervals[i] = 0;

  sHrOfOneSecond      = -100;
  sInnerHeartRate     = -100;
  sInnerLastHeartRate = -100;
  sPreviousMatched    = 1;
  sOutHR = 0;

  sLastArrSelected.type = NML;
  sLastArrSelected.position = 0;
  sLastArrSelected.isSaved  = 1;

  sBlankLength = 0;
  
  sNotUpdatedTime = 0;

  InitTompkinsStatic( );
}


INT PacePulseOfTheSecond( void )
{
	INT pace_count, i;
	
	pace_count = 0;
	
	//select valid pace spike position
	for( i = 0; i < MAX_PACE_NUM; i ++ )
	{
		if( gPaceEcg1Cnt[i] <= ARR_SAMPLE_RATE - 1 )
			pace_count ++;
	}
	return pace_count;
}

Re: C# ECG Analysis Algorithm

Mycroft Holmes9-Dec-15 19:00

Mycroft Holmes

9-Dec-15 19:00

And what precisely is your expectation here. You have just dumped a bunch of code in the forum.

Never underestimate the power of human stupidity
RAH

Re: C# ECG Analysis Algorithm

Eddy Vluggen10-Dec-15 4:46

Eddy Vluggen

10-Dec-15 4:46

I've GPL'd your code.

What was the question again?

Bastard Programmer from Hell Suspicious | :suss:

If you can't read my code, try converting it here[^]

Re: C# ECG Analysis Algorithm

Gerry Schmitz11-Dec-15 7:14

Gerry Schmitz

11-Dec-15 7:14

Is this in any way related to the detection of obstructive sleep apnea through ECG signal features?

How I Can Make My Program With Multiple Language For Forms In C# ?

eng_aza9-Dec-15 15:07

eng_aza

9-Dec-15 15:07

How I Can Make My Program With Multiple Language For Forms In C# ?

Re: How I Can Make My Program With Multiple Language For Forms In C# ?

Mycroft Holmes9-Dec-15 19:03

Mycroft Holmes

9-Dec-15 19:03

Do some research, this is the first entry[^] when I typed your question into Google.

Never underestimate the power of human stupidity
RAH

Re: How I Can Make My Program With Multiple Language For Forms In C# ?

Gerry Schmitz11-Dec-15 7:15

Gerry Schmitz

11-Dec-15 7:15

Resources.

Solid color image vs Panel with BackColor

David Sattler9-Dec-15 5:34

David Sattler

9-Dec-15 5:34

Simply put, what would be more efficient?

If I make a program with lets say 20 images that are just solid colors, but put together to make custom controls, then those custom controls are used several times each, would that be as efficient as just creating panels with a solid BackColor?

Would they yield the same results in terms of RAM/CPU consumption? Would one be better then the other?

Re: Solid color image vs Panel with BackColor

OriginalGriff9-Dec-15 5:48

OriginalGriff

9-Dec-15 5:48

Without actually testing it it difficult to be certain - and you could check with the Stopwatch class by handing the Paint event - but my gut feeling is that the solid background colour will be faster and more ram efficient. It's pretty certain to be more ram efficient because it doesn't need to store the colour bitmaps, and a quick look at the reference source says that Graphics.Clear just calls the native clear method SafeNativeMethods.Gdip.GdipGraphicsClear - it doesn't have to faff about with looking to see if any scaling is needed and so forth which the DrawImage version does. And since it is called for every control in Windows every time it's painted, I'd imagine even Microsoft will have put good effort into ensuring it's as fast as possible! Laugh | :laugh:

Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...

Re: Solid color image vs Panel with BackColor

David Sattler9-Dec-15 5:52

David Sattler

9-Dec-15 5:52

Thanks for this Smile | :)

I was trying to prove a point to a friend about avoiding images when your just using a solid color and just wanted to re-assure myself Laugh | :laugh:

how to fill the cells of a DataGridView directly

Member 114494479-Dec-15 1:49

Member 11449447

9-Dec-15 1:49

How to fill directly the cells of a datagrid linked to a table in a databasis? I tried this code but no data is added to the table. It only works when the data comes from a textbox and then sent to the datagrid cells :

public void BD_Conexao()
    {
        try
        {
            OdbcConnection con = new OdbcConnection("driver= {MySQL ODBC 5.1 Driver};server=xxxxx; database=lic; uid=es; password=1234; option = 3 ");
            con.Open();
        }

        catch (Exception ex)
        {
            Console.WriteLine("Erro na ligação à base de dados. \n{0}", ex.Message);
            return;
        }

    }
public void Consulta()
    {
        con = new OdbcConnection("driver= {MySQL ODBC 5.1 Driver};server=xxx; database=lice; uid=estagio; password=1234; option = 3 ");
        con.Open();

        OdbcCommand Command = con.CreateCommand();
        Command.CommandText = "select lojas.Id, lojas.NIF, lojas.Loja, lojas.Bloqueado, lojas.DataFim, lojas.lastupdate, lojas.Nome";


        Command.CommandType = CommandType.Text;
        Command.Connection = con;

        OdbcDataAdapter adapter = new OdbcDataAdapter();
        adapter.SelectCommand = Command;

        DataSet dataSet = new DataSet();
        adapter.Fill(dataSet);

        grid_lic.DataSource = dataSet;

        grid_lic.DataMember = dataSet.Tables[0].TableName;
      }

 private void bt_preencher_Click(object sender, EventArgs e)
 {
   BD_Conexao();

   string DataFim = dateTimePicker.Value.ToString("yyyy-MM-dd");
   string lastupdate = dateTimePicker2.Value.ToString("yyyy-MM-dd");
   Commandtext = "insert into lojas (NIF,Loja,bloqueado, DataFim, lastupdate, Nome) values (@NIF,@Loja,@Bloqueado,@DataFim,@lastupdate,@Nome)";

   OdbcCommand Command = new OdbcCommand(Commandtext, con);

   Command.CommandType = CommandType.Text;

   Command.Parameters.AddWithValue("@NIF", grid_lic.CurrentRow.Cells[1].Value);
   Command.Parameters.AddWithValue("@Loja", grid_lic.CurrentRow.Cells[2].Value);
   Command.Parameters.AddWithValue("@Bloqueado", checkBox_bloq.Checked);
   Command.Parameters.AddWithValue("@DataFim", grid_lic.CurrentRow.Cells[4].Value);
   Command.Parameters.AddWithValue("@lastupdate", grid_lic.CurrentRow.Cells[5].Value);
   Command.Parameters.AddWithValue("@Nome", grid_lic.CurrentRow.Cells[6].Value);

   Command.ExecuteNonQuery();
   Consulta();
}

modified 9-Dec-15 10:09am.

Re: how to fill the cells of a DataGridView directly

Richard MacCutchan9-Dec-15 2:37

Richard MacCutchan

9-Dec-15 2:37

Command.CommandText = "select lojas.Id, lojas.NIF, lojas.Loja, lojas.Bloqueado, lojas.DataFim, lojas.lastupdate, lojas.Nome";

That SELECT statment does not look complete, you have not told it which table to extract the data from. You should also add some error checking to your code to test that your commands work as expected.

Re: how to fill the cells of a DataGridView directly

Member 114494479-Dec-15 3:58

Member 11449447

9-Dec-15 3:58

The problem is not there, actually I forgot to include here the end of that select ("select lojas.Id, lojas.NIF, lojas.Loja, lojas.Bloqueado, lojas.DataFim, lojas.lastupdate, lojas.Nome from lojas";).

I´ve made exactly the same but using textboxes instead of filling directly the datagrid cell, and the data was added. The code written below works, but data is inserted in texboxes instead of datagrid cells. I don't want to use any buttons, I want to add data directly in the datagrid with no buttons nor texboxes:

C++

string NIF = textBoxNIF.Text;
 int loja = int.Parse(textBoxLoja.Text);

 int bloqueador = 0;

 if (checkBoxBloq.Checked == true)
   bloqueador = 1;
   else
 bloqueador = 0;

 string DataFim = dateTimePicker1.Value.ToString("yyyy-MM-dd");

 string lastupdate = dateTimePicker2.Value.ToString("yyyy-MM-dd HH:mm:ss");

 string Nome = textBoxNome.Text;

string  Commandtext = "insert into lojas (NIF,loja,Bloqueado,DataFim,lastupdate,Nome) values ('" + NIF + "', " + loja + "," + bloqueador + ",'" + DataFim + "','" + lastupdate + "','" + Nome + "')";
OdbcCommand cm2 = new OdbcCommand(Commandtext, con);
cm2.ExecuteNonQuery();
Consulta();

Why does this code works but the first I put doesn't?

Re: how to fill the cells of a DataGridView directly

Richard Deeming9-Dec-15 4:02

Richard Deeming

9-Dec-15 4:02

Why have you taken a perfectly good parameterized query, and replaced it with one that's vulnerable to SQL Injection[^]?

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: how to fill the cells of a DataGridView directly

Member 114494479-Dec-15 4:30

Member 11449447

9-Dec-15 4:30

Which query is vulnerable to injection? What do you propose in order to fill de datagrid directly in its cells without texboxes?

Thank you.

Re: how to fill the cells of a DataGridView directly

Richard Deeming9-Dec-15 4:44

Richard Deeming

9-Dec-15 4:44

Member 11449447 wrote:
Which query is vulnerable to injection?

Take a guess!

Member 11449447 wrote:

string  Commandtext = "insert into lojas (NIF,loja,Bloqueado,DataFim,lastupdate,Nome) values ('" + NIF + "', " + loja + "," + bloqueador + ",'" + DataFim + "','" + lastupdate + "','" + Nome + "')";
OdbcCommand cm2 = new OdbcCommand(Commandtext, con);

NEVER use string concatenation to build a SQL query. ALWAYS use a parameterized query.

The OdbcCommand uses positional, not named, parameters. You have to use ? as the parameter placeholder in the query, and add the parameters in the same order as they appear in the query.

using (OdbcConnection connection = CreateConnection())
using (OdbcCommand command = new OdbcCommand("insert into lojas (NIF, Loja, bloqueado, DataFim, lastupdate, Nome) values (?, ?, ?, ?, ?, ?)", connection))
{
   command.CommandType = CommandType.Text;
 
   // Parameter names don't matter here; only the order:
   command.Parameters.AddWithValue("NIF", grid_lic.CurrentRow.Cells[1].Value);
   command.Parameters.AddWithValue("Loja", grid_lic.CurrentRow.Cells[2].Value);
   command.Parameters.AddWithValue("Bloqueado", checkBox_bloq.Checked);
   command.Parameters.AddWithValue("DataFim", grid_lic.CurrentRow.Cells[4].Value);
   command.Parameters.AddWithValue("lastupdate", grid_lic.CurrentRow.Cells[5].Value);
   command.Parameters.AddWithValue("Nome", grid_lic.CurrentRow.Cells[6].Value);
   
   connection.Open();
   command.ExecuteNonQuery();
}

As to your original problem: you're storing the OdbcConnection instance in a field, which is a bad idea. Your BD_Conexao method is creating and opening a new connection, but only stores it in a local variable. The field is never updated, so your bt_preencher_Click method is unable to use that field.

Remove the field, and use a method which creates and returns the connection object instead:

private static OdbcConnection CreateConnection()
{
    return new OdbcConnection("driver= {MySQL ODBC 5.1 Driver};server=xxxxx; database=lic; uid=es; password=1234; option = 3 ");
}

public void Consulta()
{
    using (OdbcConnection connection = CreateConnection())
    using (OdbcCommand command = new OdbcCommand("SELECT Id, NIF, Loja, Bloqueado, DataFim, lastupdate, Nome FROM lojas", connection))
    {
        ...
    }
}

private void bt_preencher_Click(object sender, EventArgs e)
{
    using (OdbcConnection connection = CreateConnection())
    using (OdbcCommand command = new OdbcCommand("insert into lojas (NIF, Loja, bloqueado, DataFim, lastupdate, Nome) values (?, ?, ?, ?, ?, ?)", connection))
    {
        ...
    }
}

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.