// AUTOMGEN interpretor runtime	 - target
// Target specific file : Windows 32 bits OS - GUI
// (C) 2003-2008 IRAI

#include "windows.h"
#include "stdio.h"
#include "conio.h"
#include "core.h"
#include "com.h"
#include "io.h"

#include "resource.h"

//
// General functions
//

// Must return current time in ms in a DWORD, no matter the starting value
DWORD target_gettimeinms(void)
{
return GetTickCount();
}

// Return RTC time
void target_readrtc(unsigned short *ms,unsigned short *sec,unsigned short *min,unsigned short *hour,unsigned short *day,unsigned short *month,unsigned short *year)
{
SYSTEMTIME st;
GetLocalTime(&st);
*ms=st.wMilliseconds;
*sec=st.wSecond;
*min=st.wMinute;
*hour=st.wHour;
*day=st.wDay;
*month=st.wMonth;
*year=st.wYear;
}

// Called when a fatal error occurs
void target_fatal(void)
{
#ifdef _DEBUG
_asm int 3
#endif
}

// Return a 16 chars string target identifier
char *target_id(void)
{
static char id[16]="WINDOWS32 RTV01";
return id;
}

// Return a byte with bits as follow :
// b0= 0: time base 1ms (alsways 0, for 1 is for backward compatibility)
// b1= 0: integers are coded with LSB first, 1: integers are coded with MSB first 
unsigned char target_confbyte(void)
{
return 0;
} 

//
// Serial communication functions
//

HANDLE hcom=(HANDLE)-1;

// Open a serial port
int target_com_open(unsigned port,unsigned speed,unsigned parity,unsigned databit,unsigned stopbit)
{
DCB dcb;
char szBuff[16];
sprintf(szBuff,"COM%lu",port);
hcom=CreateFile(szBuff, GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,NULL);
if(hcom==(HANDLE)-1) return -1;
// 4 Ko buffers
SetupComm(hcom, 4096, 4096 ) ;
memset(&dcb,0,sizeof(dcb));
dcb.DCBlength=sizeof(dcb);
dcb.BaudRate=speed;
dcb.fBinary=1;
dcb.ByteSize=databit;
dcb.fRtsControl=RTS_CONTROL_DISABLE;
switch(parity)
	{
	case 'N' : 
		{	
		dcb.fParity=0;
		dcb.Parity=0;
		} break;
	case 'O' : 
		{	
		dcb.fParity=1;
		dcb.Parity=1;
		} break;
	case 'E' : 
		{	
		dcb.fParity=1;
		dcb.Parity=2;
		} break;
	case 'M' : 
		{	
		dcb.fParity=1;
		dcb.Parity=3;
		} break;
	case 'S' : 
		{	
		dcb.fParity=1;
		dcb.Parity=4;
		} break;
	}
switch(stopbit)
	{
	case 1 : dcb.StopBits=0; break;
	case 2 : dcb.StopBits=2; break;
	default : 
		{
		CloseHandle(hcom);
		hcom=(HANDLE)-1;
		return -1;
		}
	}
if(!SetCommState(hcom,&dcb))
	{
	CloseHandle(hcom);
	hcom=(HANDLE)-1;
	return -1;
	}
return 0;
}

OVERLAPPED OVL;

// Send a buffer to serial port
void target_com_send(unsigned char *buff,unsigned len)
{
DWORD dw;
WriteFile(hcom,buff,len,&dw,&OVL);
}


// Is there one or more chars in RX buffer?
int target_com_ischarin(void)
{
COMSTAT CS;
DWORD dw;
ClearCommError(hcom,&dw,&CS);
if(CS.cbInQue>0) 
	{
	return 1;
	}
return 0;
}

// Get one char
int target_com_getchar(void)
{
DWORD dw;
int result=0;
unsigned char c;
ReadFile(hcom,&c,1,&dw,&OVL);
result=c;
if(dw==0) return -1;
return result;
}

// Close serial com port 
void target_com_close(void)
{
if(hcom!=(HANDLE)-1)
	{
	CloseHandle(hcom);
	hcom=(HANDLE)-1;
	}
}

//
// TCP-IP functions
//


#include "winsock.h"							

#define MAXCLIENTSOCK 16			// Max client connections
#define MAX_PENDING_CONNECTS  8     // Maximum length of the queue of pending connections
#define MAXDATAINLEN 0x1000

#pragma pack(1)

typedef enum {NEWCLICONNECTED,CLIENTDATARECEIVED,CLIDECONNECTED} NETEVENTTYPE;

