mô phỏng màn hình hiển thị của hệ thống Radar xung và các phương pháp hiển thị mục tiêu

LỜI MỞ ĐẦU
Radar là tiếng viết tắt của tiếng Anh “Radio Dectection and Ranging” có nghĩa là
phương tiện dùng sóng vô tuyến điện để phát hiện và xác định vị trí mục tiêu. Tên
này do Hải quân Mỹ đặt tra trong đại chiến thứ hai, tuy chưa đủ nghĩa nhưng cũng
trở nên thông dụng trên thế giới.
Radar là một trong những thành tựu khoa học kỹ thuật vĩ đại nhất trong thời đại
ngày nay. Trong các loại vũ khí, khí tài công nghệ cao thì Radar là một trong các
khí tài có nhiều ứng dụng đặc biệt. Radar có khả năng phát hiện ra mục tiêu ở cự ly
rất xa trong bất kỳ điều kiện nào, tính toán được tốc độ, hướng bay và các đặc điểm
của mục tiêu để chỉ thị cho các đơn vị hỏa lực có thể bám sát và tiêu diệt mục tiêu.
Sau chiến tranh, kỹ thuật tên lửa và vũ khí tiến công hàng không ngày càng phát
triển thì vai trờ của Radar ngày càng trở nên quan trọng. Radar phòng không là lực
lượng đảm bảo chủ yếu tin tức về máy bay địch trong đội hình chiến đấu của quân
chủng – phòng không có mặt trên khắp các chiến trường, phục vụ các chiến dịch,
cùng lực lượng phòng không đánh thắng cuộc chiến tranh bằng không quân của đế
quốc Mỹ.
Trong cuộc chiến tranh vùng Vịnh, bằng vũ khí công nghệ cao với thử đoạn tác
chiến diện tử, Mỹ và liên quân đã vô hiệu hóa hệ thống Radar phòng không của
Irắc từ đó làm rối loạn hệ thống chỉ huy, làm mất hiệu lực hệ thống phòng không
của Irắc khiến cho Irắc phải chịu thất bại mặc dù Irắc có trong tay một lực lượng
quân sự khổng lồ.
Áp dụng vào mục đích hòa bình của Radar lại càng tỏ rõ tính ưư việt của nó, Nhờ
Radar mà việc diều khiển các con tàu vũ trụ thật dễ dàng và chính xác. Trong lĩnh
vực khí tượng thủy văn, Radar giúp cho việc dự báo thời tiết được chính xác và
thuận lợi…
Radar có thể phát hiện được sự bất thường của khí quyển xa hàng trăm Km., giúp
máy bay, tàu bè có thể phòng tránh an toàn. Nhờ có Radar mà máy bay có thể hạ
1
cánh và cất cánh trong bất kỳ trường hợp thời tiết nào. Các tàu biển đi lại được an
toàn, tránh được sự va chạm với các tàu bè khác, trành khỏi đâm vào các núi băng
trôi.

Radar được ứng dụng rất niều ngành kỹ thuật và đời sống. Do vậy việc nghiên cứu,
phát triển Radar đều được các nước trên thế giới quan tâm chú trọng.
Trong bài tập này, em mô phỏng màn hình hiển thị của hệ thống Radar xung và các
phương pháp hiển thị mục tiêu. Do hạn chế về mặt kiến thức và thời gian nên
chương trình còn nhiều thiếu sót, em mong thầy và các bạn đóng gớp ý kiến để bài
tập ngày càng hoàn thiện.
I. GIỚI THIỆU CHUNG
1. Những vấn đề chung về Radar
- Radar là thiết bị đảm bảo nhận những tin tức về những mục tiêu nhờ thu
và phân tích sóng vô tuyến.
- Mục tiêu có thể là:
 Loại khí động lực: máy bay, tên lửa có cánh…
 Loại vượt đại châu và vũ trụ: đầu đạn hạt nhân, vệ tinh…
 Mục tiêu trên mặt đất, trên mặt nước và mục tiêu có nguồn gốc
thiên nhiên.
- Quá trình nhận biết tin tức Radar trong nhiều trường hợp có thể chia
thành các bước sau:
 Phát hiện mục tiêu: là quyết đoán có hay không có mục tiêu trong
một vùng không gian với xác suất quyết đoán sai nào đó cho phép.
 Đo tọa độ và các tham số chuyển động với một sai số cho phép nào
đó.
 Phân biệt là bái toán phát hiện và đo đạc các tham số của mục tiêu
