com.c

AUTOMGEN runtime is an open source royalty free runtime for open PLCs. By using this runtime, any ta

// AUTOMGEN interpretor runtime	 - communication serial and TCP_IP
// (C) 2003-2008 IRAI

#include "stdlib.h"
#include "stdio.h"
#include "memory.h"

#define BOOL int
#define TRUE 1
#define FALSE 0
#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned long

#include "core.h"
#include "com.h"
#include "target.h"


unsigned char slavenumber=SLAVENUMBER; 

unsigned lasttimetimout;


// Timeout process
void inittimout(void)
{
lasttimetimout=target_gettimeinms();
}

int istimout(void)
{
return (target_gettimeinms()-lasttimetimout>=TIMEOUT)?1:0;
}

unsigned curtcpclient;
unsigned _tcpipport=TCPIPPORT;
unsigned _com=TCPIP;
unsigned _baudrate=_BAUDRATE;
unsigned _parity=_PARITY;
unsigned _stopbit=_STOPBIT;

// Send 
void sendtrame(unsigned char *data,unsigned len)
{
unsigned char crc;
unsigned count;
unsigned char buff[MAXTRAMEOUT];
unsigned pos=0;
crc='Z'+slavenumber+(unsigned char)(len&0xff)+(unsigned char)(len>>8);
buff[pos++]='Z';
buff[pos++]=slavenumber;
buff[pos++]=(unsigned char)(len&0xff);
buff[pos++]=(unsigned char)(len>>8);
for(count=0;count<len;count++)
    {
    buff[pos++]=data[count];
    crc+=data[count];
	}
buff[pos++]=(unsigned char )(~crc);
if(_com==TCPIP)
	{
	target_netcom_srvsenddata(curtcpclient,buff,pos);
	}
else
	{
	target_com_send(buff,pos);
	}
}


// RX buffer
unsigned ltramein;
unsigned char tramein[MAXTRAMEIN+256];

void com_no(void)
{
sendtrame((unsigned char *)"\xFF",1);
}

void com_no2(void)
{
sendtrame((unsigned char *)"\xFE",1);
}

void com_ok(void)
{
sendtrame((unsigned char *)"\x00",1);
}