struct _NE
	{
	NETEVENTTYPE event;
	int data1,data2,data3,data4;
	};

WSADATA WSAData;

SOCKET WinSocket=INVALID_SOCKET;
SOCKET ClientSock[MAXCLIENTSOCK]; 
DWORD ClientID[MAXCLIENTSOCK];
SOCKADDR_IN local_sin,accept_sin;
int accept_sin_len;
unsigned maxtramelen;

// TCP-IP initialization
int target_netcom_start(void)
{
unsigned count;
for(count=0;count<MAXCLIENTSOCK;count++)
	{
	ClientSock[count]=INVALID_SOCKET;
	}
if(WSAStartup(MAKEWORD(1,1),&WSAData)!= 0) 
  {
  return -1;
  }
maxtramelen=WSAData.iMaxUdpDg;
if(maxtramelen==0||maxtramelen>0x10000)
	{
	maxtramelen=0x10000;
	}
return 0;
}

// TCP-IP close
int target_netcom_close(void)
{
if(WSACleanup()!=0)
	{
	return -1;
	}
return 0;
}

HANDLE htsrv,htsrvr;
BOOL bStophtsrv,bStophtsrvr;


// Client connection thread
DWORD WINAPI asyncconnectsrv(LPVOID p)
{
int (*netevent)(struct _NE *pne)=(int (*)(struct _NE *pne))p;
do
	{
	unsigned pos;
	SOCKET clisocket;
	accept_sin_len = sizeof (accept_sin);
	clisocket=accept(WinSocket,(struct sockaddr *)&accept_sin,(int *)&accept_sin_len);
	if(clisocket==INVALID_SOCKET||bStophtsrv)
		{
		CloseHandle(htsrv);
		htsrv=NULL;
		ExitThread(0);
		}
	else
		{
		// Search a free space for this connection
		pos=0;
		while(pos<MAXCLIENTSOCK)
			{
			if(ClientSock[pos]==INVALID_SOCKET) break;
			pos++;
			}
		if(pos!=MAXCLIENTSOCK) // Found!
			{
			struct _NE ne;
			ClientSock[pos]=clisocket;
			ne.event=NEWCLICONNECTED;
			ne.data1=pos;
			ne.data2=(int)accept_sin.sin_addr.S_un.S_addr;
			ClientID[pos]=ne.data2;
			(*netevent)(&ne);
			}
		}
	Sleep(10);
	}
while(1);
}

#define MAXRECEIVELEN 0x1000

// Client datas received thread
DWORD WINAPI asyncconnectsrvr(LPVOID p)
{
int (*netevent)(struct _NE *pne)=(int (*)(struct _NE *pne))p;
do
	{
	unsigned count;
	for(count=0;count<MAXCLIENTSOCK;count++)
		{
		if(ClientSock[count]!=INVALID_SOCKET)
			{
			BYTE data[MAXRECEIVELEN];
			int iRet;
			// Available datas ?
			iRet=recv(ClientSock[count],(char *)data,MAXRECEIVELEN,0);
			if(iRet==SOCKET_ERROR)
				{
				DWORD dwerr=WSAGetLastError();
				if(dwerr==WSAEWOULDBLOCK)
					{
					iRet=0;
					}
				}
			if(iRet==SOCKET_ERROR)
				{
				struct _NE ne;
				closesocket(ClientSock[count]);
				ClientSock[count]=INVALID_SOCKET;
				ne.event=CLIDECONNECTED;
				ne.data1=count;
				ne.data2=ClientID[count];
				(*netevent)(&ne);
				}
			else
				{
				if(iRet>0)
					{
					struct _NE ne;
					ne.event=CLIENTDATARECEIVED;
					ne.data1=count;
					ne.data2=ClientID[count];
					ne.data3=iRet;
					ne.data4=(int)(char *)&data;
					(*netevent)(&ne);
					}
				}
			}
		if(bStophtsrvr)
			{
			htsrvr=NULL;
			CloseHandle(htsrvr);
			ExitThread(0);
			}
		}		
	Sleep(10);
	}
while(1);
}

unsigned char cliconnected[MAXCLIENTSOCK];
unsigned datain[MAXCLIENTSOCK][MAXDATAINLEN];
unsigned datainlen[MAXCLIENTSOCK];

