uint8_t SOCK_Socket(uint8_t sock, uint8_t eth_protocol, uint16_t tcp_port) {
uint8_t val, retval = 0;
if (sock!=0) {
return retval;
}
/* Make sure we close the socket first */
if (W5100_MemReadByte(W5100_S0_SR, &val)!=ERR_OK) {
return 0; /* failure */
}
if (val==W5100_SOCK_CLOSED) {
SOCK_Close(sock);
}
/* Assigned Socket 0 Mode Register */
W5100_MemWriteByte(W5100_S0_MR, eth_protocol);
/* Now open the Socket 0 */
W5100_MemWriteWord(W5100_S0_PORT, tcp_port);
W5100_MemWriteByte(W5100_S0_CR, W5100_CR_OPEN); /* Open Socket */
/* Wait for Opening Process */
do {
W5100_MemReadByte(W5100_S0_CR, &val);
} while(val!=0);
/* Check for Init Status */
W5100_MemReadByte(W5100_S0_SR, &val);
if (val==W5100_SOCK_INIT) {
retval = 1;
} else {
SOCK_Close(sock);
}
return retval;
}
static void WiznetSetup(void) {
CLS1_SendStr((unsigned char*)"Reset W5100.\r\n", CLS1_GetStdio()->stdOut);
/* reset device */
if (W5100_MemWriteByte(W5100_MR, W5100_MR_BIT_RST)!=ERR_OK) {
CLS1_SendStr((unsigned char*)"Failed to reset device!\r\n", CLS1_GetStdio()->stdErr);
}
CLS1_SendStr((unsigned char*)"Configure network.\r\n", CLS1_GetStdio()->stdOut);
/* configure network: IP address, gateway, netmask, MAC */
if (W5100_WriteConfig((w5100_config_t*)&W5100_config)!=ERR_OK) {
CLS1_SendStr((unsigned char*)"Failed to set Net Configuration!\r\n", CLS1_GetStdio()->stdErr);
}
CLS1_SendStr((unsigned char*)"Configure RX/TX memory.\r\n", CLS1_GetStdio()->stdOut);
/* we have 8 KByte we can use for the RX and TX sockets: */
if (W5100_MemWriteByte(W5100_RMSR,
W5100_xMSR_SOCKET_1_MEM_SIZE_2KB
|W5100_xMSR_SOCKET_2_MEM_SIZE_2KB
|W5100_xMSR_SOCKET_3_MEM_SIZE_2KB
|W5100_xMSR_SOCKET_4_MEM_SIZE_2KB
)!=ERR_OK)
{
CLS1_SendStr((unsigned char*)"Failed to set RX socket memory size!\r\n", CLS1_GetStdio()->stdErr);
}
if (W5100_MemWriteByte(W5100_TMSR,
W5100_xMSR_SOCKET_1_MEM_SIZE_2KB
|W5100_xMSR_SOCKET_2_MEM_SIZE_2KB
|W5100_xMSR_SOCKET_3_MEM_SIZE_2KB
|W5100_xMSR_SOCKET_4_MEM_SIZE_2KB
)!=ERR_OK)
{
CLS1_SendStr((unsigned char*)"Failed to set TX socket memory size!\r\n", CLS1_GetStdio()->stdErr);
}
CLS1_SendStr((unsigned char*)"done!\r\n", CLS1_GetStdio()->stdOut);
}
uint8_t SOCK_OpenSocket(uint8_t sock, uint8_t eth_protocol, uint16_t tcp_port) {
uint8_t val;
uint16_t sockaddr;
if (sock>=W5100_NUM_SOCKETS) {
return ERR_VALUE; /* out of range */
}
sockaddr = W5100_SKT_BASE(sock);
/* Make sure we close the socket first */
if (W5100_MemReadByte(sockaddr+W5100_SR_OFFSET, &val)!=ERR_OK) {
return ERR_FAILED; /* failure */
}
if (val==W5100_SOCK_CLOSED) {
/* make sure we close the socket */
SOCK_CloseSocket(sock);
}
/* Assigned Socket 0 Mode Register */
W5100_MemWriteByte(sockaddr+W5100_MR_OFFSET, eth_protocol);
/* Now open the Socket 0 */
W5100_MemWriteWord(sockaddr+W5100_PORT_OFFSET, tcp_port);
W5100_MemWriteByte(sockaddr+W5100_CR_OFFSET, W5100_CR_OPEN); /* Open Socket */
/* Wait for Opening Process */
do {
W5100_MemReadByte(sockaddr+W5100_CR_OFFSET, &val);
} while(val!=0);
/* Check for Init Status */
W5100_MemReadByte(sockaddr+W5100_SR_OFFSET, &val);
if (val==W5100_SOCK_INIT) {
return ERR_OK;
} else {
SOCK_CloseSocket(sock);
}
return ERR_FAILED;
}
uint16_t SOCK_Recv(uint8_t sock, uint8_t *buf, uint16_t buflen) {
uint16_t offaddr, realaddr;
if (buflen<=0 || sock!=0) {
return 1;
}
/* If the request size > MAX_BUF,just truncate it */
if (buflen>W5100_MAX_BUF) {
buflen = W5100_MAX_BUF-2;
}
/* Read the Rx Read Pointer */
W5100_MemReadWord(W5100_S0_RX_RD, &offaddr);
#if _DEBUG_MODE
printf("RX Buffer: %x\n",offaddr);
#endif
while (buflen) {
buflen--;
realaddr = W5100_RXBUFADDR+(offaddr&W5100_RX_BUF_MASK);
W5100_MemWriteByte(realaddr, *buf);
offaddr++;
buf++;
}
*buf='\0'; /* String terminated character */
/* Increase the S0_RX_RD value, so it point to the next receive */
W5100_MemWriteWord(W5100_S0_RX_RD, offaddr);
/* Now Send the RECV command */
W5100_MemWriteByte(W5100_S0_CR, W5100_CR_RECV);
WAIT1_Waitus(5); // Wait for Receive Process
return 1;
}
uint16_t SOCK_Send(uint8_t sock, const uint8_t *buf, uint16_t buflen) {
uint16_t offaddr, realaddr, txsize, timeout;
uint8_t val;
if (buflen<=0 || sock!=0) {
return 0;
}
#if _DEBUG_MODE
printf("Send Size: %d\n",buflen);
#endif
/* Make sure the TX Free Size Register is available */
W5100_MemReadWord(W5100_SO_TX_FSR, &txsize);
#if _DEBUG_MODE
printf("TX Free Size: %d\n",txsize);
#endif
timeout=0;
while (txsize<buflen) {
WAIT1_WaitOSms(1);
W5100_MemReadWord(W5100_SO_TX_FSR, &txsize);
/* Timeout for approximately 1000 ms */
if (timeout++ > 1000) {
#if _DEBUG_MODE
printf("TX Free Size Error!\n");
#endif
/* Disconnect the connection */
SOCK_Disconnect(sock);
return 0;
}
}
/* Read the Tx Write Pointer */
W5100_MemReadWord(W5100_S0_TX_WR, &offaddr);
#if _DEBUG_MODE
printf("TX Buffer: %x\n", offaddr);
#endif
while(buflen) {
buflen--;
/* Calculate the real W5100 physical Tx Buffer Address */
realaddr = W5100_TXBUFADDR+(offaddr&W5100_TX_BUF_MASK);
/* Copy the application data to the W5100 Tx Buffer */
W5100_MemWriteByte(realaddr, *buf);
offaddr++;
buf++;
}
/* Increase the S0_TX_WR value, so it point to the next transmit */
W5100_MemWriteWord(W5100_S0_TX_WR, offaddr);
/* Now Send the SEND command */
W5100_MemWriteByte(W5100_S0_CR, W5100_CR_SEND);
/* Wait for Sending Process */
do {
W5100_MemReadByte(W5100_S0_CR, &val);
} while(val!=0);
return 1;
}
uint8_t SOCK_Listen(uint8_t sock) {
uint8_t val;
uint16_t sockaddr;
if (sock>=W5100_NUM_SOCKETS) {
return ERR_VALUE;
}
sockaddr = W5100_SKT_BASE(sock);
W5100_MemReadByte(sockaddr+W5100_SR_OFFSET, &val);
if (val==W5100_SOCK_INIT) {
/* Send the LISTEN Command */
W5100_MemWriteByte(sockaddr+W5100_CR_OFFSET, W5100_CR_LISTEN);
/* Wait for Listening Process */
do {
W5100_MemReadByte(sockaddr+W5100_CR_OFFSET, &val);
} while(val!=0);
/* Check for Listen Status */
W5100_MemReadByte(sockaddr+W5100_SR_OFFSET, &val);
if (val==W5100_SOCK_LISTEN) {
return ERR_OK;
} else {
SOCK_CloseSocket(sock);
}
}
return ERR_FAILED;
}
uint8_t SOCK_Receive(uint8_t sock, uint8_t *buf, size_t bufSize, size_t readSize) {
uint16_t offaddr, realaddr;
uint16_t sockaddr;
if (readSize<=0 || sock>=W5100_NUM_SOCKETS) {
return ERR_VALUE; /* failure */
}
if (readSize>bufSize) { /* If the requested size > MAX_BUF, just truncate it */
readSize = bufSize-2;
}
sockaddr = W5100_SKT_BASE(sock);
/* Read the Rx Read Pointer */
W5100_MemReadWord(sockaddr+W5100_RX_RD_OFFSET, &offaddr);
while (readSize) {
readSize--;
realaddr = (W5100_RXBUFADDR + (0x0800*sock))+(offaddr&W5100_RX_BUF_MASK);
W5100_MemReadByte(realaddr, buf);
offaddr++;
buf++;
}
*buf='\0'; /* string terminated character */
/* Increase the S0_RX_RD value, so it point to the next receive */
W5100_MemWriteWord(sockaddr+W5100_RX_RD_OFFSET, offaddr);
/* Now Send the RECV command */
W5100_MemWriteByte(sockaddr+W5100_CR_OFFSET, W5100_CR_RECV);
WAIT1_Waitus(5); /* Wait for Receive Process */
return ERR_OK;
}
uint8_t W5100_MemWriteBlock(uint16_t addr, void *data, size_t dataSize) {
while(dataSize>0) {
if (W5100_MemWriteByte(addr, *((uint8_t*)data))!=ERR_OK) {
return ERR_FAILED;
}
data++; addr++; dataSize--;
}
return ERR_OK;
}
uint8_t SOCK_Send(uint8_t sock, const uint8_t *buf, size_t buflen) {
uint16_t offaddr, realaddr, txsize, timeout, sockaddr;
uint8_t val;
if (buflen<=0 || sock>=W5100_NUM_SOCKETS) {
return ERR_VALUE;
}
sockaddr = W5100_SKT_BASE(sock);
/* Make sure the TX Free Size Register is available */
W5100_MemReadWord(sockaddr+W5100_TX_FSR_OFFSET, &txsize);
timeout=0;
while (txsize<buflen) {
WAIT1_WaitOSms(1);
W5100_MemReadWord(sockaddr+W5100_TX_FSR_OFFSET, &txsize);
/* Timeout for approximately 1000 ms */
if (timeout++ > 1000) {
/* Disconnect the connection */
SOCK_Disconnect(sock);
return ERR_FAILED;
}
}
/* Read the Tx Write Pointer */
W5100_MemReadWord(sockaddr+W5100_TX_WR_OFFSET, &offaddr);
while(buflen) {
buflen--;
/* Calculate the real W5100 physical Tx Buffer Address */
realaddr = (W5100_TXBUFADDR+(0x0800*sock)) + (offaddr&W5100_TX_BUF_MASK);
/* Copy the application data to the W5100 Tx Buffer */
W5100_MemWriteByte(realaddr, *buf);
offaddr++;
buf++;
}
/* Increase the S0_TX_WR value, so it point to the next transmit */
W5100_MemWriteWord(sockaddr+W5100_TX_WR_OFFSET, offaddr);
/* Now Send the SEND command */
W5100_MemWriteByte(sockaddr+W5100_CR_OFFSET, W5100_CR_SEND);
/* Wait for Sending Process */
do {
W5100_MemReadByte(sockaddr+W5100_CR_OFFSET, &val);
} while(val!=0);
return ERR_OK;
}
void SOCK_Disconnect(uint8_t sock) {
uint8_t val;
if (sock!=0) {
return;
}
/* Send Disconnect Command */
W5100_MemWriteByte(W5100_S0_CR, W5100_CR_DISCON);
do { /* Wait for Disconnecting Process */
W5100_MemReadByte(W5100_S0_CR, &val);
} while(val!=0);
}
void SOCK_Close(uint8_t sock) {
uint8_t val;
if (sock!=0) {
return;
}
/* Send Close Command */
W5100_MemWriteByte(W5100_S0_CR, W5100_CR_CLOSE);
do { /* Waiting until the S0_CR is clear */
W5100_MemReadByte(W5100_S0_CR, &val);
} while(val!=0);
}
uint8_t SOCK_Disconnect(uint8_t sock) {
uint8_t val;
uint16_t sockaddr;
if (sock>=W5100_NUM_SOCKETS) {
return ERR_VALUE;
}
sockaddr = W5100_SKT_BASE(sock);
/* Send Disconnect Command */
W5100_MemWriteByte(sockaddr+W5100_CR_OFFSET, W5100_CR_DISCON);
do { /* Wait for Disconnecting Process */
W5100_MemReadByte(sockaddr+W5100_CR_OFFSET, &val);
} while(val!=0);
return ERR_OK;
}
uint8_t SOCK_CloseSocket(uint8_t sock) {
uint8_t val;
uint16_t sockaddr;
if (sock>=W5100_NUM_SOCKETS) {
return ERR_VALUE;
}
sockaddr = W5100_SKT_BASE(sock);
/* Send Close Command */
W5100_MemWriteByte(sockaddr+W5100_CR_OFFSET, W5100_CR_CLOSE);
do { /* Waiting until the S0_CR is clear */
W5100_MemReadByte(sockaddr+W5100_CR_OFFSET, &val);
} while(val!=0);
return ERR_OK;
}
uint8_t SOCK_Listen(uint8_t sock) {
uint8_t val, retval = 0;
if (sock!=0) {
return retval;
}
W5100_MemReadByte(W5100_S0_SR, &val);
if (val==W5100_SOCK_INIT) {
/* Send the LISTEN Command */
W5100_MemWriteByte(W5100_S0_CR, W5100_CR_LISTEN);
/* Wait for Listening Process */
do {
W5100_MemReadByte(W5100_S0_CR, &val);
} while(val!=0);
/* Check for Listen Status */
W5100_MemReadByte(W5100_S0_SR, &val);
if (val==W5100_SOCK_LISTEN) {
retval = 1;
} else {
SOCK_Close(sock);
}
}
return retval;
}
//---------------------------------------------------------------------------------------
// Name: DHCP_SendMessage
// Param: Socket: socket to use
// MessageType: message type to send
// Return: TRUE in case of success, FALSE if an error occurred
//
// Description: This function is used to send DHCP messages
//---------------------------------------------------------------------------------------
static bool DHCP_SendMessage(uint8_t u8Socket, uint8_t u8MessageType) {
bool bResult = FALSE;
uint8_t u8Index;
uint16_t u16TxFreeSize;
uint16_t u16TxPointer;
uint16_t u16TxBaseAddress;
uint16_t u16TxBufferSize;
/* Check Message Type */
if ((u8MessageType == DHCP_DISCOVER) || (u8MessageType == DHCP_REQUEST)) {
/* Base Address and Buffer Size in W5100 device to transmit data */
switch (u8Socket) {
case 0: u16TxBaseAddress = W5100_TX_MEMORY_SOCKET_0_ADDRESS; u16TxBufferSize = W5100_TX_SOCKET_0_SIZE_BYTES; break;
case 1: u16TxBaseAddress = W5100_TX_MEMORY_SOCKET_1_ADDRESS; u16TxBufferSize = W5100_TX_SOCKET_1_SIZE_BYTES; break;
case 2: u16TxBaseAddress = W5100_TX_MEMORY_SOCKET_2_ADDRESS; u16TxBufferSize = W5100_TX_SOCKET_2_SIZE_BYTES; break;
case 3: u16TxBaseAddress = W5100_TX_MEMORY_SOCKET_3_ADDRESS; u16TxBufferSize = W5100_TX_SOCKET_3_SIZE_BYTES; break;
default: break;
}
/* Destination IP (broadcast) */
W5100_MemWriteByte(W5100_Sn_DIPR0(u8Socket), 0xFF);
W5100_MemWriteByte(W5100_Sn_DIPR1(u8Socket), 0xFF);
W5100_MemWriteByte(W5100_Sn_DIPR2(u8Socket), 0xFF);
W5100_MemWriteByte(W5100_Sn_DIPR3(u8Socket), 0xFF);
/* Port */
W5100_MemWriteByte(W5100_Sn_DPORT0(u8Socket), (uint8_t)(DHCP_SERVER_PORT >> 8));
W5100_MemWriteByte(W5100_Sn_DPORT1(u8Socket), (uint8_t)(DHCP_SERVER_PORT & 0x00FF));
/* Get socket memory free size */
u16TxFreeSize = W5100_ReadByte(W5100_Sn_TX_FSR0(u8Socket)) << 8;
u16TxFreeSize += W5100_ReadByte(W5100_Sn_TX_FSR1(u8Socket));
/* Check free size */
if (u16TxFreeSize > 400)
{
/* Get TX pointer */
u16TxPointer = W5100_ReadByte(W5100_Sn_TX_WR0(u8Socket)) << 8;
u16TxPointer += W5100_ReadByte(W5100_Sn_TX_WR1(u8Socket));
/* Op Code */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), DHCP_BOOTREQUEST);
u16TxPointer++;
/* Htype */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), DHCP_HTYPE_10MB);
u16TxPointer++;
/* Hlen */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), DHCP_HLEN_ETHERNET);
u16TxPointer++;
/* Hops */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), DHCP_HOPS);
u16TxPointer++;
/* Wid */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_XID & 0xFF000000) >> 24));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_XID & 0x00FF0000) >> 16));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_XID & 0x0000FF00) >> 8));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_XID & 0x000000FF)));
u16TxPointer++;
/* Secs */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_SECS & 0xFF00) >> 8));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_SECS & 0x00FF)));
u16TxPointer++;
/* Flags */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_FLAGS & 0xFF00) >> 8));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_FLAGS & 0x00FF)));
u16TxPointer++;
/* Client IP Address */
for (u8Index = 0; u8Index < 4; u8Index++) {
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* Your IP Address */
for (u8Index = 0; u8Index < 4; u8Index++) {
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* Server IP Address */
for (u8Index = 0; u8Index < 4; u8Index++)
{
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* Gateway IP Address Relay */
for (u8Index = 0; u8Index < 4; u8Index++) {
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* Client Hardware Address */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_0);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_1);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_2);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_3);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_4);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_5);
u16TxPointer++;
for (u8Index = 0; u8Index < 10; u8Index++)
{
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* Sname */
for (u8Index = 0; u8Index < 64; u8Index++)
{
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* File */
for (u8Index = 0; u8Index < 128; u8Index++)
{
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x00);
u16TxPointer++;
}
/* Option: Magic cookie */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_MAGIC_COOKIE & 0xFF000000) >> 24));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_MAGIC_COOKIE & 0x00FF0000) >> 16));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_MAGIC_COOKIE & 0x0000FF00) >> 8));
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), (uint8_t)((DHCP_MAGIC_COOKIE & 0x000000FF)));
u16TxPointer++;
/* Option: DHCP Message Type */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpMessageType);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x01);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), u8MessageType);
u16TxPointer++;
/* Option: Client identifier */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpClientIdentifier);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x07);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x01);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_0);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_1);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_2);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_3);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_4);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), W5100_MAC_ADDRESS_5);
u16TxPointer++;
/* Option: Requested IP address */
if (u8MessageType == DHCP_REQUEST)
{
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpRequestedIPaddr);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x04);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_YourIPAddress[0]);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_YourIPAddress[1]);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_YourIPAddress[2]);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_YourIPAddress[3]);
u16TxPointer++;
}
/* Option: Server identifier */
if (u8MessageType == DHCP_REQUEST)
{
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpServerIdentifier);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x04);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_ServerIPAddress[0]);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_ServerIPAddress[1]);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_ServerIPAddress[2]);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), g_DHCP_ServerIPAddress[3]);
u16TxPointer++;
}
/* Option: Parameter request list */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpParamRequest);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), 0x05);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), subnetMask);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), routersOnSubnet);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dns);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpT1value);
u16TxPointer++;
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), dhcpT2value);
u16TxPointer++;
/* End options */
W5100_MemWriteByte(u16TxBaseAddress + (u16TxPointer & (u16TxBufferSize - 1)), endOption);
u16TxPointer++;
/* Write TX Pointer */
W5100_MemWriteByte(W5100_Sn_TX_WR0(u8Socket), (uint8_t)(u16TxPointer >> 8));
W5100_MemWriteByte(W5100_Sn_TX_WR1(u8Socket), (uint8_t)(u16TxPointer & 0x00FF));
/* Send data */
W5100_MemWriteByte(W5100_Sn_CR(u8Socket), Sn_CR_SEND);
/* Wait */
while (W5100_ReadByte(W5100_Sn_CR(u8Socket)));
/* Result */
bResult = TRUE;
}
}
//---------------------------------------------------------------------------------------
// Name: DHCP_GetIPAddress
// Param: -
// Return: TRUE in case of success, FALSE if an error occurred
//
// Description: This function is used to get IP Address and other network parameters using DHCP
//---------------------------------------------------------------------------------------
bool DHCP_GetIPAddress(void) {
uint8_t u8Index;
uint8_t u8Socket = DHCP_SOCKET;
bool bResult = FALSE;
/* Initializations */
g_DHCP_LeaseTime = 0;
for (u8Index = 0; u8Index < 4; u8Index++) {
g_DHCP_YourIPAddress[u8Index] = 0;
g_DHCP_RouterIPAddress[u8Index] = 0;
g_DHCP_DNSIPAddress[u8Index] = 0;
g_DHCP_SubnetMask[u8Index] = 0;
g_DHCP_ServerIPAddress[u8Index] = 0;
}
/* Open a new socket */
if (SOCK_OpenSocket(u8Socket, W5100_SKT_MR_UDP, DHCP_CLIENT_PORT)==ERR_OK) {
/* Send DISCOVER message */
if (DHCP_SendMessage(u8Socket, DHCP_DISCOVER) == TRUE) {
/* Parse OFFER message */
if (DHCP_Parse(u8Socket) == DHCP_OFFER) {
/* Send REQUEST message */
if (DHCP_SendMessage(u8Socket, DHCP_REQUEST) == TRUE) {
/* Parse ACK message */
if (DHCP_Parse(u8Socket) == DHCP_ACK) {
/* Set Gateway IP Address */
W5100_MemWriteByte(W5100_GAR0, g_DHCP_RouterIPAddress[0]);
W5100_MemWriteByte(W5100_GAR1, g_DHCP_RouterIPAddress[1]);
W5100_MemWriteByte(W5100_GAR2, g_DHCP_RouterIPAddress[2]);
W5100_MemWriteByte(W5100_GAR3, g_DHCP_RouterIPAddress[3]);
/* Set Subnet Mask */
W5100_MemWriteByte(W5100_SUBR0, g_DHCP_SubnetMask[0]);
W5100_MemWriteByte(W5100_SUBR1, g_DHCP_SubnetMask[1]);
W5100_MemWriteByte(W5100_SUBR2, g_DHCP_SubnetMask[2]);
W5100_MemWriteByte(W5100_SUBR3, g_DHCP_SubnetMask[3]);
/* Set my IP Address */
W5100_MemWriteByte(W5100_SIPR0, g_DHCP_YourIPAddress[0]);
W5100_MemWriteByte(W5100_SIPR1, g_DHCP_YourIPAddress[1]);
W5100_MemWriteByte(W5100_SIPR2, g_DHCP_YourIPAddress[2]);
W5100_MemWriteByte(W5100_SIPR3, g_DHCP_YourIPAddress[3]);
bResult = TRUE;
}
}
}
}
/* Close the socket (socket can be used later in the application) */
SOCKET_Close(u8Socket);
}
return bResult;
}
