main(bl2100).c

rabbit现场采集

/*******************************************************************************
        RTU_100.c
        CH.Control, 2005

        This program support Web server access and modbus/tcp comm. with computer
        User can program code to comm. with  3'rd device
        to get realtime information from the modbus/tcp port.

*******************************************************************************/
#class auto
#use "Protocol.lib"

//// Initialization for the BL2100 controllers
#define NUM_CHANNELS 11		//number of A/D channels
#define OUTPUTBITS 0		//initialize for 12 bit operation
#define MAXROUTE 3			//N to 1 module,number of N

/***********************************
 * Configuration                   *
 * -------------                   *
 * All fields in this section must *
 * be altered to match your local  *
 * network settings.               *
 ***********************************/

/*
 * Pick the predefined TCP/IP configuration for this sample.  See
 * LIB\TCPIP\TCP_CONFIG.LIB for instructions on how to set the
 * configuration.
 */

#define USE_ETHERNET		1
#define IFCONFIG_ETH0 IFS_UP

#define USE_HTTP_DIGEST_AUTHENTICATION	1

/*
 * Web server configuration
 */

/*
 * Only one server is needed for a reserved port
 */
#define HTTP_MAXSERVERS 1
#define MAX_TCP_SOCKET_BUFFERS 2   //http server and mbtcp server

/*
 * Our web server as seen from the clients.
 * This should be the address that the clients (netscape/IE)
 * use to access your server. Usually, this is your IP address.
 * If you are behind a firewall, though, it might be a port on
 * the proxy, that will be forwarded to the Rabbit board. The
 * commented out line is an example of such a situation.
 */
#define REDIRECTHOST		_PRIMARY_STATIC_IP
//#define REDIRECTHOST	"proxy.domain.com:1212"


/********************************
 * End of configuration section *
 ********************************/

/*
 *  REDIRECTTO is used by each ledxtoggle cgi's to tell the
 *  browser which page to hit next.  The default REDIRECTTO
 *  assumes that you are serving a page that does not have
 *  any address translation applied to it.
 *
 */

#define REDIRECTTO 		"http://" REDIRECTHOST ""

#memmap xmem
#use "dcrtcp.lib"
#use "http.lib"

#ximport "ProgDev/pages/rtu100-1.shtml" index_html

void init_FORMSpecName(void);
void get_parameters(char *buffer,int FORMSpecSize);


/* the default for / must be first */
const HttpType http_types[] =
{
    { ".shtml", "text/html", shtml_handler}, // ssi
    { ".html", "text/html", NULL},           // html
    { ".cgi", "", NULL},                     // cgi
    { ".gif", "image/gif", NULL}
};
//POINT 2
/*
*------define variable of input text line -------
*/
char T1[16];  //host ip
char T2[16];  //subnet mask
char T3[16];  //default gateway
char T4[8];   //unit index
char T5[8];   //update interval
char T6[8];   //reply timeout
/*
*------define variable of select menu--- -------
*/
char D1[8];/*port A baud rate*/
char D2[8];/*port A parity*/
char D3[8];/*port A protocol select*/
char D4[8];/*port B baud rate*/
char D5[8];/*port B parity*/
char D6[8];/*port B protocol select*/
char D7[8];/*port C baud rate*/
char D8[8];/*port C parity*/
char D9[8];/*port C protocol select*/
/*
*----define variable of radio/check button -----
*/
char R1[2];/*ethernet protocol type*/
char R2[2];/*port A data bits*/
char R3[2];/*port A stop bits*/
char R4[2];/*port B data bits*/
char R5[2];/*port B stop bits*/
char R6[2];/*port C data bits*/
char R7[2];/*port C stop bits*/
char C1[2];/*unsolicited message select*/

