Użytkownik "Roman Tyczka" <n...@b...no> napisał w wiadomości grup
dyskusyjnych:1...@t...com...
> On Fri, 30 Sep 2016 14:11:36 -0700 (PDT), g...@g...com wrote:
> Teoretycy gawędziarze nie mogą nic pokazać, bo ich siłą nie są konkrety
> tylko znokautowanie przeciwnika pozornie logicznymi argumentami. Nazwałbym
> to retoryką sofizmatyczną ;-)

Jeżeli ktoś twierdzi, że jego jeden program to 1 milionów linii kodu - to
znaczy że jest autorem i ma copyright do 1 miliona linii kodu - to powinien
umieć to udowodnić, albo pogodzić się że sceptycy, tacy jak ja, będą uważali
go za konfabulanta and/or grafomana.

Na razie nie zobaczyłem ani linijki kodu z tego miliona, nie dowiedziałem
się nawet do czego ten program służy. Ok, rozumiem tajemnicę zawodową.

Niemniej jednak coś jest nie teges, jeżeli ktoś upiera się że jego program
to 1 milion linii kodu, a potem sam przyznaje iż przez znaczny okres
pracowało nad tym programem czworo ludzi, a obecnie jest troje programistów.
Niezależnie od wszystkiego innego... jest to po prostu nieetyczne.


I jeszcze drobiazg - ktoś czegoś takiego potrzebował - nie udało mi się
wyszukać programu w Pascalu na obsługę portu szeregowego (musiałbym
przekopywać się przez 5.25 calowe dyskietki, mam pod ręką napęd 3.5 calowy),
ale z archiwum wyciągnąłem program w C++ do testowania takowej. Oczywiście:
nie wysyłam całego - jak ktoś ma pracę domową "transmisja szeregowa" - to
większego pożytku z tego mieć nie będzie, brak plików *.h, *.rh, *.rc, *.ico
itd. itp. Ale mniej-więcej można się połapać co i jak robić. Polecam też
książkę Wojtka Mielczarka "Szeregowe interfejsy cyfrowe" ISBN 83-85701-23-0,
warto przejrzeć, chyba dalej aktualna (RS232C raczej się nie zmienił),
kosztowała 9 zł 10 gr, wydana przez Hellion w 1993.




////////////////////////////////////////////////////
////////////////////////////////////////////////////
////////////////////////
//
// TESTOWANIE TRANSMISJI SZEREGOWEJ Z MIERNIKIEM METEX ILESTAM
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~
//
// Pisane latem, w lipcu 1998 roku
// slawek
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
////////////////////////

#include <owl/pch.h> // OWL Pre-Compiled Headers
#include <owl/checkbox.h> // Kazdy rodzaj kontrolek, ktory wystepuje w
programie, musi miec wlasny plik naglowkowy z deklaracja-
#include <owl/combobox.h> // mi klasy reprezentujacej takie kontrolki.
#include <owl/edit.h>
#include <owl/listbox.h>
#include <stdlib.h> // Funkcje konwersji w rodzaju atoi, itoa etc.

#include "comtest.rh" // Definicje odpowiednich stalych symbolicznych
zamiast "magicznych liczb" identyfikujacych odpowie-
// dnie elementy dialogow i innych elementow GUI
zawartych w tzw. zasobach programu (resources).


//==================================================
====================================================
========================

const char IdPortStr[][16] = { "COM1", "COM2", "COM3", "COM4" };
const char IdPortVal[] = { 1 , 2 , 3 , 4 };
const char BaudRateStr[][16] = { "110", "300", "600",
"1200", "2400", "4800", "9600",
"14400", "19200", "38400",
"56000", "128000", "256000",};
const UINT BaudRateVal[] = { CBR_110 , CBR_300 , CBR_600 ,
CBR_1200 , CBR_2400 , CBR_4800 , CBR_9600,
CBR_14400 , CBR_19200 , CBR_38400 ,
CBR_56000 , CBR_128000, CBR_256000 };
const char ByteSizeStr[][16] = { "4", "5", "6", "7", "8"};
const BYTE ByteSizeVal[] = { 4 , 5 , 6 , 7 , 8 };
const char ParityStr[][16] = { "EVENPARITY", "MARKPARITY", "NOPARITY",
"ODDPARITY"};
const BYTE ParityVal[] = { EVENPARITY , MARKPARITY , NOPARITY ,
ODDPARITY };
const char StopBitsStr[][16] = { "ONESTOPBIT", "ONE5STOPBITS",
"TWOSTOPBITS"};
const BYTE StopBitsVal[] = { ONESTOPBIT , ONE5STOPBITS ,
TWOSTOPBITS };

