Управление офисным освещением по Wi-Fi. Часть 1: Wi-Fi модуль Atmel WINC1500

Xplained Pro Kits — это серия отладочных плат среднего ценового сегмента (самыми дешевыми являются киты серии Xplained mini) на различные семейства микроконтроллеров Atmel и набор модулей расширения к ним. Причем, за счет унифицированных краевых разъемов на отладках модули расширения подходят к любой плате. Т.е. реализована концепция а-ля Arduino. На всех платах установлен отладчик EDBG. Остальная периферия на плате зависит от установленного на ней контроллера.

• IEEE®802.11 b/g/n 20MHz (1x1) solution
• Single spatial stream in 2.4GHz ISM band
• Integrated PA and T/R Switch
• Integrated PCB antenna
• Superior Sensitivity and Range via advanced PHY signal processing
• Advanced Equalization and Channel Estimation
• Advanced Carrier and Timing Synchronization
• Wi-Fi Direct and Soft-AP support
• Supports IEEE 802.11 WEP, WPA, WPA2 Security
• Supports China WAPI security
• Superior MAC throughput via hardware accelerated two-level A-MSDU/A-MPDU frame aggregation and block acknowledgement
• On-chip memory management engine to reduce host load
• SPI, UART, and I2C host interfaces
• 2- or 3-wire Bluetooth® coexistence interface
• Operating temperature range of -40°C to +85°C
• I/O operating voltage of 2.7V to 3.6V
• Integrated Flash memory for system software
• Power Save Modes
• Integrated Network IP stack to minimize host CPU requirements
• Network features TCP, UDP, DHCP, ARP, HTTP, SSL, and DNS
• Small footprint host driver (4KB flash – less than 1KB RAM)

//  ---------- PIN settings ---------
#define CONF_WINC_PIN_RESET				PIN_PA27
#define CONF_WINC_PIN_CHIP_ENABLE		PIN_PA28
#define CONF_WINC_PIN_WAKE				PIN_PB08

//    ---------- SPI settings ---------
#define CONF_WINC_USE_SPI				(1)

/** SPI pin and instance settings. */
#define CONF_WINC_SPI_MODULE			SERCOM2
#define CONF_WINC_SPI_SERCOM_MUX		SPI_SIGNAL_MUX_SETTING_D
#define CONF_WINC_SPI_PINMUX_PAD0		PINMUX_PA12C_SERCOM2_PAD0 /* out */
#define CONF_WINC_SPI_PINMUX_PAD1		PINMUX_PA13C_SERCOM2_PAD1 /* sck  */
#define CONF_WINC_SPI_PINMUX_PAD2		PINMUX_UNUSED /* cs driven from software */
#define CONF_WINC_SPI_PINMUX_PAD3		PINMUX_PA15C_SERCOM2_PAD3 /* in  */
#define CONF_WINC_SPI_CS_PIN			PIN_PA14

/** SPI interrupt pin. */
#define CONF_WINC_SPI_INT_PIN			PIN_PB09A_EIC_EXTINT9
#define CONF_WINC_SPI_INT_MUX			MUX_PB09A_EIC_EXTINT9
#define CONF_WINC_SPI_INT_EIC			(9)

static void configure_console(void)
{
	struct usart_config usart_conf;

	usart_get_config_defaults(&usart_conf);
	usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
	usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
	usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
	usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
	usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
	usart_conf.baudrate    = 115200;

	stdio_serial_init(&cdc_uart_module, EDBG_CDC_MODULE, &usart_conf);
	usart_enable(&cdc_uart_module);
}

int main(void)
{
	tstrWifiInitParam settings;
	int8_t ret;

	// Initialize the board.
	system_init();

	// Initialize the UART console.
	configure_console();
	printf(STRING_HEADER);

	// Initialize the BSP.
	nm_bsp_init();

	// Initialize Wi-Fi parameters structure.
	memset((uint8_t *)&settings, 0, sizeof(tstrWifiInitParam));

	//Initialize Wi-Fi driver with data and status callbacks.
	ret = m2m_wifi_init(&settings);
	if (M2M_SUCCESS != ret) 
        {
		printf("main: m2m_wifi_init call error!(%d)rn", ret);
		while (1);
	}

	// Display WINC1500 chip information.
	printf("Chip ID : rttt%xrn", (unsigned int)nmi_get_chipid());
	printf("RF Revision ID : rttt%xrn", (unsigned int)nmi_get_rfrevid());
	printf("Done.rnrn");

	while (1);
	return 0;
}

Код функции main:

	// Initialize AP mode parameters structure with SSID, channel and OPEN security type. 
	memset(&strM2MAPConfig, 0x00, sizeof(tstrM2MAPConfig));
	strcpy((char *)&strM2MAPConfig.au8SSID, MAIN_WLAN_SSID);
	strM2MAPConfig.u8ListenChannel = MAIN_WLAN_CHANNEL;
	strM2MAPConfig.u8SecType = MAIN_WLAN_AUTH;

	strM2MAPConfig.au8DHCPServerIP[0] = 192;
	strM2MAPConfig.au8DHCPServerIP[1] = 168;
	strM2MAPConfig.au8DHCPServerIP[2] = 1;
	strM2MAPConfig.au8DHCPServerIP[3] = 1;

