Hilfe MFC/Win32 und serielle Schnittstelle
p_o...@my-dejanews.com
schreiben mit dem ich über die serielle Schnittstelle eine
Schrittmotorsteuerung ansprechen muß. Als erstes habe ich versucht ein
Programm in MFC zu schreiben, ist ja auch nicht besonders schwer ( dazu muß
ich sagen daß ich erst Neuling in Sachen Visual C++ / C++ bin ) aber als ich
dann zum besagten Problem ankam die serielle Schnittstelle anzusprechen
verzweifelte ich. Die Hilfe von Visual C++ konnte mir in keinster Weise
weiterhelfen. Das einzige was ich fand waren die Befehle WriteFile, ReadFile
und CreateFile etc. allerrdings war ich nicht in der Lage diese im
MFC-Programm zu nutzen. Dann hatte ich das Beispiel-Programm TTY unter dem
Begriff Comm gefunden. Allerdings mußte ich feststellen, daß dieses Programm
als Win32-API geschrieben wurde, womit ich nun zuerst gar nichts anfangen
konnte. Mittlerweile verstehe ich davon zwar schon etwas, aber wenn ich unter
Win32-API selber programmieren muß, bekomme ich nur Kopfschmerzen. Dazu muß
ich auch noch sagen, daß ich E.-Technik Student an der UNI-Duisburg bin und
das mir sämtliche Literatur fehlt, da alle Bücher über VC++ ( ca. 4 Stk)
ausgeliehen sind und ich hier am Institut (IMST) wo ich an dem Projekt
arbeite auch keine geeignete Literatur zur Verfügung steht. Meine Fragen sind
nun : 1. Kann man MFC Programmierung mit Win32 API Progammierung vermischen?
2. Wenn ja, kann mir dafür jemand Beispiele nennen/ zur Vefügung stellen? 3.
Gibt es vernünftige online-Literatur zu Win32 /bzw MFC ( am besten
tabellarisch )? 4. Kann man auch nur mit MFC die serielle Schnittstelle
ansprechen ( das wäre noch besser )? Das wäre schön da ich die MFC irgendwie
einfacher finde, als die Win32-Api.
Danke schon mal im voraus für Antworten aller Art.
E-Mail to:
ot...@imst.de
oder
p.o...@uni-duisburg.de
-----== Posted via Deja News, The Leader in Internet Discussion ==-----
http://www.dejanews.com/rg_mkgrp.xp Create Your Own Free Member Forum
p_o...@my-dejanews.com
-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/ Search, Read, Discuss, or Start Your Own
Der kleine Nic
- schnippel 8>< - schnippel 8>< - schnippel 8><
> 1. Kann man MFC Programmierung mit Win32 API Progammierung vermischen?
>2. Wenn ja, kann mir dafür jemand Beispiele nennen/ zur Vefügung stellen? 3.
Hallo Otto,
ich bin zwar selbst nicht fit in der Schnittstellenprogrammierung aber
ich würde Dir vorschlagen das IO Control aus der Microsoft Componant
Gallery zu verwenden. Damit müsste es ganz einfach sein ;o)
Grüße
Harald
>Gibt es vernünftige online-Literatur zu Win32 /bzw MFC ( am besten
>tabellarisch )? 4. Kann man auch nur mit MFC die serielle Schnittstelle
>ansprechen ( das wäre noch besser )? Das wäre schön da ich die MFC irgendwie
>einfacher finde, als die Win32-Api.
>
>Danke schon mal im voraus für Antworten aller Art.
>
>E-Mail to:
>ot...@imst.de
>oder
>p.o...@uni-duisburg.de
>
>-----== Posted via Deja News, The Leader in Internet Discussion ==-----
>http://www.dejanews.com/rg_mkgrp.xp Create Your Own Free Member Forum
...............................
mind the gap please
....................................
Jürgen Heckmann
> nun : 1. Kann man MFC Programmierung mit Win32 API Progammierung vermischen?
Ja, du must nur wissen wie du an die entsprechenden Handels für
Fenster etc. rankommst.
P.S. schau dir mal die Seite http://www.sysinternals.com/comport.htm
an, vielleicht hilft dier das bei deinem Problem weiter.
Oliver Schreck
Thomas Hieber
p_o...@my-dejanews.com schrieb in Nachricht
<6vi0hm$1fp$1...@nnrp1.dejanews.com>...
>1. Kann man MFC Programmierung mit Win32 API Progammierung vermischen?
Ja, sogar problemlos. Die meisten MFC-Klassen sind nur recht dünne
Wrapper fürs API. Ein CWnd::MoveWindow(x,y,a,b) wird z.B. umgesetzt in
::MoveWindow(m_hWnd, x,y,a,b). Alle Beispiele, die reines API verwenden,
kann man an jeder Stelle in einem MFC-Programm einbauen. (Einzige
Ausnahme ist vielleicht Code, der sich mit Windows-Message-Handling
beschäftigt)
>2. Wenn ja, kann mir dafür jemand Beispiele nennen/ zur Vefügung
stellen?
www.codeguru.com ist eine Top-Quelle für Beispiele.
>3.Gibt es vernünftige online-Literatur zu Win32 /bzw MFC ( am besten
>tabellarisch )?
www.microsoft.com/msdn Dort kann man kostenlos auf das komplette
Developers Network zugreifen. Als CD kostet das immerhin fast 1000,- pro
Jahr.
>4. Kann man auch nur mit MFC die serielle Schnittstelle
>ansprechen ( das wäre noch besser )? Das wäre schön da ich die MFC
irgendwie
>einfacher finde, als die Win32-Api.
Ich kenne keine MFC-Klasse für die serielle Schnittstelle. Nach der
Anzahl von Fragen bzgl. Serieller Schnittstelle unter Windows wäre es
aber langsam Zeit für so was. (evtl hat es ja MSVC 6.0) Letztlich ist es
aber gernicht so kompliziert. Das TTY Beispiel, das Du erwähnt hast, ist
eine optimale Ausgangsbasis für eigene Experimente. Am besten kopiert
man sich den entsprechenden Code und paßt nur noch die Parameter bei
Bedarf an.
Thomas
--
The above E-Mail adress is invalid.
Use thieber at bluewin dot de instead.
Andreas Schroeder
> Hallo erstmal. Ich habe ein ganz großes Problem. Ich muß ein Windows-Programm
> schreiben mit dem ich über die serielle Schnittstelle eine
Hy,
vielleicht bringt dich das hier weiter:
------------------------------------------------------------------------------
/* ******************************************************************** */
/* SerialCharOut schickt ein Zeichen zur Schnittstelle. */
/* Ihr wird ein Haensel auf das Schnittstellenobjekt uebergeben */
/* und als zweiter Parameter das zu sendende Zeichen. */
/* Konnte das Zeichen nicht gesendet werden, so liefert die Funktion */
/* FALSE, ansonsten TRUE. */
/* ******************************************************************** */
unsigned char SerialCom::SerialCharOut(HANDLE seriHandle, unsigned char charData)
{
//char rausString[10];
DWORD dwGeschrieben;
OVERLAPPED osSchreib = {0};
//sprintf(rausString,"%c",charData);
if (!WriteFile (seriHandle, &charData, 1,
&dwGeschrieben,&osSchreib))
{
if (messageFlag)
if (GetLastError() == ERROR_TIMEOUT)
MessageBox(NULL,"TimeOut beim Schreiben",
"Schnittstellenfehler",0);
else
MessageBox(NULL,"Kann nicht schreiben",
"Schnittstellenfehler",0);
return(FALSE);
}
return (TRUE);
}
/* ******************************************************************** */
/* SerialCharIn empfaengt ein Zeichen von der Schnittstelle. */
/* Ihr wird ein Haensel auf das Schnittstellenobjekt uebergeben */
/* und als zweiter Parameter liefert sie das empfangene Zeichen. */
/* Konnte kein Zeichen empfangen werden (TimeOut), so liefert die */
/* Funktion FALSE, ansonsten TRUE. */
/* ******************************************************************** */
unsigned char SerialCom::SerialCharIn(HANDLE seriHandle, unsigned char *charData)
{
//char reinString[10];
DWORD dwGelesen;
OVERLAPPED osLies = {0};
if (!ReadFile (seriHandle, charData, 1, &dwGelesen, &osLies))
{
if (SHOW_RERRORS && messageFlag)
if (GetLastError() == ERROR_TIMEOUT)
MessageBox(NULL,"TimeOut beim Lesen",
"Schnittstellenfehler",0);
else
MessageBox(NULL,"Kann nicht lesen",
"Schnittstellenfehler",0);
*charData = ' ';
return(FALSE);
}
if (dwGelesen == 0)
{
if (SHOW_RERRORS && messageFlag)
if (GetLastError() == ERROR_TIMEOUT)
MessageBox(NULL,"TimeOut beim Lesen",
"Schnittstellenfehler",0);
else
MessageBox(NULL,"Kein Byte gelesen",
"Schnittstellenfehler",0);
*charData = ' ';
return(FALSE);
}
//*charData = reinString[0];
return (TRUE);
}
/* ******************************************************************** */
/* SerialSetParameter konfiguriert die Schnittstelle. */
/* Ihr wird ein Haensel auf das Schnittstellenobjekt uebergeben, */
/* die Baudrate als Integer-Wert, die Paritaet als Buchstabe, */
/* die Anzahl der Bits (int) und die Anzahl der Stopbits (int). */
/* Konnte aus den uebergebenen Parametern kein Parameter-String ge- */
/* bildet werden, oder konnte die Schnittstelle mit dem angegebenen */
/* Haensel nicht konfiguriert werden, so liefert die Funktion FALSE. */
/* -------------------------------------------------------------------- */
/* Wertebereiche der Parameter sind: */
/* Baudrate: 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 38400,*/
/* 56000, 57600, 115200, 128000, 256000 */
/* Parity: 'n', 'o', 'e', 'm', 's' */
/* Bits: 4, 5, 6, 7, 8 */
/* Stops: 1, 2 */
/* rTimeOut: 0 - 65000 ms (Wenn Null, dann TIME_ROUT) */
/* ******************************************************************** */
unsigned char SerialCom::SerialSetParameter(HANDLE seriHandle,
int Baudrate,
char Parity,
int Bits,
int Stops,
int rTimeOut)
{
char speziString [20];
DCB dcb;
// DWORD dwGeschrieben;
// OVERLAPPED osSchreib = {0};
sprintf(speziString, "%d,%c,%d,%d", Baudrate, Parity, Bits, Stops);
//*+*+*+*+*+*+*+*+*+*+*
if (testInfoFlag)
MessageBox(NULL,speziString,"Testausgabe - Init-String:",0);
//*+*+*+*+*+*+*+*+*+*+*
FillMemory(&dcb, sizeof(dcb), 0);
dcb.DCBlength = sizeof(dcb);
if (!BuildCommDCB(speziString, &dcb))
{
if (messageFlag)
MessageBox(NULL,"Kann Parameter-String nicht erzeugen!",
"Programmfehler",0);
return(FALSE);
}
else
{
if (rtsctsFlag)
{
dcb.fOutxCtsFlow = TRUE;
dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
}
else
{
dcb.fOutxCtsFlow = FALSE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
}
if (!SetCommState(seriHandle, &dcb))
{
if (messageFlag)
MessageBox(NULL,"Kann Parameter nicht setzten",
"Schnittstellenfehler",0);
return(FALSE);
}
else
{
}
}
/**** Wenn alles geklappt hat, dann hier ****/
/* +++++++++++++++++++++++ TIMEOUTS +++++++++++++++++++++++++++ */
/******** Alle TimeOut-Werte in 'ms' ********/
COMMTIMEOUTS TimeOutTimes; /* Struktur mit fuenf TimeOut-Zeiten */
/****** Time-Out-Festlegung fuer LESEN: ******************/
/*** Folgende Kombination legt fest, dass ***/
/*** a) ein vorhandenes Zeichen sofort gelesen wird, ***/
/*** b) bei leerem Buffer TIME_OUT-lang gewartet wird, ***/
/*** c) wenn kein Zeichen kommt ReadFile abbricht ***/
TimeOutTimes.ReadIntervalTimeout = MAXDWORD;
TimeOutTimes.ReadTotalTimeoutMultiplier = MAXDWORD;
if (rTimeOut)
TimeOutTimes.ReadTotalTimeoutConstant = rTimeOut;
else
TimeOutTimes.ReadTotalTimeoutConstant = TIME_ROUT;
/****** Time-Out-Festlegung fuer SCHREIBEN: **************/
/*** Folgende Werte werden hier festgelegt: ***/
/*** a) fuer jedes zu sendende Byte eine Verlaengerung ***/
/*** um TIME_WMULTI ***/
/*** b) eine Grundzeit von TIME_WCONST ***/
/*** Gesamt-Timeoutzeit ist dann: ***/
/*** TIME_WCONST + n * TIME_WMULTI ***/
/*** (wobei n = Anzahl zu sendender Bytes) ***/
TimeOutTimes.WriteTotalTimeoutMultiplier = TIME_WBYTE;
TimeOutTimes.WriteTotalTimeoutConstant = TIME_WDAZU;
if (!SetCommTimeouts(seriHandle, &TimeOutTimes))
return (FALSE);
return(TRUE); /*** Alles hat geklappt! ***/
}
/* ******************************************************************** */
/* SerialMake eine serielle Schnittstelle. */
/* Sie liefert einen Haensel auf das Schnittstellenobjekt, das mit */
/* der Angabe der entsprechenden COM-Nummer ueberein stimmt. */
/* -------------------------------------------------------------------- */
/* Wertebereiche von comport sind: */
/* 1, 2, 3, 4 (entspricht COM1, COM2, COM3, COM4 */
/* ******************************************************************** */
unsigned char SerialCom::SerialMake(HANDLE *seriHandle, int comPort)
{
char *portNamen [4] = {"COM1","COM2","COM3","COM4"};
HANDLE fussdle;
fussdle = CreateFile (portNamen[comPort-1],
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
0,
0);
if (fussdle == INVALID_HANDLE_VALUE)
{
if (messageFlag)
MessageBox(NULL,"Kann Port nicht öffnen!","Schnittstellenfehler",0);
return(FALSE);
}
else
{
if (!SerialSetParameter(fussdle,9600,'n',8,1,0))
{
if (messageFlag)
MessageBox(NULL,"Fehler beim setzten der Parameter",
"Schnittstellenfehler",0);
return(FALSE);
}
else
{
*seriHandle = fussdle;
}
}
return(TRUE);
}
/* ******************************************************************** */
/* SerialClose schliesst die serielle Schnittstelle. */
/* Ihr wird ein Haensel auf das Schnittstellenobjekt uebergeben. */
/* ******************************************************************** */
unsigned char SerialCom::SerialClose(HANDLE *seriHandle)
{
CloseHandle (seriHandle);
return(TRUE);
}
-------------------------------------------------------
Bis denn,
Andreas.