////////////////////////////////////////////////////////////////
// CFGSocket 2004 (c) SofTech di Germinara Francesco 2000,2004
//                      www.germinara.it info@germinara.it
//
// Story:       First Release 29/04/2004        
// 
////////////////////////////////////////////////////////////////
// Checked Version: 29/4/2004
////////////////////////////////////////////////////////////////


// CFGSocket.cpp : implementation file
//

#include "stdafx.h"
#include "CFGSocket.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CFGSocket

CFGSocket::CFGSocket()
{
 int i=0;
 for(i=0;i<4;i++)
  StatoIO.IOStatus[i]=0x00;
  
  m_OpenConnection=FALSE;
}

CFGSocket::~CFGSocket()
{
	Close();  
	m_OpenConnection=FALSE;
}


void CFGSocket::OnAccept(int nErrorCode) 
{
		
	CSocket::OnAccept(nErrorCode);
}


void CFGSocket::InitDevice(CString ipAddress,UINT nPort){
 ipAddr=decodeAddress(ipAddress) ;
	// Clear IP address fields
	memset( (char*) &addr, 0, sizeof( addr ) );
	memset( (char*) &clientAddr, 0, sizeof( clientAddr ) );

	// Set my IP address : TCP port 
	addr.sin_family = AF_INET;
	addr.sin_port = htons(nPort);	
	addr.sin_addr.s_addr = INADDR_ANY;

	clientAddr.sin_family = AF_INET;
	clientAddr.sin_port = htons(nPort);
	clientAddr.sin_addr.s_addr = htonl(ipAddr);
	
	clientLenght = sizeof(clientAddr);
}


//Decode ipaddress string in ipaddress value
unsigned int CFGSocket::decodeAddress(CString ipAddr){

 char *a,*pTmp;
	char *dot;
	unsigned int addr = 0;
	
	a=(char*)calloc(32,1);
	pTmp=a;
	strcpy(a,ipAddr);
	
	dot = strchr(a,'.');
	if (!dot )
		return 0;
	
	*dot = '\0';
	addr = atoi(a)<<24;
	a = dot + 1;
	dot = strchr(a,'.');
	
	if (!dot )
		return 0;
	
	*dot = '\0';
	addr |= atoi(a)<<16;
	a = dot + 1;
	dot = strchr(a,'.');
	
	if (!dot )
		return 0;

	*dot = '\0';
	addr |= atoi(a)<<8;
	a = dot + 1;
	addr |= atoi(a);

 free(pTmp);
	return addr;
}

//Leggo stato di Input e Output
bool CFGSocket::ReadStatus(){
   char commandBuf, *responseBuf=NULL;
   int  commandLen;
   commandBuf=IOGet;
   commandLen=1;
   bool sts=false;   
   if(SendTo(&commandBuf,commandLen,(struct sockaddr*)& clientAddr,clientLenght,0) != SOCKET_ERROR){
    Sleep(50);   
    //Ok,leggo i dati ...
    int nLenReceived=0;
    responseBuf=(char*) calloc(0x10,1);
    if( nLenReceived = ReceiveFrom(responseBuf,0x10,(struct sockaddr*)& clientAddr,&clientLenght,0) > 3){
      for(int i=0; i<4; i++)
       StatoIO.IOStatus[i]=responseBuf[i];
      sts=true;  
      /* Debug only 
       CString msg;
       msg.Format("Valori letti: Input: [%x] [%x] OutPut: [%x] [%x]",StatoIO.IOStatus[0],StatoIO.IOStatus[1],StatoIO.IOStatus[2],StatoIO.IOStatus[3]);
       AfxMessageBox(msg);
      */
     }
     free(responseBuf);
   }
   return sts;
}


CFGSocket* CFGSocket::CreateSocket(CString IP, UINT nPort)
{
	ASSERT(this);
	if (!Create()){
		return NULL;
	}
	while(!Connect(IP , nPort)){
		return NULL;
	}
	
	InitDevice(IP,nPort);
	
	m_OpenConnection=TRUE;
 return this;
}



BOOL CFGSocket::TestConnection(CString IP, UINT nPort)
{
	ASSERT(this);

	if (!Create())
	{
		return FALSE;
	}

	while (!Connect(IP , nPort)){
		return FALSE;
	}

	Close();
	return TRUE;
}


