realtime.cpp

读取串口数据并画实时曲线的VC源码

			xb = xe = GL + 1;
		if ((sec % 1000) == 0 && ((sec / 1000) % (m_nTimeSpan / m_nXTicks)) == 0)
			DrawLine(xb, GT + 1, xe, GB - 1);
	}

	for(i = 1; i < YGridTicks; i ++) 
	{
		yb = ye = GT + (int)(1.0 * i * (GB-GT) / YGridTicks);
		DrawLine(GL + 1, yb, GR - 1, ye);
	}

	::SelectObject(m_hDC, hOldPen);
	::DeleteObject(hPen);
}

void CRealTime::DrawRealTimeLines()
{
	int n = m_LineArray.GetSize();
	if (m_bLegendShadow)
		DrawShadow(n);

	for(int i = 0; i < n; i ++)
	{
		m_pCurLine = &m_LineArray[i];
		DrawCurrentLine();
		if (m_bEnableLegend)
		{
			m_CurPen = ::CreatePen(m_pCurLine->m_nLineStyle, m_pCurLine->m_nLineWidth, m_pCurLine->m_nColor);
			m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
			CGraphics::Legend(m_pCurLine->m_nColor, i + 1, m_pCurLine->m_sName.GetChar());
			::SelectObject(m_hDC, m_OldPen);
			::DeleteObject(m_CurPen);
		}
	}

	DrawTickLine();
}

void CRealTime::DrawCurrentLine()
{
	if (m_nEnd < 2)
		return;

	m_CurPen = ::CreatePen(m_pCurLine->m_nLineStyle, m_pCurLine->m_nLineWidth, m_pCurLine->m_nColor);
	m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);

	m_nP = 0;
	DWORD nB, nE;

	if (m_bAutoScrollX)
	{
		nB = m_nBegin;
		nE = m_nEnd;

		// forward drawing: something like "*******------" 
		// or "------******------", or "------******"
		if (nB == 0 && nE <= m_TimeToDraw)
		{
			m_nTimeStart = nB;
			ForwardDraw(nB, nE);
		}
		else if (nB == 0 && nE > m_TimeToDraw)
		{
			nB = nE - m_TimeToDraw;
			m_nTimeStart = nB;
			ForwardDraw(nB, nE);
		}
		else if (nB >= m_TimeToDraw)
		{
			m_nTimeStart = nB - m_TimeToDraw;
			ForwardDraw(nB - m_TimeToDraw, nB);
		}
		// backward drawing: something like "******--------******"
		else
		{
			m_nTimeStart = nE - m_TimeToDraw + nB;
			BackwardDraw(nB, nE);
		}
	}
	else
	{
		nB = m_nFrom;
		nE = m_nTo + 1;
		if (nB <= m_nDataPerLine - m_TimeToDraw)
		{
			ForwardDraw(nB, nE);
		}
		else
		{
			ForwardDraw(nB, m_nDataPerLine);
			ForwardDraw(0, nE);
		}
	}

	if(m_nP > 1)
		::Polyline(m_hDC, m_pLineArray, m_nP);

	::SelectObject(m_hDC, m_OldPen);
	::DeleteObject(m_CurPen);
}

int CRealTime::ForwardDraw(int nB, int nE)
{
	for(int i = nB; i < nE; i ++)
	{
		if (m_pCurLine->m_pValues[i].bFlag)
		{
			m_Pt.x = (int)(GL + ((m_pValueTime[i] - m_Scale.xmin) / m_Scale.dx));
			m_Pt.y = (int)(GB - ((m_pCurLine->m_pValues[i].YValue - m_Scale.ymin) / m_Scale.dy));
			if(m_Pt.x >= GL && m_Pt.x <= GR)
			{
				assert(m_nP<m_nDataPerLine);
				m_pLineArray[m_nP].x = m_Pt.x;
				m_pLineArray[m_nP].y = m_Pt.y;
				m_nP++;
			}
			else // something wrong
				assert(false);
		}
	}

	return m_nP;
}

int CRealTime::BackwardDraw(int nB, int nE)
{
	//-----------------------------******
	ForwardDraw(nE - m_TimeToDraw + nB, nE);	
	nE = nB;
	nB = 0;
	//******-----------------------------
	ForwardDraw(nB, nE);

	return m_nP;
}

void CRealTime::UpdateTimeRange(DWORD& vtime)
{
	if ((int)m_nCyclesPerSec == 0)
		m_nTimes += (int)(0.5 + 1 / m_nCyclesPerSec);
	else
	{
		if (m_nCounter == (int)m_nCyclesPerSec)
		{
			m_nTimes ++;
			m_nCounter = 1;
		}
		else
			m_nCounter ++;
	}

	if (m_nEnd == m_nDataPerLine)
	{
		if (m_nBegin == m_nDataPerLine)	m_nBegin = 0;
		m_pValueTime[m_nBegin++] = vtime;
	}
	else
		m_pValueTime[m_nEnd++] = vtime;

	if (vtime > (DWORD)m_Scale.xmax)
	{
		DWORD span	 = (DWORD)(m_Scale.xmax - m_Scale.xmin);
		m_nMin = vtime - span; 
		m_nMax = vtime;
	}

	if(m_bAutoScrollX)
		SetTimeRange(m_nMin, m_nMax);
	else
	{
		m_nFrom ++; 
		m_nTo ++;

		if (m_nFrom == m_nDataPerLine)
			m_nFrom = 0;
		if (m_nTo == m_nDataPerLine)
			m_nTo = 0;
		
		SetTimeRange(m_pValueTime[m_nFrom], m_pValueTime[m_nTo]);
	}
}

