com.c

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

					if(ltramein!=5||num>=a7int->no)
						{
						com_no(); // NO
						break;
                        }
					setvar(a7int,1,num,tramein[4],(unsigned)-1);
                    com_ok(); // Ok
                    } break;
                case 2 : // B
                    {
                    if(ltramein!=5||num>=a7int->nb)
                        {
                        com_no(); // NO
                        break;
						}
					setvar(a7int,2,num,tramein[4],(unsigned)-1);
					com_ok(); // Ok
                    } break;
                case 3 : // T preset
					{
                    if(ltramein!=8||num>=a7int->nt)
                        {
                        com_no(); // NO
                        break;
						}
					memcpy(&a7int->pT[num*sizeof(unsigned long)*2],&tramein[4],sizeof(unsigned long));
					com_ok(); // Ok
					} break;
                case 4 : // C
					{
                    if(ltramein!=6||num>=a7int->nc)
                        {
                        com_no(); // NO
                        break;
						}
					memcpy(&a7int->pC[num],&tramein[4],sizeof(unsigned short));
					com_ok(); // Ok
					} break;
                case 5 : // M
					{
                    if(ltramein!=6||num>=a7int->nm)
                        {
                        com_no(); // NO
                        break;
						}
					memcpy(&a7int->pM[num],&tramein[4],sizeof(unsigned short));
					com_ok(); // Ok
					} break;
				case 6 : // F
					{
					if(ltramein!=8||num>=a7int->nf)
						{
						com_no(); // NO
						break;
						}
					memcpy(&a7int->pF[num],&tramein[4],sizeof(float));
					com_ok(); // Ok
					} break;
				case 7 : // L
					{
					if(ltramein!=8||num>=a7int->nl)
						{
						com_no(); // NO
						break;
						}
					memcpy(&a7int->pL[num],&tramein[4],sizeof(unsigned long));
					com_ok(); // Ok
					} break;
				default :
					{
					com_no(); // NO
					}
				}
			} break;
		case 4 : // Begining of program download
			{
			if(ltramein<6||ltramein>17)
				{
				com_no(); // NO
				break;
				}
			memcpy(&proglen,&tramein[1],4);
			memcpy(&progname,&tramein[5],ltramein-5);
			progname[ltramein-5]=0;
			if(a7int->progmem!=NULL)
                {
				free(a7int->progmem);
				a7int->progmem=NULL;
                }
			a7int->progmem=(unsigned char *)malloc(proglen);
			com_ok(); // OK
			downloadprog=TRUE;
			} break;
		case 5 : // Program block download
			{
			unsigned long pos,len;
			memcpy(&pos,&tramein[1],4);
			memcpy(&len,&tramein[5],4);
			if(!downloadprog||pos+len>proglen)
				{
				com_no(); // NO
				break;
				}
			memcpy(&a7int->progmem[pos],&tramein[9],(unsigned)len);
			com_ok(); // OK
			} break;
		case 6 : // End of download 
			{
			if(!downloadprog||ltramein<6||ltramein>17)
				{
				com_no(); // NO
				break;
				}
			if(memcmp(&proglen,&tramein[1],4)!=0||memcmp(&progname,&tramein[5],ltramein-5)!=0)
				{
	            downloadprog=FALSE;
				com_no2(); // erreur
				break;
				}
			a7int->init=1;
			com_ok(); // OK
            downloadprog=FALSE;
			} break;
        case 7 : // Begining of program compare
            {
            if(ltramein<6||ltramein>17)
				{
                com_no(); // NO
                break;
                }
            memcpy(&proglen,&tramein[1],4);
            memcpy(&progname,&tramein[5],ltramein-5);
            progname[ltramein-5]=0;
            com_ok(); // OK
            } break;
        case 8 : // Compare one program block
            {
			unsigned long pos,len;
			if(ltramein!=9)
				{
				com_no(); // NO
				break;
				}
			memcpy(&pos,&tramein[1],4);
			memcpy(&len,&tramein[5],4);
			if(pos+len>proglen)
				{
				com_no(); // NO
				break;
				}
			memcpy(&tramein[1],&a7int->progmem[pos],len);
			tramein[0]=0;
			sendtrame(tramein,(unsigned)len+1); // OK
			} break;
		case 9 : // End of program compare
            {
            if(ltramein<6||ltramein>17)
                {
                com_no(); // NO
                break;
                }
			if(memcmp(&proglen,&tramein[1],4)!=0||memcmp(&progname,&tramein[5],ltramein-5)!=0)
				{
				com_no2(); // error
				break;
				}
			if(memcmp(&proglen,&tramein[1],4)!=0||memcmp(&progname,&tramein[5],ltramein-5)!=0)
				{
                com_no2(); // error
                break;
                }
            com_ok(); // OK
            } break;
        default :
            {
            com_no(); // NO
            }
        }
    }
}