//==================================================
====================================================
========================

class TSelectCommDialog : public TDialog
{
public:

TSelectCommDialog(TWindow* parent, TResId resid); // Konstruktor, nieco
uproszczony (brak np. TModule).
void CmOk(); // Kiedy nacisniety
jest "Ok" ta metoda jest wywolywana.

private:

TListBox* IdPortBox;

protected:

virtual void SetupWindow(); // Wraz z metoda CmOk tworzy pare.
SetupWindow inicjalizuje odpowiednie elementy dialogu,
// natomiast CmOk odczytuje kontrolki (tj.
stany check-box'ow, teksty w okienkach edycyjnych
// itd.) i wykonuje akcje zgodne z wola
uzytkownika, wyrazona poprzez interakcje z dialogiem.
DECLARE_RESPONSE_TABLE(TSelectCommDialog);
};

// Ponizsza klasa przeznaczona jest do manipulowania _wszystkimi_
parametrami bloku DCB za pomoca odpowiedniego dialogu. Pola
// DCB okreslone jako "dummy" nie sa modyfikowalne - bo z definicji nie
wplywaja na transmisje.

class TSetupCommDialog : public TDialog
{
public:

TSetupCommDialog(TWindow* parent, TResId resid); // Konstruktor
void CmOk(); // Kiedy nacisniety
jest "Ok" ta metoda jest wywolywana. Zanim nie zostanie
// wywolana, stan portu
szeregowego nie jest zmieniany. Uwaga: stan portu
// szeregowego _jest_
zmieniany nawet wtedy, gdy uzytkownik nacisnie
// "Anuluj"! Jest to
jednak zmiana na identyczne parametry jak poprzednie,
// tj. sekwencja
GetCommState/SetCommState z tym samym DCB.
private:

TCheckBox* fBinaryBox; // Duza ilosc check-box'ow moglaby byc
zastapiona np. tablica kontrolek o kolejnych numerach
TCheckBox* fRtsDisableBox; // identyfikacyjnych. Doswiadczenie uczy
jednak, ze lepiej miec nawet az za duzo obiektow do en-
TCheckBox* fParityBox; // kapsulacji "czystych" kontrolek (i miec
mozliwosc pelnej manipulacji nimi za pomoca OWL)
TCheckBox* fOutxCtsFlowBox; // - niz czesc kontrolek (trudniejszych)
obslugiwac bezposrednio poprzez API Windows, a czesc
TCheckBox* fOutxDsrFlowBox; // poprzez OWL. W istocie takie deklaracje
duzej ilosci kontrolek robi sie latwo. Odwrotnie,
TCheckBox* fDtrDisableBox; // wlasciwe ich uzycie w programie wcale
takie mechaniczne nie jest. Uwaga: program nie ma nic
TCheckBox* fOutXBox; // wspolnego z ClassExpert'em. Nie uzywa
takze mechanizmu "transferu", albowiem mechanizm ten
TCheckBox* fInXBox; // okazuje sie dosc zawodny. Nazwy kontrolek
odpowiadaja nazwom pol struktury DCB takiej, jaka
TCheckBox* fPeCharBox; // jest zdefiniowana w API Win16, z
dopisanym "Box".
TCheckBox* fNullBox;
TCheckBox* fChEvtBox;
TCheckBox* fDtrflowBox;
TCheckBox* fRtsflowBox;

TComboBox* IdPortBox;
TComboBox* BaudRateBox;
TComboBox* ByteSizeBox;
TComboBox* ParityBox;
TComboBox* StopBitsBox;

TEdit* RlsTimeoutEdit;
TEdit* CtsTimeoutEdit;
TEdit* DsrTimeoutEdit;
TEdit* XonCharEdit;
TEdit* XoffCharEdit;
TEdit* XonLimEdit;
TEdit* XoffLimEdit;
TEdit* PeCharEdit;
TEdit* EofCharEdit;
TEdit* EvtCharEdit;
TEdit* TxDelayEdit;

protected:

virtual void SetupWindow(); // Wraz z metoda CmOk tworzy pare.
SetupWindow inicjalizuje odpowiednie elementy dialogu,
// natomiast CmOk odczytuje kontrolki (tj.
stany check-box'ow, teksty w okienkach edycyjnych
// itd.) i wykonuje akcje zgodne z wola
uzytkownika, wyrazona poprzez interakcje z dialogiem.
DECLARE_RESPONSE_TABLE(TSetupCommDialog);
};

