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();
}

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

do góry

On Sat, 1 Oct 2016 01:39:21 -0700 (PDT), g...@g...com wrote:
> Owszem, milion linii kodu to dużo. Dużo za dużo, żeby n=
> a podstawie

Najpierw ten mistyczny milion LOC musiałby istnieć. A w to szczerze
wątpię.

do góry

W dniu sobota, 1 października 2016 11:52:23 UTC+2 użytkownik slawek napisał:

> > 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.

Może też nie każdy ma na tyle duże kompleksy, żeby musieć coś udowadniać
samozwańczym kozakom z usenetu, tym bardziej, że owo udowadnianie
nie służyłoby żadnemu innemu celowi.

> 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ą.

Pominę kwestię, że nawet o to nie zapytałeś.

> 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.

Dlaczego 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.
>
> #include <owl/pch.h> // OWL Pre-Compiled Headers
> #include <owl/checkbox.h> // Kazdy rodzaj kontrolek, ktory wystepuje w
[...]

Na przyszłość poleciłbym raczej wrzucanie większych fragmentów kodu
na serwisy w rodzaju pastebin albo github. Czytnik usenetu niekonieczne
jest dobrą przeglądarką kodu źródłowego.
Ogólnie z całego programu podobało mi się użycie nazw CmOk.
Zabawne zresztą jest to, że na moją uwagę, że obsługa portu szeregowego
w .NET jest zjebana, wysyłasz jakiś -- jak twierdzisz -- swój stary kod
w C++. To działanie ma coś na celu?

do góry

On Sat, 1 Oct 2016 03:41:07 -0700 (PDT), g...@g...com wrote:
> Pominę kwestię, że nawet o to nie zapytałeś.

Przeczytaj uważnie pierwszy wpis w tym wątku: wyraźnie jest pytanie.
Proste i sensowne.

> Dlaczego nieetyczne?

Bo jest nieetyczne przypisywanie sobie wyłącznego autorstwa dzieła,
które to dzieło ma także innych współautorów. W większości
cywilizowanych państw może być to także karane jako przestępstwo
i/lub być podstawą do oskarżeń przez współautorów. I naturalnie po
jednym takim fikołku nikt z IQ powyżej ameby może nie chcieć robić z
tobą czegokolwiek razem.

De facto jest to forma piractwa rozumianego jako naruszenie prawa
autorskiego.

Nota bene, coś podobnego zdarzyło się studentowi na praktyce w Pewnej
Dużej Firmie. Konkurencja wyjechała z pozwem. Duża Firma miała
nieciekawie, uczelnia miała kłopoty, a student zwyczajnie miał
przesłane. Co najgorsze: studenty straciły raz na zawsze możliwość
tych praktyk. Czyli jeden geniusz zchrzanił nie tylko swoje życie,
ale przy okazji wszystkim kolegom i koleżankom. Z bieżącego roku i
wszystkich kolejnych.

> Na przyszłość poleciłbym raczej wrzucanie większyc=
> h fragmentów kodu
> na serwisy w rodzaju pastebin albo github. Czytnik usenetu
niekonieczne

Jakby ci tu... A już wiem. Taki karny jeżyk to był.

Zresztą 600 linijek to dużo nie jest. Ciesz się że nie jest to
godzinny film 4K po UUencode.




> w .NET jest zjebana, wysyłasz jakiś -- jak twierdzisz -- swó=
> j stary kod
> w C++. To działanie ma coś na celu?

do góry

W dniu 2016-10-01 o 11:53, slawek pisze:
>
> 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

Nie. To znaczy, że jego program to 1 mln kodu. Nic więcej.
Wniosek, że cały milion pochodzi od jednego człowieka jest delikatnie
mówiąc z dupy.

A wracając do sedna, to chciałeś przykład na duży program napisany w
Delphi. Dostałeś. Nie napisałeś, że miał być napisany przez jednego
człowieka. Nie rozumiem dlaczego czepiasz się nieistotnych detali. Czy
to, że niemożliwe jest (według ciebie) napisanie przez jednego człowieka
miliona linii kodu wyklucza istnienie takiego programu napisanego w Delphi?
Czemu ma służyć ta przepychanka?

> - to
> powinien umieć to udowodnić, albo pogodzić się że sceptycy, tacy jak ja,
> będą uważali go za konfabulanta and/or grafomana.

I co jeszcze? Zatańczyć na linie?

> 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.

Jeśli kiedyś będziesz pracował nad projektem komercyjnym, to się
dowiesz, że prawa autorskie do kodu (fragmentów kodu) to nie to samo co
autorskie prawa majątkowe. I nie ma nic nieetycznego w tym, że
właściciel praw majątkowych mówi o programie "mój" program, pomimo tego,
że nie napisał całego miliona linijek osobiście.