#if USE_WEP
	strcpy((char *)&strM2MAPConfig.au8WepKey, MAIN_WLAN_WEP_KEY);
	strM2MAPConfig.u8KeySz = strlen(MAIN_WLAN_WEP_KEY);
	strM2MAPConfig.u8KeyIndx = MAIN_WLAN_WEP_KEY_INDEX;
#endif

	/* Bring up AP mode with parameters structure. */
	ret = m2m_wifi_enable_ap(&strM2MAPConfig);
	if (M2M_SUCCESS != ret) 
	{
		printf("main: m2m_wifi_enable_ap call error!rn");
		while (1);
	}

	printf("AP mode started. You can connect to %s.rn", (char *)MAIN_WLAN_SSID);

	while (1) 
	{

		while (m2m_wifi_handle_events(NULL) != M2M_SUCCESS);		// Handle pending events from network controller.
}	

// Код callback 
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
	switch (u8MsgType) {
	case M2M_WIFI_RESP_CON_STATE_CHANGED:
	{
		tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
		if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
		} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
			printf("Station disconnectedrn");
		}

		break;
	}

	case M2M_WIFI_REQ_DHCP_CONF:
	{
		uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
		printf("Station connectedrn");
		printf("Station IP is %u.%u.%u.%urn",
				pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
		break;
	}

	default:
	{
		break;
	}
	}
}


Файл main.h:
/** Security mode */
#define USE_WEP					 (1) /*< Set to (1) to use WEP, and (0) to use OPEN */

/** AP mode Settings */
#define MAIN_WLAN_SSID           "WINC1500_AP" /* < SSID */
#if USE_WEP
#define MAIN_WLAN_AUTH           M2M_WIFI_SEC_WEP /* < Security manner */
#define MAIN_WLAN_WEP_KEY        "1234567890" /* < Security Key in WEP Mode */
#define MAIN_WLAN_WEP_KEY_INDEX  (1)
#else
#define MAIN_WLAN_AUTH           M2M_WIFI_SEC_OPEN /* < Security manner */
#endif
#define MAIN_WLAN_CHANNEL        (6) /* < Channel number */

static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
	switch (u8MsgType) {
	case M2M_WIFI_RESP_SCAN_DONE:
	{
		tstrM2mScanDone *pstrInfo = (tstrM2mScanDone *)pvMsg;
		scan_request_index = 0;
		if (pstrInfo->u8NumofCh >= 1) 
		{
			m2m_wifi_req_scan_result(scan_request_index);
			scan_request_index++;
		} 
		else 
		{
			m2m_wifi_request_scan(M2M_WIFI_CH_ALL);
		}

		break;
	}

	case M2M_WIFI_RESP_SCAN_RESULT:
	{
		tstrM2mWifiscanResult *pstrScanResult = (tstrM2mWifiscanResult *)pvMsg;
		uint16_t demo_ssid_len;
		uint16_t scan_ssid_len = strlen((const char *)pstrScanResult->au8SSID);

		/* display founded AP. */
		printf("[%d] SSID:%srn", scan_request_index, pstrScanResult->au8SSID);

		num_founded_ap = m2m_wifi_get_num_ap_found();
		if (scan_ssid_len) {
			/* check same SSID. */
			demo_ssid_len = strlen((const char *)MAIN_WLAN_SSID);
			if(	(demo_ssid_len == scan_ssid_len) &&	(!memcmp(pstrScanResult->au8SSID, (uint8_t *)MAIN_WLAN_SSID, demo_ssid_len))) 
			{
				/* A scan result matches an entry in the preferred AP List.
				 * Initiate a connection request.
				 */
				printf("Found %s rn", MAIN_WLAN_SSID);
				m2m_wifi_connect((char *)MAIN_WLAN_SSID,sizeof(MAIN_WLAN_SSID),	MAIN_WLAN_AUTH,(void *)MAIN_WLAN_PSK,M2M_WIFI_CH_ALL);
				break;
			}
		}

		if (scan_request_index < num_founded_ap) 
		{
			m2m_wifi_req_scan_result(scan_request_index);
			scan_request_index++;
		}
		else 
		{
			printf("can not find AP %srn", MAIN_WLAN_SSID);
			m2m_wifi_request_scan(M2M_WIFI_CH_ALL);
		}

		break;
	}

	case M2M_WIFI_RESP_CON_STATE_CHANGED:
	{
		tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
		if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) 
                {
			m2m_wifi_request_dhcp_client();
		}
                else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED)
               {
			printf("Wi-Fi disconnectedrn");

			/* Request scan. */
			m2m_wifi_request_scan(M2M_WIFI_CH_ALL);
		}

		break;
	}

	case M2M_WIFI_REQ_DHCP_CONF:
	{
		uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
		printf("Wi-Fi connectedrn");
		printf("Wi-Fi IP is %u.%u.%u.%urn", pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
		break;
	}

	default:
	{
		break;
	}
	}
}