//Imposto il valore del bit specificato
void CFGSocket::SetBit(int nBit,BOOL sts){
 if(nBit<0)
  return; //NOP
 
 dato.byte=word.byte.msb;
 switch(nBit){
  case 0: dato.bit.b0=sts; break;
  case 1: dato.bit.b1=sts; break;
  case 2: dato.bit.b2=sts; break;
  case 3: dato.bit.b3=sts; break;
  case 4: dato.bit.b4=sts; break;
  case 5: dato.bit.b5=sts; break;
  case 6: dato.bit.b6=sts; break;
  case 7: dato.bit.b7=sts; break;
 }
 word.byte.msb=dato.byte;

 dato.byte=word.byte.lsb;
 switch(nBit){
  case  8: dato.bit.b0=sts; break;
  case  9: dato.bit.b1=sts; break;
  case 10: dato.bit.b2=sts; break;
  case 11: dato.bit.b3=sts; break;
  case 12: dato.bit.b4=sts; break;
  case 13: dato.bit.b5=sts; break;
  case 14: dato.bit.b6=sts; break;
  case 15: dato.bit.b7=sts; break;
 }
 word.byte.lsb=dato.byte;
}

//Imposto il valore del bit specificato
void CFGSocket::SetBit(CString strNBit,BOOL sts){
 int nBit=0;
 if(strNBit.IsEmpty() || strNBit=="  ")
  return; //NOP
 nBit=atoi(strNBit);
 SetBit(nBit,sts);
}


//Restituisce il valore del bit specificato
BOOL CFGSocket::GetBit(int nBit){
 if(nBit<8){
  dato.byte=word.byte.msb;
  switch(nBit){
   case 0: return dato.bit.b0;
   case 1: return dato.bit.b1;
   case 2: return dato.bit.b2;
   case 3: return dato.bit.b3;
   case 4: return dato.bit.b4;
   case 5: return dato.bit.b5;
   case 6: return dato.bit.b6;
   case 7: return dato.bit.b7;
   default: return FALSE;
  }
 }else{
  dato.byte=word.byte.lsb;
  switch(nBit){
   case  8: return dato.bit.b0; 
   case  9: return dato.bit.b1;
   case 10: return dato.bit.b2;
   case 11: return dato.bit.b3;
   case 12: return dato.bit.b4;
   case 13: return dato.bit.b5;
   case 14: return dato.bit.b6;
   case 15: return dato.bit.b7;
   default: return FALSE;
  }
 }
}

//Restituisce il valore del bit specificato
BOOL CFGSocket::GetBit(CString strNBit){
 int nBit=0;
 nBit=atoi(strNBit);
 return GetBit(nBit);
}

void CFGSocket::ShowInputStatus(CString& msgStsInp){
 CString fit;
 BOOL sts=0;
 word.dw = StatoIO.porta.input.dw;
 msgStsInp="Stato Input: ";
 for(int i=0; i< 16; i++){
  sts=GetBit(i);
  fit.Format("b%02d[%s] ",i, sts==0 ? "Off" : "On");
  msgStsInp+=fit;
 }
}

void CFGSocket::ShowOutputStatus(CString& msgStsOut){
 CString fit;
 BOOL sts=0;
 word.dw = StatoIO.porta.output.dw;
 msgStsOut="Stato Output: ";
 for(int i=0; i< 16; i++){
  sts=GetBit(i);
  fit.Format("b%02d[%s] ",i, sts==0 ? "Off" : "On");
  msgStsOut+=fit;
 }
}


//Imposto stato Output
BOOL CFGSocket::SetOutput(){
   char commandBuf[3], *responseBuf=NULL;
   int  commandLen;
   int outbit=0,outdata=0;
   
   commandBuf[0]=IOSet;
   commandBuf[1]=(BYTE)StatoIO.porta.output.byte.lsb;
   commandBuf[2]=(BYTE)StatoIO.porta.output.byte.msb;
   
   commandLen=3;
   bool sts=false;   
   if(SendTo(&commandBuf,commandLen,(struct sockaddr*)& clientAddr,clientLenght,0) != SOCKET_ERROR){
    sts=true;
   }
   
   Sleep(50);
   return sts;
}


BOOL CFGSocket::GetInputStatus(int nBit){
 BOOL sts=0;
 word.dw = StatoIO.porta.input.dw;
 sts=GetBit(nBit);
 return sts;
}

BOOL CFGSocket::GetOutputStatus(int nBit){
 BOOL sts=0;
 word.dw = StatoIO.porta.output.dw;
 sts=GetBit(nBit);
 return sts;
}

void CFGSocket::SetOutputStatus(int nBit,BOOL status){
 BOOL sts=0;
 word.dw = StatoIO.porta.output.dw;
 SetBit(nBit,status);
 StatoIO.porta.output.dw=word.dw;
}

void CFGSocket::SetAllOutputStatus(BOOL status){
 for(int i=0;i<16;i++)
  SetOutputStatus(i,status);
 SetOutput();  
}

//End