int8_t getsockopt(uint8_t sn, sockopt_type sotype, void* arg)
{
CHECK_SOCKNUM();
switch(sotype)
{
case SO_FLAG:
*(uint8_t*)arg = getSn_MR(sn) & 0xF0;
break;
case SO_TTL:
*(uint8_t*) arg = getSn_TTL(sn);
break;
case SO_TOS:
*(uint8_t*) arg = getSn_TOS(sn);
break;
case SO_MSS:
*(uint16_t*) arg = getSn_MSSR(sn);
break;
case SO_DESTIP:
getSn_DIPR(sn, (uint8_t*)arg);
break;
case SO_DESTPORT:
*(uint16_t*) arg = getSn_DPORT(sn);
break;
#if _WIZCHIP_ > 5200
case SO_KEEPALIVEAUTO:
CHECK_SOCKMODE(Sn_MR_TCP);
*(uint16_t*) arg = getSn_KPALVTR(sn);
break;
#endif
case SO_SENDBUF:
*(uint16_t*) arg = getSn_TX_FSR(sn);
break;
case SO_RECVBUF:
*(uint16_t*) arg = getSn_RX_RSR(sn);
break;
case SO_STATUS:
*(uint8_t*) arg = getSn_SR(sn);
break;
case SO_REMAINSIZE:
if(getSn_MR(sn) & Sn_MR_TCP)
*(uint16_t*)arg = getSn_RX_RSR(sn);
else
*(uint16_t*)arg = sock_remained_size[sn];
break;
case SO_PACKINFO:
//CHECK_SOCKMODE(Sn_MR_TCP);
#if _WIZCHIP_ != 5300
if((getSn_MR(sn) == Sn_MR_TCP))
return SOCKERR_SOCKMODE;
#endif
*(uint8_t*)arg = sock_pack_info[sn];
break;
default:
return SOCKERR_SOCKOPT;
}
return SOCK_OK;
}
void do_udp(void){
uint16 len = 0;
uint8 buffer[2048];/*定义一个2KB的缓存*/
// uint8 pc_ip[4] = { 192, 168, 10, 10 };/*配置服务器的IP地址*/
// uint16 pc_port = 5000; /*定义计算机的一个端口并初始化*/
uint16 local_port = 5000;
if(isGetIP){
switch (getSn_SR(SOCKET_UDP))/*获取socket 0的状态*/
{
case SOCK_UDP:/*socket 的套接字初始化完成*/
if (getSn_IR(SOCKET_UDP) & Sn_IR_RECV)
{
setSn_IR(SOCKET_UDP, Sn_IR_RECV);/*Sn_IR的第0位置1*/
printf("Sendto Fail\r\n");
}
if ((len = getSn_RX_RSR(SOCKET_UDP)) > 0)
{
len = recvfrom(SOCKET_UDP, buffer, len, remote_ip, &remote_port);/*W5500接收计算机发送来的数据*/
printf("%d.%d.%d.%d:%d \r\n", remote_ip[0], remote_ip[1], remote_ip[2], remote_ip[3], remote_port);
if (len != sendto(SOCKET_UDP, buffer, len, remote_ip, remote_port))
{
printf("Sendto Fail\r\n");
}
}
break;
case SOCK_CLOSED:/*socket 关闭*/
socket(SOCKET_UDP, Sn_MR_UDP, local_port, 0);/*初始化socket 0的套接字*/
break;
}
}
}
/**
*@brief UDP测试程序
*@param 无
*@return 无
*/
void do_udp(void)
{
uint16 len=0;
uint8 buff[2048]; /*定义一个2KB的缓存*/
switch(getSn_SR(SOCK_UDPS)) /*获取socket的状态*/
{
case SOCK_CLOSED: /*socket处于关闭状态*/
socket(SOCK_UDPS,Sn_MR_UDP,local_port,0); /*初始化socket*/
break;
case SOCK_UDP: /*socket初始化完成*/
delay_ms(10);
if(getSn_IR(SOCK_UDPS) & Sn_IR_RECV)
{
setSn_IR(SOCK_UDPS, Sn_IR_RECV); /*清接收中断*/
}
if((len=getSn_RX_RSR(SOCK_UDPS))>0) /*接收到数据*/
{
recvfrom(SOCK_UDPS,buff, len, remote_ip,&remote_port);
/*W5500接收计算机发送来的数据*/
buff[len-8]=0x00; /*添加字符串结束符*/
printf("%s\r\n",buff); /*打印接收缓存*/
sendto(SOCK_UDPS,buff,len-8, remote_ip, remote_port); /*W5500把接收到的数据发送给Remote*/
}
break;
}
}
/**
* UDP loopback program.
*/
void loopback_udp(SOCKET s, uint16 port, uint8* buf, uint16 mode)
{
uint32 len;
uint8 destip[4];
uint16 destport;
switch(getSn_SSR(s))
{
// -------------------------------
case SOCK_UDP: //
if((len=getSn_RX_RSR(s)) > 0) // check the size of received data
{
len = recvfrom(s,buf,len,destip,&destport); // receive data from a destination
if(len !=sendto(s,buf,len,destip,destport)) // send the data to the destination
{
printf("%d : Sendto Fail.len=%d,",s,len);
printf("%d.%d.%d.%d(%d)\r\n",destip[0],destip[1],destip[2],destip[3],destport);
}
}
break;
// -----------------
case SOCK_CLOSED: // CLOSED
close(s); // close the SOCKET
socket(s,Sn_MR_UDP,port,mode); // open the SOCKET with UDP mode
break;
default:
break;
}
}
uint16_t network_read(void)
{
uint16_t len;
if( (len = getSn_RX_RSR(MACRAW_PREFERRED_SOCKET)) > 0 ) // Has MACRAW socket 0 received a packet?
return macrawrecv( MACRAW_PREFERRED_SOCKET, (uint8_t*)uip_buf, len);
else
return 0;
}
void DoSimpleHttp( SOCKET sock )
{
uint16_t maxlen = DATA_BUF_SIZE;
uint16_t len;
uint8_t workingBuffer[100];
uint8_t* msgBuffer = gHttpRxBuffer;
uint8_t* outbuffer = gHttpTxBuffer;
HTMLPageDef* htmlpagePtr;
// Nachsehen, wieviele Daten angekommen sind
len = getSn_RX_RSR(sock);
if( len < 1 )
return;
// nicht mehr abholen, als Daten da sind
if (len > maxlen)
len = maxlen;
// daten aus dem wiznet buffer holen
len = recv(sock, msgBuffer, len);
//Aufbau einer unterstützten Anfrage:
// GET /url HTTP/1.1 HOST: ip ....
msgBuffer = strwrd( msgBuffer, workingBuffer, 100, " ");
if( msgBuffer )
{
printf( "[%s]\n", workingBuffer);
if( !strcmp(workingBuffer, "GET") )
{
// Get Anfrage gefunden
msgBuffer = strwrd( msgBuffer, workingBuffer, 100, " ");
if( msgBuffer)
{
printf( "[%s]\n", workingBuffer);
if( workingBuffer[0] == '/' )
{
// eine URL gefudnen
htmlpagePtr = HTMLPagesGet_index();
len = sprintf( outbuffer,
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: keep-alive\r\nContent-Length: %i \r\n\r\n %s",
strlen(htmlpagePtr->PageContent),
htmlpagePtr->PageContent
);
send( sock, outbuffer, len );
}
}
}
}
}
uint8_t check_for_connections(TCP_CONFIG *config)
{
if(!(getSn_SR(config->s) != SOCK_ESTABLISHED))
{
while ((bytesReceived = getSn_RX_RSR(config->s)) == 0); // wait for connection
return 1;
}
return 0;
}
int32_t loopback_udps(uint8_t sn, uint8_t* buf, uint16_t port)
{
int32_t ret;
uint16_t size, sentsize;
uint8_t destip[4];
uint16_t destport;
switch(getSn_SR(sn))
{
case SOCK_UDP :
if((size = getSn_RX_RSR(sn)) > 0)
{
if(size > DATA_BUF_SIZE)
size = DATA_BUF_SIZE;
ret = recvfrom(sn, buf, size, destip, (uint16_t*)&destport);
if(ret <= 0)
{
#ifdef _LOOPBACK_DEBUG_
printk("%d: recvfrom error. %ld\r\n",sn,ret);
#endif
return ret;
}
size = (uint16_t) ret;
sentsize = 0;
while(sentsize != size)
{
ret = sendto(sn, buf+sentsize, size-sentsize, destip, destport);
if(ret < 0)
{
#ifdef _LOOPBACK_DEBUG_
printk("%d: sendto error. %ld\r\n",sn,ret);
#endif
return ret;
}
sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
}
}
break;
case SOCK_CLOSED:
#ifdef _LOOPBACK_DEBUG_
//printk("%d:UDP loopback start\r\n",sn);
#endif
if((ret = socket(sn, Sn_MR_UDP, port, 0x00)) != sn)
return ret;
#ifdef _LOOPBACK_DEBUG_
printk("%d:Opened, UDP loopback, port [%d]\r\n", sn, port);
#endif
break;
default :
break;
}
return 1;
}
int32_t loopback_tcpc_bsd(uint8_t* buf)
{
int32_t ret;
uint16_t size = 0, sentsize=0;
uint8_t sn;
struct sockaddr_in sa;
uint32_t s_addr;
uint8_t destip[4] = {192, 168, 0, 2};
uint16_t destport = 5001;
ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(ret == -1)
{
#ifdef _LOOPBACK_DEBUG_
printf("%d:Socket Error\r\n", ret);
#endif
return ret;
}
sn = ret;
memset(&sa, 0, sizeof(sa));
sa.sin_len = (uint16_t)sizeof(sa);
sa.sin_family = AF_INET;
sa.sin_port = htons(destport);
s_addr = (((((destip[0] << 8) | destip[1]) << 8) | destip[2]) << 8) | destip[3];
sa.sin_addr.s_addr = htonl(s_addr);
if( (ret = connect(sn, (struct sockaddr*)&sa, sa.sin_len)) != SOCK_OK) return ret;
while(1)
{
if((size = getSn_RX_RSR(sn)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur.
{
ret = recv(sn, buf, size, 0);
if(ret <= 0) continue;
sentsize = 0;
while(size != sentsize)
{
ret = send(sn, buf+sentsize, size-sentsize, 0);
if(ret < 0)
{
close(sn);
return ret;
}
sentsize += ret;
}
}
}
close(sn);
return 1;
}
//TCP-Server 처리
void ProcessTcpSever(void) {
// if len is not volatile, it will overflow
// and causes 'cstack' overstack error
volatile int len;
uint8_t *data_buf = (uint8_t) TX_BUF;
uint16 max_bufsize = sizeof(data_buf);
unsigned int port = MY_LISTEN_PORT;
getSn = getSn_SR(SOCK_TCPS);
switch (getSn_SR(SOCK_TCPS)) {
case SOCK_INIT:
lis = listen(SOCK_TCPS);
break;
case SOCK_ESTABLISHED:
/* check Rx data */
if ((len = getSn_RX_RSR(SOCK_TCPS)) > 0) {
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
if (len > max_bufsize) len = max_bufsize;
/* the data size to read is MAX_BUF_SIZE. */
/* read the received data */
CheckCounter++;
len = recv(SOCK_TCPS, data_buf, len);
length = len;
SendFlag = True;
/* send the received data */
//send(SOCK_TCPS, data_buf, len);
}
break;
case SOCK_CLOSE_WAIT:
SendFlag = False;
//If the client request to close
disconnect(SOCK_TCPS);
break;
case SOCK_CLOSED:
//reinitialize the socket
if(socket(SOCK_TCPS, Sn_MR_TCP, port ,0x00) == 0) {
printf("Fail to create socket.");
} else {
SendFlag = False;
lis = listen(SOCK_TCPS);
}
break;
}
}
/**
* @brief This function listenes the eventing message from IGD(Internet Gateway Device).
*/
void eventing_listener(
SOCKET sockfd /**< a socket number. */
)
{
uint16 len;
const uint8 HTTP_OK[] = "HTTP/1.1 200 OK\r\n\r\n";
switch (getSn_SR(sockfd))
{
case SOCK_ESTABLISHED: /* if connection is established */
Delay_ms(500);
if((len = getSn_RX_RSR(sockfd)) > 0){
TCPRecv(sockfd, (void *)recv_buffer, len);
TCPSend(sockfd, (void *)HTTP_OK, strlen((void *)HTTP_OK));
parseEventing(recv_buffer);
#ifdef UPNP_DEBUG
printf("\r\nReceiveData\r\n%s\r\n", recv_buffer);
#endif
}
break;
case SOCK_CLOSE_WAIT: /* If the client request to close */
if ((len = getSn_RX_RSR(sockfd)) > 0) /* check Rx data */
{
TCPRecv(sockfd, (void *)recv_buffer, len); /* read the received data */
}
TCPClose(sockfd);
break;
case SOCK_CLOSED: /* if a socket is closed */
if(TCPServerOpen(sockfd,PORT_UPNP_EVENTING) == FAIL) /* reinitialize the socket */
{
printf("\r\n%d : Fail to create socket.",sockfd);
}
break;
default:
break;
}
}
int32_t loopback_udps_bsd(uint8_t sn, uint8_t* buf, uint16_t port)
{
int32_t ret;
uint16_t size, sentsize;
struct sockaddr_in sa;
int len;
switch(getSn_SR(sn))
{
case SOCK_UDP :
if((size = getSn_RX_RSR(sn)) > 0)
{
if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE;
ret = recvfrom(sn, buf, size, 0, (struct sockaddr*)&sa, (socklen_t*)&len);
if(ret <= 0)
{
#ifdef _LOOPBACK_DEBUG_
printf("%d: recvfrom error. %ld\r\n",sn,ret);
#endif
return ret;
}
size = (uint16_t) ret;
sentsize = 0;
while(sentsize != size)
{
ret = sendto(sn, buf+sentsize, size-sentsize, 0, (struct sockaddr*)&sa, len);
if(ret < 0)
{
#ifdef _LOOPBACK_DEBUG_
printf("%d: sendto error. %ld\r\n",sn,ret);
#endif
return ret;
}
sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
}
}
break;
case SOCK_CLOSED:
#ifdef _LOOPBACK_DEBUG_
printf("%d:UDP loopback start\r\n",sn);
#endif
if((ret = socket(AF_INET, SOCK_STREAM, IPPROTO_UDP)) != sn) return ret;
#ifdef _LOOPBACK_DEBUG_
printf("%d:Opened, UDP loopback, port [%d]\r\n", sn, port);
#endif
break;
default :
break;
}
return 1;
}
void sender_tcpc(SOCKET s, uint16 port)
{
uint16 RSR_len;
uint8 DATA_BUFF_IN[INPUT_SIZE_BUF];
switch (getSn_SR(s))
{
case SOCK_ESTABLISHED: /* if connection is established */
if(ch_status[s]==1)
{
ch_status[s] = 2;
}
send(s, DATA_BUFF_IN, MAX_SIZE_BUF, (bool)WINDOWFULL_FLAG_OFF, FPGA);
break;
case SOCK_CLOSE_WAIT: /* If the client request to close */
if ((RSR_len = getSn_RX_RSR(s)) > 0) /* check Rx data */
{
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
if (RSR_len > TX_RX_MAX_BUF_SIZE) RSR_len = TX_RX_MAX_BUF_SIZE; /* the data size to read is MAX_BUF_SIZE. */
// received_len = recv(s, DATA_BUFF_A, RSR_len); /* read the received data */
}
disconnect(s);
ch_status[s] = 0;
break;
case SOCK_CLOSED: /* if a socket is closed */
if(!ch_status[s])
{
ch_status[s] = 1;
}
if(socket(s, Sn_MR_TCP, port, 0x00) == 0) /* reinitialize the socket */
{
ch_status[s] = 0;
}
break;
case SOCK_INIT: /* if a socket is initiated */
if(time_return() - presentTime >= (tick_second * 3)) /* For TCP client's connection request delay : 3 sec */
{
/* Try to connect to TCP server(Socket, DestIP, DestPort) */
connect(s, Config_Msg.destip, Config_Msg.port);
presentTime = time_return();
}
break;
default:
break;
}
}
/*
功能描述 : 将数据接收上来并传输到FPGA缓存当中
参数 : @s socket number
@data_buf W7100A指向的数据存储位置
日期 : 2015年6月26日 21:04:42
*/
static void loopback_recv(SOCKET s)
{
uint16 xdata len = 0;
uint8 xdata destip[4] = { 0 };
uint16 xdata destport = 0;
if ((len = getSn_RX_RSR(s)) > 0) // check the size of received data
{
/*将数据拷贝到fpga的空间当中*/
len = recvfrom(s, 0x010000, len, (uint8*)destip, &destport);
#ifdef DEBUG_PRINT
printf("CH %bu: Received %d bytes from %.3bu. %.3bu. %.3bu. %.3bu \r\n",
s, len, destip[0], destip[1], destip[2], destip[3]);
#endif
}
}
int32_t WIZCHIP_EXPORT(recv)(uint8_t sn, uint8_t * buf, uint16_t len)
{
uint8_t tmp = 0;
uint16_t recvsize = 0;
CHECK_SOCKNUM();
CHECK_SOCKMODE(Sn_MR_TCP);
CHECK_SOCKDATA();
recvsize = getSn_RxMAX(sn);
if(recvsize < len) len = recvsize;
while(1)
{
recvsize = getSn_RX_RSR(sn);
tmp = getSn_SR(sn);
if (tmp != SOCK_ESTABLISHED)
{
if(tmp == SOCK_CLOSE_WAIT)
{
if(recvsize != 0) break;
else if(getSn_TX_FSR(sn) == getSn_TxMAX(sn))
{
// dpgeorge: Getting here seems to be an orderly shutdown of the
// socket, and trying to get POSIX behaviour we return 0 because:
// "If no messages are available to be received and the peer has per‐
// formed an orderly shutdown, recv() shall return 0".
// TODO this return value clashes with SOCK_BUSY in non-blocking mode.
WIZCHIP_EXPORT(close)(sn);
return 0;
}
}
else
{
WIZCHIP_EXPORT(close)(sn);
return SOCKERR_SOCKSTATUS;
}
}
if((sock_io_mode & (1<<sn)) && (recvsize == 0)) return SOCK_BUSY;
if(recvsize != 0) break;
MICROPY_THREAD_YIELD();
};
if(recvsize < len) len = recvsize;
wiz_recv_data(sn, buf, len);
setSn_CR(sn,Sn_CR_RECV);
while(getSn_CR(sn));
return len;
}
/**
*@brief 微博上传函数
*@param weibo： 要上传的微博内容
*@return 无
*/
unsigned char post_weibo_update(char* weibo)
{
char post_data[385]={0x00,};
char tmp_buf[BUF_SIZE]={0x00,};
unsigned char ret=0;
unsigned int len=0;
char* p;
if(socket(SOCK_WEIBO,Sn_MR_TCP,any_local_port++,0)!=1) /*初始化TCP socket*/
{
printf("Socket initialization failed.\r\n");
return 0;
}
else
{
printf("Connect with Weibo server.\r\n");
ret=connect(SOCK_WEIBO,weibo_server_ip,80); /*连接微博服务器, 默认端口为 80 */
if(ret!=1)
{
printf("Connect Weibo server failed.\r\n");
return 0;
}
else
{
while(getSn_SR(SOCK_WEIBO)!=SOCK_ESTABLISHED); /*等待连接建立成功*/
printf("Connected with Weibo server.\r\n");
sprintf(post_data,"id=%s&pw=%s&cmd=update&status=%s",(char*)weibo_id,(char*)weibo_pwd,weibo);
sprintf(tmp_buf,"POST %s HTTP/1.1\r\nHost: %s\r\nUser-Agent: w5500\r\nContent-Type: application/x-www-form-urlencoded; charset=gb2312\r\nConnection: close\r\nContent-Length: %d\r\n\r\n%s",(char*)http_path,(char*)weibo_server,strlen(post_data),post_data);
len=send(SOCK_WEIBO,(unsigned char*)tmp_buf,strlen(tmp_buf)); /*上传传微博内容*/
while(1)
{
len=getSn_RX_RSR(SOCK_WEIBO);
if(len>0)
{
memset(tmp_buf,0x00,MAX_BUF_SIZE);
len=recv(SOCK_WEIBO, (unsigned char*)tmp_buf, len); /*接收来自微博服务器的返回结果*/
p=strstr(tmp_buf,(char*)"\r\n\r\n")+4; /*获取有效负载*/
printf("rev%s\r\n",p);
printf("发送成功\r\n");
close(SOCK_WEIBO); /*关闭socket*/
return 1; /*成功就返回 1*/
}
}
}
}
}
// Stores the frame in self->eth_frame and returns number of bytes in the frame, 0 for no frame
STATIC uint16_t wiznet5k_recv_ethernet(wiznet5k_obj_t *self) {
uint16_t len = getSn_RX_RSR(0);
if (len == 0) {
return 0;
}
byte ip[4];
uint16_t port;
int ret = WIZCHIP_EXPORT(recvfrom)(0, self->eth_frame, 1514, ip, &port);
if (ret <= 0) {
printf("wiznet5k_lwip_poll: fatal error len=%u ret=%d\n", len, ret);
netif_set_link_down(&self->netif);
netif_set_down(&self->netif);
return 0;
}
return ret;
}
/*
********************************************************************************
* MAKE DNS QUERY AND PARSE THE REPLY
*
* Description : This function makes DNS query message and parses the reply from DNS server.
* Arguments : name - is a pointer to the domain name.
* Returns : if succeeds : 1, fails : -1
* Note :
********************************************************************************
*/
uint8 dns_query(uint8 s, uint8 * name)
{
static uint32 dns_wait_time = 0;
struct dhdr dhp;
uint8 ip[4];
uint16 len, port;
switch(getSn_SR(s))
{
case SOCK_UDP:
if ((len = getSn_RX_RSR(s)) > 0)
{
if (len > MAX_DNS_BUF_SIZE) len = MAX_DNS_BUF_SIZE;
len = recvfrom(s, BUFPUB, len, ip, &port);
if(parseMSG(&dhp, BUFPUB))
{
close(s);
return DNS_RET_SUCCESS;
}
else
dns_wait_time = DNS_RESPONSE_TIMEOUT;
}
else
{
Delay_ms(1000);
dns_wait_time++;
//if(ConfigMsg.debug) printf("dns wait time=%d\r\n", dns_wait_time);
}
if(dns_wait_time >= DNS_RESPONSE_TIMEOUT) // 3ÃÊ
{
close(s);
return DNS_RET_FAIL;
}
break;
case SOCK_CLOSED:
dns_wait_time = 0;
socket(s, Sn_MR_UDP, 3000, 0);
//if(ConfigMsg.debug) printf("dns socket init over\r\n");
len = dns_makequery(0, name, BUFPUB, MAX_DNS_BUF_SIZE);
//if(ConfigMsg.debug) printf("dns make query\r\n");
sendto(s, BUFPUB, len, EXTERN_DNS_SERVERIP, IPPORT_DOMAIN);
break;
}
return DNS_RET_PROGRESS;
}
int32_t loopback_tcps_bsd(uint8_t* buf)
{
int32_t ret;
uint16_t size = 0, sentsize=0;
uint8_t sn;
ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(ret == -1)
{
#ifdef _LOOPBACK_DEBUG_
printf("%d:Socket Error\r\n", ret);
#endif
return ret;
}
sn = ret;
if( (ret = listen(sn, BACKLOG)) != SOCK_OK) return ret;
while(1)
{
if((size = getSn_RX_RSR(sn)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur.
{
ret = recv(sn, buf, size, 0);
if(ret <= 0) continue;
sentsize = 0;
while(size != sentsize)
{
ret = send(sn, buf+sentsize, size-sentsize, 0);
if(ret < 0)
{
close(sn);
return ret;
}
sentsize += ret;
}
}
}
close(sn);
return 1;
}
int32_t recv(uint8_t sn, uint8_t * buf, uint16_t len)
{
uint8_t tmp = 0;
uint16_t recvsize = 0;
CHECK_SOCKNUM();
CHECK_SOCKMODE(Sn_MR_TCP);
CHECK_SOCKDATA();
recvsize = getSn_RxMAX(sn);
if(recvsize < len) len = recvsize;
while(1)
{
recvsize = getSn_RX_RSR(sn);
tmp = getSn_SR(sn);
if (tmp != SOCK_ESTABLISHED)
{
if(tmp == SOCK_CLOSE_WAIT)
{
if(recvsize != 0) break;
else if(getSn_TX_FSR(sn) == getSn_TxMAX(sn))
{
close(sn);
return SOCKERR_SOCKSTATUS;
}
}
else
{
close(sn);
return SOCKERR_SOCKSTATUS;
}
}
if((sock_io_mode & (1<<sn)) && (recvsize == 0)) return SOCK_BUSY;
if(recvsize != 0) break;
HAL_Delay(1);
};
if(recvsize < len) len = recvsize;
wiz_recv_data(sn, buf, len);
setSn_CR(sn,Sn_CR_RECV);
while(getSn_CR(sn));
return len;
}
/* Is data available in rx buffer? Returns 0 if no, number of available bytes if yes. */
int UdpBytewiseClass::available() {
if(_rxSize==0 || _rxSize-_rxIndex==0) {
//if local buffer is empty or depleted
//check wiz5100 buffer for new packet
_rxSize = getSn_RX_RSR(_sock); //note: return value is inflated by 8 byte header
if(_rxSize){
//if we have a new packet there
//reset buffer index
_rxIndex=0;
//copy packet into our local buffer
_rxSize = recvfrom(_sock,_rxBuffer,_rxSize-8,_rxIp,&_rxPort);
} else {
//else do nothing and rxsize is still 0
;
}
return _rxSize; //return the new number of bytes in our buffer
} else{
//if buffer is not empty, return remaining # of bytes
return (_rxSize-_rxIndex);
}
}
/**
* "TCP CLIENT" loopback program.
*/
void loopback_tcpc(SOCKET s, uint8* addr, uint16 port, uint8* buf, uint16 mode)
{
uint32 len;
static uint16 any_port = 1000;
switch(getSn_SSR(s)) // check SOCKET status
{ // ------------
case SOCK_ESTABLISHED: // ESTABLISHED?
if(getSn_IR(s) & Sn_IR_CON) // check Sn_IR_CON bit
{
printf("%d : Connect OK\r\n",s);
setSn_IR(s,Sn_IR_CON); // clear Sn_IR_CON
}
if((len=getSn_RX_RSR(s)) > 0) // check the size of received data
{
len = recv(s,buf,len); // recv
if(len !=send(s,buf,len)) // send
{
printf("%d : Send Fail.len=%d\r\n",s,len);
}
}
break;
// ---------------
case SOCK_CLOSE_WAIT: // PASSIVE CLOSED
disconnect(s); // disconnect
break;
// --------------
case SOCK_CLOSED: // CLOSED
close(s); // close the SOCKET
socket(s,Sn_MR_TCP,any_port++,mode);// open the SOCKET with TCP mode and any source port number
break;
// ------------------------------
case SOCK_INIT: // The SOCKET opened with TCP mode
connect(s, addr, port); // Try to connect to "TCP SERVER"
printf("%d : LOOPBACK_TCPC(%d.%d.%d.%d:%d) Started.\r\n",s,addr[0],addr[1],addr[2],addr[3],port);
break;
default:
break;
}
}
uint8_t echo (){
int16_t size = getSn_RX_RSR(0);
if (size == 0) return IP_STATE_ECHO;
if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE;
int32_t ret = recv(0,read_buffer,size);
if (ret<=0)
return IP_STATE_CLOSE;
for (uint8_t i = 0 ; i < ret; i++){
write_buffer[i]=toupper(read_buffer[i]);
}
int32_t send_ret = send(0, write_buffer, ret);
if (ret != send_ret){
return IP_STATE_CLOSE;
}
for (int i=0; i< ret ; i++){
if (read_buffer[i]=='.'){
return IP_STATE_GREETING;
}
}
return IP_STATE_ECHO;
}
/**
* "TCP SERVER" loopback program.
*/
void loopback_tcps(SOCKET s, uint16 port, uint8* buf, uint16 mode)
{
uint32 len;
switch(getSn_SSR(s)) // check SOCKET status
{ // ------------
case SOCK_ESTABLISHED: // ESTABLISHED?
if(getSn_IR(s) & Sn_IR_CON) // check Sn_IR_CON bit
{
printf("%d : Connect OK\r\n",s);
setSn_IR(s,Sn_IR_CON); // clear Sn_IR_CON
}
if((len=getSn_RX_RSR(s)) > 0) // check the size of received data
{
len = recv(s,buf,len); // recv
if(len !=send(s,buf,len)) // send
{
printf("%d : Send Fail.len=%d\r\n",s,len);
}
}
break;
// ---------------
case SOCK_CLOSE_WAIT: // PASSIVE CLOSED
disconnect(s); // disconnect
break;
// --------------
case SOCK_CLOSED: // CLOSED
close(s); // close the SOCKET
socket(s,Sn_MR_TCP,port,mode); // open the SOCKET
break;
// ------------------------------
case SOCK_INIT: // The SOCKET opened with TCP mode
listen(s); // listen to any connection request from "TCP CLIENT"
printf("%d : LOOPBACK_TCPS(%d) Started.\r\n",s,port);
break;
default:
break;
}
}
// Try to receive more incoming data from the socket. The mutex is alrady owned.
void W5500Socket::ReceiveData()
{
const uint16_t len = getSn_RX_RSR(socketNum);
if (len != 0)
{
// debugPrintf("%u available\n", len);
NetworkBuffer * const lastBuffer = NetworkBuffer::FindLast(receivedData);
// NOTE: reading only part of the received data doesn't work because the wizchip doesn't track the buffer pointer properly.
// We could probably make it work by tracking the buffer pointer ourselves, just as we do when sending data, and using wiz_recv_data_at.
if (lastBuffer != nullptr && lastBuffer->SpaceLeft() >= len)
{
wiz_recv_data(socketNum, lastBuffer->UnwrittenData(), len);
ExecCommand(socketNum, Sn_CR_RECV);
lastBuffer->dataLength += len;
if (reprap.Debug(moduleNetwork))
{
debugPrintf("Appended %u bytes\n", (unsigned int)len);
}
}
else if (NetworkBuffer::Count(receivedData) < MaxBuffersPerSocket)
{
NetworkBuffer * const buf = NetworkBuffer::Allocate();
if (buf != nullptr)
{
wiz_recv_data(socketNum, buf->Data(), len);
ExecCommand(socketNum, Sn_CR_RECV);
buf->dataLength = (size_t)len;
NetworkBuffer::AppendToList(&receivedData, buf);
if (reprap.Debug(moduleNetwork))
{
debugPrintf("Received %u bytes\n", (unsigned int)len);
}
}
}
// else debugPrintf("no buffer\n");
}
}
/**
@brief Send ping-request to the specified peer and receive ping-reply from the specified peer.
@return 1 - success, 0 - fail because free socket is not found or can't be opened.
*/
uint8_t ping(
uint8_t count, /**< Ping request count. */
uint16_t time, /**< wait ping reply time (unit : ms) */
uint8_t* addr, /**< Peer IP Address string in dotted decimal format */
PING_LOG* log /**< result of ping */
)
{
PING_MSG* pPingRequest; // pointer for Ping Request
PING_MSG* pPingReply; // pointer for Ping Reply
uint32_t peerip; // 32 bit Peer IP Address
uint32_t tempip; // IP address received from a destination
uint16_t port; // port number received from a destination
SOCKET s; // socket variable for pinging
uint16_t RandomSeqNum; // Ping-Request ID
uint16_t len;
uint8_t IsReceived; // Received packet = 1, not received packet = 0
portTickType xInitialTick;
/* Initialise PingRequest */
if( !(pPingRequest = (PING_MSG *) pvPortMalloc( sizeof(PING_MSG) )))
return 0;
if( !(pPingReply = (PING_MSG *) pvPortMalloc( sizeof(PING_MSG) )))
{
vPortFree(pPingRequest);
return 0;
}
RandomSeqNum = htons( (uint16_t)rand()); // set ping-request's sequence number to random integer value
pPingRequest->type = 0x08; // Ping-Request - ICMP
pPingRequest->code = 0x00; // always 0
pPingRequest->checksum = 0; // value of checksum before calculating checksum of ping-request packet
pPingRequest->id = htons(PING_ID); // set ping-request ID
for(uint16_t i = 0 ; i < PING_OPT_LEN; i++)
pPingRequest->OPT[i] = 'a' + i % 23; // fill 'a'~'w' characters into ping-request's data
/* Initialise result of ping */
memset((void*)log,0,sizeof(PING_LOG));
/* Verify arguments */
if(!count) count = 4; // set count to default value (4 pings)
if(!time) time = 1000; // set response time to default value (1000ms)
/* Create a ping socket */
s = getSocket(SOCK_CLOSED,0);
if(s == MAX_SOCK_NUM) // if it isn't exist free socket, Error
{
vPortFree(pPingRequest);
vPortFree(pPingReply);
return 0;
}
setSn_PROTO(s,IP_PROTO_ICMP); // Set upper-protocol of IP protocol
if( socket( s, Sn_MR_IPRAW, 3000, 0) == 0) // Open IP_RAW Mode , if fail then Error
{
vPortFree(pPingRequest);
vPortFree(pPingReply);
return 0;
}
peerip = htonl( inet_addr(addr)); // convert address string into 32bit address
xSerialPrintf_P(PSTR("\r\nPinging %s with %d bytes of data:\r\n"), addr, (sizeof(PING_MSG) - 8));
/* Ping Service */
while( count-- != 0)
{
IsReceived = 0;
pPingRequest->seqNum = htons( RandomSeqNum++); // Increase Sequence number for next ping-request packet
pPingRequest->checksum = 0;
pPingRequest->checksum = htons( checksum( (uint8_t*)pPingRequest, sizeof(PING_MSG))); // update checksum field
(*log).PingRequest++; // Increase PingRequest's value
xInitialTick = xTaskGetTickCount();
if( sendto( s, (const uint8_t *)pPingRequest, sizeof(PING_MSG), (uint8_t*)&peerip, 3000)== 0) // Send Ping-Request to the specified peer. If fail, then it is occurred ARP Error.
{
(*log).ARPErr++; // Increase ARPErr
close(s); // close the pinging socket
/* Reopen pinging socket */
setSn_PROTO(s,IP_PROTO_ICMP);
if(socket( s, Sn_MR_IPRAW, 3000, 0)==0)
{
vPortFree(pPingRequest);
vPortFree(pPingReply);
return 0;
}
continue;
}
while( xTaskGetTickCount() < (xInitialTick + ( time / portTICK_RATE_MS )) ) // as long as time is remaining
{
if((len = getSn_RX_RSR(s)) > 0) // Has pinging socket received a packet?
{
len = recvfrom( s, (uint8_t*)pPingReply, len, (uint8_t*)&tempip, &port); // receive a packet from unknown peer
xSerialPrintf_P(PSTR("\r\nReply from %s"), inet_ntoa( ntohl(tempip))); // convert 32 bit unknown peer IP address into string of IP Address.
if( checksum((uint8_t*)pPingReply,len) != 0) // if the packet's checksum value is correct
{ // not correct
(*log).CheckSumErr++; // checksum error
if(tempip == peerip) IsReceived = 1;
xSerialPrint_P(PSTR(": Checksum Error"));
}
else if(pPingReply->type == 0) // if the received packet is ping-reply
{
if((pPingReply->id!=pPingRequest->id) || (pPingReply->seqNum!=pPingRequest->seqNum) || (tempip!=peerip)) // verify id,sequence nubmer, and ip address
{
xSerialPrint_P(PSTR(": Unmatched ID / SeqNum from peer")); // fail to verify
(*log).UnknownMSG++;
}
else // success
{
IsReceived = 1;
xSerialPrintf_P(PSTR(": bytes=%d, time<=%dms"),len-8,(xTaskGetTickCount()-xInitialTick)*portTICK_RATE_MS );
(*log).PingReply++;
}
}
else if( pPingReply->type == 3) // If the packet is unreachable message
{
IsReceived = 1;
xSerialPrint_P(PSTR(": Destination unreachable"));
(*log).UnreachableMSG++;
}
else if( pPingReply->type == 11) // If the packet is time exceeded message
{
IsReceived = 1;
xSerialPrint_P(PSTR(": TTL expired in transit"));
(*log).TimeExceedMSG++;
}
else if( pPingReply->type == 8) // Send ping reply to a peer
{
xSerialPrint_P(PSTR(": Ping Request message"));
SendPingReply(pPingReply,tempip);
}
else // if the packet is unknown message
{
xSerialPrintf_P(PSTR(": Unknown message (type = 0x%02X)"), pPingReply->type);
(*log).UnknownMSG++;
}
}
else if(getSn_SR(s)==SOCK_CLOSED) // if it is occurred to fail to send arp packet
{
(*log).ARPErr++;
close(s); // close the pinging socket
setSn_PROTO( s, IP_PROTO_ICMP); // reopen the pinging socket
if(socket( s, Sn_MR_IPRAW, 3000, 0) == 0 )
{
vPortFree(pPingRequest);
vPortFree(pPingReply);
return 0;
}
break;
}
if((xTaskGetTickCount() >= (xInitialTick + ( time / portTICK_RATE_MS ))) && (IsReceived == 0)) // If it is not received packet from the specified peer during waiting ping-reply packet.
{
(*log).Loss++;
xSerialPrint_P(PSTR("Request timed out\r\n"));
}
}
}
/* Release pinging socket */
setSn_PROTO(s,0);
close(s);
vPortFree(pPingRequest);
vPortFree(pPingReply);
return 1;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main()
{
//uint8_t tx_size[8] = { 2, 2, 2, 2, 2, 2, 2, 2 };
//uint8_t rx_size[8] = { 2, 2, 2, 2, 2, 2, 2, 2 };
uint8_t mac_addr[6] = {0x00, 0x08, 0xDC, 0x01, 0x02, 0x03};
uint8_t src_addr[4] = {192, 168, 0, 9};
uint8_t gw_addr[4] = {192, 168, 0, 1};
uint8_t sub_addr[4] = {255, 255, 255, 0};
//uint8_t dns_server[4] = {8, 8, 8, 8}; // for Example domain name server
uint8_t tmp[8];
int32_t ret;
uint16_t port=5000, size = 0, sentsize=0;
uint8_t destip[4];
uint16_t destport;
*(volatile uint32_t *)(0x41001014) = 0x0060100; //clock setting 48MHz
/* External Clock */
//CRG_PLL_InputFrequencySelect(CRG_OCLK);
/* Set Systme init */
SystemInit();
SSP0_Initialize();
SSP1_Initialize();
GPIO_Initialize();
GPIO_SetBits(GPIOC, GPIO_Pin_8); // LED red off
GPIO_SetBits(GPIOC, GPIO_Pin_9); // LED green off
GPIO_ResetBits(GPIOC, GPIO_Pin_6); // Test off
/* UART Init */
UART_StructInit(&UART_InitStructure);
UART_Init(UART1,&UART_InitStructure);
/* SysTick_Config */
SysTick_Config((GetSystemClock()/1000));
/* Set WZ_100US Register */
setTIC100US((GetSystemClock()/10000));
//getTIC100US();
//printf(" GetSystemClock: %X, getTIC100US: %X, (%X) \r\n",
// GetSystemClock, getTIC100US(), *(uint32_t *)TIC100US);
#ifdef __DEF_USED_IC101AG__ //For using IC+101AG
*(volatile uint32_t *)(0x41003068) = 0x64; //TXD0 - set PAD strengh and pull-up
*(volatile uint32_t *)(0x4100306C) = 0x64; //TXD1 - set PAD strengh and pull-up
*(volatile uint32_t *)(0x41003070) = 0x64; //TXD2 - set PAD strengh and pull-up
*(volatile uint32_t *)(0x41003074) = 0x64; //TXD3 - set PAD strengh and pull-up
*(volatile uint32_t *)(0x41003050) = 0x64; //TXE - set PAD strengh and pull-up
#endif
printf("PHY is linked. \r\n");
#ifdef __DEF_USED_MDIO__
/* mdio Init */
mdio_init(GPIOB, MDC, MDIO );
//mdio_error_check(GPIOB, MDC, MDIO); //need verify...
/* PHY Link Check via gpio mdio */
while( link() == 0x0 )
{
printf(".");
delay(500);
}
printf("PHY is linked. \r\n");
#else
delay(1000);
delay(1000);
#endif
/* Network Configuration */
setSHAR(mac_addr);
setSIPR(src_addr);
setGAR(gw_addr);
setSUBR(sub_addr);
getSHAR(tmp);
printf(" MAC ADDRESS : %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\r\n",tmp[0],tmp[1],tmp[2],tmp[3],tmp[4],tmp[5]);
getSIPR(tmp);
printf("IP ADDRESS : %d.%d.%d.%d\r\n",tmp[0],tmp[1],tmp[2],tmp[3]);
getGAR(tmp);
printf("GW ADDRESS : %d.%d.%d.%d\r\n",tmp[0],tmp[1],tmp[2],tmp[3]);
getSUBR(tmp);
printf("SN MASK: %d.%d.%d.%d\r\n",tmp[0],tmp[1],tmp[2],tmp[3]);
/* Set Network Configuration */
//wizchip_init(tx_size, rx_size);
printf(" TEST- START \r\n");
while(1)
{
switch(getSn_SR(SOCK_NUM))
{
case SOCK_ESTABLISHED:
if(getSn_IR(SOCK_NUM) & Sn_IR_CON)
{
getSn_DIPR(SOCK_NUM, destip);
destport = getSn_DPORT(SOCK_NUM);
printf("%d:Connected - %d.%d.%d.%d : %d\r\n",SOCK_NUM, destip[0], destip[1], destip[2], destip[3], destport);
setSn_IR(SOCK_NUM,Sn_IR_CON);
}
if((size = getSn_RX_RSR(SOCK_NUM)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur.
{
if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE;
ret = recv(SOCK_NUM, test_buf, size);
if(ret <= 0) return ret; // check SOCKERR_BUSY & SOCKERR_XXX. For showing the occurrence of SOCKERR_BUSY.
/* Send only data to SSP1 */
for (TxIdx=0; TxIdx<size; TxIdx++)
{
SSP_SendData(SSP0, test_buf[TxIdx]);
while( SSP_GetFlagStatus(SSP0, SSP_FLAG_BSY) );
}
/* Receive only data from SSP0 */
while(SSP_GetFlagStatus(SSP1, SSP_FLAG_RNE))
{
SSP1_Buffer_Rx[RxIdx] = SSP_ReceiveData(SSP1);
RxIdx++;
}
RxIdx=0;
sentsize = 0;
while(size != sentsize)
{
ret = send(SOCK_NUM, SSP1_Buffer_Rx+sentsize, size-sentsize);
if(ret < 0)
{
close(SOCK_NUM);
return ret;
}
sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
}
}
break;
case SOCK_CLOSE_WAIT:
printf("%d:CloseWait\r\n",SOCK_NUM);
if((ret = disconnect(SOCK_NUM)) != SOCK_OK) return ret;
printf("%d:Socket Closed\r\n", SOCK_NUM);
break;
case SOCK_INIT:
printf("%d:Listen, TCP server loopback, port [%d]\r\n", SOCK_NUM, port);
if( (ret = listen(SOCK_NUM)) != SOCK_OK) return ret;
break;
case SOCK_CLOSED:
printf("%d:TCP server loopback start\r\n",SOCK_NUM);
if((ret = socket(SOCK_NUM, Sn_MR_TCP, port, 0x00)) != SOCK_NUM) return ret;
printf("%d:Socket opened\r\n",SOCK_NUM);
break;
default:
break;
}
}
}
int32_t recvfrom(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t *port)
{
uint8_t mr;
uint8_t head[8];
uint16_t pack_len=0;
CHECK_SOCKNUM();
//CHECK_SOCKMODE(Sn_MR_UDP);
switch((mr=getSn_MR(sn)) & 0x0F)
{
case Sn_MR_UDP:
case Sn_MR_MACRAW:
break;
#if ( _WIZCHIP_ < 5200 )
case Sn_MR_IPRAW:
case Sn_MR_PPPoE:
break;
#endif
default:
return SOCKERR_SOCKMODE;
}
CHECK_SOCKDATA();
if(sock_remained_size[sn] == 0)
{
while(1)
{
pack_len = getSn_RX_RSR(sn);
if(getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
if( (sock_io_mode & (1<<sn)) && (pack_len == 0) ) return SOCK_BUSY;
if(pack_len != 0) break;
};
}
sock_pack_info[sn] = PACK_COMPLETED;
switch (mr & 0x07)
{
case Sn_MR_UDP :
if(sock_remained_size[sn] == 0)
{
wiz_recv_data(sn, head, 8);
setSn_CR(sn,Sn_CR_RECV);
while(getSn_CR(sn));
// read peer's IP address, port number & packet length
addr[0] = head[0];
addr[1] = head[1];
addr[2] = head[2];
addr[3] = head[3];
*port = head[4];
*port = (*port << 8) + head[5];
sock_remained_size[sn] = head[6];
sock_remained_size[sn] = (sock_remained_size[sn] << 8) + head[7];
sock_pack_info[sn] = PACK_FIRST;
}
if(len < sock_remained_size[sn]) pack_len = len;
else pack_len = sock_remained_size[sn];
//
// Need to packet length check (default 1472)
//
wiz_recv_data(sn, buf, pack_len); // data copy.
break;
case Sn_MR_MACRAW :
if(sock_remained_size[sn] == 0)
{
wiz_recv_data(sn, head, 2);
setSn_CR(sn,Sn_CR_RECV);
while(getSn_CR(sn));
// read peer's IP address, port number & packet length
sock_remained_size[sn] = head[0];
sock_remained_size[sn] = (sock_remained_size[sn] <<8) + head[1];
if(sock_remained_size[sn] > 1514)
{
close(sn);
return SOCKFATAL_PACKLEN;
}
sock_pack_info[sn] = PACK_FIRST;
}
if(len < sock_remained_size[sn]) pack_len = len;
else pack_len = sock_remained_size[sn];
wiz_recv_data(sn,buf,pack_len);
break;
#if ( _WIZCHIP_ < 5200 )
case Sn_MR_IPRAW:
if(sock_remained_size[sn] == 0)
{
wiz_recv_data(sn, head, 6);
setSn_CR(sn,Sn_CR_RECV);
while(getSn_CR(sn));
addr[0] = head[0];
addr[1] = head[1];
addr[2] = head[2];
addr[3] = head[3];
sock_remained_size[sn] = head[4];
sock_remaiend_size[sn] = (sock_remained_size[sn] << 8) + head[5];
sock_pack_info[sn] = PACK_FIRST;
}
//
// Need to packet length check
//
if(len < sock_remained_size[sn]) pack_len = len;
else pack_len = sock_remained_size[sn];
wiz_recv_data(sn, buf, pack_len); // data copy.
break;
#endif
default:
wiz_recv_ignore(sn, pack_len); // data copy.
sock_remained_size[sn] = pack_len;
break;
}
setSn_CR(sn,Sn_CR_RECV);
/* wait to process the command... */
while(getSn_CR(sn)) ;
sock_remained_size[sn] -= pack_len;
if(sock_remained_size[sn] != 0) sock_pack_info[sn] |= 0x01;
return pack_len;
}
/*----------- TCP Server Routine ------------*/
void ProcessTcpServer(SOCKET mSocket, uint16 port) {
// if len is not volatile, it will overflow
// and causes 'cstack' overstack error
volatile uint16_t len;
getSn = getSn_SR(mSocket);
switch (getSn_SR(mSocket)) {
case SOCK_ESTABLISHED:
if(ch_status[mSocket] == 0) {
printf("\r\n------------------------");
printf("\r\nSocket No. %d : Connected", mSocket);
printf("\r\n - Peer IP : %d.%d.%d.%d",
IINCHIP_READ(Sn_DIPR0(mSocket)+0), IINCHIP_READ(Sn_DIPR0(mSocket)+1),
IINCHIP_READ(Sn_DIPR0(mSocket)+2), IINCHIP_READ(Sn_DIPR0(mSocket)+3));
printf("\r\n - Peer Port : %d",
( (uint16)(IINCHIP_READ(Sn_DPORT0(mSocket)+0)<<8) +
(uint16)IINCHIP_READ(Sn_DPORT0(mSocket)+1)) );
printf("\r\n - Source Port : %d", IINCHIP_READ(Sn_PORT0(mSocket)));
ch_status[mSocket] = 1;
}
/* check Rx data and set flags only when there's valid character recognized */
if ((len = getSn_RX_RSR(mSocket)) > 0) {
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
/* the data size to read is MAX_BUF_SIZE. */
if (len > TX_RX_MAX_BUF_SIZE) len = TX_RX_MAX_BUF_SIZE;
switch(mSocket) {
case SOCK_ZERO : E1Flag = true; break; // EQ-DAQ-01 board
case SOCK_ONE : E2Flag = true; break; // EQ-DAQ-02 board
case SOCK_TWO : PCFlag = true; break; // PC Client
default : break;
}
/* prevent from overflowing */
len = recv(mSocket, RX_BUF, len);
}
break;
case SOCK_CLOSE_WAIT:
E1Flag = false; // Reset E1 flag
E2Flag = false; // Reset E2 flag
PCFlag = false; // Reset PC flag
printf("\r\nSocket No. %d : CLOSE_WAIT", mSocket);
// disconnect and set status
disconnect(mSocket);
ch_status[mSocket] = 0;
break;
case SOCK_INIT:
lis = listen(mSocket);
break;
case SOCK_CLOSED:
//reinitialize the socket
if(socket(mSocket, Sn_MR_TCP, port ,0x00) == 0) {
printf("Fail to create socket.");
} else {
E1Flag = false; // Reset E1 flag
E2Flag = false; // Reset E2 flag
PCFlag = false; // Reset PC flag
lis = listen(mSocket);
}
break;
}
}
/* ------------ TCP Client Routine ------------ */
void ProcessTcpClient(SOCKET mSocket) {
// if len is not volatile, it will overflow
// and causes 'cstack' overstack error
volatile uint16_t len;
getSn = getSn_SR(mSocket);
switch (getSn_SR(mSocket)) {
case SOCK_ESTABLISHED:
if(ch_status[mSocket]==1) {
printf("\r\n%d : Connected", mSocket);
ch_status[mSocket] = 2;
}
/* check Rx data */
if ((len = getSn_RX_RSR(mSocket)) > 0) {
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
/* the data size to read is MAX_BUF_SIZE. */
if (len > TX_RX_MAX_BUF_SIZE) len = TX_RX_MAX_BUF_SIZE;
/* read the received data */
len = recv(mSocket, RX_BUF, len);
RSR_len = len;
/* sent the received data back */
//send(mSocket, RX_BUF, len, (bool)WINDOWFULL_FLAG_OFF);
}
break;
case SOCK_CLOSE_WAIT: /* If the client request to close */
E1Flag = false; // Reset E1 flag
E2Flag = false; // Reset E2 flag
printf("\r\n%d : CLOSE_WAIT", mSocket);
/* check Rx data */
if ((len = getSn_RX_RSR(mSocket)) > 0) {
/* if Rx data size is lager than TX_RX_MAX_BUF_SIZE */
/* the data size to read is MAX_BUF_SIZE. */
if (len > TX_RX_MAX_BUF_SIZE) len = TX_RX_MAX_BUF_SIZE;
/* read the received data */
len = recv(mSocket, RX_BUF, len);
RSR_len = len;
}
disconnect(mSocket);
ch_status[mSocket] = 0;
break;
case SOCK_INIT: /* if a socket is initiated */
/* For TCP client's connection request delay : 3 sec */
if(time_return() - presentTime >= (tick_second * 3)) {
/* Try to connect to TCP server(Socket, DestIP, DestPort) */
printf("\r\n[ Attempt to connect on socket %d ]", mSocket);
connect(mSocket, Chconfig_Type_Def.destip, Chconfig_Type_Def.port);
presentTime = time_return();
}
break;
case SOCK_CLOSED: /* if a socket is closed */
if(!ch_status[mSocket]) {
printf("\r\n%d : Loop-Back TCP Client Started. port: %d", mSocket, Chconfig_Type_Def.port);
ch_status[mSocket] = 1;
}
/* reinitialize the socket */
if(socket(mSocket, Sn_MR_TCP, Chconfig_Type_Def.port, 0x00) == 0) {
printf("\a%d : Fail to create socket.", mSocket);
ch_status[mSocket] = 0;
}
break;
}
}