// Process in buffer
void processtrame(struct _a7int *a7int)
{
// For program download
static unsigned char progname[13];
static char fname[_MAX_PATH];
static unsigned long proglen;
static unsigned long flen;
static BOOL downloadprog=FALSE;
if(ltramein>0)
    {
    switch(tramein[0]) // Function code
        {
		case 0 : // Connection test
            {
            if(ltramein==1)
                {
				unsigned char data[32];
				unsigned maxbloclen=MAXTRAMEIN-128;
				data[0]=0;
				if(_com!=TCPIP)
					{
					maxbloclen=256;
					}
				*((WORD *)(&data[1]))=maxbloclen;
	            data[3]=target_confbyte();
				memcpy(&data[4],target_id(),16);
				sendtrame(data,19); // Ok
                }
            else
                {
                com_no();
                }
            } break;
        case 1 : // Select mode RUN/STOP/INIT/STEP
            {
            if(ltramein!=2)
                {
                com_no(); // NO
                }
            else
                {
                switch(tramein[1]) // Mode
                    {
                    case 0 : // stop
                        {
                        if(a7int->run)
							{
							a7int->run=0;
							com_ok(); // Ok
							}
						else
							{
							com_no2(); // NO
							}
						} break;
					case 1 : // run
						{
						if(!a7int->run)
							{
							a7int->run=1;
							com_ok(); // Ok
							}
						else
							{
							com_no2(); // NO
							}
						} break;
					case 2 : // step
						{
						if(!a7int->run)
							{
							a7int->step=1;
							com_ok(); // Ok
							}
						else
							{
							com_no2(); // NO
							}
						} break;
					case 3 : // init
                        {
						a7int->init=1;
                        com_ok(); // Ok
                        } break;
                    case 0x80 : // read RUN/STOP
                        {
                        sendtrame(a7int->run?(unsigned char *)"\x00\x01":(unsigned char *)"\x00\x00",2); 
                        } break;
					default :
						{
						com_no(); // NO
						}
					}
				}
			} break;
		case 2 : // Read one or more variable states
			{
			unsigned char data[1025];
			unsigned first,len;
			unsigned count;
			int checkforce=0;
			if(ltramein!=6)
				{
				com_no(); // NO
				break;
				}
            first=tramein[2]+(tramein[3]<<8);
            len=tramein[4]+(tramein[5]<<8);
            if(tramein[1]&0x80)
				{
				checkforce=1;
				tramein[1]&=0x7f;
				}
			switch(tramein[1]) // Type
                {
                case 0 : // I
                    {
                    unsigned pos=0,bpos=0;
					if(len+first>a7int->ni||(len+7)/8>1024)
                        {
						com_no(); // NO
                        break;
                        }
                    memset(data,0,1025);
                    for(count=0;count<len;count++)
                        {
                        if(a7int->pI[count+first]&0x20) data[1+pos]|=1<<bpos;
						bpos++;
						if(bpos==8)
							{
							pos++;
							bpos=0;
							}
						if(checkforce)
							{
				            if(isforced(a7int,tramein[1],(WORD)(first+count))) data[1+pos]|=1<<bpos;
							bpos++;
							if(bpos==8)
								{
								pos++;
								bpos=0;
								}
					        }
                        }
					sendtrame(data,2+pos);
                    } break;
                case 1 : // O
					{
                    unsigned pos=0,bpos=0;
					if(len+first>a7int->no||(len+7)/8>1024)
                        {
						com_no(); // NO
                        break;
                        }
                    memset(data,0,1025);
                    for(count=0;count<len;count++)
                        {
                        if(a7int->pO[count+first]&0x20) data[1+pos]|=1<<bpos;
						bpos++;
						if(bpos==8)
							{
							pos++;
							bpos=0;
							}
						if(checkforce)
							{
				            if(isforced(a7int,tramein[1],(WORD)(first+count))) data[1+pos]|=1<<bpos;
							bpos++;
							if(bpos==8)
								{
								pos++;
								bpos=0;
								}
					        }
                        }
					sendtrame(data,2+pos);
                    } break;
                case 2 : // B
                    {
                    unsigned pos=0,bpos=0;
                    if(len+first>a7int->nb||(len+7)/8>1024)
                        {
						com_no(); // NO
                        break;
                        }
                    memset(data,0,1025);
                    for(count=0;count<len;count++)
                        {
                        if(a7int->pB[count+first]&0x20) data[1+pos]|=1<<bpos;
						bpos++;
						if(bpos==8)
							{
							pos++;
							bpos=0;
							}
						if(checkforce)
							{
				            if(isforced(a7int,tramein[1],(WORD)(first+count))) data[1+pos]|=1<<bpos;
							bpos++;
							if(bpos==8)
								{
								pos++;
								bpos=0;
								}
					        }
                        }
					sendtrame(data,2+pos);
                    } break;
                case 3 : // T counter
                    {
					DWORD *ps,*pt;
					if(len+first>a7int->nt||len*sizeof(unsigned long)>1024)
                        {
                        com_no(); // NO
						break;
                        }
                    data[0]=0;
					ps=(DWORD *)&a7int->pT[sizeof(unsigned long)+first*sizeof(unsigned long)*2];
					pt=(DWORD *)&data[1];
					for(count=0;count<len;count++)
						{
						memcpy(pt,ps,sizeof(DWORD));
						pt++;
						ps+=2;
						}
					sendtrame(data,1+len*sizeof(unsigned long));
                    } break;
                case 4 : // C
                    {
                    if(len+first>a7int->nc||len*sizeof(unsigned long)>1024)
                        {
                        com_no(); // NO
						break;
                        }
                    data[0]=0;
					memcpy(&data[1],&a7int->pC[first],len*sizeof(unsigned short));
					sendtrame(data,1+len*sizeof(unsigned short));
                    } break;
                case 5 : // M
                    {
                    if(len+first>a7int->nm||len*sizeof(unsigned long)>1024)
                        {
                        com_no(); // NO
						break;
                        }
                    data[0]=0;
					memcpy(&data[1],&a7int->pM[first],len*sizeof(unsigned short));
					sendtrame(data,1+len*sizeof(unsigned short));
                    } break;
                case 6 : // F
                    {
                    if(len+first>a7int->nf||len*sizeof(float)>1024)
                        {
                        com_no(); // NO
                        break;
                        }
                    data[0]=0;
					memcpy(&data[1],&a7int->pF[first],len*sizeof(float));
                    sendtrame(data,1+len*sizeof(float));
                    } break;
				case 7 : // L
                    {
                    if(len+first>a7int->nl||len*sizeof(unsigned long)>1024)
                        {
						com_no(); // NO
                        break;
                        }
                    data[0]=0;
                    memcpy(&data[1],&a7int->pL[first],len*sizeof(unsigned long));
                    sendtrame(data,1+len*sizeof(unsigned long));
                    } break;
                case 8 : // T preset
                    {
					DWORD *pt,*ps;
                    if(len+first>a7int->nt||len*sizeof(unsigned long)>1024)
                        {
                        com_no(); // NO
						break;
                        }
                    data[0]=0;
					ps=(DWORD *)&a7int->pT[first*sizeof(unsigned long)*2];
					pt=(DWORD *)&data[1];
					for(count=0;count<len;count++)
						{
						memcpy(pt,ps,sizeof(DWORD));
						pt++;
						ps+=2;
						}
					sendtrame(data,1+len*sizeof(unsigned long));
                    } break;
                default :
                    {
                    com_no(); // NO
                    }
                }
			} break;
		case 3 : // Write one variable state
			{
			unsigned num;
			num=tramein[2]+(tramein[3]<<8);
			switch(tramein[1]) // Type
				{
				case 0 : // I
					{
					if(ltramein!=5||num>=a7int->ni)
						{
						com_no(); // NO
						break;
						}
					setvar(a7int,0,num,tramein[4],(unsigned)-1);
					com_ok(); // Ok
					} break;
				case 1 : // O
					{