static int8 event_enqueue(int8 id, int8 event)
{
#define QFULL -1
struct atc_eventq **eqdp;
eqdp = &eventqueue;
if(eqp_cnt >= EVENT_QUEUE_SIZE-1) {
while((*eqdp)->next) eqdp = &(*eqdp)->next;
if((*eqdp)->event != QFULL) {
eqdp = &(*eqdp)->next;
*eqdp = malloc(sizeof(struct atc_eventq));
if(*eqdp == NULL) {
ERRA("malloc fail - size(%d)", sizeof(struct atc_eventq));
return RET_NOK;
}
(*eqdp)->id = QFULL;
(*eqdp)->event = QFULL;
eqp_cnt++;
}
return RET_NOK;
}
while(*eqdp) eqdp = &(*eqdp)->next;
*eqdp = malloc(sizeof(struct atc_eventq));
if(*eqdp == NULL) {
ERRA("malloc fail - size(%d)", sizeof(struct atc_eventq));
return RET_NOK;
}
(*eqdp)->id = id;
(*eqdp)->event = event;
eqp_cnt++;
return RET_OK;
}
/**
* Initialize SPI Peripheral Device.
* @param spi SPI index number (@ref wizpf_spi)
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8 wizspi_init(wizpf_spi spi)
{
SPI_TypeDef *SPIx;
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
switch(spi) {
case WIZ_SPI1:
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = SPI1_SCS_PIN;
GPIO_Init(SPI1_SCS_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = SPI1_SCLK_PIN;
GPIO_Init(SPI1_SCLK_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI1_MISO_PIN;
GPIO_Init(SPI1_MISO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI1_MOSI_PIN;
GPIO_Init(SPI1_MOSI_PORT, &GPIO_InitStructure);
GPIO_SetBits(SPI1_SCS_PORT, SPI1_SCS_PIN);
SPIx = SPI1;
break;
case WIZ_SPI2:
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = SPI2_SCS_PIN;
GPIO_Init(SPI2_SCS_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = SPI2_SCLK_PIN;
GPIO_Init(SPI2_SCLK_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI2_MISO_PIN;
GPIO_Init(SPI2_MISO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI2_MOSI_PIN;
GPIO_Init(SPI2_MOSI_PORT, &GPIO_InitStructure);
GPIO_SetBits(SPI2_SCS_PORT, SPI2_SCS_PIN);
SPIx = SPI2;
break;
//case WIZ_SPI3:
// break;
default:
ERRA("SPI(%d) is not allowed", spi);
return RET_NOK;
}
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPIx, &SPI_InitStructure);
SPI_Cmd(SPIx, ENABLE);
return RET_OK;
}
int8 wizpf_gpio_init(GPIO_TypeDef* GPIOx, uint16 GPIO_Pin, wizpf_gpio_mode mode)
{
GPIO_InitTypeDef GPIO_InitStructure;
switch(mode) {
case WIZ_GPIO_IN_FLOAT:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
break;
case WIZ_GPIO_IN_PULLUP:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
break;
case WIZ_GPIO_IN_PULLDOWN:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
break;
case WIZ_GPIO_OUT_PUSHPULL:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
break;
case WIZ_GPIO_OUT_OPENDRAIN:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
break;
default:
ERRA("GPIO Mode(%d) is not allowed", mode);
return RET_NOK;
}
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin;
GPIO_Init(GPIOx, &GPIO_InitStructure);
return RET_OK;
}
/**
* Send/Receive 1 Byte through SPI
* @param spi SPI index number (@ref wizpf_spi)
* @param byte 1 Byte to send
* @return Received 1 Byte
*/
uint8 wizpf_spi_byte(wizpf_spi spi, uint8 byte)
{
SPI_TypeDef *SPIx;
switch(spi) {
case WIZ_SPI1:
#if defined(SPI1_SCS_PIN) && defined(SPI1_SCLK_PIN) && defined(SPI1_MISO_PIN) && defined(SPI1_MOSI_PIN)
SPIx = SPI1;
break;
#else
LOG("Not implemented");
return 0;
#endif
case WIZ_SPI2:
#if defined(SPI2_SCS_PIN) && defined(SPI2_SCLK_PIN) && defined(SPI2_MISO_PIN) && defined(SPI2_MOSI_PIN)
SPIx = SPI2;
break;
#else
LOG("Not implemented");
return 0;
#endif
//case WIZ_SPI3:
// break;
default:
ERRA("SPI(%d) is not allowed", spi);
return 0;
}
while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);
SPI_I2S_SendData(SPIx, byte);
while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);
return (uint8)SPI_I2S_ReceiveData(SPIx);
}
int8 wizpf_led_set(wizpf_led led, uint8 action)
{
GPIO_TypeDef* GPIOx;
uint16 GPIO_Pin;
switch(led) {
case WIZ_LED1:
GPIOx = LED1_PORT;
GPIO_Pin = LED1_PIN;
break;
case WIZ_LED2:
GPIOx = LED2_PORT;
GPIO_Pin = LED2_PIN;
break;
//case WIZ_LED3:
// // ToDo
// break;
//case WIZ_LED4:
// // ToDo
// break;
default:
ERRA("LED(%d) is not allowed", led);
return RET_NOK;
}
if(action == VAL_ON) {
GPIO_ResetBits(GPIOx, GPIO_Pin); // LED on
} else if(action == VAL_OFF) {
GPIO_SetBits(GPIOx, GPIO_Pin); // LED off
} else {
GPIOx->ODR ^= GPIO_Pin;
}
return RET_OK;
}
int8 wizpf_led_get(wizpf_led led)
{
GPIO_TypeDef* GPIOx;
uint16 GPIO_Pin;
switch(led) {
case WIZ_LED1:
GPIOx = LED1_PORT;
GPIO_Pin = LED1_PIN;
break;
case WIZ_LED2:
GPIOx = LED2_PORT;
GPIO_Pin = LED2_PIN;
break;
//case WIZ_LED3:
// // ToDo
// break;
//case WIZ_LED4:
// // ToDo
// break;
default:
ERRA("LED(%d) is not allowed", led);
return RET_NOK;
}
return (GPIOx->ODR & GPIO_Pin)? VAL_OFF: VAL_ON;
}
int8 dhcp_init(uint8 sock, pFunc ip_update_hook, pFunc ip_conflict_hook, wiz_NetInfo *def)
{
if(sock >= TOTAL_SOCK_NUM) {
ERRA("wrong socket number(%d)", sock);
return RET_NOK;
}
#ifdef DHCP_ALARM
dhcp_alarm = TRUE;
#endif
#ifdef DHCP_ASYNC
dhcp_async = TRUE;
#endif
memset(&di, 0, sizeof(di));
memcpy(&storage, def, sizeof(storage));
memset(&workinfo, 0, sizeof(workinfo));
memcpy(workinfo.Mac, storage.Mac, 6);
SetNetInfo(&workinfo);
di.xid = 0x12345678;
di.sock = sock;
if(ip_update_hook) di.ip_update = ip_update_hook;
if(ip_conflict_hook) di.ip_conflict = ip_conflict_hook;
IINCHIP_WRITE(WIZC_SIPR0, 0);
IINCHIP_WRITE(WIZC_SIPR1, 0);
IINCHIP_WRITE(WIZC_SIPR2, 0);
IINCHIP_WRITE(WIZC_SIPR3, 0);
return RET_OK;
}
/**
* Initialize DHCP module.
* This should be called just one time at first time
*
* @param sock Socket number to use
* @param ip_update_hook Callback function for IP-update hooking
* @param ip_conflict_hook Callback function for IP-conflict hooking (Not implemented yet)
* @param def Default Address to set
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8 dhcp_init(uint8 sock, void_func ip_update_hook, void_func ip_conflict_hook, wiz_NetInfo *def)
{
if(sock >= TOTAL_SOCK_NUM) {
ERRA("wrong socket number(%d)", sock);
return RET_NOK;
}
#ifdef DHCP_AUTO
dhcp_alarm = TRUE;
#endif
#ifdef DHCP_ASYNC
dhcp_async = TRUE;
#endif
memset(&di, 0, sizeof(di));
memcpy(&storage, def, sizeof(storage));
memset(&workinfo, 0, sizeof(workinfo));
memcpy(workinfo.mac, storage.mac, 6);
workinfo.dhcp = NETINFO_STATIC;
SetNetInfo(&workinfo);
di.xid = 0x12345678;
di.sock = sock;
if(ip_update_hook) di.ip_update = ip_update_hook;
if(ip_conflict_hook) di.ip_conflict = ip_conflict_hook;
// ToDo: Remove setting zero IP & SN (set at start func)
return RET_OK;
}
/**
* Set/Clear SPI CS Pin
* @param spi SPI index number (@ref wizpf_spi)
* @param val VAL_LOW: Active(set low) \n VAL_HIGH: Inactive(set high)
*/
void wizspi_cs(wizpf_spi spi, uint8 val)
{
GPIO_TypeDef* GPIOx;
uint16 GPIO_Pin;
switch(spi) {
case WIZ_SPI1:
GPIOx = SPI1_SCS_PORT;
GPIO_Pin = SPI1_SCS_PIN;
break;
case WIZ_SPI2:
GPIOx = SPI2_SCS_PORT;
GPIO_Pin = SPI2_SCS_PIN;
break;
//case WIZ_SPI3:
// break;
default:
ERRA("SPI(%d) is not allowed", spi);
return;
}
if (val == VAL_LOW) {
GPIO_ResetBits(GPIOx, GPIO_Pin);
}else if (val == VAL_HIGH){
GPIO_SetBits(GPIOx, GPIO_Pin);
}
}
int32 main(void)
{
#define TCP_LISTEN_PORT 5000
#define UDP_LISTEN_PORT 5000
int8 ret, root;
uint32 tick = 0;
ret = platform_init();
if(ret != RET_OK) {
goto FAIL_TRAP;
}
ret = network_init(SOCK_DHCP, NULL, NULL);
if(ret != RET_OK) {
ERRA("network_init fail - ret(%d)", ret);
goto FAIL_TRAP;
}
printf("\r\n-----------------------------------\r\n");
printf("SMTP Client using W5200\r\n");
printf("-----------------------------------\r\n\r\n");
Delay_tick(2000);
menu_init();
root = menu_add("Network setting", 0, NULL);
menu_add("Show", root, mn_show_network);
menu_add("Static Set", root, mn_set_network);
menu_add("Loopback", 0, mn_loopback);
menu_add("LED Test", 0, mn_set_led);
root = menu_add("App Test", 0, NULL);
menu_add("DNS", root, mn_dns);
menu_add("BASE64", root, mn_base64);
menu_add("eMail", root, mn_email);
menu_print_tree();
dhcp_alarm_start(NULL);
while(1) {
alarm_run();
menu_run();
if(lb_tcp) loopback_tcps(7, (uint16)TCP_LISTEN_PORT);
if(lb_udp) loopback_udp(7, (uint16)UDP_LISTEN_PORT);
if(wizpf_tick_elapse(tick) > 1000) { // running check
wizpf_led_set(WIZ_LED3, VAL_TOG);
tick = wizpf_get_systick();
}
}
FAIL_TRAP:
wizpf_led_trap(1);
return 0;
}
/**
* DHCP manual mode handler.
* - Blocking Function
* - Used only at DHCP manual mode (DHCP mode could be chosen at wizconfig.h file)
* - DHCP_MANUAL mode does not need a loop structure, but if there is no loop structure, \n
* you should handle renew & rebind with your own way, or just ignore renew & rebind action
*
* @param action The action you want to do. (@ref dhcp_action)
* @param renew For returning renew time when DHCP be bound (NULL will be ignored)
* @param rebind For returning rebind time when DHCP be bound (NULL will be ignored)
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8 dhcp_manual(dhcp_action action, uint32 *renew, uint32 *rebind) // blocking function
{
dhcp_state curstt = di.state;
if(dhcp_alarm == TRUE) return RET_NOK;
while(curstt != DHCP_STATE_INIT && curstt != DHCP_STATE_BOUND) {
dhcp_run();
curstt = di.state;
}
if(curstt == DHCP_STATE_INIT) {
di.action = DHCP_ACT_START;
memset(&workinfo, 0, sizeof(workinfo));
workinfo.dhcp = NETINFO_DHCP;
SetNetInfo(&workinfo);
// ToDo: Set zero IP & SN
do {
dhcp_run();
curstt = di.state;
} while((curstt != DHCP_STATE_INIT || di.action != DHCP_ACT_START)
&& curstt != DHCP_STATE_BOUND);
if(curstt != DHCP_STATE_BOUND) return RET_NOK;
if(renew) *renew = di.renew_time;
if(rebind) *rebind = di.rebind_time;
} else if(curstt == DHCP_STATE_BOUND) {
if(action == DHCP_ACT_START) {
if(renew) *renew = 0;
if(rebind) *rebind = 0;
return RET_OK;
} else if(action == DHCP_ACT_RENEW) { // renew
SET_STATE(DHCP_STATE_SELECTING);
di.action = DHCP_ACT_RENEW;
di.xid++;
} else if(action == DHCP_ACT_REBIND) { // rebind
SET_STATE(DHCP_STATE_SELECTING);
di.action = DHCP_ACT_REBIND;
di.xid++;
} else {
ERRA("wrong action(%d)", action);
return RET_NOK;
}
curstt = di.state;
while(curstt != DHCP_STATE_INIT && curstt != DHCP_STATE_BOUND) {
dhcp_run();
curstt = di.state;
}
if(curstt != DHCP_STATE_BOUND) return RET_NOK;
if(renew) *renew = di.renew_time;
if(rebind) *rebind = di.rebind_time;
}
return RET_OK;
}
int8 dhcp_manual(int8 action, uint8 *saved_ip, uint32 *renew, uint32 *rebind) // blocking function
{
int8 curstt = dhcp_get_state();
if(dhcp_alarm == TRUE) return RET_NOK;
while(curstt != DHCP_STATE_INIT && curstt != DHCP_STATE_BOUND) {
dhcp_run();
curstt = dhcp_get_state();
}
if(curstt == DHCP_STATE_INIT) {
di.action = DHCP_ACT_START;
memset(&workinfo, 0, sizeof(workinfo));
if(saved_ip) memcpy(workinfo.IP, saved_ip, 4);
workinfo.DHCP = NETINFO_DHCP_BUSY;
SetNetInfo(&workinfo);
do {
dhcp_run();
curstt = dhcp_get_state();
} while((curstt != DHCP_STATE_INIT || workinfo.DHCP == NETINFO_DHCP_BUSY)
&& curstt != DHCP_STATE_BOUND);
if(curstt != DHCP_STATE_BOUND) return RET_NOK;
if(renew) *renew = di.renew_time;
if(rebind) *rebind = di.rebind_time;
} else if(curstt == DHCP_STATE_BOUND) {
if(action == DHCP_ACT_START) {
if(renew) *renew = 0;
if(rebind) *rebind = 0;
return RET_OK;
} else if(action == DHCP_ACT_RENEW) { // renew
SET_STATE(DHCP_STATE_SELECTING);
di.action = DHCP_ACT_RENEW;
di.xid++;
} else if(action == DHCP_ACT_REBIND) { // rebind
SET_STATE(DHCP_STATE_SELECTING);
di.action = DHCP_ACT_REBIND;
di.xid++;
} else {
ERRA("wrong action(%d)", action);
return RET_NOK;
}
curstt = dhcp_get_state();
while(curstt != DHCP_STATE_INIT && curstt != DHCP_STATE_BOUND) {
dhcp_run();
curstt = dhcp_get_state();
}
if(curstt != DHCP_STATE_BOUND) return RET_NOK;
if(renew) *renew = di.renew_time;
if(rebind) *rebind = di.rebind_time;
}
return RET_OK;
}
/**
* Set a item of event to watch at @ref sockwatch_run.
* Once opened a socket by @ref sockwatch_open, \n
* you have to register events for watching that using this function.
* It is possible to set plural item of event at the same time.
*
* @ingroup sockwatch_module
* @param sock The socket number to watch
* @param item The item of event to watch
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8_t sockwatch_set(uint8_t sock, uint8_t item)
{
DBGA("WATCH Set - sock(%d), item(0x%x)", sock, item);
if(sock >= TOTAL_SOCK_NUM) {
ERRA("wrong sock(%d)", sock);
return RET_NOK;
}
BITSET(watch_sock[sock], 0x7F & item);
return RET_OK;
}
/**
* Assign a callback function to a socket.
* When @ref sockwatch_run function detected a event, \n
* this callback function will be called.
*
* @ingroup sockwatch_module
* @param sock The socket number which is corresponding to 'cb' param
* @param cb The callback function to be called when \n
* the socket has any completion or event.
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8_t sockwatch_open(uint8_t sock, watch_cbfunc cb)
{
DBGA("WATCH Open - sock(%d), CB(%p)", sock, (void*)cb);
if(cb == NULL || sock >= TOTAL_SOCK_NUM) {
ERRA("wrong arg - sock(%d)", sock);
return RET_NOK;
}
if(watch_cb[sock] == NULL) watch_cb[sock] = cb;
else return RET_NOK;
return RET_OK;
}
void wizspi_cs(uint8 val)
{
if(wizspix != SPI1) {
ERRA("### Currently, Only SPI1 is allowed - wizspix(%p), SPI1(%p)", wizspix, SPI1);
return ;
}
if (val == VAL_LOW) {
GPIO_ResetBits(GPIOA, WIZ_SCS);
}else if (val == VAL_HIGH){
GPIO_SetBits(GPIOA, WIZ_SCS);
}
}
int8 wizpf_flash_write(uint32 addr, const uint8 *data, uint16 len)
{
FLASH_Status ret;
uint16 word, left;
DBGA("Flash Write - Addr(0x%x),Len(%d)", addr, len);
if(addr&0x3 != 0 || len == 0) {
ERR("Address should be 4-byte aligned, Length should not be zero");
return RET_NOK; // 4 byte alignment
}
word = len / 4;
left = len % 4;
FLASH_Unlock();
while(word--) {
ret = FLASH_ProgramWord(addr, *(uint32*)data);
if(ret != FLASH_COMPLETE) {
ERRA("Flash write(chunk) failed - ret(%d)", ret);
FLASH_Lock();
return RET_NOK;
} //else DBG("Flash write(chunk) SUCC");
addr += 4;
data += 4;
}
if(left) {
uint32 tmp = 0;
memcpy(&tmp, data, left);
ret = FLASH_ProgramWord(addr, *(uint32*)data);
if(ret != FLASH_COMPLETE) {
ERRA("Flash write(residue) failed - ret(%d)", ret);
FLASH_Lock();
return RET_NOK;
} //else DBG("Flash write(residue) SUCC");
}
FLASH_Lock();
return RET_OK;
}
/**
* Remove callback function from a socket and Stop to watch all event.
*
* @ingroup sockwatch_module
* @param sock The socket number to close
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8_t sockwatch_close(uint8_t sock)
{
DBGA("WATCH Close - sock(%d)", sock);
if(sock >= TOTAL_SOCK_NUM) {
ERRA("wrong sock(%d)", sock);
return RET_NOK;
}
sockwatch_clr(sock, WATCH_SOCK_ALL_MASK);
watch_cb[sock] = NULL;
return RET_OK;
}
int8 wizpf_led_set(wizpf_led led, uint8 action)
{
GPIO_TypeDef* GPIOx = NULL;
uint16 GPIO_Pin = 0;
switch(led) {
#ifdef LED1_PIN
case WIZ_LED1:
GPIOx = LED1_PORT;
GPIO_Pin = LED1_PIN;
break;
#endif
#ifdef LED2_PIN
case WIZ_LED2:
GPIOx = LED2_PORT;
GPIO_Pin = LED2_PIN;
break;
#endif
#ifdef LED3_PIN
case WIZ_LED3:
GPIOx = LED3_PORT;
GPIO_Pin = LED3_PIN;
break;
#endif
#ifdef LED4_PIN
case WIZ_LED4:
GPIOx = LED4_PORT;
GPIO_Pin = LED4_PIN;
break;
#endif
default:
ERRA("LED(%d) is not allowed", led);
action = VAL_TOG + 1;
}
if(action == VAL_OFF) {
GPIO_SetBits(GPIOx, GPIO_Pin); // LED off
} else if(action == VAL_ON) {
GPIO_ResetBits(GPIOx, GPIO_Pin); // LED on
} else if(action == VAL_TOG) {
GPIOx->ODR ^= GPIO_Pin;
} else return RET_NOK;
return RET_OK;
}
/**
* Send/Receive 1 Byte through SPI
* @param spi SPI index number (@ref wizpf_spi)
* @param byte 1 Byte to send
* @return Received 1 Byte
*/
uint8 wizspi_byte(wizpf_spi spi, uint8 byte)
{
SPI_TypeDef *SPIx;
switch(spi) {
case WIZ_SPI1:
SPIx = SPI1;
break;
case WIZ_SPI2:
SPIx = SPI2;
break;
//case WIZ_SPI3:
// break;
default:
ERRA("SPI(%d) is not allowed", spi);
return 0;
}
while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);
SPI_I2S_SendData(SPIx, byte);
while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);
return (uint8)SPI_I2S_ReceiveData(SPIx);
}
int8 wizpf_led_get(wizpf_led led)
{
GPIO_TypeDef* GPIOx = NULL;
uint16 GPIO_Pin = 0;
switch(led) {
#ifdef LED1_PIN
case WIZ_LED1:
GPIOx = LED1_PORT;
GPIO_Pin = LED1_PIN;
break;
#endif
#ifdef LED2_PIN
case WIZ_LED2:
GPIOx = LED2_PORT;
GPIO_Pin = LED2_PIN;
break;
#endif
#ifdef LED3_PIN
case WIZ_LED3:
GPIOx = LED3_PORT;
GPIO_Pin = LED3_PIN;
break;
#endif
#ifdef LED4_PIN
case WIZ_LED4:
GPIOx = LED4_PORT;
GPIO_Pin = LED4_PIN;
break;
#endif
default:
ERRA("LED(%d) is not allowed", led);
}
if(GPIOx != NULL) return (GPIOx->ODR & GPIO_Pin)? VAL_OFF: VAL_ON;
return RET_NOK;
}
/**
* Set/Clear SPI CS Pin
* @param spi SPI index number (@ref wizpf_spi)
* @param val VAL_LOW: Active(set low) \n VAL_HIGH: Inactive(set high)
*/
void wizpf_spi_cs(wizpf_spi spi, uint8 val)
{
GPIO_TypeDef* GPIOx;
uint16 GPIO_Pin;
switch(spi) {
case WIZ_SPI1:
#if defined(SPI1_SCS_PIN) && defined(SPI1_SCLK_PIN) && defined(SPI1_MISO_PIN) && defined(SPI1_MOSI_PIN)
GPIOx = SPI1_SCS_PORT;
GPIO_Pin = SPI1_SCS_PIN;
break;
#else
LOG("Not implemented");
return ;
#endif
case WIZ_SPI2:
#if defined(SPI2_SCS_PIN) && defined(SPI2_SCLK_PIN) && defined(SPI2_MISO_PIN) && defined(SPI2_MOSI_PIN)
GPIOx = SPI2_SCS_PORT;
GPIO_Pin = SPI2_SCS_PIN;
break;
#else
LOG("Not implemented");
return ;
#endif
//case WIZ_SPI3:
// break;
default:
ERRA("SPI(%d) is not allowed", spi);
return;
}
if (val == VAL_LOW) {
GPIO_ResetBits(GPIOx, GPIO_Pin);
}else if (val == VAL_HIGH){
GPIO_SetBits(GPIOx, GPIO_Pin);
}
}
static int8 send_request(void)
{
uint8 srv_ip[4];
int32 len = 0;
memset(&dm, 0, sizeof(struct dhcp_msg));
dm.op = DHCP_BOOTREQUEST;
dm.htype = DHCP_HTYPE10MB;
dm.hlen = DHCP_HLENETHERNET;
dm.hops = DHCP_HOPS;
dm.xid = htonl(di.xid);
dm.secs = htons(DHCP_SECS);
if(di.action == DHCP_ACT_RENEW) {
dm.flags = 0; // For Unicast
memcpy(dm.ciaddr, workinfo.ip, 4);
} else {
dm.flags = htons(DHCP_BROADCAST);
}
memcpy(dm.chaddr, storage.mac, 6);
// MAGIC_COOKIE
*(uint32*)&dm.opt[len] = htonl(MAGIC_COOKIE);
len += 4;
// Option Request Param.
dm.opt[len++] = dhcpMessageType;
dm.opt[len++] = 0x01;
dm.opt[len++] = DHCP_MSG_REQUEST;
dm.opt[len++] = dhcpClientIdentifier;
dm.opt[len++] = 0x07;
dm.opt[len++] = 0x01;
memcpy(&dm.opt[len], storage.mac, 6);
len += 6;
if(di.action != DHCP_ACT_RENEW) {
dm.opt[len++] = dhcpRequestedIPaddr;
dm.opt[len++] = 0x04;
memcpy(&dm.opt[len], workinfo.ip, 4);
len += 4;
dm.opt[len++] = dhcpServerIdentifier;
dm.opt[len++] = 0x04;
memcpy(&dm.opt[len], di.srv_ip, 4);
len += 4;
}
// host name
dm.opt[len++] = hostName;
dm.opt[len++] = strlen(HOST_NAME) + 6; // length of hostname + 3
strcpy((char*)&dm.opt[len], HOST_NAME);
len += strlen(HOST_NAME);
sprintf((char*)&dm.opt[len], "%02x%02x%02x",
storage.mac[3], storage.mac[4], storage.mac[5]);
len += 6;
dm.opt[len++] = dhcpParamRequest;
dm.opt[len++] = 0x08;
dm.opt[len++] = subnetMask;
dm.opt[len++] = routersOnSubnet;
dm.opt[len++] = dns;
dm.opt[len++] = domainName;
dm.opt[len++] = dhcpT1value;
dm.opt[len++] = dhcpT2value;
dm.opt[len++] = performRouterDiscovery;
dm.opt[len++] = staticRoute;
dm.opt[len++] = endOption;
// send broadcasting packet
if(di.action == DHCP_ACT_RENEW) {
memcpy(srv_ip, di.srv_ip, 4);
} else {
srv_ip[0] = srv_ip[1] = srv_ip[2] = srv_ip[3] = 255;
}
if(dhcp_async) {
len = UDPSendNB(di.sock, (int8*)&dm, sizeof(struct dhcp_msg), srv_ip, DHCP_SERVER_PORT);
if(len < sizeof(struct dhcp_msg)) {
if(len < 0) ERRA("UDPSend fail - ret(%d)", len);
else ERRA("UDPSend sent less than size - size(%d), sent(%d)", sizeof(struct dhcp_msg), len);
return RET_NOK;
} else sockwatch_set(di.sock, WATCH_SOCK_UDP_SEND);
} else {
len = UDPSend(di.sock, (int8*)&dm, sizeof(struct dhcp_msg), srv_ip, DHCP_SERVER_PORT);
if(len <= 0) {
ERRA("UDPSend fail - ret(%d)", len);
return RET_NOK;
}
}
return RET_OK;
}
static int8 recv_handler(void)
{
uint8 *cur, *end;
uint8 recv_ip[4], opt_len, msg_type;
int32 recv_len;
uint16 recv_port;
recv_len = GetSocketRxRecvBufferSize(di.sock);
if(recv_len == 0) return RET_NOK;
else memset(&dm, 0, sizeof(struct dhcp_msg));
recv_len = UDPRecv(di.sock, (int8*)&dm, sizeof(struct dhcp_msg), recv_ip, &recv_port);
if(recv_len < 0) {
ERRA("UDPRecv fail - ret(%d)", recv_len);
return RET_NOK;
}
//DBGFUNC(print_dump(&dm, sizeof(dm))); // For debugging received packet
DBGA("DHCP_SIP:%d.%d.%d.%d",di.srv_ip[0],di.srv_ip[1],di.srv_ip[2],di.srv_ip[3]);
DBGA("DHCP_RIP:%d.%d.%d.%d",di.srv_ip_real[0],di.srv_ip_real[1],di.srv_ip_real[2],di.srv_ip_real[3]);
DBGA("recv_ip:%d.%d.%d.%d",recv_ip[0],recv_ip[1],recv_ip[2],recv_ip[3]);
if(dm.op != DHCP_BOOTREPLY || recv_port != DHCP_SERVER_PORT) {
if(dm.op != DHCP_BOOTREPLY) DBG("DHCP : NO DHCP MSG");
if(recv_port != DHCP_SERVER_PORT) DBG("DHCP : WRONG PORT");
return RET_NOK;
}
if(memcmp(dm.chaddr, storage.mac, 6) != 0 || dm.xid != htonl(di.xid)) {
DBG("No My DHCP Message. This message is ignored.");
DBGA("SRC_MAC_ADDR(%02X:%02X:%02X:%02X:%02X:%02X)",
storage.mac[0], storage.mac[1], storage.mac[2],
storage.mac[3], storage.mac[4], storage.mac[5]);
DBGA("chaddr(%02X:%02X:%02X:%02X:%02X:%02X)", dm.chaddr[0],
dm.chaddr[1], dm.chaddr[2], dm.chaddr[3], dm.chaddr[4], dm.chaddr[5]);
DBGA("DHCP_XID(%08lX), xid(%08lX), yiaddr(%d.%d.%d.%d)", htonl(di.xid),
dm.xid, dm.yiaddr[0], dm.yiaddr[1], dm.yiaddr[2], dm.yiaddr[3]);
return RET_NOK;
}
if( *((uint32*)di.srv_ip) != 0x00000000 ) {
if( *((uint32*)di.srv_ip_real) != *((uint32*)recv_ip) &&
*((uint32*)di.srv_ip) != *((uint32*)recv_ip) ) {
DBG("Another DHCP sever send a response message. This is ignored.");
DBGA("IP:%d.%d.%d.%d",recv_ip[0],recv_ip[1],recv_ip[2],recv_ip[3]);
return RET_NOK;
}
}
memcpy(workinfo.ip, dm.yiaddr, 4);
DBG("DHCP MSG received..");
DBGA("yiaddr : %d.%d.%d.%d",workinfo.ip[0],workinfo.ip[1],workinfo.ip[2],workinfo.ip[3]);
msg_type = 0;
cur = (uint8 *)(&dm.op);
cur = cur + 240;
end = cur + (recv_len - 240); //printf("cur : 0x%08X end : 0x%08X recv_len : %d\r\n", cur, end, recv_len);
while ( cur < end )
{
switch ( *cur++ )
{
case padOption:
break;
case endOption:
return msg_type;
case dhcpMessageType:
opt_len = *cur++;
msg_type = *cur;
DBGA("dhcpMessageType : %x", msg_type);
break;
case subnetMask:
opt_len =* cur++;
memcpy(workinfo.sn,cur,4);
DBGA("subnetMask : %d.%d.%d.%d",
workinfo.sn[0],workinfo.sn[1],workinfo.sn[2],workinfo.sn[3]);
break;
case routersOnSubnet:
opt_len = *cur++;
memcpy(workinfo.gw,cur,4);
DBGA("routersOnSubnet : %d.%d.%d.%d",
workinfo.gw[0],workinfo.gw[1],workinfo.gw[2],workinfo.gw[3]);
break;
case dns:
opt_len = *cur++;
memcpy(workinfo.dns,cur,4);
break;
case dhcpIPaddrLeaseTime:
opt_len = *cur++;
di.lease_time = ntohl(*((uint32*)cur));
di.renew_time = di.lease_time / 2; // 0.5
di.rebind_time = di.lease_time / 8 * 7; // 0.875
DBGA("lease(%d), renew(%d), rebind(%d)", di.lease_time, di.renew_time, di.rebind_time);
break;
case dhcpServerIdentifier:
opt_len = *cur++;
DBGA("DHCP_SIP : %d.%d.%d.%d", di.srv_ip[0], di.srv_ip[1], di.srv_ip[2], di.srv_ip[3]);
if( *((uint32*)di.srv_ip) == 0 || *((uint32*)di.srv_ip_real) == *((uint32*)recv_ip) ||
*((uint32*)di.srv_ip) == *((uint32*)recv_ip) ) {
memcpy(di.srv_ip,cur,4);
memcpy(di.srv_ip_real,recv_ip,4); // Copy the real ip address of my DHCP server
DBGA("My dhcpServerIdentifier : %d.%d.%d.%d",
di.srv_ip[0], di.srv_ip[1], di.srv_ip[2], di.srv_ip[3]);
DBGA("My DHCP server real IP address : %d.%d.%d.%d",
di.srv_ip_real[0], di.srv_ip_real[1], di.srv_ip_real[2], di.srv_ip_real[3]);
} else {
DBGA("Another dhcpServerIdentifier : MY(%d.%d.%d.%d)",
di.srv_ip[0], di.srv_ip[1], di.srv_ip[2], di.srv_ip[3]);
DBGA("Another(%d.%d.%d.%d)", recv_ip[0], recv_ip[1], recv_ip[2], recv_ip[3]);
}
break;
default:
opt_len = *cur++;
DBGA("opt_len : %d", opt_len);
break;
} // switch
cur+=opt_len;
} // while
return RET_NOK;
}
static void dhcp_run(void)
{
static bool udp_open_fail = FALSE;
if(di.state == DHCP_STATE_INIT && di.action != DHCP_ACT_START) {
DBG("wrong attempt");
return;
} else if(GetUDPSocketStatus(di.sock) == SOCKSTAT_CLOSED) {
if(udp_open_fail == TRUE && !IS_TIME_PASSED(dhcp_run_tick, DHCP_RETRY_DELAY))
goto RET_ALARM;
ClsNetInfo(NI_IP_ADDR);
ClsNetInfo(NI_SN_MASK);
ClsNetInfo(NI_GW_ADDR);
ClsNetInfo(NI_DNS_ADDR);
if(UDPOpen(di.sock, DHCP_CLIENT_PORT) == RET_OK) {
if(dhcp_async) sockwatch_open(di.sock, dhcp_async_cb);
udp_open_fail = FALSE;
dhcp_run_tick = wizpf_get_systick();
dhcp_run_cnt = 0;
} else {
ERR("UDPOpen fail");
udp_open_fail = TRUE;
dhcp_run_tick = wizpf_get_systick();
goto RET_ALARM;
}
}
switch(di.state) {
case DHCP_STATE_INIT:
if(dhcp_run_cnt==0 && !IS_TIME_PASSED(dhcp_run_tick, DHCP_OPEN_DELAY))
goto RET_ALARM;
if(dhcp_run_cnt < DHCP_SEND_RETRY_COUNT) {
dhcp_run_cnt++;
if(send_discover() == RET_OK) { // Discover ok
if(dhcp_async) {
DBG("DHCP Discovery Send Async");
sockwatch_set(di.sock, WATCH_SOCK_UDP_SEND);
return; // alarm set is not needed
} else {
DBG("DHCP Discovery Sent");
SET_STATE(DHCP_STATE_SEARCHING);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Discovery SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Discovery SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_cnt = 0;
UDPClose(di.sock);
if(dhcp_async) sockwatch_close(di.sock);
dhcp_fail();
return; // alarm set is not needed
}
break;
case DHCP_STATE_SEARCHING:
if(!IS_TIME_PASSED(dhcp_run_tick, DHCP_RETRY_DELAY)) {
int8 ret = recv_handler();
if(ret == DHCP_MSG_OFFER) {
SET_STATE(DHCP_STATE_SELECTING);
dhcp_run_tick = wizpf_get_systick();
dhcp_run_cnt = 0;
} else if(ret != RET_NOK) DBGCRTCA(TRUE, "recv wrong packet(%d)", ret);
} else {
ERRA("DHCP Offer RECV fail - for (%d)msec", DHCP_RETRY_DELAY);
SET_STATE(DHCP_STATE_INIT);
dhcp_run_tick = wizpf_get_systick();
}
break;
case DHCP_STATE_SELECTING:
if(dhcp_run_cnt < DHCP_SEND_RETRY_COUNT) {
dhcp_run_cnt++;
if(send_request() == RET_OK) { // Request ok
if(dhcp_async) {
DBG("DHCP Request Send Async");
sockwatch_set(di.sock, WATCH_SOCK_UDP_SEND);
return; // alarm set is not needed
} else {
DBG("DHCP Request Sent");
SET_STATE(DHCP_STATE_REQUESTING);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Request SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Request SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_cnt = 0;
UDPClose(di.sock);
if(dhcp_async) sockwatch_close(di.sock);
dhcp_fail();
return; // alarm set is not needed
}
break;
case DHCP_STATE_REQUESTING:
if(!IS_TIME_PASSED(dhcp_run_tick, DHCP_RETRY_DELAY)) {
int8 ret = recv_handler();
if(ret == DHCP_MSG_ACK) { // Recv ACK
LOG("DHCP Success");
SET_STATE(DHCP_STATE_IP_CHECK);
dhcp_run_tick = wizpf_get_systick();
dhcp_run_cnt = 0;
} else if(ret == DHCP_MSG_NAK) { // Recv NAK
if(di.action == DHCP_ACT_START) {
SET_STATE(DHCP_STATE_INIT);
dhcp_run_tick = wizpf_get_systick();
} else {
SET_STATE(DHCP_STATE_BOUND);
}
dhcp_run_cnt = 0;
} else if(ret != RET_NOK) DBGCRTCA(TRUE, "recv wrong packet(%d)", ret);
} else {
ERRA("DHCP ACK RECV fail - for (%d)msec", DHCP_RETRY_DELAY);
if(di.action == DHCP_ACT_START) {
SET_STATE(DHCP_STATE_INIT);
dhcp_run_tick = wizpf_get_systick();
} else {
SET_STATE(DHCP_STATE_BOUND);
}
}
break;
case DHCP_STATE_IP_CHECK:
//if(send_checker() == RET_OK) {
SET_STATE(DHCP_STATE_BOUND);
SetNetInfo(&workinfo);
if(di.ip_update) di.ip_update();
LOGA("DHCP ok - New IP (%d.%d.%d.%d)",
workinfo.ip[0], workinfo.ip[1], workinfo.ip[2], workinfo.ip[3]);
//} else {
// SET_STATE(DHCP_STATE_INIT);
// ERR("IP Addr conflicted - IP(%d.%d.%d.%d)", workinfo.ip[0], workinfo.ip[1], workinfo.ip[2], workinfo.ip[3]);
// send_rel_dec(DHCP_MSG_DECLINE);
// if(di.ip_conflict) (*di.ip_conflict)();
//}
break;
case DHCP_STATE_BOUND:
di.action = DHCP_ACT_NONE;
UDPClose(di.sock);
if(dhcp_async) sockwatch_close(di.sock);
return; // alarm set is not needed
case DHCP_STATE_FAILED:
return; // alarm set is not needed
default:
ERRA("wrong state(%d)", di.state);
return; // alarm set is not needed
}
RET_ALARM:
if(dhcp_alarm) alarm_set(10, dhcp_alarm_cb, 0);
}
void change_std_usart(wizpf_usart usart)
{
if(usart == WIZ_USART1) std_usart = USART1;
else if(usart == WIZ_USART2) std_usart = USART2;
else ERRA("wrong USART Index (%d)", usart);
}
int32 main(void)
{
#define TCP_LISTEN_PORT 5000
#define UDP_LISTEN_PORT 5000
int8 ret, root;
uint32 dhcp_renew, dhcp_rebind, dhcp_time;
uint32 dhcp_tick, led_tick;
ret = platform_init();
if(ret != RET_OK) {
goto FAIL_TRAP;
}
ret = network_init(SOCK_DHCP, NULL, NULL);
if(ret != RET_OK) {
ERRA("network_init fail - ret(%d)", ret);
goto FAIL_TRAP;
}
printf("\r\n-----------------------------------\r\n");
printf("SMTP Client using W5200\r\n");
printf("-----------------------------------\r\n\r\n");
Delay_tick(2000);
do {
ret = dhcp_manual(DHCP_ACT_START, NULL, &dhcp_renew, &dhcp_rebind);
} while(ret != RET_OK);
dhcp_renew = wizpf_tick_conv(FALSE, dhcp_renew);
dhcp_rebind = wizpf_tick_conv(FALSE, dhcp_rebind);
dhcp_time = dhcp_renew;
menu_init();
root = menu_add("Network setting", 0, NULL);
menu_add("Show", root, mn_show_network);
menu_add("Static Set", root, mn_set_network);
menu_add("Loopback", 0, mn_loopback);
menu_add("LED Test", 0, mn_set_led);
root = menu_add("App Test", 0, NULL);
menu_add("DNS", root, mn_dns);
menu_add("BASE64", root, mn_base64);
menu_add("eMail", root, mn_email);
menu_print_tree();
dhcp_tick = led_tick = wizpf_get_systick();
while(1) {
if(wizpf_tick_elapse(dhcp_tick) > dhcp_time) {
if(dhcp_time==dhcp_renew) DBG("start renew"); else DBG("start rebind");
ret = dhcp_manual(dhcp_time==dhcp_renew? DHCP_ACT_RENEW: DHCP_ACT_REBIND,
NULL, &dhcp_renew, &dhcp_rebind);
dhcp_tick = wizpf_get_systick();
if(ret == RET_OK) { // renew success
dhcp_renew = wizpf_tick_conv(FALSE, dhcp_renew);
dhcp_rebind = wizpf_tick_conv(FALSE, dhcp_rebind);
dhcp_time = dhcp_renew;
} else {
if(dhcp_time == dhcp_renew) dhcp_time = dhcp_rebind; // renew fail, so try rebind
else dhcp_time = 60000; // retry after 1 min
}
}
menu_run();
if(lb_tcp) loopback_tcps(7, (uint16)TCP_LISTEN_PORT);
if(lb_udp) loopback_udp(7, (uint16)UDP_LISTEN_PORT);
if(wizpf_tick_elapse(led_tick) > 1000) {
wizpf_led_set(WIZ_LED3, VAL_TOG);
led_tick = wizpf_get_systick();
}
}
FAIL_TRAP:
wizpf_led_trap(1);
return 0;
}