int internalnetevent(struct _NE *pne)
{
switch(pne->event)
	{
	case CLIENTDATARECEIVED :
		{
		if(datainlen[pne->data1]+pne->data3<MAXDATAINLEN)
			{
			memcpy(&datain[pne->data1][datainlen[pne->data1]],(void *)pne->data4,pne->data3);
			datainlen[pne->data1]+=pne->data3;
			}
		} break;
	case CLIDECONNECTED :
		{
		cliconnected[pne->data1]=0;
		} break;
	case NEWCLICONNECTED :
		{
		cliconnected[pne->data1]=1;
		datainlen[pne->data1]=0;
		} break;
	}
return 0;
}

// Read datas from a client
int target_netcom_srvread(unsigned client,unsigned char *data,unsigned maxdata)
{
unsigned len;
if(!cliconnected[client]) return -1;
len=min(maxdata,datainlen[client]);
if(len==0) return 0;
memcpy(data,datain[client],len);
if(len<datainlen[client])
	{
	memmove(&datain[client][0],((unsigned char *)&datain[client][0])+1,datainlen[client]-len);
	}	
datainlen[client]-=len;
return len;
}

// How many bytes in RX buffer?
int target_netcom_srvgetlenin(unsigned client)
{
if(!cliconnected[client]) return -1;
return datainlen[client];
}

// Get first connected client number : return -1 if none
int target_netcom_srvgetfirstclient(void)
{
unsigned count;
for(count=0;count<MAXCLIENTSOCK;count++)
	{
	if(cliconnected[count]) return count;
	}
return -1;
}

// Get next connected client : return -1 if none
int target_netcom_srvgetnextclient(unsigned cli)
{
unsigned count;
for(count=cli+1;count<MAXCLIENTSOCK;count++)
	{
	if(cliconnected[count]) return count;
	}
return -1;
}

// Oopen a TCP-IP server
int target_netcom_srvopen(int (*netevent)(struct _NE *pne),WORD port)
{
DWORD tid;
// Create a TCP/IP socket, WinSocket.
if((WinSocket=socket(AF_INET,SOCK_STREAM,0))==INVALID_SOCKET) 
  {
  return -1;
  }
// Fill out the local socket's address information.
local_sin.sin_family = AF_INET;
local_sin.sin_port = htons (port);  
local_sin.sin_addr.s_addr = htonl (INADDR_ANY);
// Associate the local address with WinSocket.
if (bind(WinSocket,(struct sockaddr *) &local_sin,sizeof (local_sin)) == SOCKET_ERROR) 
	{
	closesocket(WinSocket);
    return -2;
	}
// Establish a socket to listen for incoming connections.
if(listen(WinSocket,MAX_PENDING_CONNECTS)==SOCKET_ERROR) 
  {
  closesocket(WinSocket);
  return -3;
  }
bStophtsrv=FALSE;
bStophtsrvr=FALSE;
if(netevent==NULL) netevent=internalnetevent;
// Create thread for clients connection
htsrv=CreateThread(NULL,0,asyncconnectsrv,(PVOID)netevent,0,&tid);
if(htsrv==NULL)
	{
	return -4;
	}
// Create a thread for clients datas RX
htsrvr=CreateThread(NULL,0,asyncconnectsrvr,(PVOID)netevent,0,&tid);
if(htsrvr==NULL)
	{
	bStophtsrv=TRUE;
	WSACancelBlockingCall();
	TerminateThread(htsrv,0);
	CloseHandle(htsrv);
	return -5;
	}
return 0;
}

int target_netcom_srvclose(void)
{
unsigned count;
if(closesocket(WinSocket)!=0) return -1;
for(count=0;count<MAXCLIENTSOCK;count++)
	{
	if(ClientSock[count]!=INVALID_SOCKET)
		{
		// Disable both sending and receiving on ClientSock.
		shutdown(ClientSock[count],0x02);
		closesocket(ClientSock[count]);
		ClientSock[count]=INVALID_SOCKET;
		}
	}
if(htsrv!=NULL)
	{
	bStophtsrv=TRUE;
	WSACancelBlockingCall();
	TerminateThread(htsrv,0);
	CloseHandle(htsrv);
	htsrv=NULL;
	}
if(htsrvr!=NULL)
	{
	bStophtsrvr=TRUE;
	WSACancelBlockingCall();
	TerminateThread(htsrvr,0);
	CloseHandle(htsrvr);
	htsrvr=NULL;
	}
return 0;
}



int target_netcom_srvsenddata(int pos,BYTE *data,int len)
{
if(send(ClientSock[pos],(char *)data,len,0)==SOCKET_ERROR) 
	{
	return -1;
	}
return 0;	
}


//
// Main
//