//POINT 6
const char default_para[]=
{
	"T1=192.168.1.100&"\
	"T2=255.255.255.0&"\
	"T3=192.168.1.1&"\
	"T4=0&"\
	"T5=100&"\
	"T6=3&"\
	"D1=4&"\
	"D2=0&"\
	"D3=0&"\
	"D4=4&"\
	"D5=0&"\
	"D6=0&"\
	"D7=4&"\
	"D8=0&"\
	"D9=0&"\
	"R1=1&"\
	"R2=0&"\
	"R3=0&"\
	"R4=0&"\
	"R5=0&"\
	"R6=0&"\
	"R7=0&"\
	"C1=1&"\
	"'\0'"
};

const char FORMSpecName[][] =
{
	{"T1"},{"T2"},{"T3"},{"T4"},{"T5"},{"T6"},
	{"D1"},{"D2"},{"D3"},{"D4"},{"D5"},{"D6"},{"D7"},{"D8"},{"D9"},
	{"R1"},{"R2"},{"R3"},{"R4"},{"R5"},{"R6"},{"R7"}
};

struct user_block
{
    struct
    {
        char username[16];
		char password[6];
    }users;
    char setup_str[256];
    int crc_16;
}setup_para;

long block_len;

#define MAX_FORMSIZE	16

typedef struct
{
    char *name;
  	char value[MAX_FORMSIZE];
}FORMType;

FORMType FORMSpec[22];

/* read & wirte user block*/
void userblock_init(void)
{
    void* save_data[3];
  	unsigned int save_lens[3];
    int checksum,len;
    save_data[0] = &setup_para;
    save_lens[0] = sizeof(setup_para);

	if(readUserBlockArray(save_data, save_lens, 1, 0))
	{
		if(writeUserBlockArray(0, save_data, save_lens, 1))
		{
			printf("write user block error!\r\n");
			exit(-1);
		}
    }

    len = strlen(setup_para.setup_str);
    len = len <256 ? len : 255;
    checksum = Calc_CRC(setup_para.setup_str,len);
    setup_para.setup_str[len] = '\0';
    if(setup_para.crc_16 != checksum)
    {
		strcpy(setup_para.setup_str,default_para);
		//printf("%s,%d\r\n",setup_para.setup_str,strlen(setup_para.setup_str));
		save_data[0] = &setup_para;
		save_lens[0] = sizeof(setup_para);
		len = strlen(setup_para.setup_str);
		setup_para.crc_16 = Calc_CRC(setup_para.setup_str,len);
		setup_para.setup_str[len] = '\0';
		if(writeUserBlockArray(0, save_data, save_lens, 1))
		{
			printf("write user block error!\r\n");
			exit(-1);
		}
    }
    init_FORMSpecName();
    get_parameters(setup_para.setup_str,sizeof(FORMSpec)/sizeof(FORMType));
}

int rebootflag;
int cur_route;

/*
 * submit.cgi function
 */
int submit(HttpState* state)
{
	auto int i;
	auto int len;
	void* save_data[3];
	unsigned int save_lens[3];

	if(state->length)
	{
		//buffer to write out
		if(state->offset < state->length )
		{
			state->offset += sock_fastwrite(&state->s,state->buffer + (int)state->offset,(int)state->length - (int)state->offset);
		}
		else
		{
			state->offset = 0;
			state->length = 0;
		}
	}
	else
	{
		switch(state->substate)
		{
			case 0:
				strcpy(state->buffer, "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n");
				state->length = strlen(state->buffer);
				state->offset = 0;
				state->substate++;
				break;
			case 1:
				strcpy(state->buffer, "<html><head><title>Results</title></head><body>\r\n");
				state->length = strlen(state->buffer);
				state->offset = 0;
				state->substate++;
				break;
			case 2:
				init_FORMSpecName();
				if(parse_post(state))
				{
					//printf ("parse_post return: %d\r\n",i);

					strcpy(setup_para.setup_str,state->buffer);
					state->offset = 0;
					state->length = 0;
					state->substate++;
					break;
				}
				else{}
				break;
			case 3:
				/* write user block data */
				save_data[0] = &setup_para;
				save_lens[0] = sizeof(setup_para);
				len = strlen(setup_para.setup_str);
				setup_para.crc_16 = Calc_CRC(setup_para.setup_str,len);
				setup_para.setup_str[len] = '\0';
				if((writeUserBlockArray(0, save_data, save_lens, 1))!=0)
				{
					strcpy(state->buffer,"<p>write user block occur error!<p>\r\n");
				}
				else
				{
					strcpy(state->buffer,"<p>write user block succeed!<p>\r\n");
				}
				state->offset = 0;
				state->length = strlen(state->buffer);
				state->substate++;
				break;
			case 4:
				/*parse the POST information
				if(parse_post(state))
				{
					sprintf(state->buffer, "<p>Username: %s<p>\r\n<p>Email: %s<p>\r\n",
					FORMSpec[0].value, FORMSpec[1].value);
					state->length = strlen(state->buffer);
					state->substate++;
				}
				else
				{
				}
				break;
			case 4:
				strcpy(state->buffer, "<p>Go <a href=\"/\">home</a></body></html>\r\n");
				state->length = strlen(state->buffer);
				state->substate++;
				break;*/

			default:
				state->substate = 0;
				rebootflag = 1;
				return 1;
		}
	}
	//cgi_redirectto(state,REDIRECTTO);
    return 0;
}