// Initialisation
int initcom(void)
{
if(_com==TCPIP)
	{
	if(target_netcom_start()<0)
		{
		return -1;
		}
	if(target_netcom_srvopen(NULL,(WORD)_tcpipport)<0)
		{
		return -2;
		}
	}
else
	{
	if(target_com_open(_com,_baudrate,_parity,8,_stopbit)!=0)
		{
		return -1; // error
		}
	}

return 0;
}

int uninitcom(void)
{
if(_com==TCPIP)
	{
	target_netcom_srvclose();
	target_netcom_close();
	}
else	
	{
	target_com_close();
	}
return 0;
}


int ischar(void)
{
if(_com==TCPIP)
	{
	if(target_netcom_srvgetlenin(curtcpclient)>0) return 1;
	return 0;
	}
return target_com_ischarin();
}

int getcom(void)
{
if(_com==TCPIP)
	{
	int c=0;
	if(target_netcom_srvread(curtcpclient,(unsigned char *)&c,1)==1)
		{
		return c;
		}
	return -1;
	}
return target_com_getchar();
}



// Requests processing
void _process(struct _a7int *a7int)
{
static unsigned phase;
static unsigned len;
static unsigned char crc;
static unsigned char slave;
do
    {
    switch(phase)
        {
        case 0 : // Wait header char
            {
            if(ischar()) // 
                {
                if(getcom()=='Z') // Herader char?
                    {
                    phase++; // Yes
                    }
                else
                    {
                    return;
                    }
                }
            else
                {
                return;
                }
            crc='Z';
            inittimout();
            }
		case 1 : // Wait slave number
			{
            if(ischar()) 
                {
                slave=getcom();
                crc+=slave;
                phase++;
                }
            else
                {
                if(istimout())
                    {
                    phase=0;
                    }
                return;
                }
            inittimout();
			}
		case 2 : // Wait LSB length
            {
            if(ischar()) 
                {
                len=getcom();
                crc+=len;
                phase++;
                }
            else
                {
                if(istimout())
                    {
                    phase=0;
                    }
                return;
                }
            inittimout();
            }
        case 3 : // Wait MSB length
            {
            if(ischar()) 
                {
                len|=(unsigned)getcom()<<8;
                crc+=(len>>8);
                ltramein=0;
                phase++;
                }
            else
                {
                if(istimout())
                    {
                    phase=0;
                    }
                return;
                }
            inittimout();
            }
        case 4 : // Wait DATAs
            {
            if(ischar())
                {
                tramein[ltramein]=getcom();
                crc+=tramein[ltramein++];
                }
            else
                {
                if(istimout())
                    {
                    phase=0;
                    }
                return;
                }
            inittimout();
            if(ltramein==len) phase++;
            else break;
            }
        case 5 : // Wait crc
            {
            if(ischar())
                {
                int charin;
                charin=getcom();
                if((unsigned char)~crc==(unsigned char)charin)
                    { // CRC ok
					if(slave==slavenumber||slave==0xff)
						{ // Slave = this slave
	                    processtrame(a7int);
						}
                    }
                phase=0;
                }
            else
				{
				if(istimout())
					{
					phase=0;
					}
				return;
				}
			}
		}
	}
while(1);
}

unsigned ncliconnected;

void processcom(struct _a7int *a7int)
{
if(_com==TCPIP)
	{
	int client,n=0;
	client=target_netcom_srvgetfirstclient();
	while(client!=-1)
		{
		n++;
		curtcpclient=(unsigned)client;
		_process(a7int);
		client=target_netcom_srvgetnextclient(client);
		}
	ncliconnected=n;
	}
else
	{
	_process(a7int);
	}
}