khi gần mục tiêu này còn có những mục tiêu khác.
2
 Nhận biết: đài Radar sẽ xác định mục tiêu thuộc loại nào, của ai,
bay đi đâu, trên đường bay nào do đó trên mục tiêu phải gắn
transponder. Bước này chỉ có ở Radar thứ cấp.
- Các thiết bị Radar phải có khả năng chống nhiễu cao đối với nhiễu thiên
nhiên và nhiễu nhân tạo. Khả năng chống nhiễu là khả năng của đài
Radar đảm bảo được các chỉ tiêu chất lượng, phát hiện, đo lường ở một

mức độ đã cho khi có nhiễu, đó cũng chính là khả năng sử dụng nguồn
nhiễu làm tin tức Radar.
- Sóng Radar có thể là sóng siêu âm dùng để phát hiện mục tiêu dưới nước.
Thông thường sóng Radar là sóng điện từ có bước sóng từ 1mm đến
100km. Các sóng ở dải mm, cm, m có vai trò quan trọng nhất.Hiện nay
các sóng điện từ ngắn hơn: sóng hồng ngoại, sóng ánh sang cũng được sử
dụng trong Radar.
2. Nguyên tắc nhận tin tức Radar
- Những tin tức về mục tiêu mang trong tín hiệu Radar là những dao động
điện từ có các tham số liên hệ chặt chẽ với các tham số của mục tiêu.
- Phương pháp nhận tin tửc Radar thông thường nhất là phương pháp
Radar chủ động. Radar này chiếu xạ mục tiêu nhờ năng lượng điện tử và
sóng phản xạ bởi mục tiêu bằng thiết bị thu. Phản xạ sóng xảy ra ở giới
hạn hai môi trường có các tính chất điện từ và từ khác nhau. Chú ý những
dao động điện từ chiếu xạ mục tiêu vẫn chưa phải là tín hiệu Radar vì
chúng không chứa đựng những tin tức về mục tiêu
- Khi cần nhận biết mục tiêu, tín hiệu Radar được tạo nên bằng phương
pháp hỏi đáp chủ động. Trong trường hợp này năng lượng điện từ chiếu
xạ mục tiêu làm cho máy trả lời trên mục tiêu phát ra những tín hiệu vô
tuyến hoàn toàn xác định, những tín hiệu này được nhận bởi máy thu của
đài Radar.
3
- Khi phát hiện và đo lường các tham số của mục tiêu chúng ta sử dụng
những tính chất vật lý của sóng vô tuyến:
 Sóng điện từ trong môi trường đồng nhất và đăng hướng thì truyền
thẳng.
 Sóng điện từ truyền với tốc độ trung bình bằng vận tốc ánh sang
trong môi truờng khí quyển và trong chân không.
 Khi sóng điện từ truyền lan trên môi trường đồng nhất nếu gặp
phải môi trường thứ hai không đồng nhất với môi trường thứ nhất

(không cùng chiết suất) thì xảy ra hiện tượng tán xạ sóng điện từ.
Hiện tượng tán xạ xảy ra ở xung quanh môi trường thứ hai hay ở
biên giới giữa hai môi trường, chỉ có một phần phản xạ về nguồn
phát xạ. Tia này cùng phương ngược chiều với tia chiếu xạ giúp
cho hệ thống phát hiện được mục tiêu, là đối tượng hay mục tiêu
cần định vị.
 Khi sóng điện từ chiếu xạ vào mục tiêu đang chuyển động với một
tần số nào đó gọi là tần số chiếu xạ thì năng lượng phản xạ về là tín
hiệu phản xạ có tần số sai khác so với tần số chiếu xạ.
f(chieuxa) ± f(doppler) = f(chieuxa) ± ∆f = f(phanxa)
Dấu “+” khi mục tiêu tiến dần về phía nguồn chiếu xạ.
Dấu “ - ” khi mục tiêu đi xa nguồn chiếu xạ.
∆f phụ thuộc vận tốc xuyên tâm do đó xác định được ∆f ta xác định
được vận tốc xuyên tâm. Hiệu ứng này gọi là hiệu ứng Doppler.
3. Tính năng chiến đấu và kỹ thuật của Radar:
3.1. Tính năng kỹ thuật:
- Vùng quan sát: Radar có nhiệm vụ quan sát mục tiêu trong phạm vi này.
Vùng quan sát giới hạn bởi cự ly cực đại Dmax và cực tiểu Dmin và các
góc quan sát trong mặt phẳng ngang và đứng.
4
- Chu kỳ quét Tq: là thời gian để Radar quét hết vùng quan sát một lần.
- Các tọa độ được đo.
- Độ chính xác đo các tọa độ và tốc độ mục tiêu.
- Độ tin cậy sử dụng: độ tin cậy nêu lên khả năng hoàn thành chức năng
của đài trong một khoảng thời gian xác định. Thông thường độ tin cậy
được biểu thị bởi xác suất đài làm việc trong một khoảng thời gian đã
cho.
- Khả năng chống nhiễu: là khả năng duy trì được các chỉ tiêu kỹ thuật của
đài Radar trong điều khiển có nhiễu tác động.
- Về tính năng chiến thuật đôi khi người ta còn kể them những điều kiện