Pozdrawiam
Piotr

do góry

W dniu 2016-10-01 o 13:21, slawek pisze:
>
> Bo jest nieetyczne przypisywanie sobie wyłącznego autorstwa dzieła,
> które to dzieło ma także innych współautorów. W większości
> cywilizowanych państw może być to także karane jako przestępstwo i/lub
> być podstawą do oskarżeń przez współautorów. I naturalnie po jednym
> takim fikołku nikt z IQ powyżej ameby może nie chcieć robić z tobą
> czegokolwiek razem.

Brak umiejętności czytania ze zrozumieniem też jest nieetyczne. Powinno
być karane śmiercią.
Jeszcze raz, powoli: wloochacz napisał, że _jego_ program ma mln linii
kodu. Gdzie ty tam wyczytałeś, że sobie przypisuje wyłączne autorstwo?

Pozdrawiam
Piotr

do góry

On Sat, 01 Oct 2016 12:21:24 +0200, slawek wrote:

>> Owszem, milion linii kodu to dużo. Dużo za dużo, żeby n=
>> a podstawie
>
> Najpierw ten mistyczny milion LOC musiałby istnieć. A w to szczerze
> wątpię.

Na pewno miałeś na myśli mistyczny? Bo już kolejny raz w tym wątku mam
wątpliwość czy nie masz przypadkiem problemów z językiem polskim. Jak na
tak wysoce wyedukowanego omnibusa jest to cokolwiek podejrzane.

--
pozdrawiam
Roman Tyczka

do góry

W dniu poniedziałek, 26 września 2016 19:55:53 UTC+2 użytkownik Sebastian Biały
napisał:
> On 2016-09-26 15:57, slawek wrote:
> > Skąd więc OBECNA popularność Pascala jako np. języka obowiązkowego dla
> > techników-informatyków itp.?!
>
> Z powodu inercji. Biologia działa zbyt powoli.

Przyczyny są ciut bardziej złożone, ale faktycznie biologia jest tu głównym
czynnikiem. Uwzględnijcie, że w polskich szkołach do poziomu ponadgimnazjalnego
(uwaga: nie wiem, jak jest w technikach informatycznych) programowania uczą ludzie,
którzy nie nigdy nie wyszli poza programowanie imperatywne, więc niewielkie są
szanse, że ich uczniowie w ogóle powąchają OOP!

Z drugiej strony - ilu z Was próbowało nauczyć, powiedzmy, dwunastolatka
programowania? Przy okrojonej matmie w szkołach i braku pewnego sposobu myślenia może
się to okazać ciężkie.

Nie lubiłem i nie lubię Pascala. Przez lata szukałem języka idealnego do dydaktyki,
parę roczników męczyłem Pythonem czy C++, choć wertowałem także hamerykańskie
podręczniki do Javy czy Ruby'ego dla nieletnich, ale nagle okazało się, że do UCZENIA
statystycznego Jasia Kowalskiego (nie pasjonata i nerda) ten prehistoryczny Pascal
wcale taki głupi nie jest. Co więcej, pewne rzeczy w Pythonie/C++ są dla młodziaków
nie do przeskoczenia.

Serdeczności,
joahim


PS. Gdzieś słyszałem, że o popularności Pascala zadecydowało embargo CoCom pod koniec
komuny.
PS2. Korci mnie, żeby zryć głowy jakiemuś rocznikowi gimnazjalistów Perlem, ha!

do góry

On Sat, 1 Oct 2016 18:10:40 +0200, Roman Tyczka <n...@b...no>
wrote:
> Na pewno miałeś na myśli mistyczny?

Tajemniczy, niezbadany, niewyjaśniony. To chyba dobre określenie na
coś, co wymaga głębokiej wiary w twoje możliwości. Skoro pizza może
być mistyczny, to makaron jaki klepiesz chyba też...

do góry

On Sat, 1 Oct 2016 09:18:18 -0700 (PDT), joahim <w...@g...com>
wrote:
> technikach informatycznych) programowania uczą ludzie, którzy nie=
> nigdy nie wyszli poza programowanie imperatywne, więc niewielkie
s?=
> ? szanse, że ich uczniowie w ogóle powąchają OOP!

A czy każdy dwunastolatek jest taki jak twoje dzieciaczki, że nie
potrafi sam przeczytać książki, sam się czegoś nauczyć?


> PS2. Korci mnie, żeby zryć głowy jakiemuś rocznikowi gi=
> mnazjalistów Perlem, ha!

Czyli uczysz gimnazjalistów. I uznałeś Perl za wredny. Ok. A myślałeś
kiedyś o Tcl? A z klasyki to Forth też przyjemny. I Cobol niczego
sobie.

do góry