// Jeszcze jeden warpper - tym razem do manipulacji dialogiem, pozwalajacym
wybrac ksztalt lancucha bajtow wysylanych do METEX'a

class TSetupTestDialog : public TDialog
{
public:

TSetupTestDialog(TWindow* parent, TResId resid);
void CmOk();

private:

TCheckBox* crBox;
TCheckBox* lfBox;
TCheckBox* nullBox;

protected:

virtual void SetupWindow();

DECLARE_RESPONSE_TABLE(TSetupTestDialog);
};

// Program ma glowne okno wywiedzione z klasy TFrameWindow. Glowne okono
jest jedynie konstrukcyjna "rama". Komunikacja szerego-
// wa odbywa sie jednak z oknem-klientem pochodzacym od TWindow (scislej
TMyWindow), zadeklarowanym ponizej. W danej chwili
// w programie istnieje tylko jedno okno klasy TMyFrameWindow i tylko jedno
okono klasy TMyWindow.

class TMyWindow : public TWindow
{
public:

TMyWindow(TWindow* parent, const char far* title);
virtual bool CanClose();
virtual void Paint(TDC& dc, bool erase, TRect& rect);

friend TSetupCommDialog;
friend TSetupTestDialog;
friend TSelectCommDialog;

private:

bool isComBusy; // Flaga, ktora jest true jezeli port jest otwarty.
Zabezpiecza przed zbyt pospiesznym zakonczeniem progra-
// mu, ktore doprowadziloby to ew. bledu przy kolejnych
uruchomieniach (chyba, ze system zamknie port sam).
int idComPort; // Identyfikator portu szeregowego. Tzn. idComPort rowny
dwa odpowiada portowi COM2, rowny np. 3 to COM3
// itd. Domysla wartosc wynika z tego, ze ja mam myszke
(szeregowa) na COM1.
int idComDev; // Identyfikator (uchwyt) do otwartego kanalu transmisji
przez port szeregowy (patrz OpenComm).

char input[32]; // Bufory wejsciowy i wyjsciowy dla transmisji
szeregowej. Bufor wejsciowy, czyli input, to ten,
char output[32];// ktory jest przez program ComTest czytany. Zapisy w
nim sa sporzadzane przez urzadzenie zewnetrzne (tj.
// miernik Metex) kierujacy do komputera dane
retransmitowane nastepnie przez system operacyjny.
int cbInput; // Liczba znakow w buforach odpowiednio input i output.
int cbOutput;

bool send_cr; // Jezeli wszystkie sa true, to do urzadzenia o uchwycie
idComDev wysylane jest lancuch "D\0x0A\0x0D\0",
bool send_lf; // jezeli ktoras z tych flag jest false, to urzadzenie
to nie otrzymuje odpowiedniego znaku z podanego
bool send_null; // wyzej ciagu - odpowiednio CR albo LF albo NULL
(ewentualnie nawet zadnego z nich).

DCB dcb; // Device Control Block, struktura ktora przechowuje
ustawienia portu szeregowego (por. SetCommState).

void CheckCommState(); // Sprawdza stan lacza szeregowego, a w razie
bledu pokazuje MessageBox.

protected:

void CmSelectComm();
void CmOpenComm(); // Otwiera lacze szeregowe (wywolujac funkcje API
Win16) przez OpenComm. Wywoluje tez SetCommState.
void CmCloseComm(); // Zamyka lacze szeregowe (wywolujac funkcje API
Win16) przez CloseComm.
void CmSetupComm(); // Najpierw wywoluje GetCommState, potem pozwala
zmodyfikowac DCB i wywoluje SetCommState.
void CmFlushComm(); // Wymiata bufory (wejsciowy i wyjsciowy) przed dwa
kolejne wywolania FlushComm.
void CmWriteComm(); // Kieruje do urzadzenia idComDev stosowny lancuch
znakow (wywoluje WriteComm).
void CmReadComm(); // Odczytuje urzadzenie idCommDev za pomoca funkcji
ReadComm. Wyniki wyswietla.
void CmSetupTest(); // Pozwala poprzez GUI manipulowac flagami send_...
void CmRunTest(); // Testuje CommEvent's tak, aby odczyt nastepowal
wtedy, gdy bufor input otrzymac moze juz 14 bajtow.
void CmAbout();