DWORD CRealTime::GetCursorTime()
{
	DWORD time;
	if (m_bAutoScrollX)
	{
		if (m_nEnd < (int)m_TimeToDraw) 
		{
			time = m_pValueTime[m_nTick];
		}
		else if (m_nEnd < m_nDataPerLine)
		{
			time = m_pValueTime[m_nEnd - m_TimeToDraw + m_nTick];
		}
		else
		{
			int tv = m_nDataPerLine - m_nSTicks + m_nBegin + m_nTick - 1;
			tv %= m_nDataPerLine;
			time = m_pValueTime[tv];
		}
	}
	else
	{
		int tv = m_nFrom % m_nDataPerLine;
		tv += m_nTick;
		tv %= m_nDataPerLine;
		time = m_pValueTime[tv];
	}

	return time;
}

int CRealTime::GetCursorTimeAndIndex(DWORD& time)
{
	int Index;
	if (m_bAutoScrollX)
	{
		
		if (m_nEnd < (int)m_TimeToDraw) 
		{
			Index = m_nTick;
			time  = m_pValueTime[Index];
		}
		else if (m_nEnd < m_nDataPerLine)
		{
			Index = m_nEnd - m_TimeToDraw + m_nTick;
			time = m_pValueTime[Index];
		}
		else
		{
			int tv = m_nDataPerLine - m_nSTicks + m_nBegin + m_nTick - 1;
			tv %= m_nDataPerLine;
			Index = tv;
			time = m_pValueTime[Index];
		}
	}
	else
	{
		int tv = m_nFrom % m_nDataPerLine;
		tv += m_nTick;
		tv %= m_nDataPerLine;
		Index = tv;
		time = m_pValueTime[Index];
	}

	return Index;
}

void CRealTime::Redraw(HWND hWnd)
{
	RECT rt;
	rt.left   = GL;
	rt.top    = GT - 1;
	rt.right  = GR;
	rt.bottom = m_Rect.bottom - 1;
	::InvalidateRect(hWnd, &rt, FALSE);
}

void CRealTime::DrawTickLine()
{
	POINT pt;
	if (m_nEnd < (int)m_TimeToDraw)
	{
		if (m_nTick == 0) return;
		else if (!m_bIsForwardDrawing)
			pt.x = GR - 1;
		else
			pt.x = GL + PX * (m_nTick - 1) / (m_TimeToDraw - 1);
	}
	else
		pt.x = GL + PX * m_nTick / (m_TimeToDraw - 1);

	if (pt.x == GL)
		pt.x ++;
	if (pt.x == GR)
		pt.x --;

	pt.y = GT + 1;

	m_CurPen = ::CreatePen(PS_SOLID, m_wdTickLine, RGB(0, 0, 0));
	m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
	::MoveToEx(m_hDC, pt.x + 1, pt.y, NULL);
	pt.y = GB - 1;
	::LineTo(m_hDC, pt.x + 1, pt.y);
	::SelectObject(m_hDC, m_OldPen);
	::DeleteObject(m_CurPen);

	m_CurPen = ::CreatePen(PS_SOLID, m_wdTickLine, m_crTickLine);
	m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
	::MoveToEx(m_hDC, pt.x, pt.y, NULL);
	pt.y = GT + 1;
	::LineTo(m_hDC, pt.x, pt.y);
	::SelectObject(m_hDC, m_OldPen);
	::DeleteObject(m_CurPen);

}

void CRealTime::SetPrintTime(DWORD time, int flag)
{
	if (flag == MaxTime)
		m_nMaxTime = time / 1000;
	else
		m_nCursorTime = time / 1000;
}

void CRealTime::PrintTime()
{
	int n = 5;
	if (m_bPrinting)	n *= m_nPrintScale;
	n = m_Rect.bottom - n - 1;
	SetStringAlign(LEFT, BOTTOM);
	ShowTime(GL, n, "Cursor time", m_nCursorTime);
	SetStringAlign(RIGHT, BOTTOM);
	ShowTime(GR, n, "Total lapse time", m_nMaxTime);
}

void CRealTime::ShowTime(int x, int y, const char* Tag, DWORD& cTime)
{
	if (m_nCyclesPerSec > 0.9999 && m_nCyclesPerSec < 1.0001)
		sprintf(m_sTempStr, "%s (%d:%d:%d)", Tag, 
				cTime / 3600, (cTime / 60) % 60, cTime % 60);
	else
		sprintf(m_sTempStr, "%s (%d:%d:%d / %d:%d:%d)", Tag,
			    ((DWORD)(m_nCyclesPerSec * cTime)) / 3600, 
				(((DWORD)(m_nCyclesPerSec * cTime)) / 60) % 60, 
				((DWORD)(m_nCyclesPerSec * cTime)) % 60, 
				cTime / 3600, (cTime / 60) % 60, cTime % 60);
	PrintString(x, y, 0, m_sTempStr);	
}