Controller via Com-Port

[monomo]

Hi

Ich beschäftige mich seit einiger Zeit mit Controllern der 8051-Familie.
Nun wollt ich meinen Rechner einbinden nur wie.
Welche Hardware ich brauche ist mir bekannt. (RS232) am COM Port.
Aber ich komme nicht weiter.

Hat da jemand einen Tip.

 

[Tobias K.]

moin


Was ist denn genau dein Problem?

Den Com-Port kannst du wie folgt ansprechen und Zeichen an ihn senden:

#include <windows.h>
#include <iostream>

using namespace std;

int i=0;

int main()
{
	DCB           dcb;
	HANDLE hCom = CreateFile ("COM1", GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
	dcb.DCBlength = sizeof(DCB);
	GetCommState (hCom, &dcb); 
	dcb.BaudRate  = 2400;
	dcb.ByteSize  = 8;   
	dcb.Parity    = NOPARITY;    
	dcb.StopBits  = ONESTOPBIT;  
	SetCommState (hCom, &dcb);

	DWORD iBytesWritten;
	unsigned char ucMsg[5];

	ucMsg[0] = (char)13;
	ucMsg[1] = (char)1;
	ucMsg[2] = 'S';
	ucMsg[3] = (char)49 + i;
	ucMsg[4] = ucMsg[0] ^ ucMsg[1] ^ ucMsg[2] ^ ucMsg[3];

	WriteFile (hCom, ucMsg, 5, &iBytesWritten, NULL);
	//WriteFile (hCom, ucMsg, 5, &iBytesWritten, NULL); //nicht unbedingt nötig es 2 mal zusenden!
	
	CloseHandle (hCom);

	return 0;
}

mfg
umbrasaxum

 

[monomo]

Ich bräuchte genauere Informationen zum RS 232.
Vor allem will ich wissen wie genau das Funktioniert.

Einzelne Zeichen an den Comport Schicken ist ein guter Anfang.

Wie kann geht das am LTP?

 

[Tobias K.]

moin


Wie du brauchst genauere Informationen?
Du musst wissen was deine Hardware kann, und auf welche Nachrichten sie wie Funktioniert.

Am LPT sollte es ähnlich gehe. Halt LPT1 statt COM1 angeben und ein paar Sachen beim bcd.... ändern, dann sollte es Funktionieren.

Hast du überhaupt schon Hardwayre die bei richtiger ansteuerung laufen würde?


mfg
umbrasaxum

 

[monomo]

Also ich bin noch in der Lernphase.
Besitze keine Hardware die funktionieren würde.
Bin bis jetzt noch nicht dazu gekommen mir Bauteile zu kaufen (hatte kein Geld).
Hat bis jetzt nur zu Büchern gereicht.
Nun hab ich mich in die Programmierung von Controllern mittels Assembler eingearbeitet.
Nun such ich nur nach der Möglichkeit wie man Daten zwischen Controller und Rechner hin und her transferiert. Ich dachte ich könnte das als Befehl realiesieren.
Nun happert es an dem Verständnis was ich machen muß um das sich die beiden verstehen.
Bin da schon auf einigen interessanten Seiten gewesen.

Nur den richtigen Durchblick hab ich noch nicht.

Ich bin immerhin schon so weit das ich weiß das ich die Übertragungsrate in den Programmen festlegen muß.
Und danach die einzelnen Bits nacheinander zum entsprechenden Gegenüber
transferieren.

Aber weiter bin ich noch nicht.

Ich hoffe es ist jetzt verständlich geworden was mein Problem ist.

 

[Tobias K.]

moin

Ich bin immerhin schon so weit das ich weiß das ich die Übertragungsrate in den Programmen festlegen muß.

Tja dann weisst du erst 1%. Und genau das ist von deiner selbstentwickelten Hardware abhängig.

Das ist mitm RS232 nciht ganz so leicht. Du musst auf deiner Platine einen Chip haben der auch was mit dem Befehlen anfangen kann und dann irgendwelche Datan zurück sendet. Diesen Chip musst du möglicherweise noch selber Programmieren, weiss nciht ob es da schon was fertig gibt.

Das Programm das ich oben gepostet hab kann das im Prinzip schon alles, man müsste nur noch ein Read hinzufügen, das auf Antwort von deiner Platine wartet.

Von oben:

dcb.BaudRate  = 2400;
	dcb.ByteSize  = 8;   
	dcb.Parity    = NOPARITY;    
	dcb.StopBits  = ONESTOPBIT;

Das sind Sachen die du einstellen musst damit die Platine überhaupt mit dem PC kommunizieren kann.


mfg
umbrasaxum

 

[monomo]

Also ich hab mich nochmal schlau gemacht in meiner Literatur.

Und nun ist mir einigermaßen wie ich die Daten über den RS232 zum Controller bekomme.

Nur muß ich leider gestehen das ich mit dem Geposteten Programm nicht so recht klar komme.

Wärs möglich eine genauere Beschreibung zu den einzelen Zeilen zu bekommen.

Ich wäre ihnen dafür sehr dankbar.

 

[Tobias K.]

moin


In meinem Programm wird der Com-Port zum lesen und schreiben göffnet.
Dann wird eine Strktur ( dcb ) mit Informationen bestückt, wie die Daten gesendet werden sollen. Stop-Bit, Parity, Byte-Size und Baudrate sollten dir mitlerweile ein Begriff sein.

Als letztes wird eien Nachricht (ucMsg) über den Port nach "draußen" gesendet.


mfg
umbrasaxum

 

[jower]

Hallo,
versuche gerade, über eine serielle Schnittstelle ein Gerät anzusteuern. Ich würde gerne an das Gerät ein Statusrequest senden. Das ist im letzten Codeausschnitt unter data_status_req zu finden, nur antwortet das Gerät nicht.
Wie kann ich denn überprüfen, ob ich auch das richtige Sende. Irgendwie sagt mir eine Ausgabe nur, dass data_status_req nur 1 BYte groß sei. aber wieso?
ich schicke Euch mal den aktuellen Stand. Vielleicht kann mir ja jemand helfen.Würde mir wirklich weiterhelfen.
vielen Dank Jower

Cport_m_dcb.h:
#ifndef CPORT_M_DCB_H
#define CPORT_M_DCB_H "cport_m_dcb.h"

#include <windows.h>

class ComPort
{
private:
HANDLE hCom;
DCB m_dcb;

public:
enum {OFF,ON};
enum {MAX_PORT = 6};
enum {STATE_ERR = -3, OPEN_ERR, WRONG_PORT, COMM_OK};

ComPort(void);
~ComPort(void);

HANDLE GetHCom(void);

int OpenCom(int portnr);
void CloseCom(void);

BOOL SetUART(void);
BOOL SetUART(DWORD baud, BYTE bytes, BYTE parity, BYTE stopbit);

BOOL SetTimeouts(COMMTIMEOUTS *timeouts);
BOOL SetReadTimeouts(long interval, int multiplier, int constant);
BOOL SetWriteTimeouts(int multiplier, int constant);

BOOL GetUART(DWORD &baud, BYTE &bytes, BYTE &parity, BYTE &stopbit);

unsigned long Send(const char *text);
unsigned long Receive(char *text, DWORD maxsize);

static const char *GetCP(int index);
};

#endif

Cport_m_dcb.cpp
#include "stdafx.h"
#include "cport_m_dcb.h"

ComPort::ComPort(void)
{
m_dcb.DCBlength = sizeof(m_dcb);
hCom=INVALID_HANDLE_VALUE;
}

ComPort::~ComPort(void)
{
CloseCom();
}

HANDLE ComPort::GetHCom(void)
{
return hCom;
}

int ComPort::OpenCom(int portnr)
{
BOOL res;

if(portnr<=0 || portnr>MAX_PORT)
return(WRONG_PORT);

hCom = CreateFile(GetCP(portnr-1), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if(hCom==INVALID_HANDLE_VALUE)
return(OPEN_ERR);

res=GetCommState(hCom, &m_dcb);
if(!res) {
CloseCom();
return(STATE_ERR);
} //end if

return(COMM_OK);
}

void ComPort::CloseCom(void)
{
CloseHandle(hCom);
hCom=INVALID_HANDLE_VALUE;
}

BOOL ComPort::SetUART(void)//DCB dcb)//funktioniert nicht
{
if(hCom!=INVALID_HANDLE_VALUE)
return(SetCommState(hCom, &m_dcb));
else
return(false);
}

BOOL ComPort::SetUART(DWORD baud, BYTE bytes, BYTE parity, BYTE stopbits)
{
if(hCom!=INVALID_HANDLE_VALUE)
{
m_dcb.BaudRate=baud;
m_dcb.ByteSize=bytes;
m_dcb.Parity=parity;
m_dcb.StopBits=stopbits;

if (SetCommState(hCom, &m_dcb)){
std::cout << "Baudrate: " << m_dcb.BaudRate;
std::cout << " ByteSize: " << m_dcb.ByteSize;
std::cout << " Parity: " << m_dcb.Parity;
std::cout << " StopBits: " << m_dcb.StopBits;
std::cout << "SetUART OK" << std::endl ;
return (true);
}
std::cout << "SetUART Fehler (SetCommState)" << std::endl ;
return(false);
}
else {
std::cout << "SetUART Fehler (INVALID_HANDLE_VALUE)" << std::endl ;
return(false);
}
}

BOOL ComPort::GetUART(DWORD &baud, BYTE &bytes, BYTE &parity, BYTE &stopbit)
{
if(hCom!=INVALID_HANDLE_VALUE)
{
GetCommState(hCom, &m_dcb);

baud = m_dcb.BaudRate;
bytes = m_dcb.ByteSize;
parity = m_dcb.Parity;
stopbit = m_dcb.StopBits;

return(true);
}
else
return(false);
}

BOOL ComPort::SetReadTimeouts(long interval, int multiplier, int constant)
{
if(hCom!=INVALID_HANDLE_VALUE)
{
COMMTIMEOUTS timeouts;

timeouts.ReadIntervalTimeout=interval;
timeouts.ReadTotalTimeoutMultiplier=multiplier;
timeouts.ReadTotalTimeoutConstant=constant;

return(SetCommTimeouts(hCom, &timeouts));
}
else
return(false);
}


BOOL ComPort::SetWriteTimeouts(int multiplier, int constant)
{
if(hCom!=INVALID_HANDLE_VALUE)
{
COMMTIMEOUTS timeouts;

timeouts.WriteTotalTimeoutMultiplier=multiplier;
timeouts.WriteTotalTimeoutConstant=constant;

return(SetCommTimeouts(hCom, &timeouts));
}
else
return(false);
}


unsigned long ComPort::Send(const char *text)
{
if(hCom!=INVALID_HANDLE_VALUE)
{
unsigned long sent;

if (WriteFile(hCom, text, (DWORD) strlen(text), &sent, NULL)){
std::cout << "Send OK" << " Daten: " << text << " gesendete Bytes " << sent << std::endl;
std::cout << std::endl;
return(sent);
}
else
return(0);
}
else
return(0);
}


unsigned long ComPort::Receive(char *text, DWORD maxsize)
{
if(hCom!=INVALID_HANDLE_VALUE)
{
unsigned long received;
BOOL success = false;
success = ReadFile(hCom, text, maxsize, &received, NULL);
if (success==(BOOL)true){
text[received]='\0';
std::cout << "Receive OK" << " Daten: " << std::showbase << std::hex << text << std::dec << std::endl;
std::cout << std::endl;
return(received);
}
else{
std::cout << "Readfile ZERO" << " Daten: " << std::showbase << std::hex << text << std::dec << "gelesene Bytes" << received << std::endl;
return(0);
}
}
else {
std::cout << "Readfile INVALID_HANDLE_VALUE" << " Daten: " << text << std::endl;
return(0);
}
}

const char *ComPort::GetCP(int index)
{
static const char *CP[]={"COM1","COM2","COM3","COM4","COM5","COM6"};

if(index>-1&&index<ComPort::MAX_PORT)
return(CP[index]);
else
return("");
}

und hier die Aufrufe
// COM.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "cport_m_dcb.h"
#include <windows.h>

int _tmain(int argc, _TCHAR* argv[])
{
ComPort comport;
int portnr = 1;

// Open Com1
if (comport.OpenCom(portnr) != 0)
std::cout << "Der Port COM" << portnr << "konnte nicht geoeffnet werden" << std::endl ;
else
std::cout << "Der Port COM" << portnr << " ist geoeffnet" << std::endl;
std::cout << std::endl;

//define DCB Parameters
DWORD BaudRate = CBR_38400;
BYTE ByteSize = 8;
BYTE Parity = 0; //PARITY_NONE;
BYTE StopBits = 0; //NOPARITY;

// set DCB Parameters
comport.SetUART(BaudRate, ByteSize, Parity, StopBits);
comport.GetUART(BaudRate, ByteSize, Parity, StopBits);

comport.SetReadTimeouts(10000,10,10000);
//comport.SetWriteTimeouts(100,100);

DWORD max_datasize = 30;
char data[] = {0};

DWORD dwBytesRead = 0;
dwBytesRead = comport.Receive(data, max_datasize);std::cout << "Auf Start-up Meldung gewartet" << std::endl;
if (dwBytesRead){
std::cout << "start-up Meldung empfangen," << " Daten: "<< data << " bytesread: " << dwBytesRead << std::endl;
}
else
std::cout << "keine start-up Meldung empfangen," << " Daten: " << data << " bytesread: " << dwBytesRead << std::endl;// Fehler


//Status Request - STX, NUL, SOH, NUL, 1, NAK, DC2
char data_status_req[7];
data_status_req[0] = 0x02;
data_status_req[1] = 0x00;
data_status_req[2] = 0x01;
data_status_req[3] = 0x00;
data_status_req[4] = 0x31;
data_status_req[5] = 0x15;
data_status_req[6] = 0x12;
std::cout << "Status Request Daten: " << std::showbase << std::hex << data_status_req << " Bytes: " << std::showbase << std::dec << (DWORD) strlen(data_status_req) << std::endl;

DWORD dwBytesWRITE = 0;
dwBytesWRITE = comport.Send(data_status_req); std::cout << "Status Request Daten gesendet - gesendete Bytes:" << std::showbase << std::dec << dwBytesWRITE<< std::endl;
dwBytesRead = 0;
data[0] = '\0';



dwBytesRead = comport.Receive(data, max_datasize+100);
if (dwBytesRead){
std::cout << "Status Meldung empfangen," << " Daten: " << std::showbase << std::hex << data << std::dec << " bytesread: " << dwBytesRead << std::endl; // Fehler
}
else
std::cout << "keine Status Meldung empfangen," << " Daten: " << std::showbase << std::hex << data << std::dec << " bytesread: " << dwBytesRead << std::endl; std::cout << std::endl;
/**/

// close COM
comport.CloseCom();
std::cout << "Port geschlossen" << std::endl;

return 0;
}

Vielen Dank Jower