void EvCommNotify(uint commId, uint status); // Funkcja obslugi
komunikatu WM_COMMNOTIFY, dosc uproszczona (patrz wyzej).

DECLARE_RESPONSE_TABLE(TMyWindow);
};

// Klasa TMyApplication, jak w kazdym programie OWL.

class TMyApplication : public TApplication
{
public:

TMyApplication() : TApplication("Comtest") {};

protected:

virtual void InitMainWindow();
};

//==================================================
====================================================
========================

// Definicje tabel pozwalajacych powiazac komunikaty Windows z odpowiednimi
metodami. Trzy pierwsze sa trywialne i odpowiadaja
// dialogom. Czwarta rozdysponowuje polecenia glownego menu programu. Uwaga:
w tej samej kolejnosci beda ponizej metody danych
// klas.

DEFINE_RESPONSE_TABLE1(TSelectCommDialog, TDialog)
EV_COMMAND(IDOK, CmOk),
END_RESPONSE_TABLE;

DEFINE_RESPONSE_TABLE1(TSetupCommDialog, TDialog)
EV_COMMAND(IDOK, CmOk),
END_RESPONSE_TABLE;

DEFINE_RESPONSE_TABLE1(TSetupTestDialog, TDialog)
EV_COMMAND(IDOK, CmOk),
END_RESPONSE_TABLE;

DEFINE_RESPONSE_TABLE1(TMyWindow, TWindow)
EV_COMMAND(CM_SELECTCOMM,CmSelectComm),
EV_COMMAND(CM_OPENCOMM, CmOpenComm),
EV_COMMAND(CM_CLOSECOMM, CmCloseComm),
EV_COMMAND(CM_FLUSHCOMM, CmFlushComm),
EV_COMMAND(CM_SETUPCOMM, CmSetupComm),
EV_COMMAND(CM_WRITECOMM, CmWriteComm),
EV_COMMAND(CM_READCOMM, CmReadComm),
EV_COMMAND(CM_SETUPTEST, CmSetupTest),
EV_COMMAND(CM_RUNTEST, CmRunTest),
EV_COMMAND(CM_ABOUT, CmAbout),
EV_WM_COMMNOTIFY,
END_RESPONSE_TABLE;

//==================================================
====================================================
========================

TSelectCommDialog::TSelectCommDialog(TWindow* parent, TResId resid) :
TDialog(parent, resid)
{
IdPortBox = new TListBox(this,IDC_LISTBOX_IDPORT);
}

void TSelectCommDialog::SetupWindow()
{
TDialog::SetupWindow();

for(int i = 0; i < sizeof IdPortVal / sizeof IdPortVal[0]; i++)
IdPortBox->AddString(IdPortStr[i]);
IdPortBox->SetSelIndex(static_cast<TMyWindow*>(Paren
t)->idComPort - 1);
}

void TSelectCommDialog::CmOk()
{
static_cast<TMyWindow*>(Parent)->idComPort = IdPortBox->GetSelIndex() + 1;
TDialog::CmOk();
}

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

