Merge branch 'master' of github.com:arduino/ARM

Author: cmaglie

hardware/arduino/sam/libraries/SPI/SPI.cpp

@@ -22,8 +22,8 @@ SPIClass::SPIClass(Spi *_spi, uint32_t _id, void(*_initCb)(void)) :
 void SPIClass::begin() {
 	// NPCS control is left to the user
 
-	// Default speed set to 500Khz
-	setClockDivider(BOARD_SPI_DEFAULT_SS, 168);
+	// Default speed set to 4Mhz
+	setClockDivider(BOARD_SPI_DEFAULT_SS, 21);
 	setDataMode(BOARD_SPI_DEFAULT_SS, SPI_MODE0);
 }
 
@@ -34,8 +34,8 @@ void SPIClass::begin(uint8_t _pin) {
 		g_APinDescription[spiPin].ulPinType,
 		g_APinDescription[spiPin].ulPin,
 		g_APinDescription[spiPin].ulPinConfiguration);
-	// Default speed set to 500Khz
-	setClockDivider(_pin, 168);
+	// Default speed set to 4Mhz
+	setClockDivider(_pin, 21);
 	setDataMode(_pin, SPI_MODE0);
 }
 
@@ -52,15 +52,16 @@ void SPIClass::setDataMode(uint8_t _pin, uint8_t _mode) {
 	mode[_channel] = _mode | SPI_CSR_CSAAT;
 	// SPI_CSR_DLYBCT(1) keeps CS enabled for 32 MCLK after a completed
 	// transfer. Some device needs that for working properly.
-	SPI_ConfigureNPCS(spi, _channel, mode[_channel] | SPI_CSR_SCBR(divider[_channel]) | SPI_CSR_DLYBCT(1));
+	SPI_ConfigureNPCS(spi, _channel, mode[_channel] | SPI_CSR_SCBR(divider[_channel]) | SPI_CSR_DLYBCT(10) | (32<<16));
 }
 
 void SPIClass::setClockDivider(uint8_t _pin, uint8_t _divider) {
 	uint32_t _channel = BOARD_PIN_TO_SPI_CHANNEL(_pin);
 	divider[_channel] = _divider;
 	// SPI_CSR_DLYBCT(1) keeps CS enabled for 32 MCLK after a completed
 	// transfer. Some device needs that for working properly.
-	SPI_ConfigureNPCS(spi, _channel, mode[_channel] | SPI_CSR_SCBR(divider[_channel]) | SPI_CSR_DLYBCT(1));
+//	SPI_ConfigureNPCS(spi, _channel, mode[_channel] | SPI_CSR_SCBR(divider[_channel]) | SPI_CSR_DLYBCT(1));
+	SPI_ConfigureNPCS(spi, _channel, mode[_channel] | SPI_CSR_SCBR(divider[_channel]) | SPI_CSR_DLYBCT(10) | (32<<16));
 }
 
 byte SPIClass::transfer(byte _pin, uint8_t _data, SPITransferMode _mode) {

hardware/arduino/sam/libraries/WiFi/WiFi.cpp

@@ -0,0 +1,200 @@
+#include <stdio.h>
+#include "wifi_drv.h"
+#include "WiFi.h"
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+  #include "utility/wl_types.h"
+  #include "debug.h"
+}
+
+// XXX: don't make assumptions about the value of MAX_SOCK_NUM.
+int16_t 	WiFiClass::_state[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+uint16_t 	WiFiClass::_server_port[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+
+WiFiClass::WiFiClass()
+{
+	// Driver initialization
+	init();
+}
+
+void WiFiClass::init()
+{
+    WiFiDrv::wifiDriverInit();
+}
+
+uint8_t WiFiClass::getSocket()
+{
+    for (uint8_t i = 0; i < MAX_SOCK_NUM; ++i)
+    {
+        if (WiFiClass::_server_port[i] == 0)
+        {
+             return i;
+        }
+    }
+    return NO_SOCKET_AVAIL;
+}
+
+char* WiFiClass::firmwareVersion()
+{
+	return WiFiDrv::getFwVersion();
+}
+
+int WiFiClass::begin(char* ssid)
+{
+	uint8_t status = WL_IDLE_STATUS;
+	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
+
+   if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)
+   {
+	   do
+	   {
+		   delay(WL_DELAY_START_CONNECTION);
+		   status = WiFiDrv::getConnectionStatus();
+	   }
+	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+   }else
+   {
+	   status = WL_CONNECT_FAILED;
+   }
+   return status;
+}
+
+int WiFiClass::begin(char* ssid, uint8_t key_idx, const char *key)
+{
+	uint8_t status = WL_IDLE_STATUS;
+	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
+
+	// set encryption key
+   if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)
+   {
+	   do
+	   {
+		   delay(WL_DELAY_START_CONNECTION);
+		   status = WiFiDrv::getConnectionStatus();
+	   }
+	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+   }else{
+	   status = WL_CONNECT_FAILED;
+   }
+   return status;
+}
+
+int WiFiClass::begin(char* ssid, const char *passphrase)
+{
+	uint8_t status = WL_IDLE_STATUS;
+	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
+
+    // set passphrase
+    if (WiFiDrv::wifiSetPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase))!= WL_FAILURE)
+    {
+ 	   do
+ 	   {
+ 		   delay(WL_DELAY_START_CONNECTION);
+ 		   status = WiFiDrv::getConnectionStatus();
+ 	   }
+	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+    }else{
+    	status = WL_CONNECT_FAILED;
+    }
+    return status;
+}
+
+int WiFiClass::disconnect()
+{
+    return WiFiDrv::disconnect();
+}
+
+uint8_t* WiFiClass::macAddress(uint8_t* mac)
+{
+	uint8_t* _mac = WiFiDrv::getMacAddress();
+	memcpy(mac, _mac, WL_MAC_ADDR_LENGTH);
+    return mac;
+}
+   
+IPAddress WiFiClass::localIP()
+{
+	IPAddress ret;
+	WiFiDrv::getIpAddress(ret);
+	return ret;
+}
+
+IPAddress WiFiClass::subnetMask()
+{
+	IPAddress ret;
+	WiFiDrv::getSubnetMask(ret);
+	return ret;
+}
+
+IPAddress WiFiClass::gatewayIP()
+{
+	IPAddress ret;
+	WiFiDrv::getGatewayIP(ret);
+	return ret;
+}
+
+char* WiFiClass::SSID()
+{
+    return WiFiDrv::getCurrentSSID();
+}
+
+uint8_t* WiFiClass::BSSID(uint8_t* bssid)
+{
+	uint8_t* _bssid = WiFiDrv::getCurrentBSSID();
+	memcpy(bssid, _bssid, WL_MAC_ADDR_LENGTH);
+    return bssid;
+}
+
+int32_t WiFiClass::RSSI()
+{
+    return WiFiDrv::getCurrentRSSI();
+}
+
+uint8_t WiFiClass::encryptionType()
+{
+    return WiFiDrv::getCurrentEncryptionType();
+}
+
+
+int8_t WiFiClass::scanNetworks()
+{
+	uint8_t attempts = 10;
+	uint8_t numOfNetworks = 0;
+
+	if (WiFiDrv::startScanNetworks() == WL_FAILURE)
+		return WL_FAILURE;
+ 	do
+ 	{
+ 		delay(2000);
+ 		numOfNetworks = WiFiDrv::getScanNetworks();
+ 	}
+	while (( numOfNetworks == 0)&&(--attempts>0));
+	return numOfNetworks;
+}
+
+char* WiFiClass::SSID(uint8_t networkItem)
+{
+	return WiFiDrv::getSSIDNetoworks(networkItem);
+}
+
+int32_t WiFiClass::RSSI(uint8_t networkItem)
+{
+	return WiFiDrv::getRSSINetoworks(networkItem);
+}
+
+uint8_t WiFiClass::encryptionType(uint8_t networkItem)
+{
+    return WiFiDrv::getEncTypeNetowrks(networkItem);
+}
+
+uint8_t WiFiClass::status()
+{
+    return WiFiDrv::getConnectionStatus();
+}
+
+int WiFiClass::hostByName(const char* aHostname, IPAddress& aResult)
+{
+	return WiFiDrv::getHostByName(aHostname, aResult);
+}
+
+WiFiClass WiFi;