// Variables
unsigned char i[10000];
unsigned char o[10000];
unsigned char b[10000];
unsigned char t[100*(sizeof(unsigned char)+sizeof(unsigned long)+sizeof(unsigned long))];
unsigned short c[10000];
unsigned short m[10000];
float f[10000];
unsigned long l[10000];
struct _a7int a7int;


// Variable memory and interpretor structure initialization
int init(void)
{
memset(&a7int,0,sizeof(a7int));
a7int.ni=10000;
a7int.no=10000;
a7int.nb=10000;
a7int.nt=100;
a7int.nc=10000;
a7int.nm=10000;
a7int.nf=10000;
a7int.nl=10000;
a7int.pI=i;
a7int.pO=o;
a7int.pB=b;
a7int.pT=t;
a7int.pC=c;
a7int.pM=m;
a7int.pF=f;
a7int.pL=l;			 
a7int.init=1;
return 0;
}

// Execute the program one time
void cycle(void)
{
if(a7int.init) 
	{
	automgenintinit(&a7int);
	a7int.init=0;
	}
if((a7int.run||a7int.step))
	{
	automgenintrun(&a7int);
	if(a7int.pB[SYSTEM_BIT_EMERGENCY_STOP]&TRUEFORBOOL)
		{ // Emergency stop stops the program
		a7int.run=0;
		}
	a7int.step=0;
	}
// Process system variables
automgenintprocesssysvar(&a7int);
}

void uninit(void)
{
}

int stop=0;
char status[512];

DWORD WINAPI runtime(LPVOID lp)
{
unsigned count=0;
if(init()<0) // Interpretor initialization
	{
	sprintf(status,"AUTOMGEN INTERPRETOR INITIALIZATION FAILED\n");
	return (DWORD)-1;
	}; 
if(initcom()<0) // Communication setup
	{
	sprintf(status,"AUTOMGEN COMMUNICATION INITIALIZATION FAILED\n");
	return (DWORD)-2;
	}
if(initio()<0) // I/O initialization
	{
	sprintf(status,"AUTOMGEN I/O INITIALIZATION FAILED\n");
	return (DWORD)-3;
	}
do
	{
	sprintf(status,"%c - %c - %4.4X - %u\r",a7int.run?'R':'S',(a7int.pB[SYSTEM_BIT_EMERGENCY_STOP]&TRUEFORBOOL)?'E':' ',a7int.pM[SYSTEM_WORD_ERROR_NUMBER],count++);
	// Process the communication
	processcom(&a7int);
	// Process inputs
	// Reset I/O pos
	a7int.io_i_pos=0;
	a7int.io_o_pos=0;
	a7int.io_m_pos=200;
	readi(&a7int);
	// Ex閏ute the program one time
	cycle();
	// Process outputs
	writeo(&a7int);
	// Let time for other tasks
	}
while(!stop);
uninitio();	// I/O stop
uninitcom(); // Communication STOP
uninit(); // Interpretor stop
return 0;
}

LRESULT CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam)
{
switch(msg)
	{
	case WM_INITDIALOG:
		{
		SetTimer(hwnd,1,500,NULL);
		return TRUE;
		}
	case WM_COMMAND:
		{
		switch(wparam)
			{
			case IDC_CLOSE: 
				{
				stop=1;
				DestroyWindow(hwnd);
				} break;
			case IDC_RUN:
				{
				a7int.run=a7int.run?0:1;
				} break;
			}
		return TRUE;
		}
	case WM_TIMER:
		{
		SetDlgItemText(hwnd,IDC_STATUS,status);
		CheckDlgButton(hwnd,IDC_RUN,a7int.pB&&(a7int.pB[SYSTEM_BIT_RUN]&0x40)?BST_CHECKED:BST_UNCHECKED);
		return TRUE;
		} 
	case WM_DESTROY:
		{
		KillTimer(hwnd,1);
		} break;
	}
return FALSE;
}


int _stdcall WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
{
HWND hwnd;
MSG msg;
BOOL bGotMsg;
DWORD id;
HANDLE thread;
hwnd=CreateDialog(hInstance,MAKEINTRESOURCE(IDD_DIALOG),NULL,DlgProc);
ShowWindow(hwnd,SW_SHOW);
thread=CreateThread(NULL,0,runtime,0,0,&id);
while(msg.message!=WM_QUIT&&IsWindow(hwnd))
	{
	bGotMsg=PeekMessage(&msg,NULL,0,0,PM_REMOVE);
	if(bGotMsg)
		{
		if(!IsDialogMessage(hwnd,&msg))
			{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
			}
		}
	else
		{
		Sleep(1);
		}
	}
return 0;
}