TSetupCommDialog::TSetupCommDialog(TWindow* parent, TResId resid) : TDialog
(parent,resid)
{
fBinaryBox = new TCheckBox(this,IDC_CHECKBOX_FBINARY);
fRtsDisableBox = new TCheckBox(this,IDC_CHECKBOX_FRTSDISABLE);
fParityBox = new TCheckBox(this,IDC_CHECKBOX_FPARITY);
fOutxCtsFlowBox = new TCheckBox(this,IDC_CHECKBOX_FOUTXCTSFLOW);
fOutxDsrFlowBox = new TCheckBox(this,IDC_CHECKBOX_FOUTXDSRFLOW);
fDtrDisableBox = new TCheckBox(this,IDC_CHECKBOX_FDTRDISABLE);
fOutXBox = new TCheckBox(this,IDC_CHECKBOX_FOUTX);
fInXBox = new TCheckBox(this,IDC_CHECKBOX_FINX);
fPeCharBox = new TCheckBox(this,IDC_CHECKBOX_FPECHAR);
fNullBox = new TCheckBox(this,IDC_CHECKBOX_FNULL);
fChEvtBox = new TCheckBox(this,IDC_CHECKBOX_FCHEVENT);
fDtrflowBox = new TCheckBox(this,IDC_CHECKBOX_FDTRFLOW);
fRtsflowBox = new TCheckBox(this,IDC_CHECKBOX_FRTSFLOW);

IdPortBox = new TComboBox(this,IDC_COMBOBOX_IDPORT);
BaudRateBox = new TComboBox(this,IDC_COMBOBOX_BAUDRATE);
ByteSizeBox = new TComboBox(this,IDC_COMBOBOX_BYTESIZE);
ParityBox = new TComboBox(this,IDC_COMBOBOX_PARITY);
StopBitsBox = new TComboBox(this,IDC_COMBOBOX_STOPBITS);

RlsTimeoutEdit = new TEdit(this,IDC_EDIT_RLSTIMEOUT);
CtsTimeoutEdit = new TEdit(this,IDC_EDIT_CTSTIMEOUT);
DsrTimeoutEdit = new TEdit(this,IDC_EDIT_DSRTIMEOUT);
XonCharEdit = new TEdit(this,IDC_EDIT_XONCHAR);
XoffCharEdit = new TEdit(this,IDC_EDIT_XOFFCHAR);
XonLimEdit = new TEdit(this,IDC_EDIT_XONLIM);
XoffLimEdit = new TEdit(this,IDC_EDIT_XOFFLIM);
PeCharEdit = new TEdit(this,IDC_EDIT_PECHAR);
EofCharEdit = new TEdit(this,IDC_EDIT_EOFCHAR);
EvtCharEdit = new TEdit(this,IDC_EDIT_EVTCHAR);
TxDelayEdit = new TEdit(this,IDC_EDIT_TXDELAY);
}

void TSetupCommDialog::SetupWindow()
{
TDialog::SetupWindow();
TMyWindow* p = static_cast<TMyWindow*>(Parent);

if(GetCommState(((TMyWindow*)Parent)->idComDev,&p->d
cb) < 0)
MessageBox("GetComState fails");

fBinaryBox ->SetCheck(p->dcb.fBinary ? BF_CHECKED :
BF_UNCHECKED);
fRtsDisableBox ->SetCheck(p->dcb.fRtsDisable ? BF_CHECKED :
BF_UNCHECKED);
fParityBox ->SetCheck(p->dcb.fParity ? BF_CHECKED :
BF_UNCHECKED);
fOutxCtsFlowBox->SetCheck(p->dcb.fOutxCtsFlow ? BF_CHECKED :
BF_UNCHECKED);
fOutxDsrFlowBox->SetCheck(p->dcb.fOutxDsrFlow ? BF_CHECKED :
BF_UNCHECKED);
fDtrDisableBox ->SetCheck(p->dcb.fDtrDisable ? BF_CHECKED :
BF_UNCHECKED);
fOutXBox ->SetCheck(p->dcb.fOutX ? BF_CHECKED :
BF_UNCHECKED);
fInXBox ->SetCheck(p->dcb.fInX ? BF_CHECKED :
BF_UNCHECKED);
fPeCharBox ->SetCheck(p->dcb.fPeChar ? BF_CHECKED :
BF_UNCHECKED);
fNullBox ->SetCheck(p->dcb.fNull ? BF_CHECKED :
BF_UNCHECKED);
fChEvtBox ->SetCheck(p->dcb.fChEvt ? BF_CHECKED :
BF_UNCHECKED);
fDtrflowBox ->SetCheck(p->dcb.fDtrflow ? BF_CHECKED :
BF_UNCHECKED);
fRtsflowBox ->SetCheck(p->dcb.fRtsflow ? BF_CHECKED :
BF_UNCHECKED);

int i;
char buffer[32];

for(i = 0; i < sizeof IdPortVal / sizeof IdPortVal[0]; i++)
IdPortBox->AddString(IdPortStr[i]);
IdPortBox->SetSelIndex(p->idComPort - 1);

for(i = 0; i < sizeof BaudRateVal / sizeof BaudRateVal[0]; i++)
BaudRateBox->AddString(BaudRateStr[i]);
BaudRateBox->SetText(itoa(p->dcb.BaudRate,buffer,10)
);
for(i = 0; i < sizeof BaudRateVal / sizeof BaudRateVal[0]; i++)
if(p->dcb.BaudRate == BaudRateVal[i]) BaudRateBox->SetSelIndex(i);

for(i = 0; i < sizeof ByteSizeVal / sizeof ByteSizeVal[0]; i++)
ByteSizeBox->AddString(ByteSizeStr[i]);
ByteSizeBox->SetText(itoa(p->dcb.ByteSize,buffer,10)
);

for(i = 0; i < sizeof ParityVal / sizeof ParityVal[0]; i++)
ParityBox->AddString(ParityStr[i]);
for(i = 0; i < sizeof ParityVal / sizeof ParityVal[0]; i++)
if(p->dcb.Parity == ParityVal[i]) ParityBox->SetSelIndex(i);

for(i = 0; i < sizeof StopBitsVal / sizeof StopBitsVal[0]; i++)
StopBitsBox->AddString(StopBitsStr[i]);
for(i = 0; i < sizeof StopBitsVal / sizeof StopBitsVal[0]; i++)
if(p->dcb.StopBits == StopBitsVal[i]) StopBitsBox->SetSelIndex(i);

RlsTimeoutEdit->SetText(itoa(p->dcb.RlsTimeout,buffe
r,10));
CtsTimeoutEdit->SetText(itoa(p->dcb.CtsTimeout,buffe
r,10));
DsrTimeoutEdit->SetText(itoa(p->dcb.DsrTimeout,buffe
r,10));

XonCharEdit ->SetText(itoa(p->dcb.XonChar, buffer,10));
XoffCharEdit->SetText(itoa(p->dcb.XoffChar,buffer,10
));
XonLimEdit ->SetText(itoa(p->dcb.XonLim, buffer,10));
XoffLimEdit ->SetText(itoa(p->dcb.XoffLim, buffer,10));
PeCharEdit ->SetText(itoa(p->dcb.PeChar, buffer,10));
EofCharEdit ->SetText(itoa(p->dcb.EofChar, buffer,10));
EvtCharEdit ->SetText(itoa(p->dcb.EvtChar, buffer,10));
TxDelayEdit ->SetText(itoa(p->dcb.TxDelay, buffer,10));
}