làm việc của đài: tính chất của mục tiêu, điều kiện thời tiết, vị trí triển
khai
- Các tính năng chiến thuật của đài radar xác định bởi tính năng kỹ thuật
của nó.
3.2. Tính năng chiến đấu
- Nguyên tắc xây dựng đài Radar: phương pháp nhận tín hiệu Radar, dạng
dao động bức xạ, phương pháp gia công tín hiệu trong máy thu.
- Tần số sóng mang của dao động bức xạ hay bước sóng λ.
- Quy luật điều chế dao động bức xạ.
- Công suất bức xạ trung bình Ptb và công suất đỉnh Pd.
- Dạng và độ rộng của giản đồ anten.
- Độ nhạy của máy thu theo công suất Ptmin hay năng lượng.
II. BÀI TẬP
1. Yêu cầu của đề bài:
- Hiển thị được 6 mục tiêu cùng một lúc bằng 6 màu khác nhau.
- Để lại dấu vết của quỹ đạo mục tiêu.
- Radar chủ động sơ cấp quét tròn( toàn phương).
5
- Tự động bám sát một mục tiêu bất kỳ nào đó (bám theo góc phương vị).
- Có giới hạn Dmax, Dmin.
- Khi có va chạm 2 mục tiêu cùng bị phá hủy, biến mất trên màn hình.
- Lần lượt mô phỏng trên 4 trang màn hình
 Hiển thị nhìn vòng.
 Hiển thị cự ly D bằng cách quét tia điện tử đường thẳng( giống oxilo).
 Hiển thị cự ly D bằng cách quét tia điện tử vòng tròn.
 Hiển thị cự ly D bằng cách quét tia điện tử xoắn ốc.
Phải thể hiện được độ chính xác theo mức độ tăng dần.
- Radar tự động đảo chiều quét cánh sóng.
2. Lưu đồ thực hiện:
3. Viết chương trình bằng đồ họa VC:

6
// Muctieu.h: interface for the CMuctieu class.
//
//////////////////////////////////////////////////////////////////////
….
….
class CMuctieu
{
public:
double GetGoc();
double GetCuly();
CMuctieu();
void Setx(double xx){x=xx;}
void Sety(double yy){y=yy;}
void Seth(double hh){h=hh;}
double Getx(){return x;}
double Gety(){return y;}
double Geth(){return h;}
virtual ~CMuctieu();
private:
double h;
double y;
double x;
};
// Muctieu.cpp: implementation of the CMuctieu class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "DialogRN.h"
#include "Muctieu.h"