const HttpSpec http_flashspec[] =
{
	{ HTTPSPEC_FILE, 	"/",		index_html,    NULL, 0, NULL, NULL},
	{ HTTPSPEC_FILE, 	"/index.html",	index_html,    NULL, 0, NULL, NULL},

	//PIOINT 4
	{ HTTPSPEC_FUNCTION,	"/submit.cgi",		 0,  submit, 0, NULL, NULL},
	{ HTTPSPEC_VARIABLE,	"T1",		0,	T1,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"T2",		0,	T2,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"T3",		0,	T3,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"T4",		0,	T4,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"T5",		0,	T5,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"T6",		0,	T6,PTR16,"%s",NULL},

	{ HTTPSPEC_VARIABLE,	"D1",		0,	D1,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D2",		0,	D2,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D3",		0,	D3,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D4",		0,	D4,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D5",		0,	D5,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D6",		0,	D6,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D7",		0,	D7,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D8",		0,	D8,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"D9",		0,	D9,PTR16,"%s",NULL},

	{ HTTPSPEC_VARIABLE,	"R1",		0,	R1,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"R2",		0,	R2,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"R3",		0,	R3,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"R4",		0,	R4,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"R5",		0,	R5,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"R6",		0,	R6,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"R7",		0,	R7,PTR16,"%s",NULL},
	{ HTTPSPEC_VARIABLE,	"C1",		0,	C1,PTR16,"%s",NULL}
};

/******************************************************************************
* User interface part  (modbus tcp protocol code)
*****************************************************************************/

/* vars for modbus/tcp recieve daemon */
#define MB_TCP_MAX_BUFLEN 512
#define MB_TCP_PORT 502

/* define modbus/tcp states */

#define MBTCP_INIT		0
#define MBTCP_LISTEN    1
#define MBTCP_GETREQ		2
#define MBTCP_SENDRSP	3
#define MBTCP_WAITCLOSE	4

typedef struct
{
	tcp_Socket sock;
	tcp_Socket *s;

	int cmdlen;
	int cmdoffset;
	int lport;
	int state;
	int byteswritten;

	//char buf[1024];
	//char cmdbuf[1024];
	char buf[MB_TCP_MAX_BUFLEN/16];
	char cmdbuf[MB_TCP_MAX_BUFLEN];
}modbus_tcp_recv;

modbus_tcp_recv tr_state;
const modbus_tcp_recv *const mbtcpstate = &tr_state;

/*
 ********************modbus tcp realtime data buffer*************************
 */
/*
InputReg 30000
InputState 10000

*/
/*
 * Input Register Buffer
 * 0~511->portB;512~1023->portC;1024~1535->portD
 * 1536~1599 analog output buffer
 */
int Port_InputReg[1600];

/*
 * Holding Register Buffer
 * 0~511->portB;512~1023->portC;1024~1535->portD
 * 1536~1599 analog input buffer
 */
int Port_HoldingReg[1600];