static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
	switch (u8MsgType) {
	case M2M_WIFI_RESP_CON_STATE_CHANGED:
	{
		tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
		if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED)
               {
			printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: CONNECTEDrn");
			m2m_wifi_request_dhcp_client();
		} 
               else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) 
               {
			printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: DISCONNECTEDrn");
			wifi_connected = 0;
			m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
		}

		break;
	}

	case M2M_WIFI_REQ_DHCP_CONF:
	{
		uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
		wifi_connected = 1;
		printf("wifi_cb: M2M_WIFI_REQ_DHCP_CONF: IP is %u.%u.%u.%urn",pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
		break;
	}

	default:
	{
		break;
	}
	}
}

static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
	
	printf("wifi_cb: u8MsgType= %dn",u8MsgType);
	switch (u8MsgType) {
	case M2M_WIFI_RESP_CON_STATE_CHANGED:
	{
		tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
		if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) 
		{
			printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: CONNECTEDrn");
				
			tstrM2MIPConfig ip_client;
			ip_client.u32StaticIP = _htonl(0xc0a8142d); //corresponds to 192.168.20.45
			ip_client.u32DNS = _htonl(0xc0a80266); //corresponds to 192.168.2.102
			ip_client.u32SubnetMask =_htonl(0xFFFFFF00); //corresponds to 255.255.255.0
			ip_client.u32Gateway = _htonl(0xc0a81401);  //corresponds to 192.168.20.1
			m2m_wifi_set_static_ip(&ip_client);
		
			wifi_connected = 1;
		}
		else
		{
			if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) 
			{
			   printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: DISCONNECTEDrn");
			   wifi_connected = 0;
			   m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
			}
		}
		break;
	}

	default:
		break;
	}
}

static void socket_cb(SOCKET sock, uint8_t u8Msg, void *pvMsg)
{
	// Check for socket event on RX socket. 
	if (sock == rx_socket)
	{
		if (u8Msg == SOCKET_MSG_BIND) 
		{
			tstrSocketBindMsg *pstrBind = (tstrSocketBindMsg *)pvMsg;
			if (pstrBind && pstrBind->status == 0) 
			{
				// Prepare next buffer reception. 
				sock_bind_state = 1;
				recv(sock, udp_data_rx, MAIN_WIFI_M2M_BUFFER_SIZE, 0);
			} 
			else 
			{
				printf("socket_cb: bind error!rn");
			}
		} 
		else if (u8Msg == SOCKET_MSG_RECVFROM) 
		{
			tstrSocketRecvMsg *pstrRx = (tstrSocketRecvMsg *)pvMsg;
			if (pstrRx->pu8Buffer && pstrRx->s16BufferSize) 
			{
				delay = 0;
				sock_rx_state = pstrRx->s16BufferSize;
				printf("socket_cb udp recv!rn");
				printf("rx packet length= %dn",pstrRx->s16BufferSize);
			} 
			else
			{
				if (pstrRx->s16BufferSize == SOCK_ERR_TIMEOUT) 
				{
					// Prepare next buffer reception. 
				       recv(sock, udp_data_rx, MAIN_WIFI_M2M_BUFFER_SIZE, 0);
				}
			}
		}
		if (u8Msg == SOCKET_MSG_SENDTO) 
		{
			recv(sock, udp_data_rx, MAIN_WIFI_M2M_BUFFER_SIZE, 0);
			sock_tx_state = 1;
		}
	}
	if (sock == tcp_client_socket)
	{		
	   switch (u8Msg) 
	   {
		   // Socket connected
		   case SOCKET_MSG_CONNECT:
		   {
		      tstrSocketConnectMsg *pstrConnect = (tstrSocketConnectMsg *)pvMsg;
			  if (pstrConnect && pstrConnect->s8Error >= 0)
			  {
				  printf("socket_cb tcp connect!rn");
				  tcp_ready_to_send=1;
			  }
			  else
			  {
				  close(tcp_client_socket);
				  tcp_client_socket = -1;
			  }
		  }
		  break;

		  // Message send
		  case SOCKET_MSG_SEND:
		  {
			   printf("socket_cb tcp send!rn");
			  recv(tcp_client_socket, tcp_data_rx, sizeof(tcp_data_rx), 0);
			  tcp_tx_ready=1;
		  }
		  break;

		  // Message receive
		  case SOCKET_MSG_RECV:
		  {
			  
			  tstrSocketRecvMsg *pstrRecv = (tstrSocketRecvMsg *)pvMsg;
			  if (pstrRecv && pstrRecv->s16BufferSize > 0)
			  {
				  tcp_rx_ready=pstrRecv->s16BufferSize;
			  }
			  else
			  {
				  close(tcp_client_socket);
				  tcp_client_socket = -1;
			  }
		  }
		  break;

		  default:
		    break;
	   }		
	}
}