void TSetupCommDialog::CmOk()
{
TMyWindow* p = static_cast<TMyWindow*>(Parent);

p->dcb.fBinary = fBinaryBox ->GetCheck() == BF_CHECKED;
p->dcb.fRtsDisable = fRtsDisableBox ->GetCheck() == BF_CHECKED;
p->dcb.fParity = fParityBox ->GetCheck() == BF_CHECKED;
p->dcb.fOutxCtsFlow = fOutxCtsFlowBox->GetCheck() == BF_CHECKED;
p->dcb.fOutxDsrFlow = fOutxDsrFlowBox->GetCheck() == BF_CHECKED;
p->dcb.fDtrDisable = fDtrDisableBox ->GetCheck() == BF_CHECKED;
p->dcb.fOutX = fOutXBox ->GetCheck() == BF_CHECKED;
p->dcb.fInX = fInXBox ->GetCheck() == BF_CHECKED;
p->dcb.fPeChar = fPeCharBox ->GetCheck() == BF_CHECKED;
p->dcb.fNull = fNullBox ->GetCheck() == BF_CHECKED;
p->dcb.fChEvt = fChEvtBox ->GetCheck() == BF_CHECKED;
p->dcb.fDtrflow = fDtrflowBox ->GetCheck() == BF_CHECKED;
p->dcb.fRtsflow = fRtsflowBox ->GetCheck() == BF_CHECKED;

int i;
char buffer[32];

i = BaudRateBox->GetSelIndex();
if(0 <= i && i < sizeof BaudRateVal / sizeof BaudRateVal[0])
p->dcb.BaudRate = BaudRateVal[i];
else{
BaudRateBox->GetText(buffer,sizeof buffer);
p->dcb.BaudRate == atoi(buffer);
}

p->dcb.ByteSize = ByteSizeVal[ByteSizeBox->GetSelIndex()];
p->dcb.Parity = ParityVal [ParityBox ->GetSelIndex()];
p->dcb.StopBits = StopBitsVal[StopBitsBox->GetSelIndex()];

RlsTimeoutEdit->GetText(buffer,sizeof buffer); p->dcb.RlsTimeout =
atoi(buffer);
CtsTimeoutEdit->GetText(buffer,sizeof buffer); p->dcb.CtsTimeout =
atoi(buffer);
DsrTimeoutEdit->GetText(buffer,sizeof buffer); p->dcb.DsrTimeout =
atoi(buffer);

XonCharEdit ->GetText(buffer,sizeof buffer); p->dcb.XonChar =
atoi(buffer);
XoffCharEdit->GetText(buffer,sizeof buffer); p->dcb.XoffChar =
atoi(buffer);
XonLimEdit ->GetText(buffer,sizeof buffer); p->dcb.XonLim =
atoi(buffer);
XoffLimEdit ->GetText(buffer,sizeof buffer); p->dcb.XoffLim =
atoi(buffer);
PeCharEdit ->GetText(buffer,sizeof buffer); p->dcb.PeChar =
atoi(buffer);
EofCharEdit ->GetText(buffer,sizeof buffer); p->dcb.EofChar =
atoi(buffer);
EvtCharEdit ->GetText(buffer,sizeof buffer); p->dcb.EvtChar =
atoi(buffer);
TxDelayEdit ->GetText(buffer,sizeof buffer); p->dcb.TxDelay =
atoi(buffer);

if(SetCommState(&p->dcb) < 0) MessageBox("SetComState fails");

TDialog::CmOk();
}

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

