void TH200COM::LoadData2TH200
{
//COMMAND 18, Initialize TAG, Descriptor, Date
	BYTE* TAG=PackASCII(MyApp->GetView()->GetVarTAG(), 8);
	BYTE* Descriptor=PackASCII(MyApp->GetView()->GetVarDescriptor(), 12);
	BYTE Day=(BYTE)MyApp->GetView()->iDay;
	BYTE Month=(BYTE)MyApp->GetView()->iMonth;
	BYTE Year=(BYTE)(MyApp->GetView()->iYear-1900);
	BYTE HARTCOMMAND_018[35] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x82, 0xAA, Flags, DeviceId[0], DeviceId[1], DeviceId[2],
		  0x12, 0x15, TAG[0], TAG[1], TAG[2], TAG[3], TAG[4], TAG[5], Descriptor[0], Descriptor[1], Descriptor[2], Descriptor[3],
		  Descriptor[4], Descriptor[5], Descriptor[6], Descriptor[7], Descriptor[8], Descriptor[9], Descriptor[10], Descriptor[11], 
		  Day, Month, Year, 0x00};
	HARTCOMMAND_018[34] = BuildChecksum(HARTCOMMAND_018, 34);
}

/*This method convert ascii to packed ascii:
    1.converts the 4 received bytes from hex to binary format.
    2.the 4 received bytes(binary) are seperated in 3 parts, 
      remove bit 6 and bit 5
    3.converts back to hex format
	  BinaryValue = ascii in binary format(4Bytes)
	  Packed = Packed ascii in binary format(3Bytes)
	  PackedASCII = return packed ascii in hex format*/
BYTE* TH200COM::PackASCII(CString String, int StringLength)
{	 
	BYTE BinaryValue[32][8], Packed[24][8], PackedASCII[24];
	int nValue[32];	

	for(int i=String.GetLength(); i<StringLength; i++) String+="_"; 

	for(int i=0; i<StringLength; i++)
	{		
	   nValue[i]=(int)String[i];
	   if(nValue[i]>96){nValue[i]=nValue[i]-32;}
	   else{nValue[i]=nValue[i];}

	    if(nValue[i]>=128) {BinaryValue[i][7]=1; nValue[i]-=128;} else BinaryValue[i][7]=0;
		if(nValue[i]>=64) {BinaryValue[i][6]=1; nValue[i]-=64;} else BinaryValue[i][6]=0;
		if(nValue[i]>=32) {BinaryValue[i][5]=1; nValue[i]-=32;} else BinaryValue[i][5]=0;
		if(nValue[i]>=16) {BinaryValue[i][4]=1; nValue[i]-=16;} else BinaryValue[i][4]=0;
		if(nValue[i]>=8) {BinaryValue[i][3]=1; nValue[i]-=8;} else BinaryValue[i][3]=0;
		if(nValue[i]>=4) {BinaryValue[i][2]=1; nValue[i]-=4;} else BinaryValue[i][2]=0;
		if(nValue[i]>=2) {BinaryValue[i][1]=1; nValue[i]-=2;} else BinaryValue[i][1]=0;
		if(nValue[i]>=1) {BinaryValue[i][0]=1; nValue[i]-=1;} else BinaryValue[i][0]=0;
	}

	int j=1, k=0, l=2, m=1, n=3;
	for(int i=0; i<24; i=i+3)
	{
		Packed[i][0]=BinaryValue[i+j][4]; 
		Packed[i][1]=BinaryValue[i+j][5];
		Packed[i][2]=BinaryValue[i+k][0]; 
		Packed[i][3]=BinaryValue[i+k][1]; 
		Packed[i][4]=BinaryValue[i+k][2];
		Packed[i][5]=BinaryValue[i+k][3];
		Packed[i][6]=BinaryValue[i+k][4];
		Packed[i][7]=BinaryValue[i+k][5];

		Packed[i+1][0]=BinaryValue[i+l][2];
		Packed[i+1][1]=BinaryValue[i+l][3];
		Packed[i+1][2]=BinaryValue[i+l][4];
		Packed[i+1][3]=BinaryValue[i+l][5];
		Packed[i+1][4]=BinaryValue[i+m][0];
		Packed[i+1][5]=BinaryValue[i+m][1];
		Packed[i+1][6]=BinaryValue[i+m][2];
		Packed[i+1][7]=BinaryValue[i+m][3];

		Packed[i+2][0]=BinaryValue[i+n][0];
		Packed[i+2][1]=BinaryValue[i+n][1];
		Packed[i+2][2]=BinaryValue[i+n][2];
		Packed[i+2][3]=BinaryValue[i+n][3];
		Packed[i+2][4]=BinaryValue[i+n][4];
		Packed[i+2][5]=BinaryValue[i+n][5];
		Packed[i+2][6]=BinaryValue[i+l][0];
		Packed[i+2][7]=BinaryValue[i+l][1];

		j++; k++; l++; m++; n++;
	}
//conversion from binary to hex format
	for(int i=0; i<24; i++)
	{
		int nValue[24];
		nValue[i]=0;

	if(Packed[i][0]==1) {nValue[i]+=1;} else {nValue[i]+=0;}
	if(Packed[i][1]==1) {nValue[i]+=2;} else {nValue[i]+=0;}
	if(Packed[i][2]==1) {nValue[i]+=4;} else {nValue[i]+=0;}
	if(Packed[i][3]==1) {nValue[i]+=8;} else {nValue[i]+=0;}
	if(Packed[i][4]==1) {nValue[i]+=16;} else {nValue[i]+=0;}
	if(Packed[i][5]==1) {nValue[i]+=32;} else {nValue[i]+=0;}
	if(Packed[i][6]==1) {nValue[i]+=64;} else {nValue[i]+=0;}
	if(Packed[i][7]==1) {nValue[i]+=128;} else {nValue[i]+=0;}

	PackedASCII[i]=(BYTE)nValue[i];
	}
  return PackedASCII;
}

(Eine gute Idee wäre es, statt des nackten Arrays eine Array-Klasse zu verwenden - std::vector<BYTE>, std::string oder auch MFC-Container)

vector<BYTE> TH200COM::PackASCII(CString String, int StringLength)
{
  ...//den eigentlichen Funktionsrumpf kannst du normal übernehmen
  return vector<BYTE>(PackedASCII,PackedASCII+24);
}

vector<BYTE> TAG=PackASCII(MyApp->GetView()->GetVarTAG(), 8);
vector<BYTE> Descriptor=PackASCII(MyApp->GetView()->GetVarDescriptor(), 12);

Möglichkeit 2 - lass dir vom Aufrufer Speicher bereitstellen:

void TH200COM::PackASCII(CString String,int StringLength,BYTE* PackedASCII)
{
  BYTE BinaryValue[32][8], Packed[24][8] /*fällt weg:, PackedASCII[24]*/;
  ...//Rest wie gehabt
  return;
}

BYTE TAG[24],Desprictor[24];
PackASCII(MyApp->GetView()->GetVarTAG(),8,TAG);
PackASCII(MyApp->GetView()->GetVarDescriptor(),12,Descriptor);

Alternativ könntest du die Variable PackedASCII auch static deklarieren und nach jedem Funktionsaufruf in ein eigenes Array kopieren oder dynamisch per new Speicher anfordern (den muß dein Hauptprogramm freigeben, wenn er nicht mehr gebraucht wird).