#include "math.h"
…
…
CMuctieu::CMuctieu()
{
}
CMuctieu::~CMuctieu()
7
{
}
double CMuctieu::GetCuly()
{
return (sqrt(pow(x,2)+pow(y,2)));
}
double CMuctieu::GetGoc()
{ int i;
double a;
if ((x>=0)&&(y>=0))
{i=0;}
else
{
if ((x>=00)&&(y<0))
{i=1;}
else
{ if ((x<=0)&&(y<0))
{i=2;}
else
i=3;
}
}

switch(i)
{ case 0:
a=(double)(atan2(x,y)/0.017453292);
break;
case 1:
a=(double)(90+atan2((-y),x)/0.017453292);
break;
case 2:
a=(double)(360+atan2(x,y)/0.017453292);
break;
case 3:
8
a=(double)(360-atan2((-x),y)/0.017453292);
break;
}
return a;
}
//////////////////////////////**************************************************
*/////////////////////////////
//////////////////////////////**************************************************
*/////////////////////////////
// DialogRNDlg.h : header file
//
#include "Muctieu.h"
….
….
class CDialogRNDlg : public CDialog
{
// Construction
public:

….
….
CString m_Culy1;
CString m_Culy2;
CString m_Culy3;
CString m_Culy4;
CString m_Culy5;
CString m_Culy6;
CString m_Docao1;
CString m_Docao2;
CString m_Docao3;
CString m_Docao4;
CString m_Docao5;
CString m_Docao6;
CString m_Gpv1;
CString m_Gpv2;
CString m_Gpv3;
CString m_Gpv4;
CString m_Gpv5;
CString m_Gpv6;
9
CString m_Vantoc1;
CString m_Vantoc2;
CString m_Vantoc3;
CString m_Vantoc4;
CString m_Vantoc5;
CString m_Vantoc6;
// Implementation
int pPart1;
int pPart;

int pEnd;
int pStart;
BOOL m_sel;
BOOL logic_F7;
BOOL logic_F6;
BOOL logic_F5;
BOOL logic_F4;
BOOL logic_F3;
BOOL logic_F2;
BOOL logicC;
int c;
BOOL logicB;
BOOL logicA;
int a;
int d;
int rectDisB;
int rectDisR;
int rectDisT;
int rectDisL;
int PosMuctieuF;
double m_HeightF;
int m_sendF;
CMuctieu MuctieuF[100];
int PosMuctieuE;
double m_HeightE;
int m_sendE;
CMuctieu MuctieuE[100];
10
int PosMuctieuA;
double m_HeightA;

int m_sendA;
CMuctieu MuctieuA[100];
int PosMuctieuB;
double m_HeightB;
int m_sendB;
CMuctieu MuctieuB[100];
int PosMuctieuC;
double m_HeightC;
int m_sendC;
CMuctieu MuctieuC[100];
int PosMuctieuD;
double m_HeightD;
int m_sendD;
CMuctieu MuctieuD[100];
int rectB;
int rectR;
int rectT;
int rectL;
private:
int m_nMinute;
POINT nPoint[2];
CBitmap m_pBitmap;
CDC m_pdcMemory;
// DialogRNDlg.cpp : implementation file
//
#include "stdafx.h"
#include "DialogRN.h"
#include "DialogRNDlg.h"
#include "Math.h"
#include "Muctieu.h"

…
11
BOOL CDialogRNDlg::OnInitDialog()
{
CDialog::OnInitDialog();
…
…
// TODO: Add extra initialization here
GetDlgItem(IDC_BQUETTHANG)->EnableWindow(FALSE);
GetDlgItem(IDC_ALL)->EnableWindow(FALSE);
logic_F2=FALSE;
logic_F3=FALSE;
logic_F4=FALSE;
logic_F5=FALSE;
logic_F6=FALSE;
logic_F7=FALSE;
pPart1=1;
pPart=1;
logicC=FALSE;
logicB=FALSE;
logicA=TRUE;
m_HeightF=100;
m_sendF=-1;
PosMuctieuF=134;
m_HeightE=56.83;
m_sendE=-1;
PosMuctieuE=104;
m_HeightD=12.22;
m_sendD=-1;

PosMuctieuD=75;
m_HeightC=105.32;
m_sendC=-1;
PosMuctieuC=51;
m_HeightB=34.56;
m_sendB=-1;
PosMuctieuB=3;
12
m_HeightA=60;
m_sendA=-1;
PosMuctieuA=12;
m_nMinute=0;
CWnd*pWnd=GetDlgItem(IDC_START);
CRect rect;
CRect rectW;
pWnd->GetClientRect(rect);
pWnd->GetWindowRect(rectW);
rectL=rectW.left;
rectT=rectW.top-18;
rectR=rectW.Width();
rectB=rectW.Height();
///////////////////////////
CWnd*pDis=GetDlgItem(IDC_DISPLAY);
CRect rectDis;
pDis->GetWindowRect(rectDis);
rectDisL=rectDis.left;
rectDisT=rectDis.top-18;
rectDisR=rectDis.Width();
d=rectDis.Width()/14;
a=d+2;

c=d+4;
rectDisB=rectDis.Height();
////////////////////////////
CRect rectWin;
GetClientRect(rectWin);
int n=rect.Width()/12;
int r=rect.Width()/2-n;
nPoint[0].x=rect.Width()/2;
nPoint[0].y=rect.Width()/2;
nPoint[1].x=rect.Width()/2;
nPoint[1].y=n;
CClientDC dc(this);
m_pdcMemory.CreateCompatibleDC(&dc);
m_pBitmap.CreateCompatibleBitmap(&dc,rectWin.Width(),rectWin.Height());
SetTimer(1,50,NULL);
13
return TRUE; // return TRUE unless you set the focus to a control
}
void CDialogRNDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}

// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CDialogRNDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM)
dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
14
}
else
{
CPaintDC dc(this);
CRect rectUpdate;
dc.GetClipBox(&rectUpdate);
CBitmap*p0ldBitmap=m_pdcMemory.SelectObject(&m_pBitmap);
m_pdcMemory.SelectClipRgn(NULL);
m_pdcMemory.IntersectClipRect(&rectUpdate);
CBrush BackgroundBrush(RGB(192,192,192));

CBrush*p0ldBrush=m_pdcMemory.SelectObject(&BackgroundBrush);
m_pdcMemory.PatBlt(rectUpdate.left,rectUpdate.top,rectUpdate.Width(),re
ctUpdate.Height(),PATCOPY);
OnDraw(&m_pdcMemory);
dc.BitBlt(rectUpdate.left,rectUpdate.top,rectUpdate.Width(),rectUpdate.Height(),
&m_pdcMemory,rectUpdate.left,rectUpdate.top,SRCCOPY);
m_pdcMemory.SelectObject(p0ldBitmap);
m_pdcMemory.SelectObject(p0ldBrush);
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
void CDialogRNDlg::OnDraw(CDC *pDC)
{
CBrush lBrush1(RGB(255,0,0));
CBrush*p0ldBrush1=pDC->SelectObject(&lBrush1);
pDC->Rectangle(25,330,45,350);
//////////////////////
CBrush lBrush2(RGB(0,255,255));
CBrush*p0ldBrush2=pDC->SelectObject(&lBrush2);
pDC->Rectangle(25,355,45,375);
///////////////////////////
CBrush lBrush3(RGB(255,0,255));
CBrush*p0ldBrush3=pDC->SelectObject(&lBrush3);
pDC->Rectangle(25,380,45,400);
15
///////////////
CBrush lBrush4(RGB(255,255,0));
CBrush*p0ldBrush4=pDC->SelectObject(&lBrush4);
pDC->Rectangle(25,405,45,425);

////////////////////////
CBrush lBrush5(RGB(255,128,0));
CBrush*p0ldBrush5=pDC->SelectObject(&lBrush5);
pDC->Rectangle(25,430,45,450);
////////////////////////
CBrush lBrush6(RGB(255,255,255));
CBrush*p0ldBrush6=pDC->SelectObject(&lBrush6);
pDC->Rectangle(25,455,45,475);
/////////////////////
/////quet thang///
if (logicA)
{ pDC->Ellipse(rectDisL+d,rectDisT+d,rectDisL+rectDisR-
d,rectDisT+rectDisB-d);
}
///////ket thuc quet thang///
CBrush lBrush(RGB(0,0,0));
CBrush*p0ldBrush=pDC->SelectObject(&lBrush);
CRect rectE1;
CWnd*pWnd=GetDlgItem(IDC_START);
pWnd->GetClientRect(rectE1);
pDC->Rectangle(rectL,rectT-7,rectR+7,rectB+8);
//////////
///////quet tron va xoan///////
if (logicC)
{pDC->Ellipse(rectDisL+c/2+5,rectDisT+c/2,rectDisL+rectDisR-
c/2,rectDisT+rectDisB-c/2-5);
pDC->Rectangle(345,318,617,368);
}
if (logicB)
{

pDC->Rectangle(345,318,617,368);
}
//////////////ket thang quet tron///
16
/////quet thang////
if (logicA)
{pDC->Ellipse(rectDisL+a,rectDisT+a,rectDisL+rectDisR-
a,rectDisT+rectDisB-a);
pDC->Rectangle(345,318,617,368);
}
////ket thang quet thang///
CPen lSolidPen(PS_SOLID,1,RGB(0,255,0));
CPen*p0ldPen=pDC->SelectObject(&lSolidPen);
int nH=rectE1.Width()/12;
double r=(double)(rectE1.Width()/2-nH);
for (int j=1;j<6;j++)
{pDC->Ellipse(CRect(j*nH,j*nH,rectE1.Width()-j*nH,rectE1.Width()-
j*nH));
}
pDC->MoveTo(rectE1.Width()/2,nH);
pDC->LineTo(rectE1.Width()/2,rectE1.Width()-nH);
pDC->MoveTo(nH,rectE1.Width()/2);
pDC->LineTo(rectE1.Width()-nH,rectE1.Width()/2);
/////////////////quetxoan///////
if (logicC)
{ pDC->MoveTo(rectDisL+148,rectDisT+13);
pDC->LineTo(rectDisL+148,rectDisT+268);
pDC->MoveTo(rectDisL+19,rectDisT+148);
pDC->LineTo(rectDisL+281,rectDisT+148);
int source_x,source_y,des_x,des_y;

double part;
source_x=source_y=0;
for(int k=0;k<=2512;k++)
{ part=0.01*k;
des_x=(int)(part*cos(part)*5);
des_y=(int)(part*sin(part)*5);
pDC->MoveTo(source_x+rectDisL+148,source_y+rectDisT+148);
pDC->LineTo(des_x+rectDisL+148,des_y+rectDisT+148);
source_x=des_x;
source_y=des_y;
17
}
}
///////////ket thuc quet xoan////
/////quet tron//////
if (logicB)
{ pDC-
>Ellipse(rectDisL+28,rectDisT+28,rectDisL+28+240,rectDisT+28+240);
pDC->Ellipse(rectDisL+78,rectDisT+78,rectDisL+218,rectDisT+218);
}
/////ket thuc quet tron///
/////quet thang////
if (logicA)
{ pDC->MoveTo(rectDisL+50,rectDisT+130);
pDC->LineTo(rectDisL+250,rectDisT+130);
pDC->MoveTo(rectDisL+50,rectDisT+200);
pDC->LineTo(rectDisL+250,rectDisT+200);
pDC->MoveTo(rectDisL+50,rectDisT+130);
pDC->LineTo(rectDisL+50,rectDisT+80);
pDC->MoveTo(rectDisL+50,rectDisT+200);

pDC->LineTo(rectDisL+50,rectDisT+160);
}
/////ket thuc quet thang///
///////////////////////
////Ve muc tieu A/////
CPen lSolidPenA(PS_SOLID,1,RGB(255,0,0));
CPen*p0ldPenA=pDC->SelectObject(&lSolidPenA);
CBrush ABrush(RGB(255,0,0));
CBrush*p0ldABrush=pDC->SelectObject(&ABrush);
if ((logic_F2)||(!logic_F2&&!logic_F3&&!logic_F4&&!logic_F5&&!
logic_F6&&!logic_F7))
{ if (m_sendA>=0)
{
/////quet xoan////
if (logicC)
18
{
int x1,y1;
double rem=MuctieuA[m_sendA].GetCuly();
x1=(int)((rem*25.12)*cos(rem*25.12)*5);
y1=(int)((rem*25.12)*sin(rem*25.12)*5);
pDC->Rectangle((rectDisL+148+x1-3),(rectDisT+148+y1-3),
(rectDisL+148+x1+3),(rectDisT+148+y1+3));
}
//////ket thuc quet xoan/////
////quet tron////
if (logicB)
{
int x1,y1,x2,y2;
double rem;

double mod;
rem=modf((MuctieuA[m_sendA].GetCuly())*200,&mod);
rem=rem*10;
rem=rem*360/10;
mod=mod*360/200;
x1=rectDisL+148+(int)(120*sin(mod*0.017453292));
y1=rectDisT+148-(int)(120*cos(mod*0.017453292));
pDC->Rectangle((x1-3),(y1-3),(x1+3),(y1+3));
x2=rectDisL+148+(int)(70*sin(rem*0.017453292));
y2=rectDisT+148-(int)(70*cos(rem*0.017453292));
pDC->Rectangle((x2-3),(y2-3),(x2+3),(y2+3));
}
/////ket thuc quet tron////
///quet thang//////
if (logicA)
{ double rem;
double mod;
rem=modf((MuctieuA[m_sendA].GetCuly())*200,&mod);
rem=rem*10;
pDC->Rectangle((rectDisL+48+(int)(mod)),(rectDisT+124),
(rectDisL+52+(int)(mod)),(rectDisT+136));
19
pDC->Rectangle((rectDisL+48+(int)(rem*20)),(rectDisT+194),
(rectDisL+52+(int)(rem*20)),(rectDisT+206));
}
//////ket thuc quet thang////
for(int i=0;i<=m_sendA;i++)
{
pDC->Rectangle((rectE1.Width()/2+(int)(MuctieuA[i].Getx()*r)-1),
(rectE1.Width()/2-(int)(MuctieuA[i].Gety()*r)-1),(rectE1.Width()/2+(int)

(MuctieuA[i].Getx()*r)+1),(rectE1.Width()/2-(int)(MuctieuA[i].Gety()*r)+1));
}
}
}
////////////ket thuc ve muc tieu A////
/////////////////////////////////////////////////
/////////Ve muc tieu B//////////
CPen lSolidPenB(PS_SOLID,1,RGB(0,255,255));
CPen*p0ldPenB=pDC->SelectObject(&lSolidPenB);
CBrush BBrush(RGB(0,255,255));
CBrush*p0ldBBrush=pDC->SelectObject(&BBrush);
if ((logic_F3)||(!logic_F2&&!logic_F3&&!logic_F4&&!logic_F5&&!
logic_F6&&!logic_F7))
{ if (m_sendB>=0)
{
/////quet xoan////
if (logicC)
{
int x1,y1;
double rem=MuctieuB[m_sendB].GetCuly();
x1=(int)((rem*25.12)*cos(rem*25.12)*5);
y1=(int)((rem*25.12)*sin(rem*25.12)*5);
pDC->Rectangle((rectDisL+148+x1-3),(rectDisT+148+y1-3),
(rectDisL+148+x1+3),(rectDisT+148+y1+3));
}
//////ket thuc quet xoan/////
////quet tron////
20
if (logicB)
{

int x1,y1,x2,y2;
double rem;
double mod;
rem=modf((MuctieuB[m_sendB].GetCuly())*200,&mod);
rem=rem*10;
rem=rem*360/10;
mod=mod*360/200;
x1=rectDisL+148+(int)(120*sin(mod*0.017453292));
y1=rectDisT+148-(int)(120*cos(mod*0.017453292));
pDC->Rectangle((x1-3),(y1-3),(x1+3),(y1+3));
x2=rectDisL+148+(int)(70*sin(rem*0.017453292));
y2=rectDisT+148-(int)(70*cos(rem*0.017453292));
pDC->Rectangle((x2-3),(y2-3),(x2+3),(y2+3));
}
/////ket thuc quet tron////
///quet thang//////
if (logicA)
{ double rem;
double mod;
rem=modf((MuctieuB[m_sendB].GetCuly())*200,&mod);
rem=rem*10;
pDC->Rectangle((rectDisL+48+(int)(mod)),(rectDisT+124),
(rectDisL+52+(int)(mod)),(rectDisT+136));
pDC->Rectangle((rectDisL+48+(int)(rem*20)),(rectDisT+194),
(rectDisL+52+(int)(rem*20)),(rectDisT+206));
}
//////ket thuc quet thang////
for(int i=0;i<=m_sendB;i++)
{
pDC->Rectangle((rectE1.Width()/2+(int)(MuctieuB[i].Getx()*r)-1),

(rectE1.Width()/2-(int)(MuctieuB[i].Gety()*r)-1), (rectE1.Width()/2+(int)
(MuctieuB[i].Getx()*r)+1), (rectE1.Width()/2-(int)(MuctieuB[i].Gety()*r)
+1));
}
}
}
21
////////////ket thuc ve muc tieu B////
////Ve muc tieu C/////
CPen lSolidPenC(PS_SOLID,1,RGB(255,0,255));
CPen*p0ldPenC=pDC->SelectObject(&lSolidPenC);
CBrush cBrush(RGB(255,0,255));
CBrush*p0ldCBrush=pDC->SelectObject(&cBrush);
if ((logic_F4)||(!logic_F2&&!logic_F3&&!logic_F4&&!logic_F5&&!
logic_F6&&!logic_F7))
{
if (m_sendC>=0)
{
/////quet xoan////
if (logicC)
{
int x1,y1;
double rem=MuctieuC[m_sendC].GetCuly();
x1=(int)((rem*25.12)*cos(rem*25.12)*5);
y1=(int)((rem*25.12)*sin(rem*25.12)*5);
pDC->Rectangle((rectDisL+148+x1-3),(rectDisT+148+y1-3),
(rectDisL+148+x1+3),(rectDisT+148+y1+3));
}
//////ket thuc quet xoan/////
////quet tron////

if (logicB)
{
int x1,y1,x2,y2;
double rem;
double mod;
rem=modf((MuctieuC[m_sendC].GetCuly())*200,&mod);
rem=rem*10;
rem=rem*360/10;
mod=mod*360/200;
x1=rectDisL+148+(int)(120*sin(mod*0.017453292));
y1=rectDisT+148-(int)(120*cos(mod*0.017453292));
pDC->Rectangle((x1-3),(y1-3),(x1+3),(y1+3));
x2=rectDisL+148+(int)(70*sin(rem*0.017453292));
y2=rectDisT+148-(int)(70*cos(rem*0.017453292));
22
pDC->Rectangle((x2-3),(y2-3),(x2+3),(y2+3));
}
/////ket thuc quet tron////
///quet thang//////
if (logicA)
{
double rem;
double mod;
rem=modf((MuctieuC[m_sendC].GetCuly())*200,&mod);
rem=rem*10;
pDC->Rectangle((rectDisL+48+(int)(mod)),(rectDisT+124),(rectDisL+52+(int)
(mod)),(rectDisT+136));
pDC->Rectangle((rectDisL+48+(int)(rem*20)),(rectDisT+194), (rectDisL+52+
(int)(rem*20)),(rectDisT+206));
}

//////ket thuc quet thang////
for(int i=0;i<=m_sendC;i++)
{
pDC->Rectangle((rectE1.Width()/2+(int)(MuctieuC[i].Getx()*r)-1),
(rectE1.Width()/2-(int)(MuctieuC[i].Gety()*r)-1), (rectE1.Width()/2+(int)
(MuctieuC[i].Getx()*r)+1),(rectE1.Width()/2-(int)(MuctieuC[i].Gety()*r)+1));
}
}
}
////////////ket thuc ve muc tieu C////
////Ve muc tieu D/////
CPen lSolidPenD(PS_SOLID,1,RGB(255,255,0));
CPen*p0ldPenD=pDC->SelectObject(&lSolidPenD);
////quet tron///
if (logicB)
{ for(int i=0;i<20;i++)
{ int x1,y1,x2,y2;
23
x1=rectDisL+(rectDisR/2)+(int)(120*sin((double)
(i*18)*0.017453292));
y1=rectDisL+(rectDisR/2)-309-(int)(120*cos((double)
(i*18)*0.017453292));
x2=rectDisL+(rectDisR/2)+(int)(115*sin((double)
(i*18)*0.017453292));
y2=rectDisL+(rectDisR/2)-309-(int)(115*cos((double)
(i*18)*0.017453292));
pDC->MoveTo(x1,y1);
pDC->LineTo(x2,y2);
}
for (i=0;i<10;i++)

{
int x1,y1,x2,y2;
x1=rectDisL+(rectDisR/2)+1+(int)(70*sin((double)
(i*36)*0.017453292));
y1=rectDisL+(rectDisR/2)-309-(int)(70*cos((double)
(i*36)*0.017453292));
x2=rectDisL+(rectDisR/2)+1+(int)(65*sin((double)
(i*36)*0.017453292));
y2=rectDisL+(rectDisR/2)-309-(int)(65*cos((double)
(i*36)*0.017453292));
pDC->MoveTo(x1,y1);
pDC->LineTo(x2,y2);
}
}
////////////ket thuc quet tron//////////
////////////////////
///////quet thang//////////
if (logicA)
{
for(int i=0;i<7;i++)
{
pDC->MoveTo(rectDisL+50+i*40,rectDisT+128);
pDC->LineTo(rectDisL+50+i*40,rectDisT+132);
}
for(i=0;i<11;i++)
24
{
pDC->MoveTo(rectDisL+50+i*20,rectDisT+198);
pDC->LineTo(rectDisL+50+i*20,rectDisT+202);
}

}
////ket thuc quet thang////
CBrush DBrush(RGB(255,255,0));
CBrush*p0ldDBrush=pDC->SelectObject(&DBrush);
if ((logic_F5)||(!logic_F2&&!logic_F3&&!logic_F4&&!logic_F5&&!
logic_F6&&!logic_F7))
{
if (m_sendD>=0)
{
////////////quet xoan/////
if(logicC)
{
int x1,y1;
double rem=MuctieuD[m_sendD].GetCuly();
x1=(int)((rem*25.12)*cos(rem*25.12)*5);
y1=(int)((rem*25.12)*sin(rem*25.12)*5);
pDC->Rectangle((rectDisL+148+x1-3),(rectDisT+148+y1-3),
(rectDisL+148+x1+3),(rectDisT+148+y1+3));
}
//////////ket thuc quet xoan//
////quet tron////
if (logicB)
{ int x1,y1,x2,y2;
double rem;
double mod;
rem=modf((MuctieuD[m_sendD].GetCuly())*200,&mod);
rem=rem*10;
rem=rem*360/10;
mod=mod*360/200;
x1=rectDisL+148+(int)(120*sin(mod*0.017453292));

y1=rectDisT+148-(int)(120*cos(mod*0.017453292));
25