TSetupTestDialog::TSetupTestDialog(TWindow* parent, TResId resid) :
TDialog(parent,resid)
{
crBox = new TCheckBox(this,IDC_CHECKBOX_CR);
lfBox = new TCheckBox(this,IDC_CHECKBOX_LF);
nullBox = new TCheckBox(this,IDC_CHECKBOX_NULL);
}

void TSetupTestDialog::SetupWindow()
{
TDialog::SetupWindow();
crBox ->SetCheck(static_cast<TMyWindow*>(Parent)->send_cr)
;
lfBox ->SetCheck(static_cast<TMyWindow*>(Parent)->send_lf)
;
nullBox->SetCheck(static_cast<TMyWindow*>(Parent)->s
end_null);
}

void TSetupTestDialog::CmOk()
{
static_cast<TMyWindow*>(Parent)->send_cr = crBox ->GetCheck() ==
BF_CHECKED;
static_cast<TMyWindow*>(Parent)->send_lf = lfBox ->GetCheck() ==
BF_CHECKED;
static_cast<TMyWindow*>(Parent)->send_null = nullBox->GetCheck() ==
BF_CHECKED;
TDialog::CmOk();
}

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

TMyWindow::TMyWindow(TWindow* parent, const char far* title) :
TWindow(parent, title)
{
isComBusy = false; // Nic nie jest jeszcze otwarte.
idComPort = 2; // Mam myszke na COM1 i dlatego wybieram port COM2
(uwaga - sa jeszcze COM3, COM4, ...)
idComDev = 0; // To nie jest potrzebne.

memset(input, 0, sizeof input); // To tez (chyba?) nie jest konieczne.
Nie zawsze jednak robi sie rzeczy, ktore sa konieczne
memset(output, 0, sizeof output); // - czasem moze sie oplacac wyzerowanie
nieuzywanych jeszcze zmniennych, ot tak, na wszelki
memset(&dcb, 0, sizeof dcb); // wypadek, aby nie bylo w nich
przypadkowych wartosci.

cbInput = 0;
cbOutput = 0;

send_cr = false; // W zasadzie powinna wystarczac sama litera 'D'
wyslana do miernika METEX. Dlatego wszystkie te flagi
send_lf = false; // maja ustawiona wartosc na false. Potem mozna to
bedzie zmienic - przez odpowiedni dialog.
send_null = false;
}

void TMyWindow::Paint(TDC& dc, bool erase, TRect& rect)
{
dc.DrawText(input, cbInput, GetClientRect());
}

bool TMyWindow::CanClose()
{
if (isComBusy)
switch(MessageBox("Com is in use!\nShould I close the com?", "Comtest",
MB_YESNOCANCEL | MB_ICONQUESTION)) {
case IDYES: CmCloseComm(); return true;
case IDNO: return true;
case IDCANCEL: return false;
}
return true;
}

void TMyWindow::CheckCommState()
{
char ErrorStr[][128] = {
"CE_BREAK Hardware detected a break condition.",
"CE_CTSTO CTS (clear-to-send) timeout.",
"CE_DNS Parallel device was not selected.",
"CE_DSRTO DSR (data-set-ready) timeout.",
"CE_FRAME Hardware detected a framing error.",
"CE_IOE I/O error occurred during an attempt to communicate with a
parallel device.",
"CE_MODE Requested mode is not supported.",
"CE_OOP Parallel device signaled that it is out of paper.",
"CE_OVERRUN Character was not read from the hardware before the next
character arrived.",
"CE_PTO Timeout occurred during an attempt to communicate with a
parallel device.",
"CE_RLSDTO RLSD (receive-line-signal-detect) timeout.",
"CE_RXOVER Receiving queue overflowed.",
"CE_RXPARITY Hardware detected a parity error.",
"CE_TXFULL Transmission queue was full when a function attempted to
queue a character."
};
int ErrorVal[] = { CE_BREAK, CE_CTSTO, CE_DNS, CE_DSRTO, CE_FRAME, CE_IOE,
CE_MODE, CE_OOP, CE_OVERRUN, CE_PTO, CE_RLSDTO,
CE_RXOVER, CE_RXPARITY, CE_TXFULL };

int err = GetCommError(idComDev,NULL);
for(int i = 0; i < sizeof ErrorVal / sizeof ErrorVal[0]; i++) if(err &
ErrorVal[i]) MessageBox(ErrorStr[i]);
}

