Habe eine frage zu Visual C++ Express Edition

[twickl]

Hallo,

ich habe mir die oben genannte Entwicklungsumgebung istalliert. Normalerweise programmiere ich Delphi oder C# bin aber noch Newbie. Der Grund für C++ ist das ansprechen einer Wetterstation die ich besitze. Mit C# habe ich es nicht geschagft aber dafür einen C++ Klasse gefunden mit der es bei anderen funktioniert.
Natürlich habe ich auch das PlatformSDK installiert um die nötigen headerdateien zu bekommen. Kann es sein das es trotzdem nicht möglich ist eine C++ Klasse die nciht .Net ist zu verwenden? Speziell geht es um die Serielle Schnittstelle. In dem Source passiert folgendes:

CWStation::CWStation(int COMNr)
{
	char COMPort[5];

	BufCnt = 0;

	sprintf(COMPort, "COM%d", COMNr);

	hWStat = CreateFile(COMPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

	if (hWStat == INVALID_HANDLE_VALUE)
		throw -1;

	// Datenübertragung vereinbaren
	// 19200 Baud, Even Parity, 8 bit Data und 2 Stop Bits,
	GetCommState(hWStat, &DCBStruct);
	DCBStruct.BaudRate	= CBR_19200;
	DCBStruct.Parity	= EVENPARITY;
	DCBStruct.StopBits	= TWOSTOPBITS;
	DCBStruct.ByteSize  = 8;
	SetCommState(hWStat, &DCBStruct);
}

In dem CreateFile habe ich dann noch den ersten Parameter als TEXT("COMPort") umgeschrieben da ich sonst nicht kompileiren konnte. Aber wenn ich das Programm starte bekomme ich ein RuntimeError nach dem If. Geht das vielleicht in .Net nicht so?

Die gesamte Klasse die ich benutzen möchte sieht folgendemassen aus:

Header:

/*****************************************************************************************************************
WS2500Access 
(c) 2005 Thomas Unterluggauer
E-Mail: tom.u@gmx.at
******************************************************************************************************************/

#ifndef WSTATIONACC_H
#define WSTATIONACC_H

#include <stdio.h>
#include <windows.h>
#include <time.h>

#define WSBUFSIZE 255

typedef enum {ACTIVATECOM, REQUESTDCF, NEXTDATASET, FIRSTDATASET, GETDATASET,\
		STATUS, INTERFACE} Command;

struct DCFDateTime
{
	bool			Status;
	unsigned short	Year;
	unsigned char	Month;
	unsigned char	Day;
	unsigned char	Second;
	unsigned char	Minute;
	unsigned char	Hour;
	unsigned char	Weekday;
};

struct WS2500Status
{
	unsigned char TempStatus[8];
	unsigned char RainStatus;
	unsigned char WindStatus;
	unsigned char LumStatus;
	unsigned char PyranStatus;
	unsigned char InsideStatus;
	unsigned char Interval;
	bool		  Language;
	bool		  DCFSync;
	bool		  HasDCF;
	bool		  Protocol;
	bool		  WS2500Type;
	unsigned char Version;
	unsigned char AddrRain;
	unsigned char AddrWind;
	unsigned char AddrLum;
	unsigned char AddrInside;
};

struct WS2500Temp
{
	bool	NewFlag;
	double	Temperature;
	double	Humidity;
};

struct WS2500Wind
{
	bool	Newflag;
	double	Speed;
	double	Direction;
	double	Tolerance;
};

struct WS2500Inside
{
	WS2500Temp	TempHum;
	unsigned	Pressure;
	bool		NewFlag;
};

struct WS2500Rain
{
	bool		NewFlag;
	unsigned	Count;
};

struct WS2500Lum
{
	unsigned	Lumidity;
	unsigned	Factor;
	bool		NewFlag;
	bool		Sunshine;
};

struct WS2500Sun
{
	unsigned	Count;
	bool		NewFlag;
};

struct WS2500Pyran
{
	int		Energy;
	int		Factor;
	bool	NewFlag;
};

struct WS2500Data
{
	unsigned short	BlockNr;
	time_t			DateTime;
	WS2500Temp		TempSens[8];
	WS2500Rain		RainSens;
	WS2500Wind		WindSens;
	WS2500Lum		LumSens;
	WS2500Sun		SunSens;
	WS2500Pyran		PyranSens;
	WS2500Inside	InsideSens;
};

class CWStation
{
private:
	HANDLE	hWStat;						// Handle zur seriellen Schnittstelle
	DCB		DCBStruct;					// DCB Struktur für Settings der seriellen Schnittstelle
	BYTE	Buffer[WSBUFSIZE];			// Buffer
	int		BufCnt;						

public:
	CWStation(int COMNr);				// Konstruktor nimmt COM Port entgegen
	~CWStation();						// Destruktor

	bool ActivateConnection();			// Verbindung aufbauen
	void KillConnection();				// Verbindung abbrechen
	bool GetDCFDateTime(DCFDateTime &Date);		// Hole die "Funkuhrzeit"
	bool GetStatus(WS2500Status &Status);		// Hole Status der WS2500 

	bool MoveFirst();					// Setze Zeiger auf erstes Element
	bool MoveNext();					// Setze Zeiger auf letztes Element
	bool RecvData(WS2500Data &Data, WS2500Status &Status);		// Daten werden zurückgegeben, wenn die Funktion true 
																// liefert, der Status MUSS vorher abgefragt werden, um
																// um ihn hier zu übergeben (eine Referenz wegs besserer
																// Performance)
	bool SetInterval(WS2500Status &Status, unsigned Minutes);	// Nicht fehlerfrei - funktioniert nicht
private:

	void SetDTR();	
	void ClearDTR();
	void SetRTS();
	void ClearRTS();

	bool ExecCmd(Command Cmd, char *Param);
	bool SendCmd(Command Cmd, char *Param);
	int	 RecvData();

	void ReplaceSymbols();
	bool TrimData();

	// Methoden zum Zerlegen von Bytes
	unsigned char GetHighNibble(unsigned char Byte);
	unsigned char GetLowNibble(unsigned char Byte);
	bool GetBit(unsigned char Byte, unsigned char Bit);
};

#endif

CPP:

/*****************************************************************************************************************
WS2500Access 
(c) 2005 Thomas Unterluggauer
E-Mail: tom.u@gmx.at
******************************************************************************************************************/

#include "WStationAccess.h"

#define SOH 0x01
#define EOT 0x04
#define STX 0x02
#define ETX 0x03
#define ENQ 0x05
#define NAK 0x15
#define DC2 0x12
#define DC3 0x13
#define ACK 0x06
#define DLE 0x10

#define TRYCNT 3

CWStation::CWStation(int COMNr)
{
	char COMPort[5];

	BufCnt = 0;

	sprintf(COMPort, "COM%d", COMNr);

	hWStat = CreateFile(COMPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

	if (hWStat == INVALID_HANDLE_VALUE)
		throw -1;

	// Datenübertragung vereinbaren
	// 19200 Baud, Even Parity, 8 bit Data und 2 Stop Bits,
	GetCommState(hWStat, &DCBStruct);
	DCBStruct.BaudRate	= CBR_19200;
	DCBStruct.Parity	= EVENPARITY;
	DCBStruct.StopBits	= TWOSTOPBITS;
	DCBStruct.ByteSize  = 8;
	SetCommState(hWStat, &DCBStruct);
}

CWStation::~CWStation()
{
	if (hWStat != INVALID_HANDLE_VALUE)
		CloseHandle(hWStat);
}

bool CWStation::SendCmd(Command Cmd, char *Param)
{
	char			CommStr[15];
	unsigned long	Written;
	unsigned char	Commands[] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x44};

	if (Param)
	{
		sprintf(CommStr, "\x01%c%s\x00\x04", Commands[Cmd], Param);

		CommStr[6] = 256 - CommStr[1] - CommStr[2] - CommStr[3] - CommStr[4] - CommStr[5];
		CommStr[6] |= 128;

		return WriteFile(hWStat, CommStr, 8, &Written, 0);
	}
	else
	{
		if (Cmd == INTERFACE)
		{
			sprintf(CommStr, "\x01%c\x00\x00\x00\x00%c\x04", Commands[Cmd], (256-Commands[Cmd]) | 128);
			return WriteFile(hWStat, CommStr, 8, &Written, 0); 
		}
		else
		{
			sprintf(CommStr, "\x01%c%c\x04", Commands[Cmd], (256-Commands[Cmd]) | 128);
			return WriteFile(hWStat, CommStr, 4, &Written, 0); 
		}
	}
}

int CWStation::RecvData()
{
	unsigned long	Read = 1;
	int				Err  = 1;
	unsigned long	Event;
	COMMTIMEOUTS	CommTOStruct;

	BufCnt		= 0;
	Buffer[0]	= 0;

	GetCommTimeouts(hWStat, &CommTOStruct);

	CommTOStruct.ReadTotalTimeoutConstant	= 60;
	CommTOStruct.ReadIntervalTimeout		= MAXDWORD;
	CommTOStruct.ReadTotalTimeoutMultiplier = MAXDWORD;

	SetCommTimeouts(hWStat, &CommTOStruct);

	while (Buffer[BufCnt-1?BufCnt:0] != ETX && Err != 0 && Read > 0)
	{
		Err = ReadFile(hWStat,Buffer + BufCnt,WSBUFSIZE - BufCnt, &Read, 0);
		BufCnt+=Read;
	}

	if (Err == 0)
		return -1;

	return 0;
}

bool CWStation::ExecCmd(Command Cmd, char *Param)
{
	int TryCount = TRYCNT;

	while (TryCount)
	{
		SendCmd(Cmd, Param);

		Sleep(50);
		if (RecvData() == 0)
		{
			ReplaceSymbols();

			if (TrimData())
				break;
			else if (!ActivateConnection())
				return false;
		}
	}

	if (TryCount != -1)
		return true;

	return false;
}

void CWStation::ReplaceSymbols()
{
	int		a;
	char	c;

	for (a = 1; a < BufCnt - 2; a++) 
	{
		c = '\0';
		if (Buffer[a] == ENQ && Buffer[a + 1] == DC2)
			c = STX;
		else if (Buffer[a] == ENQ && Buffer[a + 1] == DC3)
			c = ETX;
		else if (Buffer[a] == ENQ && Buffer[a + 1] == NAK)
			c = ENQ;
		if (c) 
		{
			Buffer[a] = c;
			memmove(Buffer + a + 1, Buffer + a + 2, BufCnt - a - 2);
			BufCnt--;
		}
	}
}

bool CWStation::TrimData()
{
	unsigned char	Length,	 Checksum,	Sum;
	int				a;

	if (Buffer[0] != STX || Buffer[BufCnt - 1] != ETX) 
		return false;

	Length = Buffer[1];

	if (Length != (BufCnt - 4))
		return false;

	Checksum = Buffer[BufCnt - 2];
	Sum = 0;

	for (a = 0; a < BufCnt - 2; ++a)
		Sum += Buffer[a];

	Sum += Checksum;

	if (Sum != 0)
		return false;

	memmove(Buffer, Buffer + 2, BufCnt - 2);		// Die ersten und letzten beiden Zeichen entfernen

	if (Length == 1 && Buffer[0] == NAK)
		return false;

	BufCnt = Length;

	return true;
}

bool CWStation::ActivateConnection()
{

	// Stoppe Wetterstation (sie könnte aktiv sein)
	ClearDTR();
	SetRTS();
	Sleep(90);		

	// Starte sie
	SetDTR();
	ClearRTS();
	Sleep(40);

	for (int i = 400; i > 0; i--)
	{
		SendCmd(ACTIVATECOM, NULL);

		// Warte für 40 ms
		//Sleep(40);

		if (!RecvData() && BufCnt == 5)
			break;
	}

	if (i == 0)		// Interface hat nicht geantwortet, somit konnte keine Verbindung hergestellt werden
		return false;

	return true;
}

bool CWStation::GetStatus(WS2500Status &Status)
{
	unsigned char High, Low;

	if (!ExecCmd(STATUS, NULL))
		return false;

	if (BufCnt == 16)
	{
		for (int i = 0; i < 8; i++)
			Status.TempStatus[i] = Buffer[i];

		Status.Version		= 10;
		Status.RainStatus	= Buffer[8];
		Status.WindStatus	= Buffer[9];
		Status.LumStatus	= Buffer[10];
		Status.PyranStatus	= Buffer[11];
		Status.InsideStatus	= Buffer[12];
		Status.Interval		= Buffer[13];

		Status.Language		= GetBit(Buffer[14],0);
		Status.DCFSync		= GetBit(Buffer[14],1);
		Status.HasDCF		= GetBit(Buffer[14],2);
		Status.Protocol		= GetBit(Buffer[14],3);
		Status.WS2500Type	= GetBit(Buffer[14],4);
		Status.AddrInside	= Buffer[14] >> 5 & 7;

		High = GetHighNibble(Buffer[15]);
		Low	 = GetLowNibble(Buffer[15]);

		if (High != 1 || Low != 0)
			return false;

		Status.Version		= High * 10 + Low;

		Status.AddrLum		= -1;
		Status.AddrRain		= -1;
		Status.AddrWind		= -1;
	}
	else if (BufCnt == 17)
	{
		for (int i = 0; i < 8; i++)
			Status.TempStatus[i] = Buffer[i];

		Status.Version		= 31;
		Status.RainStatus	= Buffer[8];
		Status.WindStatus	= Buffer[9];
		Status.LumStatus	= Buffer[10];
		Status.InsideStatus	= Buffer[11];

		Status.PyranStatus	= -1;

		Status.Interval		= Buffer[12];
		Status.Language		= GetBit(Buffer[13], 0);
		Status.DCFSync		= GetBit(Buffer[13], 1);
		Status.HasDCF		= GetBit(Buffer[13], 2);
		Status.Protocol		= GetBit(Buffer[13], 3);
		Status.WS2500Type	= GetBit(Buffer[13], 4);

		High	= GetHighNibble(Buffer[14]);
		Low		= GetLowNibble(Buffer[14]);

		if ((Low != 1 && Low != 2) || (High != 3 && High != 1))
			return false;

		Status.Version		= High * 10 + Low;

		Status.AddrRain		= Buffer[15] & 7;
		Status.AddrWind		= Buffer[15] >> 4 & 7;
		Status.AddrLum		= Buffer[16] & 7;
		Status.AddrInside	= Buffer[16] >> 4 & 7;
	}
	else
		return false;

	return true;
}

bool CWStation::GetDCFDateTime(DCFDateTime &Date)
{
	if (!ExecCmd(REQUESTDCF, NULL))
		return false;

	if (BufCnt != 6)
		return false;

	Date.Hour		= GetHighNibble(Buffer[0])*10 + GetLowNibble(Buffer[0]);
	Date.Minute		= GetHighNibble(Buffer[1])*10 + GetLowNibble(Buffer[1]);
	Date.Second		= Buffer[2];

	Date.Day		= GetHighNibble(Buffer[3]*10) + GetLowNibble(Buffer[3]);
	Date.Month		= GetLowNibble(Buffer[4]);
	Date.Weekday	= Buffer[4] >> 4 & 7;
	Date.Status		= GetBit(Buffer[4], 7);
	Date.Year		= GetHighNibble(Buffer[5])*10 + GetLowNibble(Buffer[5]);

	if (Date.Status && (Date.Month == 3) && (Date.Day == 1) && (Date.Hour < 3))
		Date.Status = false;

	return true;
}

void CWStation::SetDTR()
{
	EscapeCommFunction(hWStat, SETDTR);
}

void CWStation::ClearRTS()
{
	EscapeCommFunction(hWStat, CLRRTS);
}

void CWStation::ClearDTR()
{
	EscapeCommFunction(hWStat, CLRDTR);
}

void CWStation::SetRTS()
{
	EscapeCommFunction(hWStat, SETRTS);
}

unsigned char CWStation::GetHighNibble(unsigned char Byte)
{
	return Byte/16;
}

unsigned char CWStation::GetLowNibble(unsigned char Byte)
{
	return Byte%16;
}

bool CWStation::GetBit(unsigned char Byte, unsigned char Bit)
{
	return Byte >> Bit & 1;
}

bool CWStation::MoveFirst()
{
	if (!ExecCmd(FIRSTDATASET, NULL))
		return false;

	if (BufCnt == 1 && Buffer[0] == ACK)
		return true;

	return false;
}

bool CWStation::MoveNext()
{
	if (!ExecCmd(NEXTDATASET, NULL))
		return false;

	if (BufCnt != 1 || Buffer[0] == DLE)
		return false;

	printf("Moved next\n\n");

	return true;
}

bool CWStation::RecvData(WS2500Data &Data, WS2500Status &Status)
{
	time_t	t;
	BYTE	*Ptr;
	double	Tmp;
	int		i, j;

	if (!ExecCmd(GETDATASET, NULL))
		return false;

	if (BufCnt == 1 && Buffer[0] == DLE)
		return false;

	if (BufCnt != 36)
		return false;

	Data.BlockNr	= Buffer[0] + Buffer[1] * 256;
	Data.DateTime	= Buffer[2] + Buffer[3] * 256;

	time(&t);
	t = ((int)(t/60)) * 60;

	Data.DateTime		= t - Data.DateTime * 60;

	Ptr = Buffer + 4;

	// Temperatur und Feuchtigkeitsensoren Schema 1
	for (i = 0, j = 0; i < 8; i+=2, j+=5)
	{
		if (Status.TempStatus[i] >= 16)
		{
			Data.TempSens[i].Temperature	= ((double)GetLowNibble(Ptr[j])/10 + GetHighNibble(Ptr[j]) + (Ptr[j+1] & 7) * 10)*(GetBit(Ptr[j+1],3)?-1:1);
			if ((Tmp = GetHighNibble(Ptr[j+1])) > 9)
				Data.TempSens[i].Humidity = -1;
			else
				Data.TempSens[i].Humidity = Tmp + 20 + (Ptr[j+2] & 7) * 10;
			Data.TempSens[i].NewFlag = GetBit(Ptr[j+2], 3);
		}
	}

	// Temperatur & Feuchtigkeitssensor 2
	for (i = 1, j = 2; i < 8; i+=2, j+=5)
	{
		if (Status.TempStatus[i] >= 16)
		{
			Data.TempSens[i].Temperature	= ((double)GetHighNibble(Ptr[j])/10 + GetLowNibble(Ptr[j+1]) + (Ptr[j+1] >> 4 & 7) * 10)*(GetBit(Ptr[j+1],7)?-1:1);
			if ((Tmp = GetLowNibble(Ptr[j+2])) > 9)
				Data.TempSens[i].Humidity = -1;
			else
				Data.TempSens[i].Humidity = Tmp + 20 + (Ptr[j+2] >> 4 & 7) * 10;
			Data.TempSens[i].NewFlag = GetBit(Ptr[j+2], 7);
		}
	}

	if (Status.Version == 10)		// BIOS Version 1.0
	{
		// Niederschlagsmessung -> Counter abfragen (jedes mal Wippen (370 ml) ergibt 1 Count)
		if (Status.RainStatus >= 16)
		{
			Data.RainSens.Count		= Ptr[20] & 0x7F;
			Data.RainSens.NewFlag	= GetBit(Ptr[20], 7);
		}
		// Windgeschwindigkeitsmessung
		if (Status.WindStatus >= 16)
		{
			Data.WindSens.Speed		= (double)GetLowNibble(Ptr[21])/10 + GetHighNibble(Ptr[21]) + GetLowNibble(Ptr[22])*10;
			Data.WindSens.Direction = (int)GetHighNibble(Ptr[22])*10 + (int)(Ptr[23] & 3)*100 + (GetBit(Ptr[23], 4)?5:0);
			Data.WindSens.Newflag	= GetBit(Ptr[23], 7);
			switch (Ptr[23] >> 2 & 3)
			{
			case 0:
				Data.WindSens.Tolerance = 0;
				break;
			case 1:
				Data.WindSens.Tolerance = 22.5;
				break;
			case 2:
				Data.WindSens.Tolerance = 45;
				break;
			case 3:
				Data.WindSens.Tolerance = 67.5;
				break;
			}
		}
		// Luftdruck, Temperatur, und Luftfeuchte Innen
		if (Status.InsideStatus >= 16)
		{
			Data.InsideSens.Pressure = GetLowNibble(Ptr[24]) + GetHighNibble(Ptr[24]) * 10 + GetLowNibble(Ptr[25])*100;

			Data.InsideSens.TempHum.Temperature	= ((double)GetHighNibble(Ptr[25])/10 + GetLowNibble(Ptr[26]) + (Ptr[26] >> 4 & 7) * 10)*(GetBit(Ptr[26],7)?-1:1);

			if ((Tmp = GetLowNibble(Ptr[27])) > 9)
				Data.InsideSens.TempHum.Humidity = -1;
			else
				Data.InsideSens.TempHum.Humidity	= Tmp + 20 + (Ptr[27] >> 4 & 7)*10;

			Data.InsideSens.NewFlag	= GetBit(Ptr[27],7);
		}
		// Helligkeit in Lux
		if (Status.LumStatus >= 16)
		{
			Data.LumSens.Lumidity = GetLowNibble(Ptr[28]) + GetHighNibble(Ptr[28])*10 + GetLowNibble(Ptr[29])*100;

			switch (Ptr[29] >> 4 & 3)
			{
			case 0:
				Data.LumSens.Factor = 1; break;
			case 1:
				Data.LumSens.Factor = 10; break;
			case 2:
				Data.LumSens.Factor = 100; break;
			case 3:
				Data.LumSens.Factor = 1000; break;
			}

			Data.LumSens.NewFlag	= GetBit(Ptr[29], 7);
			Data.LumSens.Sunshine	= GetBit(Ptr[29], 6);
		}
		// Strahlungsenergie
		if (Status.PyranStatus >= 16)
		{
			Data.PyranSens.Energy = GetLowNibble(Ptr[30]) + GetHighNibble(Ptr[30])*10 + GetLowNibble(Ptr[31])*100;

			switch (Ptr[31] >> 4 & 3)
			{
			case 0:
				Data.PyranSens.Factor = 1; break;
			case 1:
				Data.PyranSens.Factor = 10; break;
			case 2:
				Data.PyranSens.Factor = 100; break;
			case 3:
				Data.PyranSens.Factor = 1000; break;
			}

			Data.PyranSens.NewFlag = GetBit(Ptr[31], 7);
		}

		Data.SunSens.Count = 0;
	}
	else							// BIOS Version 1.1 oder 3.1
	{
		if (Status.WindStatus >= 16)
		{
			Data.WindSens.Speed		= (double)GetLowNibble(Ptr[20])/10 + GetHighNibble(Ptr[20]) + GetLowNibble(Ptr[21])*10;
			Data.WindSens.Direction = (int)GetHighNibble(Ptr[21])*10 + (int)(Ptr[22] & 3)*100 + (GetBit(Ptr[22], 4)?5:0);
			Data.WindSens.Newflag	= GetBit(Ptr[22], 7);

			switch (Ptr[22] >> 2 & 3)
			{
			case 0:
				Data.WindSens.Tolerance = 0;
				break;
			case 1:
				Data.WindSens.Tolerance = 22.5;
				break;
			case 2:
				Data.WindSens.Tolerance = 45;
				break;
			case 3:
				Data.WindSens.Tolerance = 67.5;
				break;
			}
		}
		if (Status.InsideStatus >= 16)
		{

			Data.InsideSens.Pressure = GetLowNibble(Ptr[23]) + GetHighNibble(Ptr[23]) * 10 + GetLowNibble(Ptr[24])*100;

			Data.InsideSens.TempHum.Temperature	= ((double)GetHighNibble(Ptr[24])/10 + GetLowNibble(Ptr[25]) + (Ptr[25] >> 4 & 7) * 10)*(GetBit(Ptr[25],7)?-1:1);

			if ((Tmp = GetLowNibble(Ptr[26])) > 9)
				Data.InsideSens.TempHum.Humidity = -1;
			else
				Data.InsideSens.TempHum.Humidity	= Tmp + 20 + (Ptr[26] >> 4 & 7)*10;

			Data.InsideSens.NewFlag	= GetBit(Ptr[26],7);
		}
		if (Status.RainStatus >= 16)
		{
			Data.RainSens.Count		= Ptr[27] + (Ptr[28] & 7 << 8);
			Data.RainSens.NewFlag	= GetBit(Ptr[28], 3);
		}
		if (Status.LumStatus >= 16)
		{
			Data.SunSens.Count   = GetHighNibble(Ptr[28]) + (Buffer[29] << 4 & 0xFF0);

			Data.LumSens.Lumidity = GetLowNibble(Ptr[30]) + GetHighNibble(Ptr[30])*10 + GetLowNibble(Ptr[31])*100;

			switch (Ptr[31] >> 4 & 3)
			{
			case 0:
				Data.LumSens.Factor = 1; break;
			case 1:
				Data.LumSens.Factor = 10; break;
			case 2:
				Data.LumSens.Factor = 100; break;
			case 3:
				Data.LumSens.Factor = 1000; break;
			}

			Data.LumSens.NewFlag	= GetBit(Ptr[31], 7);
			Data.LumSens.Sunshine	= GetBit(Ptr[31], 6);
		}
	}

	return true;
}

bool CWStation::SetInterval(WS2500Status &Status, unsigned Minutes)
{
	char	ParamBuffer[15];

	if (Status.Version <= 10)
		return false;

	if (Minutes < 2 || Minutes > 63)
		return false;

	sprintf(ParamBuffer, "%c%c%c%c", (int)(Minutes/2) | 128, Minutes | 128, 
											Status.AddrRain | (Status.Protocol << 3) | (Status.WindStatus & 7 << 4) | 128,
											Status.AddrLum | (Status.AddrInside & 7 << 4) | 128);

	printf("servus");
	if (!ExecCmd(INTERFACE, ParamBuffer))
		return false;

	printf("hier");
	if (BufCnt == 1 && Buffer[0] == ACK)
		return true;

	return false;
}

void CWStation::KillConnection()
{
	ClearDTR();
	SetRTS();
}

Muss ich vielleicht noch irgendwas beachten damit ich diese Klasse nutzen kann?
Ich hoffe ihr könnt mir helfen...ich versuche mich schon seit Monaten daran dieses Interface mit einem eigenen programm ansprechen zu können.

Vielen vielen Dank

twickl

[Jochen Kalmbach]

Mit der VC++ Express Edition kann man natürlich ganz "normale" C/C++ Programme erstellen (auch ohne .NET!).
1. Per default ist jetzt ein Projekt als UNICODE definiert, also verwende TCHAR und was dazugehört oder stelle das Projekt wieder zurück nach "MBCS" oder "ANSI" (in den Projekteingeschaften|General)
2. Verwende doch eine geprüfte, fertige Klasse für die serielle Kommunikation:
http://www.codeproject.com/system/serial.asp

3. Warum machst Du es nicht in C#? Da ist die serielle Kommunikation noch einfacher handzuhaben... also wenn Du es in C# nicht hinbekommst, dann wirst Du es in C++ gleich dreimal nicht hinbekommen...

[twickl]

Folgendes Problem: Mann muss mehrmals den Aktivierungsstring an das Gerät schicken und sobald es Antwortet hat man 60ms Zeit einen weiteren Befehl zu schicken sonst ist das Interface wieder deaktiviert. Nun habe ich das in C# versucht aber es klappt einfach nicht. Mit dieser Klasse arbeiten aber schon mehrere und haben keine Probleme damit. Das ist der Grund warum ich das auf diesem Weg versuche...c# wäre mir auch lieber. Vielleicht könnte man diese Klasse irgendwie zu einer DLL machen die ich dann in C# nutze aber ich habe keine Ahnung wie das geht
Wenn ich nun innerhalb diese Klasse alles auf eine andere Serielle Kommunikation umbaue und es nicht funktioniert kann ich nicht beurteilen ob ich etwas falsch programmiert habe oder nicht. Man, ich glaub ich verkauf das Interface einfach wieder

Gruß

twickl

[Jochen Kalmbach]

twickl schrieb:

Folgendes Problem: Mann muss mehrmals den Aktivierungsstring an das Gerät schicken und sobald es Antwortet hat man 60ms Zeit einen weiteren Befehl zu schicken sonst ist das Interface wieder deaktiviert.

Windows ist kein Echtzeitbetriebssystem. Es kann sowohl in C# als auch in C++ vorkommen, dass Du erst nach 100-500ms bemerkst, dass Daten angekommen sind. Deswegen ist das ganze Design zumindest unter Windows nicht so geschickt...

[twickl]

Da stimme ich dir zu und dennoch gibt es Programme die vollkommen zuverlässig damit funktionieren. Aber zu dem eigentlichen Problem scheint es keine Antwort zu geben, oder? Prinzipiell wollte ich ja nur wissen ob man diesen Code in .net verwenden kann oder warum dieser Fehler bei mir Auftritt da ich leider nicht so bewandert bin in c++. dafür aber sehr neugierig

Aber trotzdem danke für deine Hilfe

Gruß

twickl

[Jochen Kalmbach]

Ich hab Dir schon in meiner ersten Antwort einen Hinweis gegeben (UNICODE). In C++/CLI kannst Du auch "normales" C/C++ verwenden.
Da Du Dein problem aber nicht genau beschrieben hast (ausser hunderte Zeilen an Source-Code, den eh niemand liest; zumindest ich nicht; sonst könntest Du mich ja als Consulting anstellen), kann ich Dir auch nicht genau helfen.

[twickl]

Ich habe den Fehler entdeckt:

TEXT("COMPort") ist verkehrt und es müssen die Anführungszeichen verschwinden.

Danke für alles

twickl