void TMyWindow::CmSelectComm()
{
TSelectCommDialog(this,IDD_SELECTCOMM).Execute();
}

void TMyWindow::CmOpenComm()
{
if(CanClose()){

idComDev = OpenComm(IdPortStr[idComPort-1], sizeof input, sizeof
output);

char ErrorStr[][32] = {
"OpenComm fails: IE_BADID",
"OpenComm fails: IE_BAUDRATE",
"OpenComm fails: IE_BYTESIZE",
"OpenComm fails: IE_DEFAULT",
"OpenComm fails: IE_HARDWARE",
"OpenComm fails: IE_MEMORY",
"OpenComm fails: IE_NOPEN",
"OpenComm fails: IE_OPEN"
};
int ErrorVal[] = { IE_BADID, IE_BAUDRATE, IE_BYTESIZE, IE_DEFAULT,
IE_HARDWARE, IE_MEMORY, IE_NOPEN, IE_OPEN };
for(int i = 0; i < sizeof ErrorVal / sizeof ErrorVal[0]; i++)
if(idComDev == ErrorVal[i]) MessageBox(ErrorStr[i]);

isComBusy = (idComDev >= 0);

char buffer[32];
lstrcpy(buffer,IdPortStr[idComPort - 1]);
lstrcat(buffer,":1200,n,7,2");
if(BuildCommDCB(buffer, &dcb) < 0) MessageBox("BuildCommDCB fails");
if(SetCommState(&dcb) < 0) MessageBox("SetComState fails");
if(GetCommState(idComDev,&dcb) < 0) MessageBox("GetComState fails");
CheckCommState();
}
}

void TMyWindow::CmCloseComm()
{
CheckCommState();
if(CloseComm(idComDev) < 0) MessageBox("CloseComm fails");
isComBusy = false;
}

void TMyWindow::CmSetupComm()
{
CheckCommState();
TSetupCommDialog(this,IDD_SETCOMMSTATE).Execute();
CheckCommState();
}

void TMyWindow::CmFlushComm()
{
FlushComm(idComDev,0);
FlushComm(idComDev,1);
}

void TMyWindow::CmWriteComm()
{
cbOutput = 0;
output[cbOutput++] = 'D';
if(send_cr) output[cbOutput++] = '\r';
if(send_lf) output[cbOutput++] = '\n';
if(send_null) output[cbOutput++] = '\0';
WriteComm(idComDev,output,cbOutput);
}

void TMyWindow::CmReadComm()
{
cbInput = ReadComm(idComDev,input,sizeof input);
Invalidate();
}

void TMyWindow::CmSetupTest()
{
TSetupTestDialog(this,IDD_SETUPTEST).Execute();
}

void TMyWindow::CmRunTest()
{
if(!EnableCommNotification(idComDev, HWindow, 14, 0))
MessageBox("EnableCommNotification failed");
CmWriteComm();
}

void TMyWindow::EvCommNotify(uint commId, uint status)
{
if(commId == idComDev){
if(status == CN_RECEIVE){
cbInput = ReadComm(idComDev,input,sizeof input);
CmRunTest();
TWindowDC dc(HWindow);
dc.DrawText(input, cbInput, GetClientRect());
}
}
}

void TMyWindow::CmAbout()
{
TDialog(this,IDD_ABOUT).Execute();
}

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

void TMyApplication::InitMainWindow()
{
TWindow* client = new TMyWindow(0,"Hello");
TFrameWindow* frame = new TFrameWindow(NULL, "Comtest",client);
frame->SetIcon(this, IDI_ICON);
frame->AssignMenu(IDM_MENU);
SetMainWindow(frame);
}

//==================================================
====================================================
========================

int OwlMain(int /*argc*/, char* /*argv*/[])
{
TMyApplication app;
return app.Run();
}

//==================================================
====================================================
========================