diff --git a/.cproject b/.cproject
index 3df778c..2887129 100644
--- a/.cproject
+++ b/.cproject
@@ -22,6 +22,11 @@
+
+
+
+
+
@@ -30,6 +35,11 @@
+
+
+
+
+
@@ -42,7 +52,12 @@
-
+
+
+
+
+
+
diff --git a/.hgignore b/.hgignore
new file mode 100644
index 0000000..b16f296
--- /dev/null
+++ b/.hgignore
@@ -0,0 +1,3 @@
+
+syntax: regexp
+^Release$
\ No newline at end of file
diff --git a/Ethernet/Dhcp.cpp b/Ethernet/Dhcp.cpp
new file mode 100644
index 0000000..5f53db4
--- /dev/null
+++ b/Ethernet/Dhcp.cpp
@@ -0,0 +1,481 @@
+// DHCP Library v0.3 - April 25, 2009
+// Author: Jordan Terrell - blog.jordanterrell.com
+
+#include "utility/w5100.h"
+
+#include
+#include
+#include "Dhcp.h"
+#include "Arduino.h"
+#include "utility/util.h"
+
+int DhcpClass::beginWithDHCP(uint8_t *mac, unsigned long timeout, unsigned long responseTimeout)
+{
+ _dhcpLeaseTime=0;
+ _dhcpT1=0;
+ _dhcpT2=0;
+ _lastCheck=0;
+ _timeout = timeout;
+ _responseTimeout = responseTimeout;
+
+ // zero out _dhcpMacAddr
+ memset(_dhcpMacAddr, 0, 6);
+ reset_DHCP_lease();
+
+ memcpy((void*)_dhcpMacAddr, (void*)mac, 6);
+ _dhcp_state = STATE_DHCP_START;
+ return request_DHCP_lease();
+}
+
+void DhcpClass::reset_DHCP_lease(){
+ // zero out _dhcpSubnetMask, _dhcpGatewayIp, _dhcpLocalIp, _dhcpDhcpServerIp, _dhcpDnsServerIp
+ memset(_dhcpLocalIp, 0, 20);
+}
+
+//return:0 on error, 1 if request is sent and response is received
+int DhcpClass::request_DHCP_lease(){
+
+ uint8_t messageType = 0;
+
+
+
+ // Pick an initial transaction ID
+ _dhcpTransactionId = random(1UL, 2000UL);
+ _dhcpInitialTransactionId = _dhcpTransactionId;
+
+ _dhcpUdpSocket.stop();
+ if (_dhcpUdpSocket.begin(DHCP_CLIENT_PORT) == 0)
+ {
+ // Couldn't get a socket
+ return 0;
+ }
+
+ presend_DHCP();
+
+ int result = 0;
+
+ unsigned long startTime = millis();
+
+ while(_dhcp_state != STATE_DHCP_LEASED)
+ {
+ if(_dhcp_state == STATE_DHCP_START)
+ {
+ _dhcpTransactionId++;
+
+ send_DHCP_MESSAGE(DHCP_DISCOVER, ((millis() - startTime) / 1000));
+ _dhcp_state = STATE_DHCP_DISCOVER;
+ }
+ else if(_dhcp_state == STATE_DHCP_REREQUEST){
+ _dhcpTransactionId++;
+ send_DHCP_MESSAGE(DHCP_REQUEST, ((millis() - startTime)/1000));
+ _dhcp_state = STATE_DHCP_REQUEST;
+ }
+ else if(_dhcp_state == STATE_DHCP_DISCOVER)
+ {
+ uint32_t respId;
+ messageType = parseDHCPResponse(_responseTimeout, respId);
+ if(messageType == DHCP_OFFER)
+ {
+ // We'll use the transaction ID that the offer came with,
+ // rather than the one we were up to
+ _dhcpTransactionId = respId;
+ send_DHCP_MESSAGE(DHCP_REQUEST, ((millis() - startTime) / 1000));
+ _dhcp_state = STATE_DHCP_REQUEST;
+ }
+ }
+ else if(_dhcp_state == STATE_DHCP_REQUEST)
+ {
+ uint32_t respId;
+ messageType = parseDHCPResponse(_responseTimeout, respId);
+ if(messageType == DHCP_ACK)
+ {
+ _dhcp_state = STATE_DHCP_LEASED;
+ result = 1;
+ //use default lease time if we didn't get it
+ if(_dhcpLeaseTime == 0){
+ _dhcpLeaseTime = DEFAULT_LEASE;
+ }
+ //calculate T1 & T2 if we didn't get it
+ if(_dhcpT1 == 0){
+ //T1 should be 50% of _dhcpLeaseTime
+ _dhcpT1 = _dhcpLeaseTime >> 1;
+ }
+ if(_dhcpT2 == 0){
+ //T2 should be 87.5% (7/8ths) of _dhcpLeaseTime
+ _dhcpT2 = _dhcpT1 << 1;
+ }
+ _renewInSec = _dhcpT1;
+ _rebindInSec = _dhcpT2;
+ }
+ else if(messageType == DHCP_NAK)
+ _dhcp_state = STATE_DHCP_START;
+ }
+
+ if(messageType == 255)
+ {
+ messageType = 0;
+ _dhcp_state = STATE_DHCP_START;
+ }
+
+ if(result != 1 && ((millis() - startTime) > _timeout))
+ break;
+ }
+
+ // We're done with the socket now
+ _dhcpUdpSocket.stop();
+ _dhcpTransactionId++;
+
+ return result;
+}
+
+void DhcpClass::presend_DHCP()
+{
+}
+
+void DhcpClass::send_DHCP_MESSAGE(uint8_t messageType, uint16_t secondsElapsed)
+{
+ uint8_t buffer[32];
+ memset(buffer, 0, 32);
+ IPAddress dest_addr( 255, 255, 255, 255 ); // Broadcast address
+
+ if (-1 == _dhcpUdpSocket.beginPacket(dest_addr, DHCP_SERVER_PORT))
+ {
+ // FIXME Need to return errors
+ return;
+ }
+
+ buffer[0] = DHCP_BOOTREQUEST; // op
+ buffer[1] = DHCP_HTYPE10MB; // htype
+ buffer[2] = DHCP_HLENETHERNET; // hlen
+ buffer[3] = DHCP_HOPS; // hops
+
+ // xid
+ unsigned long xid = htonl(_dhcpTransactionId);
+ memcpy(buffer + 4, &(xid), 4);
+
+ // 8, 9 - seconds elapsed
+ buffer[8] = ((secondsElapsed & 0xff00) >> 8);
+ buffer[9] = (secondsElapsed & 0x00ff);
+
+ // flags
+ unsigned short flags = htons(DHCP_FLAGSBROADCAST);
+ memcpy(buffer + 10, &(flags), 2);
+
+ // ciaddr: already zeroed
+ // yiaddr: already zeroed
+ // siaddr: already zeroed
+ // giaddr: already zeroed
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 28);
+
+ memset(buffer, 0, 32); // clear local buffer
+
+ memcpy(buffer, _dhcpMacAddr, 6); // chaddr
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 16);
+
+ memset(buffer, 0, 32); // clear local buffer
+
+ // leave zeroed out for sname && file
+ // put in W5100 transmit buffer x 6 (192 bytes)
+
+ for(int i = 0; i < 6; i++) {
+ _dhcpUdpSocket.write(buffer, 32);
+ }
+
+ // OPT - Magic Cookie
+ buffer[0] = (uint8_t)((MAGIC_COOKIE >> 24)& 0xFF);
+ buffer[1] = (uint8_t)((MAGIC_COOKIE >> 16)& 0xFF);
+ buffer[2] = (uint8_t)((MAGIC_COOKIE >> 8)& 0xFF);
+ buffer[3] = (uint8_t)(MAGIC_COOKIE& 0xFF);
+
+ // OPT - message type
+ buffer[4] = dhcpMessageType;
+ buffer[5] = 0x01;
+ buffer[6] = messageType; //DHCP_REQUEST;
+
+ // OPT - client identifier
+ buffer[7] = dhcpClientIdentifier;
+ buffer[8] = 0x07;
+ buffer[9] = 0x01;
+ memcpy(buffer + 10, _dhcpMacAddr, 6);
+
+ // OPT - host name
+ buffer[16] = hostName;
+ buffer[17] = strlen(HOST_NAME) + 6; // length of hostname + last 3 bytes of mac address
+ strcpy((char*)&(buffer[18]), HOST_NAME);
+
+ printByte((char*)&(buffer[24]), _dhcpMacAddr[3]);
+ printByte((char*)&(buffer[26]), _dhcpMacAddr[4]);
+ printByte((char*)&(buffer[28]), _dhcpMacAddr[5]);
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 30);
+
+ if(messageType == DHCP_REQUEST)
+ {
+ buffer[0] = dhcpRequestedIPaddr;
+ buffer[1] = 0x04;
+ buffer[2] = _dhcpLocalIp[0];
+ buffer[3] = _dhcpLocalIp[1];
+ buffer[4] = _dhcpLocalIp[2];
+ buffer[5] = _dhcpLocalIp[3];
+
+ buffer[6] = dhcpServerIdentifier;
+ buffer[7] = 0x04;
+ buffer[8] = _dhcpDhcpServerIp[0];
+ buffer[9] = _dhcpDhcpServerIp[1];
+ buffer[10] = _dhcpDhcpServerIp[2];
+ buffer[11] = _dhcpDhcpServerIp[3];
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 12);
+ }
+
+ buffer[0] = dhcpParamRequest;
+ buffer[1] = 0x06;
+ buffer[2] = subnetMask;
+ buffer[3] = routersOnSubnet;
+ buffer[4] = dns;
+ buffer[5] = domainName;
+ buffer[6] = dhcpT1value;
+ buffer[7] = dhcpT2value;
+ buffer[8] = endOption;
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 9);
+
+ _dhcpUdpSocket.endPacket();
+}
+
+uint8_t DhcpClass::parseDHCPResponse(unsigned long responseTimeout, uint32_t& transactionId)
+{
+ uint8_t type = 0;
+ uint8_t opt_len = 0;
+
+ unsigned long startTime = millis();
+
+ while(_dhcpUdpSocket.parsePacket() <= 0)
+ {
+ if((millis() - startTime) > responseTimeout)
+ {
+ return 255;
+ }
+ delay(50);
+ }
+ // start reading in the packet
+ RIP_MSG_FIXED fixedMsg;
+ _dhcpUdpSocket.read((uint8_t*)&fixedMsg, sizeof(RIP_MSG_FIXED));
+
+ if(fixedMsg.op == DHCP_BOOTREPLY && _dhcpUdpSocket.remotePort() == DHCP_SERVER_PORT)
+ {
+ transactionId = ntohl(fixedMsg.xid);
+ if(memcmp(fixedMsg.chaddr, _dhcpMacAddr, 6) != 0 || (transactionId < _dhcpInitialTransactionId) || (transactionId > _dhcpTransactionId))
+ {
+ // Need to read the rest of the packet here regardless
+ _dhcpUdpSocket.flush();
+ return 0;
+ }
+
+ memcpy(_dhcpLocalIp, fixedMsg.yiaddr, 4);
+
+ // Skip to the option part
+ // Doing this a byte at a time so we don't have to put a big buffer
+ // on the stack (as we don't have lots of memory lying around)
+ for (int i =0; i < (240 - (int)sizeof(RIP_MSG_FIXED)); i++)
+ {
+ _dhcpUdpSocket.read(); // we don't care about the returned byte
+ }
+
+ while (_dhcpUdpSocket.available() > 0)
+ {
+ switch (_dhcpUdpSocket.read())
+ {
+ case endOption :
+ break;
+
+ case padOption :
+ break;
+
+ case dhcpMessageType :
+ opt_len = _dhcpUdpSocket.read();
+ type = _dhcpUdpSocket.read();
+ break;
+
+ case subnetMask :
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read(_dhcpSubnetMask, 4);
+ break;
+
+ case routersOnSubnet :
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read(_dhcpGatewayIp, 4);
+ for (int i = 0; i < opt_len-4; i++)
+ {
+ _dhcpUdpSocket.read();
+ }
+ break;
+
+ case dns :
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read(_dhcpDnsServerIp, 4);
+ for (int i = 0; i < opt_len-4; i++)
+ {
+ _dhcpUdpSocket.read();
+ }
+ break;
+
+ case dhcpServerIdentifier :
+ opt_len = _dhcpUdpSocket.read();
+ if ((_dhcpDhcpServerIp[0] == 0 && _dhcpDhcpServerIp[1] == 0 &&
+ _dhcpDhcpServerIp[2] == 0 && _dhcpDhcpServerIp[3] == 0) ||
+ IPAddress(_dhcpDhcpServerIp) == _dhcpUdpSocket.remoteIP())
+ {
+ _dhcpUdpSocket.read(_dhcpDhcpServerIp, sizeof(_dhcpDhcpServerIp));
+ }
+ else
+ {
+ // Skip over the rest of this option
+ while (opt_len--)
+ {
+ _dhcpUdpSocket.read();
+ }
+ }
+ break;
+
+ case dhcpT1value :
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read((uint8_t*)&_dhcpT1, sizeof(_dhcpT1));
+ _dhcpT1 = ntohl(_dhcpT1);
+ break;
+
+ case dhcpT2value :
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read((uint8_t*)&_dhcpT2, sizeof(_dhcpT2));
+ _dhcpT2 = ntohl(_dhcpT2);
+ break;
+
+ case dhcpIPaddrLeaseTime :
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read((uint8_t*)&_dhcpLeaseTime, sizeof(_dhcpLeaseTime));
+ _dhcpLeaseTime = ntohl(_dhcpLeaseTime);
+ _renewInSec = _dhcpLeaseTime;
+ break;
+
+ default :
+ opt_len = _dhcpUdpSocket.read();
+ // Skip over the rest of this option
+ while (opt_len--)
+ {
+ _dhcpUdpSocket.read();
+ }
+ break;
+ }
+ }
+ }
+
+ // Need to skip to end of the packet regardless here
+ _dhcpUdpSocket.flush();
+
+ return type;
+}
+
+
+/*
+ returns:
+ 0/DHCP_CHECK_NONE: nothing happened
+ 1/DHCP_CHECK_RENEW_FAIL: renew failed
+ 2/DHCP_CHECK_RENEW_OK: renew success
+ 3/DHCP_CHECK_REBIND_FAIL: rebind fail
+ 4/DHCP_CHECK_REBIND_OK: rebind success
+*/
+int DhcpClass::checkLease(){
+ //this uses a signed / unsigned trick to deal with millis overflow
+ unsigned long now = millis();
+ signed long snow = (long)now;
+ int rc=DHCP_CHECK_NONE;
+ if (_lastCheck != 0){
+ signed long factor;
+ //calc how many ms past the timeout we are
+ factor = snow - (long)_secTimeout;
+ //if on or passed the timeout, reduce the counters
+ if ( factor >= 0 ){
+ //next timeout should be now plus 1000 ms minus parts of second in factor
+ _secTimeout = snow + 1000 - factor % 1000;
+ //how many seconds late are we, minimum 1
+ factor = factor / 1000 +1;
+
+ //reduce the counters by that mouch
+ //if we can assume that the cycle time (factor) is fairly constant
+ //and if the remainder is less than cycle time * 2
+ //do it early instead of late
+ if(_renewInSec < factor*2 )
+ _renewInSec = 0;
+ else
+ _renewInSec -= factor;
+
+ if(_rebindInSec < factor*2 )
+ _rebindInSec = 0;
+ else
+ _rebindInSec -= factor;
+ }
+
+ //if we have a lease but should renew, do it
+ if (_dhcp_state == STATE_DHCP_LEASED && _renewInSec <=0){
+ _dhcp_state = STATE_DHCP_REREQUEST;
+ rc = 1 + request_DHCP_lease();
+ }
+
+ //if we have a lease or is renewing but should bind, do it
+ if( (_dhcp_state == STATE_DHCP_LEASED || _dhcp_state == STATE_DHCP_START) && _rebindInSec <=0){
+ //this should basically restart completely
+ _dhcp_state = STATE_DHCP_START;
+ reset_DHCP_lease();
+ rc = 3 + request_DHCP_lease();
+ }
+ }
+ else{
+ _secTimeout = snow + 1000;
+ }
+
+ _lastCheck = now;
+ return rc;
+}
+
+IPAddress DhcpClass::getLocalIp()
+{
+ return IPAddress(_dhcpLocalIp);
+}
+
+IPAddress DhcpClass::getSubnetMask()
+{
+ return IPAddress(_dhcpSubnetMask);
+}
+
+IPAddress DhcpClass::getGatewayIp()
+{
+ return IPAddress(_dhcpGatewayIp);
+}
+
+IPAddress DhcpClass::getDhcpServerIp()
+{
+ return IPAddress(_dhcpDhcpServerIp);
+}
+
+IPAddress DhcpClass::getDnsServerIp()
+{
+ return IPAddress(_dhcpDnsServerIp);
+}
+
+void DhcpClass::printByte(char * buf, uint8_t n ) {
+ char *str = &buf[1];
+ buf[0]='0';
+ do {
+ unsigned long m = n;
+ n /= 16;
+ char c = m - 16 * n;
+ *str-- = c < 10 ? c + '0' : c + 'A' - 10;
+ } while(n);
+}
diff --git a/Ethernet/Dhcp.h b/Ethernet/Dhcp.h
new file mode 100644
index 0000000..1a533ef
--- /dev/null
+++ b/Ethernet/Dhcp.h
@@ -0,0 +1,178 @@
+// DHCP Library v0.3 - April 25, 2009
+// Author: Jordan Terrell - blog.jordanterrell.com
+
+#ifndef Dhcp_h
+#define Dhcp_h
+
+#include "EthernetUdp.h"
+
+/* DHCP state machine. */
+#define STATE_DHCP_START 0
+#define STATE_DHCP_DISCOVER 1
+#define STATE_DHCP_REQUEST 2
+#define STATE_DHCP_LEASED 3
+#define STATE_DHCP_REREQUEST 4
+#define STATE_DHCP_RELEASE 5
+
+#define DHCP_FLAGSBROADCAST 0x8000
+
+/* UDP port numbers for DHCP */
+#define DHCP_SERVER_PORT 67 /* from server to client */
+#define DHCP_CLIENT_PORT 68 /* from client to server */
+
+/* DHCP message OP code */
+#define DHCP_BOOTREQUEST 1
+#define DHCP_BOOTREPLY 2
+
+/* DHCP message type */
+#define DHCP_DISCOVER 1
+#define DHCP_OFFER 2
+#define DHCP_REQUEST 3
+#define DHCP_DECLINE 4
+#define DHCP_ACK 5
+#define DHCP_NAK 6
+#define DHCP_RELEASE 7
+#define DHCP_INFORM 8
+
+#define DHCP_HTYPE10MB 1
+#define DHCP_HTYPE100MB 2
+
+#define DHCP_HLENETHERNET 6
+#define DHCP_HOPS 0
+#define DHCP_SECS 0
+
+#define MAGIC_COOKIE 0x63825363
+#define MAX_DHCP_OPT 16
+
+#define HOST_NAME "WIZnet"
+#define DEFAULT_LEASE (900) //default lease time in seconds
+
+#define DHCP_CHECK_NONE (0)
+#define DHCP_CHECK_RENEW_FAIL (1)
+#define DHCP_CHECK_RENEW_OK (2)
+#define DHCP_CHECK_REBIND_FAIL (3)
+#define DHCP_CHECK_REBIND_OK (4)
+
+enum
+{
+ padOption = 0,
+ subnetMask = 1,
+ timerOffset = 2,
+ routersOnSubnet = 3,
+ /* timeServer = 4,
+ nameServer = 5,*/
+ dns = 6,
+ /*logServer = 7,
+ cookieServer = 8,
+ lprServer = 9,
+ impressServer = 10,
+ resourceLocationServer = 11,*/
+ hostName = 12,
+ /*bootFileSize = 13,
+ meritDumpFile = 14,*/
+ domainName = 15,
+ /*swapServer = 16,
+ rootPath = 17,
+ extentionsPath = 18,
+ IPforwarding = 19,
+ nonLocalSourceRouting = 20,
+ policyFilter = 21,
+ maxDgramReasmSize = 22,
+ defaultIPTTL = 23,
+ pathMTUagingTimeout = 24,
+ pathMTUplateauTable = 25,
+ ifMTU = 26,
+ allSubnetsLocal = 27,
+ broadcastAddr = 28,
+ performMaskDiscovery = 29,
+ maskSupplier = 30,
+ performRouterDiscovery = 31,
+ routerSolicitationAddr = 32,
+ staticRoute = 33,
+ trailerEncapsulation = 34,
+ arpCacheTimeout = 35,
+ ethernetEncapsulation = 36,
+ tcpDefaultTTL = 37,
+ tcpKeepaliveInterval = 38,
+ tcpKeepaliveGarbage = 39,
+ nisDomainName = 40,
+ nisServers = 41,
+ ntpServers = 42,
+ vendorSpecificInfo = 43,
+ netBIOSnameServer = 44,
+ netBIOSdgramDistServer = 45,
+ netBIOSnodeType = 46,
+ netBIOSscope = 47,
+ xFontServer = 48,
+ xDisplayManager = 49,*/
+ dhcpRequestedIPaddr = 50,
+ dhcpIPaddrLeaseTime = 51,
+ /*dhcpOptionOverload = 52,*/
+ dhcpMessageType = 53,
+ dhcpServerIdentifier = 54,
+ dhcpParamRequest = 55,
+ /*dhcpMsg = 56,
+ dhcpMaxMsgSize = 57,*/
+ dhcpT1value = 58,
+ dhcpT2value = 59,
+ /*dhcpClassIdentifier = 60,*/
+ dhcpClientIdentifier = 61,
+ endOption = 255
+};
+
+typedef struct __attribute__((packed)) _RIP_MSG_FIXED
+{
+ uint8_t op;
+ uint8_t htype;
+ uint8_t hlen;
+ uint8_t hops;
+ uint32_t xid;
+ uint16_t secs;
+ uint16_t flags;
+ uint8_t ciaddr[4];
+ uint8_t yiaddr[4];
+ uint8_t siaddr[4];
+ uint8_t giaddr[4];
+ uint8_t chaddr[6];
+}RIP_MSG_FIXED;
+
+class DhcpClass {
+private:
+ uint32_t _dhcpInitialTransactionId;
+ uint32_t _dhcpTransactionId;
+ uint8_t _dhcpMacAddr[6];
+ uint8_t _dhcpLocalIp[4];
+ uint8_t _dhcpSubnetMask[4];
+ uint8_t _dhcpGatewayIp[4];
+ uint8_t _dhcpDhcpServerIp[4];
+ uint8_t _dhcpDnsServerIp[4];
+ uint32_t _dhcpLeaseTime;
+ uint32_t _dhcpT1, _dhcpT2;
+ signed long _renewInSec;
+ signed long _rebindInSec;
+ signed long _lastCheck;
+ unsigned long _timeout;
+ unsigned long _responseTimeout;
+ unsigned long _secTimeout;
+ uint8_t _dhcp_state;
+ EthernetUDP _dhcpUdpSocket;
+
+ int request_DHCP_lease();
+ void reset_DHCP_lease();
+ void presend_DHCP();
+ void send_DHCP_MESSAGE(uint8_t, uint16_t);
+ void printByte(char *, uint8_t);
+
+ uint8_t parseDHCPResponse(unsigned long responseTimeout, uint32_t& transactionId);
+public:
+ IPAddress getLocalIp();
+ IPAddress getSubnetMask();
+ IPAddress getGatewayIp();
+ IPAddress getDhcpServerIp();
+ IPAddress getDnsServerIp();
+
+ int beginWithDHCP(uint8_t *, unsigned long timeout = 60000, unsigned long responseTimeout = 4000);
+ int checkLease();
+};
+
+#endif
diff --git a/Ethernet/Dns.cpp b/Ethernet/Dns.cpp
new file mode 100644
index 0000000..62e36f8
--- /dev/null
+++ b/Ethernet/Dns.cpp
@@ -0,0 +1,423 @@
+// Arduino DNS client for WizNet5100-based Ethernet shield
+// (c) Copyright 2009-2010 MCQN Ltd.
+// Released under Apache License, version 2.0
+
+#include "utility/w5100.h"
+#include "EthernetUdp.h"
+#include "utility/util.h"
+
+#include "Dns.h"
+#include
+//#include
+#include "Arduino.h"
+
+
+#define SOCKET_NONE 255
+// Various flags and header field values for a DNS message
+#define UDP_HEADER_SIZE 8
+#define DNS_HEADER_SIZE 12
+#define TTL_SIZE 4
+#define QUERY_FLAG (0)
+#define RESPONSE_FLAG (1<<15)
+#define QUERY_RESPONSE_MASK (1<<15)
+#define OPCODE_STANDARD_QUERY (0)
+#define OPCODE_INVERSE_QUERY (1<<11)
+#define OPCODE_STATUS_REQUEST (2<<11)
+#define OPCODE_MASK (15<<11)
+#define AUTHORITATIVE_FLAG (1<<10)
+#define TRUNCATION_FLAG (1<<9)
+#define RECURSION_DESIRED_FLAG (1<<8)
+#define RECURSION_AVAILABLE_FLAG (1<<7)
+#define RESP_NO_ERROR (0)
+#define RESP_FORMAT_ERROR (1)
+#define RESP_SERVER_FAILURE (2)
+#define RESP_NAME_ERROR (3)
+#define RESP_NOT_IMPLEMENTED (4)
+#define RESP_REFUSED (5)
+#define RESP_MASK (15)
+#define TYPE_A (0x0001)
+#define CLASS_IN (0x0001)
+#define LABEL_COMPRESSION_MASK (0xC0)
+// Port number that DNS servers listen on
+#define DNS_PORT 53
+
+// Possible return codes from ProcessResponse
+#define SUCCESS 1
+#define TIMED_OUT -1
+#define INVALID_SERVER -2
+#define TRUNCATED -3
+#define INVALID_RESPONSE -4
+
+void DNSClient::begin(const IPAddress& aDNSServer)
+{
+ iDNSServer = aDNSServer;
+ iRequestId = 0;
+}
+
+
+int DNSClient::inet_aton(const char* aIPAddrString, IPAddress& aResult)
+{
+ // See if we've been given a valid IP address
+ const char* p =aIPAddrString;
+ while (*p &&
+ ( (*p == '.') || (*p >= '0') || (*p <= '9') ))
+ {
+ p++;
+ }
+
+ if (*p == '\0')
+ {
+ // It's looking promising, we haven't found any invalid characters
+ p = aIPAddrString;
+ int segment =0;
+ int segmentValue =0;
+ while (*p && (segment < 4))
+ {
+ if (*p == '.')
+ {
+ // We've reached the end of a segment
+ if (segmentValue > 255)
+ {
+ // You can't have IP address segments that don't fit in a byte
+ return 0;
+ }
+ else
+ {
+ aResult[segment] = (byte)segmentValue;
+ segment++;
+ segmentValue = 0;
+ }
+ }
+ else
+ {
+ // Next digit
+ segmentValue = (segmentValue*10)+(*p - '0');
+ }
+ p++;
+ }
+ // We've reached the end of address, but there'll still be the last
+ // segment to deal with
+ if ((segmentValue > 255) || (segment > 3))
+ {
+ // You can't have IP address segments that don't fit in a byte,
+ // or more than four segments
+ return 0;
+ }
+ else
+ {
+ aResult[segment] = (byte)segmentValue;
+ return 1;
+ }
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+int DNSClient::getHostByName(const char* aHostname, IPAddress& aResult)
+{
+ int ret =0;
+
+ // See if it's a numeric IP address
+ if (inet_aton(aHostname, aResult))
+ {
+ // It is, our work here is done
+ return 1;
+ }
+
+ // Check we've got a valid DNS server to use
+ if (iDNSServer == INADDR_NONE)
+ {
+ return INVALID_SERVER;
+ }
+
+ // Find a socket to use
+ if (iUdp.begin(1024+(millis() & 0xF)) == 1)
+ {
+ // Try up to three times
+ int retries = 0;
+// while ((retries < 3) && (ret <= 0))
+ {
+ // Send DNS request
+ ret = iUdp.beginPacket(iDNSServer, DNS_PORT);
+ if (ret != 0)
+ {
+ // Now output the request data
+ ret = BuildRequest(aHostname);
+ if (ret != 0)
+ {
+ // And finally send the request
+ ret = iUdp.endPacket();
+ if (ret != 0)
+ {
+ // Now wait for a response
+ int wait_retries = 0;
+ ret = TIMED_OUT;
+ while ((wait_retries < 3) && (ret == TIMED_OUT))
+ {
+ ret = ProcessResponse(5000, aResult);
+ wait_retries++;
+ }
+ }
+ }
+ }
+ retries++;
+ }
+
+ // We're done with the socket now
+ iUdp.stop();
+ }
+
+ return ret;
+}
+
+uint16_t DNSClient::BuildRequest(const char* aName)
+{
+ // Build header
+ // 1 1 1 1 1 1
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | ID |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // |QR| Opcode |AA|TC|RD|RA| Z | RCODE |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | QDCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | ANCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | NSCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | ARCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // As we only support one request at a time at present, we can simplify
+ // some of this header
+ iRequestId = millis(); // generate a random ID
+ uint16_t twoByteBuffer;
+
+ // FIXME We should also check that there's enough space available to write to, rather
+ // FIXME than assume there's enough space (as the code does at present)
+ iUdp.write((uint8_t*)&iRequestId, sizeof(iRequestId));
+
+ twoByteBuffer = htons(QUERY_FLAG | OPCODE_STANDARD_QUERY | RECURSION_DESIRED_FLAG);
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+
+ twoByteBuffer = htons(1); // One question record
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+
+ twoByteBuffer = 0; // Zero answer records
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+ // and zero additional records
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+
+ // Build question
+ const char* start =aName;
+ const char* end =start;
+ uint8_t len;
+ // Run through the name being requested
+ while (*end)
+ {
+ // Find out how long this section of the name is
+ end = start;
+ while (*end && (*end != '.') )
+ {
+ end++;
+ }
+
+ if (end-start > 0)
+ {
+ // Write out the size of this section
+ len = end-start;
+ iUdp.write(&len, sizeof(len));
+ // And then write out the section
+ iUdp.write((uint8_t*)start, end-start);
+ }
+ start = end+1;
+ }
+
+ // We've got to the end of the question name, so
+ // terminate it with a zero-length section
+ len = 0;
+ iUdp.write(&len, sizeof(len));
+ // Finally the type and class of question
+ twoByteBuffer = htons(TYPE_A);
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+
+ twoByteBuffer = htons(CLASS_IN); // Internet class of question
+ iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
+ // Success! Everything buffered okay
+ return 1;
+}
+
+
+uint16_t DNSClient::ProcessResponse(uint16_t aTimeout, IPAddress& aAddress)
+{
+ uint32_t startTime = millis();
+
+ // Wait for a response packet
+ while(iUdp.parsePacket() <= 0)
+ {
+ if((millis() - startTime) > aTimeout)
+ return TIMED_OUT;
+ delay(50);
+ }
+
+ // We've had a reply!
+ // Read the UDP header
+ uint8_t header[DNS_HEADER_SIZE]; // Enough space to reuse for the DNS header
+ // Check that it's a response from the right server and the right port
+ if ( (iDNSServer != iUdp.remoteIP()) ||
+ (iUdp.remotePort() != DNS_PORT) )
+ {
+ // It's not from who we expected
+ return INVALID_SERVER;
+ }
+
+ // Read through the rest of the response
+ if (iUdp.available() < DNS_HEADER_SIZE)
+ {
+ return TRUNCATED;
+ }
+ iUdp.read(header, DNS_HEADER_SIZE);
+
+ uint16_t header_flags = htons(*((uint16_t*)&header[2]));
+ // Check that it's a response to this request
+ if ( ( iRequestId != (*((uint16_t*)&header[0])) ) ||
+ ((header_flags & QUERY_RESPONSE_MASK) != (uint16_t)RESPONSE_FLAG) )
+ {
+ // Mark the entire packet as read
+ iUdp.flush();
+ return INVALID_RESPONSE;
+ }
+ // Check for any errors in the response (or in our request)
+ // although we don't do anything to get round these
+ if ( (header_flags & TRUNCATION_FLAG) || (header_flags & RESP_MASK) )
+ {
+ // Mark the entire packet as read
+ iUdp.flush();
+ return -5; //INVALID_RESPONSE;
+ }
+
+ // And make sure we've got (at least) one answer
+ uint16_t answerCount = htons(*((uint16_t*)&header[6]));
+ if (answerCount == 0 )
+ {
+ // Mark the entire packet as read
+ iUdp.flush();
+ return -6; //INVALID_RESPONSE;
+ }
+
+ // Skip over any questions
+ for (uint16_t i =0; i < htons(*((uint16_t*)&header[4])); i++)
+ {
+ // Skip over the name
+ uint8_t len;
+ do
+ {
+ iUdp.read(&len, sizeof(len));
+ if (len > 0)
+ {
+ // Don't need to actually read the data out for the string, just
+ // advance ptr to beyond it
+ while(len--)
+ {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+ } while (len != 0);
+
+ // Now jump over the type and class
+ for (int i =0; i < 4; i++)
+ {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+
+ // Now we're up to the bit we're interested in, the answer
+ // There might be more than one answer (although we'll just use the first
+ // type A answer) and some authority and additional resource records but
+ // we're going to ignore all of them.
+
+ for (uint16_t i =0; i < answerCount; i++)
+ {
+ // Skip the name
+ uint8_t len;
+ do
+ {
+ iUdp.read(&len, sizeof(len));
+ if ((len & LABEL_COMPRESSION_MASK) == 0)
+ {
+ // It's just a normal label
+ if (len > 0)
+ {
+ // And it's got a length
+ // Don't need to actually read the data out for the string,
+ // just advance ptr to beyond it
+ while(len--)
+ {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+ }
+ else
+ {
+ // This is a pointer to a somewhere else in the message for the
+ // rest of the name. We don't care about the name, and RFC1035
+ // says that a name is either a sequence of labels ended with a
+ // 0 length octet or a pointer or a sequence of labels ending in
+ // a pointer. Either way, when we get here we're at the end of
+ // the name
+ // Skip over the pointer
+ iUdp.read(); // we don't care about the returned byte
+ // And set len so that we drop out of the name loop
+ len = 0;
+ }
+ } while (len != 0);
+
+ // Check the type and class
+ uint16_t answerType;
+ uint16_t answerClass;
+ iUdp.read((uint8_t*)&answerType, sizeof(answerType));
+ iUdp.read((uint8_t*)&answerClass, sizeof(answerClass));
+
+ // Ignore the Time-To-Live as we don't do any caching
+ for (int i =0; i < TTL_SIZE; i++)
+ {
+ iUdp.read(); // we don't care about the returned byte
+ }
+
+ // And read out the length of this answer
+ // Don't need header_flags anymore, so we can reuse it here
+ iUdp.read((uint8_t*)&header_flags, sizeof(header_flags));
+
+ if ( (htons(answerType) == TYPE_A) && (htons(answerClass) == CLASS_IN) )
+ {
+ if (htons(header_flags) != 4)
+ {
+ // It's a weird size
+ // Mark the entire packet as read
+ iUdp.flush();
+ return -9;//INVALID_RESPONSE;
+ }
+ iUdp.read(aAddress.raw_address(), 4);
+ return SUCCESS;
+ }
+ else
+ {
+ // This isn't an answer type we're after, move onto the next one
+ for (uint16_t i =0; i < htons(header_flags); i++)
+ {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+ }
+
+ // Mark the entire packet as read
+ iUdp.flush();
+
+ // If we get here then we haven't found an answer
+ return -10;//INVALID_RESPONSE;
+}
+
diff --git a/Ethernet/Dns.h b/Ethernet/Dns.h
new file mode 100644
index 0000000..6bcb98a
--- /dev/null
+++ b/Ethernet/Dns.h
@@ -0,0 +1,41 @@
+// Arduino DNS client for WizNet5100-based Ethernet shield
+// (c) Copyright 2009-2010 MCQN Ltd.
+// Released under Apache License, version 2.0
+
+#ifndef DNSClient_h
+#define DNSClient_h
+
+#include
+
+class DNSClient
+{
+public:
+ // ctor
+ void begin(const IPAddress& aDNSServer);
+
+ /** Convert a numeric IP address string into a four-byte IP address.
+ @param aIPAddrString IP address to convert
+ @param aResult IPAddress structure to store the returned IP address
+ @result 1 if aIPAddrString was successfully converted to an IP address,
+ else error code
+ */
+ int inet_aton(const char *aIPAddrString, IPAddress& aResult);
+
+ /** Resolve the given hostname to an IP address.
+ @param aHostname Name to be resolved
+ @param aResult IPAddress structure to store the returned IP address
+ @result 1 if aIPAddrString was successfully converted to an IP address,
+ else error code
+ */
+ int getHostByName(const char* aHostname, IPAddress& aResult);
+
+protected:
+ uint16_t BuildRequest(const char* aName);
+ uint16_t ProcessResponse(uint16_t aTimeout, IPAddress& aAddress);
+
+ IPAddress iDNSServer;
+ uint16_t iRequestId;
+ EthernetUDP iUdp;
+};
+
+#endif
diff --git a/Ethernet/Ethernet.cpp b/Ethernet/Ethernet.cpp
new file mode 100644
index 0000000..3eea69a
--- /dev/null
+++ b/Ethernet/Ethernet.cpp
@@ -0,0 +1,136 @@
+#include "utility/w5100.h"
+#include "Ethernet.h"
+#include "Dhcp.h"
+
+// XXX: don't make assumptions about the value of MAX_SOCK_NUM.
+uint8_t EthernetClass::_state[MAX_SOCK_NUM] = {
+ 0, 0, 0, 0 };
+uint16_t EthernetClass::_server_port[MAX_SOCK_NUM] = {
+ 0, 0, 0, 0 };
+
+int EthernetClass::begin(uint8_t *mac_address)
+{
+ static DhcpClass s_dhcp;
+ _dhcp = &s_dhcp;
+
+
+ // Initialise the basic info
+ W5100.init();
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.setMACAddress(mac_address);
+ W5100.setIPAddress(IPAddress(0,0,0,0).raw_address());
+ SPI.endTransaction();
+
+ // Now try to get our config info from a DHCP server
+ int ret = _dhcp->beginWithDHCP(mac_address);
+ if(ret == 1)
+ {
+ // We've successfully found a DHCP server and got our configuration info, so set things
+ // accordingly
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.setIPAddress(_dhcp->getLocalIp().raw_address());
+ W5100.setGatewayIp(_dhcp->getGatewayIp().raw_address());
+ W5100.setSubnetMask(_dhcp->getSubnetMask().raw_address());
+ SPI.endTransaction();
+ _dnsServerAddress = _dhcp->getDnsServerIp();
+ }
+
+ return ret;
+}
+
+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip)
+{
+ // Assume the DNS server will be the machine on the same network as the local IP
+ // but with last octet being '1'
+ IPAddress dns_server = local_ip;
+ dns_server[3] = 1;
+ begin(mac_address, local_ip, dns_server);
+}
+
+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server)
+{
+ // Assume the gateway will be the machine on the same network as the local IP
+ // but with last octet being '1'
+ IPAddress gateway = local_ip;
+ gateway[3] = 1;
+ begin(mac_address, local_ip, dns_server, gateway);
+}
+
+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway)
+{
+ IPAddress subnet(255, 255, 255, 0);
+ begin(mac_address, local_ip, dns_server, gateway, subnet);
+}
+
+void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet)
+{
+ W5100.init();
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.setMACAddress(mac);
+ W5100.setIPAddress(local_ip.raw_address());
+ W5100.setGatewayIp(gateway.raw_address());
+ W5100.setSubnetMask(subnet.raw_address());
+ SPI.endTransaction();
+ _dnsServerAddress = dns_server;
+}
+
+int EthernetClass::maintain(){
+ int rc = DHCP_CHECK_NONE;
+ if(_dhcp != NULL){
+ //we have a pointer to dhcp, use it
+ rc = _dhcp->checkLease();
+ switch ( rc ){
+ case DHCP_CHECK_NONE:
+ //nothing done
+ break;
+ case DHCP_CHECK_RENEW_OK:
+ case DHCP_CHECK_REBIND_OK:
+ //we might have got a new IP.
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.setIPAddress(_dhcp->getLocalIp().raw_address());
+ W5100.setGatewayIp(_dhcp->getGatewayIp().raw_address());
+ W5100.setSubnetMask(_dhcp->getSubnetMask().raw_address());
+ SPI.endTransaction();
+ _dnsServerAddress = _dhcp->getDnsServerIp();
+ break;
+ default:
+ //this is actually a error, it will retry though
+ break;
+ }
+ }
+ return rc;
+}
+
+IPAddress EthernetClass::localIP()
+{
+ IPAddress ret;
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.getIPAddress(ret.raw_address());
+ SPI.endTransaction();
+ return ret;
+}
+
+IPAddress EthernetClass::subnetMask()
+{
+ IPAddress ret;
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.getSubnetMask(ret.raw_address());
+ SPI.endTransaction();
+ return ret;
+}
+
+IPAddress EthernetClass::gatewayIP()
+{
+ IPAddress ret;
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.getGatewayIp(ret.raw_address());
+ SPI.endTransaction();
+ return ret;
+}
+
+IPAddress EthernetClass::dnsServerIP()
+{
+ return _dnsServerAddress;
+}
+
+EthernetClass Ethernet;
diff --git a/Ethernet/Ethernet.h b/Ethernet/Ethernet.h
new file mode 100644
index 0000000..2a07ff3
--- /dev/null
+++ b/Ethernet/Ethernet.h
@@ -0,0 +1,41 @@
+#ifndef ethernet_h
+#define ethernet_h
+
+#include
+//#include "w5100.h"
+#include "IPAddress.h"
+#include "EthernetClient.h"
+#include "EthernetServer.h"
+#include "Dhcp.h"
+
+#define MAX_SOCK_NUM 4
+
+class EthernetClass {
+private:
+ IPAddress _dnsServerAddress;
+ DhcpClass* _dhcp;
+public:
+ static uint8_t _state[MAX_SOCK_NUM];
+ static uint16_t _server_port[MAX_SOCK_NUM];
+ // Initialise the Ethernet shield to use the provided MAC address and gain the rest of the
+ // configuration through DHCP.
+ // Returns 0 if the DHCP configuration failed, and 1 if it succeeded
+ int begin(uint8_t *mac_address);
+ void begin(uint8_t *mac_address, IPAddress local_ip);
+ void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server);
+ void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway);
+ void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet);
+ int maintain();
+
+ IPAddress localIP();
+ IPAddress subnetMask();
+ IPAddress gatewayIP();
+ IPAddress dnsServerIP();
+
+ friend class EthernetClient;
+ friend class EthernetServer;
+};
+
+extern EthernetClass Ethernet;
+
+#endif
diff --git a/Ethernet/EthernetClient.cpp b/Ethernet/EthernetClient.cpp
new file mode 100644
index 0000000..a592bfd
--- /dev/null
+++ b/Ethernet/EthernetClient.cpp
@@ -0,0 +1,168 @@
+#include "utility/w5100.h"
+#include "utility/socket.h"
+
+extern "C" {
+ #include "string.h"
+}
+
+#include "Arduino.h"
+
+#include "Ethernet.h"
+#include "EthernetClient.h"
+#include "EthernetServer.h"
+#include "Dns.h"
+
+uint16_t EthernetClient::_srcport = 49152; //Use IANA recommended ephemeral port range 49152-65535
+
+EthernetClient::EthernetClient() : _sock(MAX_SOCK_NUM) {
+}
+
+EthernetClient::EthernetClient(uint8_t sock) : _sock(sock) {
+}
+
+int EthernetClient::connect(const char* host, uint16_t port) {
+ // Look up the host first
+ int ret = 0;
+ DNSClient dns;
+ IPAddress remote_addr;
+
+ dns.begin(Ethernet.dnsServerIP());
+ ret = dns.getHostByName(host, remote_addr);
+ if (ret == 1) {
+ return connect(remote_addr, port);
+ } else {
+ return ret;
+ }
+}
+
+int EthernetClient::connect(IPAddress ip, uint16_t port) {
+ if (_sock != MAX_SOCK_NUM)
+ return 0;
+
+ for (int i = 0; i < MAX_SOCK_NUM; i++) {
+ uint8_t s = socketStatus(i);
+ if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT || s == SnSR::CLOSE_WAIT) {
+ _sock = i;
+ break;
+ }
+ }
+
+ if (_sock == MAX_SOCK_NUM)
+ return 0;
+
+ _srcport++;
+ if (_srcport == 0) _srcport = 49152; //Use IANA recommended ephemeral port range 49152-65535
+ socket(_sock, SnMR::TCP, _srcport, 0);
+
+ if (!::connect(_sock, rawIPAddress(ip), port)) {
+ _sock = MAX_SOCK_NUM;
+ return 0;
+ }
+
+ while (status() != SnSR::ESTABLISHED) {
+ delay(1);
+ if (status() == SnSR::CLOSED) {
+ _sock = MAX_SOCK_NUM;
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+size_t EthernetClient::write(uint8_t b) {
+ return write(&b, 1);
+}
+
+size_t EthernetClient::write(const uint8_t *buf, size_t size) {
+ if (_sock == MAX_SOCK_NUM) {
+ setWriteError();
+ return 0;
+ }
+ if (!send(_sock, buf, size)) {
+ setWriteError();
+ return 0;
+ }
+ return size;
+}
+
+int EthernetClient::available() {
+ if (_sock != MAX_SOCK_NUM)
+ return recvAvailable(_sock);
+ return 0;
+}
+
+int EthernetClient::read() {
+ uint8_t b;
+ if ( recv(_sock, &b, 1) > 0 )
+ {
+ // recv worked
+ return b;
+ }
+ else
+ {
+ // No data available
+ return -1;
+ }
+}
+
+int EthernetClient::read(uint8_t *buf, size_t size) {
+ return recv(_sock, buf, size);
+}
+
+int EthernetClient::peek() {
+ uint8_t b;
+ // Unlike recv, peek doesn't check to see if there's any data available, so we must
+ if (!available())
+ return -1;
+ ::peek(_sock, &b);
+ return b;
+}
+
+void EthernetClient::flush() {
+ ::flush(_sock);
+}
+
+void EthernetClient::stop() {
+ if (_sock == MAX_SOCK_NUM)
+ return;
+
+ // attempt to close the connection gracefully (send a FIN to other side)
+ disconnect(_sock);
+ unsigned long start = millis();
+
+ // wait a second for the connection to close
+ while (status() != SnSR::CLOSED && millis() - start < 1000)
+ delay(1);
+
+ // if it hasn't closed, close it forcefully
+ if (status() != SnSR::CLOSED)
+ close(_sock);
+
+ EthernetClass::_server_port[_sock] = 0;
+ _sock = MAX_SOCK_NUM;
+}
+
+uint8_t EthernetClient::connected() {
+ if (_sock == MAX_SOCK_NUM) return 0;
+
+ uint8_t s = status();
+ return !(s == SnSR::LISTEN || s == SnSR::CLOSED || s == SnSR::FIN_WAIT ||
+ (s == SnSR::CLOSE_WAIT && !available()));
+}
+
+uint8_t EthernetClient::status() {
+ if (_sock == MAX_SOCK_NUM) return SnSR::CLOSED;
+ return socketStatus(_sock);
+}
+
+// the next function allows us to use the client returned by
+// EthernetServer::available() as the condition in an if-statement.
+
+EthernetClient::operator bool() {
+ return _sock != MAX_SOCK_NUM;
+}
+
+bool EthernetClient::operator==(const EthernetClient& rhs) {
+ return _sock == rhs._sock && _sock != MAX_SOCK_NUM && rhs._sock != MAX_SOCK_NUM;
+}
diff --git a/Ethernet/EthernetClient.h b/Ethernet/EthernetClient.h
new file mode 100644
index 0000000..16e2500
--- /dev/null
+++ b/Ethernet/EthernetClient.h
@@ -0,0 +1,41 @@
+#ifndef ethernetclient_h
+#define ethernetclient_h
+#include "Arduino.h"
+#include "Print.h"
+#include "Client.h"
+#include "IPAddress.h"
+
+class EthernetClient : public Client {
+
+public:
+ EthernetClient();
+ EthernetClient(uint8_t sock);
+
+ uint8_t status();
+ virtual int connect(IPAddress ip, uint16_t port);
+ virtual int connect(const char *host, uint16_t port);
+ virtual size_t write(uint8_t);
+ virtual size_t write(const uint8_t *buf, size_t size);
+ virtual int available();
+ virtual int read();
+ virtual int read(uint8_t *buf, size_t size);
+ virtual int peek();
+ virtual void flush();
+ virtual void stop();
+ virtual uint8_t connected();
+ virtual operator bool();
+ virtual bool operator==(const bool value) { return bool() == value; }
+ virtual bool operator!=(const bool value) { return bool() != value; }
+ virtual bool operator==(const EthernetClient&);
+ virtual bool operator!=(const EthernetClient& rhs) { return !this->operator==(rhs); };
+
+ friend class EthernetServer;
+
+ using Print::write;
+
+private:
+ static uint16_t _srcport;
+ uint8_t _sock;
+};
+
+#endif
diff --git a/Ethernet/EthernetServer.cpp b/Ethernet/EthernetServer.cpp
new file mode 100644
index 0000000..6d6ce8c
--- /dev/null
+++ b/Ethernet/EthernetServer.cpp
@@ -0,0 +1,91 @@
+#include "utility/w5100.h"
+#include "utility/socket.h"
+extern "C" {
+#include "string.h"
+}
+
+#include "Ethernet.h"
+#include "EthernetClient.h"
+#include "EthernetServer.h"
+
+EthernetServer::EthernetServer(uint16_t port)
+{
+ _port = port;
+}
+
+void EthernetServer::begin()
+{
+ for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+ EthernetClient client(sock);
+ if (client.status() == SnSR::CLOSED) {
+ socket(sock, SnMR::TCP, _port, 0);
+ listen(sock);
+ EthernetClass::_server_port[sock] = _port;
+ break;
+ }
+ }
+}
+
+void EthernetServer::accept()
+{
+ int listening = 0;
+
+ for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+ EthernetClient client(sock);
+
+ if (EthernetClass::_server_port[sock] == _port) {
+ if (client.status() == SnSR::LISTEN) {
+ listening = 1;
+ }
+ else if (client.status() == SnSR::CLOSE_WAIT && !client.available()) {
+ client.stop();
+ }
+ }
+ }
+
+ if (!listening) {
+ begin();
+ }
+}
+
+EthernetClient EthernetServer::available()
+{
+ accept();
+
+ for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+ EthernetClient client(sock);
+ if (EthernetClass::_server_port[sock] == _port &&
+ (client.status() == SnSR::ESTABLISHED ||
+ client.status() == SnSR::CLOSE_WAIT)) {
+ if (client.available()) {
+ // XXX: don't always pick the lowest numbered socket.
+ return client;
+ }
+ }
+ }
+
+ return EthernetClient(MAX_SOCK_NUM);
+}
+
+size_t EthernetServer::write(uint8_t b)
+{
+ return write(&b, 1);
+}
+
+size_t EthernetServer::write(const uint8_t *buffer, size_t size)
+{
+ size_t n = 0;
+
+ accept();
+
+ for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+ EthernetClient client(sock);
+
+ if (EthernetClass::_server_port[sock] == _port &&
+ client.status() == SnSR::ESTABLISHED) {
+ n += client.write(buffer, size);
+ }
+ }
+
+ return n;
+}
diff --git a/Ethernet/EthernetServer.h b/Ethernet/EthernetServer.h
new file mode 100644
index 0000000..86ccafe
--- /dev/null
+++ b/Ethernet/EthernetServer.h
@@ -0,0 +1,22 @@
+#ifndef ethernetserver_h
+#define ethernetserver_h
+
+#include "Server.h"
+
+class EthernetClient;
+
+class EthernetServer :
+public Server {
+private:
+ uint16_t _port;
+ void accept();
+public:
+ EthernetServer(uint16_t);
+ EthernetClient available();
+ virtual void begin();
+ virtual size_t write(uint8_t);
+ virtual size_t write(const uint8_t *buf, size_t size);
+ using Print::write;
+};
+
+#endif
diff --git a/Ethernet/EthernetUdp.cpp b/Ethernet/EthernetUdp.cpp
new file mode 100644
index 0000000..b5dcb78
--- /dev/null
+++ b/Ethernet/EthernetUdp.cpp
@@ -0,0 +1,218 @@
+/*
+ * Udp.cpp: Library to send/receive UDP packets with the Arduino ethernet shield.
+ * This version only offers minimal wrapping of socket.c/socket.h
+ * Drop Udp.h/.cpp into the Ethernet library directory at hardware/libraries/Ethernet/
+ *
+ * MIT License:
+ * Copyright (c) 2008 Bjoern Hartmann
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * bjoern@cs.stanford.edu 12/30/2008
+ */
+
+#include "utility/w5100.h"
+#include "utility/socket.h"
+#include "Ethernet.h"
+#include "Udp.h"
+#include "Dns.h"
+
+/* Constructor */
+EthernetUDP::EthernetUDP() : _sock(MAX_SOCK_NUM) {}
+
+/* Start EthernetUDP socket, listening at local port PORT */
+uint8_t EthernetUDP::begin(uint16_t port) {
+ if (_sock != MAX_SOCK_NUM)
+ return 0;
+
+ for (int i = 0; i < MAX_SOCK_NUM; i++) {
+ uint8_t s = socketStatus(i);
+ if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT) {
+ _sock = i;
+ break;
+ }
+ }
+
+ if (_sock == MAX_SOCK_NUM)
+ return 0;
+
+ _port = port;
+ _remaining = 0;
+ socket(_sock, SnMR::UDP, _port, 0);
+
+ return 1;
+}
+
+/* return number of bytes available in the current packet,
+ will return zero if parsePacket hasn't been called yet */
+int EthernetUDP::available() {
+ return _remaining;
+}
+
+/* Release any resources being used by this EthernetUDP instance */
+void EthernetUDP::stop()
+{
+ if (_sock == MAX_SOCK_NUM)
+ return;
+
+ close(_sock);
+
+ EthernetClass::_server_port[_sock] = 0;
+ _sock = MAX_SOCK_NUM;
+}
+
+int EthernetUDP::beginPacket(const char *host, uint16_t port)
+{
+ // Look up the host first
+ int ret = 0;
+ DNSClient dns;
+ IPAddress remote_addr;
+
+ dns.begin(Ethernet.dnsServerIP());
+ ret = dns.getHostByName(host, remote_addr);
+ if (ret == 1) {
+ return beginPacket(remote_addr, port);
+ } else {
+ return ret;
+ }
+}
+
+int EthernetUDP::beginPacket(IPAddress ip, uint16_t port)
+{
+ _offset = 0;
+ return startUDP(_sock, rawIPAddress(ip), port);
+}
+
+int EthernetUDP::endPacket()
+{
+ return sendUDP(_sock);
+}
+
+size_t EthernetUDP::write(uint8_t byte)
+{
+ return write(&byte, 1);
+}
+
+size_t EthernetUDP::write(const uint8_t *buffer, size_t size)
+{
+ uint16_t bytes_written = bufferData(_sock, _offset, buffer, size);
+ _offset += bytes_written;
+ return bytes_written;
+}
+
+int EthernetUDP::parsePacket()
+{
+ // discard any remaining bytes in the last packet
+ flush();
+
+ if (recvAvailable(_sock) > 0)
+ {
+ //HACK - hand-parse the UDP packet using TCP recv method
+ uint8_t tmpBuf[8];
+ int ret =0;
+ //read 8 header bytes and get IP and port from it
+ ret = recv(_sock,tmpBuf,8);
+ if (ret > 0)
+ {
+ _remoteIP = tmpBuf;
+ _remotePort = tmpBuf[4];
+ _remotePort = (_remotePort << 8) + tmpBuf[5];
+ _remaining = tmpBuf[6];
+ _remaining = (_remaining << 8) + tmpBuf[7];
+
+ // When we get here, any remaining bytes are the data
+ ret = _remaining;
+ }
+ return ret;
+ }
+ // There aren't any packets available
+ return 0;
+}
+
+int EthernetUDP::read()
+{
+ uint8_t byte;
+
+ if ((_remaining > 0) && (recv(_sock, &byte, 1) > 0))
+ {
+ // We read things without any problems
+ _remaining--;
+ return byte;
+ }
+
+ // If we get here, there's no data available
+ return -1;
+}
+
+int EthernetUDP::read(unsigned char* buffer, size_t len)
+{
+
+ if (_remaining > 0)
+ {
+
+ int got;
+
+ if (_remaining <= len)
+ {
+ // data should fit in the buffer
+ got = recv(_sock, buffer, _remaining);
+ }
+ else
+ {
+ // too much data for the buffer,
+ // grab as much as will fit
+ got = recv(_sock, buffer, len);
+ }
+
+ if (got > 0)
+ {
+ _remaining -= got;
+ return got;
+ }
+
+ }
+
+ // If we get here, there's no data available or recv failed
+ return -1;
+
+}
+
+int EthernetUDP::peek()
+{
+ uint8_t b;
+ // Unlike recv, peek doesn't check to see if there's any data available, so we must.
+ // If the user hasn't called parsePacket yet then return nothing otherwise they
+ // may get the UDP header
+ if (!_remaining)
+ return -1;
+ ::peek(_sock, &b);
+ return b;
+}
+
+void EthernetUDP::flush()
+{
+ // could this fail (loop endlessly) if _remaining > 0 and recv in read fails?
+ // should only occur if recv fails after telling us the data is there, lets
+ // hope the w5100 always behaves :)
+
+ while (_remaining)
+ {
+ read();
+ }
+}
+
diff --git a/Ethernet/EthernetUdp.h b/Ethernet/EthernetUdp.h
new file mode 100644
index 0000000..8a6b7ab
--- /dev/null
+++ b/Ethernet/EthernetUdp.h
@@ -0,0 +1,99 @@
+/*
+ * Udp.cpp: Library to send/receive UDP packets with the Arduino ethernet shield.
+ * This version only offers minimal wrapping of socket.c/socket.h
+ * Drop Udp.h/.cpp into the Ethernet library directory at hardware/libraries/Ethernet/
+ *
+ * NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
+ * 1) UDP does not guarantee the order in which assembled UDP packets are received. This
+ * might not happen often in practice, but in larger network topologies, a UDP
+ * packet can be received out of sequence.
+ * 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
+ * aware of it. Again, this may not be a concern in practice on small local networks.
+ * For more information, see http://www.cafeaulait.org/course/week12/35.html
+ *
+ * MIT License:
+ * Copyright (c) 2008 Bjoern Hartmann
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * bjoern@cs.stanford.edu 12/30/2008
+ */
+
+#ifndef ethernetudp_h
+#define ethernetudp_h
+
+#include
+
+#define UDP_TX_PACKET_MAX_SIZE 24
+
+class EthernetUDP : public UDP {
+private:
+ uint8_t _sock; // socket ID for Wiz5100
+ uint16_t _port; // local port to listen on
+ IPAddress _remoteIP; // remote IP address for the incoming packet whilst it's being processed
+ uint16_t _remotePort; // remote port for the incoming packet whilst it's being processed
+ uint16_t _offset; // offset into the packet being sent
+ uint16_t _remaining; // remaining bytes of incoming packet yet to be processed
+
+public:
+ EthernetUDP(); // Constructor
+ virtual uint8_t begin(uint16_t); // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+ virtual void stop(); // Finish with the UDP socket
+
+ // Sending UDP packets
+
+ // Start building up a packet to send to the remote host specific in ip and port
+ // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+ virtual int beginPacket(IPAddress ip, uint16_t port);
+ // Start building up a packet to send to the remote host specific in host and port
+ // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+ virtual int beginPacket(const char *host, uint16_t port);
+ // Finish off this packet and send it
+ // Returns 1 if the packet was sent successfully, 0 if there was an error
+ virtual int endPacket();
+ // Write a single byte into the packet
+ virtual size_t write(uint8_t);
+ // Write size bytes from buffer into the packet
+ virtual size_t write(const uint8_t *buffer, size_t size);
+
+ using Print::write;
+
+ // Start processing the next available incoming packet
+ // Returns the size of the packet in bytes, or 0 if no packets are available
+ virtual int parsePacket();
+ // Number of bytes remaining in the current packet
+ virtual int available();
+ // Read a single byte from the current packet
+ virtual int read();
+ // Read up to len bytes from the current packet and place them into buffer
+ // Returns the number of bytes read, or 0 if none are available
+ virtual int read(unsigned char* buffer, size_t len);
+ // Read up to len characters from the current packet and place them into buffer
+ // Returns the number of characters read, or 0 if none are available
+ virtual int read(char* buffer, size_t len) { return read((unsigned char*)buffer, len); };
+ // Return the next byte from the current packet without moving on to the next byte
+ virtual int peek();
+ virtual void flush(); // Finish reading the current packet
+
+ // Return the IP address of the host who sent the current incoming packet
+ virtual IPAddress remoteIP() { return _remoteIP; };
+ // Return the port of the host who sent the current incoming packet
+ virtual uint16_t remotePort() { return _remotePort; };
+};
+
+#endif
diff --git a/Ethernet/utility/socket.cpp b/Ethernet/utility/socket.cpp
new file mode 100644
index 0000000..4ed4317
--- /dev/null
+++ b/Ethernet/utility/socket.cpp
@@ -0,0 +1,469 @@
+#include "utility/w5100.h"
+#include "utility/socket.h"
+
+static uint16_t local_port;
+
+/**
+ * @brief This Socket function initialize the channel in perticular mode, and set the port and wait for W5100 done it.
+ * @return 1 for success else 0.
+ */
+uint8_t socket(SOCKET s, uint8_t protocol, uint16_t port, uint8_t flag)
+{
+ if ((protocol == SnMR::TCP) || (protocol == SnMR::UDP) || (protocol == SnMR::IPRAW) || (protocol == SnMR::MACRAW) || (protocol == SnMR::PPPOE))
+ {
+ close(s);
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.writeSnMR(s, protocol | flag);
+ if (port != 0) {
+ W5100.writeSnPORT(s, port);
+ }
+ else {
+ local_port++; // if don't set the source port, set local_port number.
+ W5100.writeSnPORT(s, local_port);
+ }
+
+ W5100.execCmdSn(s, Sock_OPEN);
+ SPI.endTransaction();
+ return 1;
+ }
+
+ return 0;
+}
+
+
+uint8_t socketStatus(SOCKET s)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ uint8_t status = W5100.readSnSR(s);
+ SPI.endTransaction();
+ return status;
+}
+
+
+/**
+ * @brief This function close the socket and parameter is "s" which represent the socket number
+ */
+void close(SOCKET s)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.execCmdSn(s, Sock_CLOSE);
+ W5100.writeSnIR(s, 0xFF);
+ SPI.endTransaction();
+}
+
+
+/**
+ * @brief This function established the connection for the channel in passive (server) mode. This function waits for the request from the peer.
+ * @return 1 for success else 0.
+ */
+uint8_t listen(SOCKET s)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ if (W5100.readSnSR(s) != SnSR::INIT) {
+ SPI.endTransaction();
+ return 0;
+ }
+ W5100.execCmdSn(s, Sock_LISTEN);
+ SPI.endTransaction();
+ return 1;
+}
+
+
+/**
+ * @brief This function established the connection for the channel in Active (client) mode.
+ * This function waits for the untill the connection is established.
+ *
+ * @return 1 for success else 0.
+ */
+uint8_t connect(SOCKET s, uint8_t * addr, uint16_t port)
+{
+ if
+ (
+ ((addr[0] == 0xFF) && (addr[1] == 0xFF) && (addr[2] == 0xFF) && (addr[3] == 0xFF)) ||
+ ((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
+ (port == 0x00)
+ )
+ return 0;
+
+ // set destination IP
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.writeSnDIPR(s, addr);
+ W5100.writeSnDPORT(s, port);
+ W5100.execCmdSn(s, Sock_CONNECT);
+ SPI.endTransaction();
+
+ return 1;
+}
+
+
+
+/**
+ * @brief This function used for disconnect the socket and parameter is "s" which represent the socket number
+ * @return 1 for success else 0.
+ */
+void disconnect(SOCKET s)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.execCmdSn(s, Sock_DISCON);
+ SPI.endTransaction();
+}
+
+
+/**
+ * @brief This function used to send the data in TCP mode
+ * @return 1 for success else 0.
+ */
+uint16_t send(SOCKET s, const uint8_t * buf, uint16_t len)
+{
+ uint8_t status=0;
+ uint16_t ret=0;
+ uint16_t freesize=0;
+
+ if (len > W5100.SSIZE)
+ ret = W5100.SSIZE; // check size not to exceed MAX size.
+ else
+ ret = len;
+
+ // if freebuf is available, start.
+ do
+ {
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ freesize = W5100.getTXFreeSize(s);
+ status = W5100.readSnSR(s);
+ SPI.endTransaction();
+ if ((status != SnSR::ESTABLISHED) && (status != SnSR::CLOSE_WAIT))
+ {
+ ret = 0;
+ break;
+ }
+ yield();
+ }
+ while (freesize < ret);
+
+ // copy data
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.send_data_processing(s, (uint8_t *)buf, ret);
+ W5100.execCmdSn(s, Sock_SEND);
+
+ /* +2008.01 bj */
+ while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
+ {
+ /* m2008.01 [bj] : reduce code */
+ if ( W5100.readSnSR(s) == SnSR::CLOSED )
+ {
+ SPI.endTransaction();
+ close(s);
+ return 0;
+ }
+ SPI.endTransaction();
+ yield();
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ }
+ /* +2008.01 bj */
+ W5100.writeSnIR(s, SnIR::SEND_OK);
+ SPI.endTransaction();
+ return ret;
+}
+
+
+/**
+ * @brief This function is an application I/F function which is used to receive the data in TCP mode.
+ * It continues to wait for data as much as the application wants to receive.
+ *
+ * @return received data size for success else -1.
+ */
+int16_t recv(SOCKET s, uint8_t *buf, int16_t len)
+{
+ // Check how much data is available
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ int16_t ret = W5100.getRXReceivedSize(s);
+ if ( ret == 0 )
+ {
+ // No data available.
+ uint8_t status = W5100.readSnSR(s);
+ if ( status == SnSR::LISTEN || status == SnSR::CLOSED || status == SnSR::CLOSE_WAIT )
+ {
+ // The remote end has closed its side of the connection, so this is the eof state
+ ret = 0;
+ }
+ else
+ {
+ // The connection is still up, but there's no data waiting to be read
+ ret = -1;
+ }
+ }
+ else if (ret > len)
+ {
+ ret = len;
+ }
+
+ if ( ret > 0 )
+ {
+ W5100.recv_data_processing(s, buf, ret);
+ W5100.execCmdSn(s, Sock_RECV);
+ }
+ SPI.endTransaction();
+ return ret;
+}
+
+
+int16_t recvAvailable(SOCKET s)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ int16_t ret = W5100.getRXReceivedSize(s);
+ SPI.endTransaction();
+ return ret;
+}
+
+
+/**
+ * @brief Returns the first byte in the receive queue (no checking)
+ *
+ * @return
+ */
+uint16_t peek(SOCKET s, uint8_t *buf)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.recv_data_processing(s, buf, 1, 1);
+ SPI.endTransaction();
+ return 1;
+}
+
+
+/**
+ * @brief This function is an application I/F function which is used to send the data for other then TCP mode.
+ * Unlike TCP transmission, The peer's destination address and the port is needed.
+ *
+ * @return This function return send data size for success else -1.
+ */
+uint16_t sendto(SOCKET s, const uint8_t *buf, uint16_t len, uint8_t *addr, uint16_t port)
+{
+ uint16_t ret=0;
+
+ if (len > W5100.SSIZE) ret = W5100.SSIZE; // check size not to exceed MAX size.
+ else ret = len;
+
+ if
+ (
+ ((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
+ ((port == 0x00)) ||(ret == 0)
+ )
+ {
+ /* +2008.01 [bj] : added return value */
+ ret = 0;
+ }
+ else
+ {
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.writeSnDIPR(s, addr);
+ W5100.writeSnDPORT(s, port);
+
+ // copy data
+ W5100.send_data_processing(s, (uint8_t *)buf, ret);
+ W5100.execCmdSn(s, Sock_SEND);
+
+ /* +2008.01 bj */
+ while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
+ {
+ if (W5100.readSnIR(s) & SnIR::TIMEOUT)
+ {
+ /* +2008.01 [bj]: clear interrupt */
+ W5100.writeSnIR(s, (SnIR::SEND_OK | SnIR::TIMEOUT)); /* clear SEND_OK & TIMEOUT */
+ SPI.endTransaction();
+ return 0;
+ }
+ SPI.endTransaction();
+ yield();
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ }
+
+ /* +2008.01 bj */
+ W5100.writeSnIR(s, SnIR::SEND_OK);
+ SPI.endTransaction();
+ }
+ return ret;
+}
+
+
+/**
+ * @brief This function is an application I/F function which is used to receive the data in other then
+ * TCP mode. This function is used to receive UDP, IP_RAW and MAC_RAW mode, and handle the header as well.
+ *
+ * @return This function return received data size for success else -1.
+ */
+uint16_t recvfrom(SOCKET s, uint8_t *buf, uint16_t len, uint8_t *addr, uint16_t *port)
+{
+ uint8_t head[8];
+ uint16_t data_len=0;
+ uint16_t ptr=0;
+
+ if ( len > 0 )
+ {
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ ptr = W5100.readSnRX_RD(s);
+ switch (W5100.readSnMR(s) & 0x07)
+ {
+ case SnMR::UDP :
+ W5100.read_data(s, ptr, head, 0x08);
+ ptr += 8;
+ // read peer's IP address, port number.
+ addr[0] = head[0];
+ addr[1] = head[1];
+ addr[2] = head[2];
+ addr[3] = head[3];
+ *port = head[4];
+ *port = (*port << 8) + head[5];
+ data_len = head[6];
+ data_len = (data_len << 8) + head[7];
+
+ W5100.read_data(s, ptr, buf, data_len); // data copy.
+ ptr += data_len;
+
+ W5100.writeSnRX_RD(s, ptr);
+ break;
+
+ case SnMR::IPRAW :
+ W5100.read_data(s, ptr, head, 0x06);
+ ptr += 6;
+
+ addr[0] = head[0];
+ addr[1] = head[1];
+ addr[2] = head[2];
+ addr[3] = head[3];
+ data_len = head[4];
+ data_len = (data_len << 8) + head[5];
+
+ W5100.read_data(s, ptr, buf, data_len); // data copy.
+ ptr += data_len;
+
+ W5100.writeSnRX_RD(s, ptr);
+ break;
+
+ case SnMR::MACRAW:
+ W5100.read_data(s, ptr, head, 2);
+ ptr+=2;
+ data_len = head[0];
+ data_len = (data_len<<8) + head[1] - 2;
+
+ W5100.read_data(s, ptr, buf, data_len);
+ ptr += data_len;
+ W5100.writeSnRX_RD(s, ptr);
+ break;
+
+ default :
+ break;
+ }
+ W5100.execCmdSn(s, Sock_RECV);
+ SPI.endTransaction();
+ }
+ return data_len;
+}
+
+/**
+ * @brief Wait for buffered transmission to complete.
+ */
+void flush(SOCKET s) {
+ // TODO
+}
+
+uint16_t igmpsend(SOCKET s, const uint8_t * buf, uint16_t len)
+{
+ uint16_t ret=0;
+
+ if (len > W5100.SSIZE)
+ ret = W5100.SSIZE; // check size not to exceed MAX size.
+ else
+ ret = len;
+
+ if (ret == 0)
+ return 0;
+
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.send_data_processing(s, (uint8_t *)buf, ret);
+ W5100.execCmdSn(s, Sock_SEND);
+
+ while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
+ {
+ if (W5100.readSnIR(s) & SnIR::TIMEOUT)
+ {
+ /* in case of igmp, if send fails, then socket closed */
+ /* if you want change, remove this code. */
+ SPI.endTransaction();
+ close(s);
+ return 0;
+ }
+ SPI.endTransaction();
+ yield();
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ }
+
+ W5100.writeSnIR(s, SnIR::SEND_OK);
+ SPI.endTransaction();
+ return ret;
+}
+
+uint16_t bufferData(SOCKET s, uint16_t offset, const uint8_t* buf, uint16_t len)
+{
+ uint16_t ret =0;
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ if (len > W5100.getTXFreeSize(s))
+ {
+ ret = W5100.getTXFreeSize(s); // check size not to exceed MAX size.
+ }
+ else
+ {
+ ret = len;
+ }
+ W5100.send_data_processing_offset(s, offset, buf, ret);
+ SPI.endTransaction();
+ return ret;
+}
+
+int startUDP(SOCKET s, uint8_t* addr, uint16_t port)
+{
+ if
+ (
+ ((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
+ ((port == 0x00))
+ )
+ {
+ return 0;
+ }
+ else
+ {
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.writeSnDIPR(s, addr);
+ W5100.writeSnDPORT(s, port);
+ SPI.endTransaction();
+ return 1;
+ }
+}
+
+int sendUDP(SOCKET s)
+{
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ W5100.execCmdSn(s, Sock_SEND);
+
+ /* +2008.01 bj */
+ while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
+ {
+ if (W5100.readSnIR(s) & SnIR::TIMEOUT)
+ {
+ /* +2008.01 [bj]: clear interrupt */
+ W5100.writeSnIR(s, (SnIR::SEND_OK|SnIR::TIMEOUT));
+ SPI.endTransaction();
+ return 0;
+ }
+ SPI.endTransaction();
+ yield();
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ }
+
+ /* +2008.01 bj */
+ W5100.writeSnIR(s, SnIR::SEND_OK);
+ SPI.endTransaction();
+
+ /* Sent ok */
+ return 1;
+}
+
diff --git a/Ethernet/utility/socket.h b/Ethernet/utility/socket.h
new file mode 100644
index 0000000..37ba854
--- /dev/null
+++ b/Ethernet/utility/socket.h
@@ -0,0 +1,44 @@
+#ifndef _SOCKET_H_
+#define _SOCKET_H_
+
+#include "utility/w5100.h"
+
+extern uint8_t socket(SOCKET s, uint8_t protocol, uint16_t port, uint8_t flag); // Opens a socket(TCP or UDP or IP_RAW mode)
+extern uint8_t socketStatus(SOCKET s);
+extern void close(SOCKET s); // Close socket
+extern uint8_t connect(SOCKET s, uint8_t * addr, uint16_t port); // Establish TCP connection (Active connection)
+extern void disconnect(SOCKET s); // disconnect the connection
+extern uint8_t listen(SOCKET s); // Establish TCP connection (Passive connection)
+extern uint16_t send(SOCKET s, const uint8_t * buf, uint16_t len); // Send data (TCP)
+extern int16_t recv(SOCKET s, uint8_t * buf, int16_t len); // Receive data (TCP)
+extern int16_t recvAvailable(SOCKET s);
+extern uint16_t peek(SOCKET s, uint8_t *buf);
+extern uint16_t sendto(SOCKET s, const uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t port); // Send data (UDP/IP RAW)
+extern uint16_t recvfrom(SOCKET s, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t *port); // Receive data (UDP/IP RAW)
+extern void flush(SOCKET s); // Wait for transmission to complete
+
+extern uint16_t igmpsend(SOCKET s, const uint8_t * buf, uint16_t len);
+
+// Functions to allow buffered UDP send (i.e. where the UDP datagram is built up over a
+// number of calls before being sent
+/*
+ @brief This function sets up a UDP datagram, the data for which will be provided by one
+ or more calls to bufferData and then finally sent with sendUDP.
+ @return 1 if the datagram was successfully set up, or 0 if there was an error
+*/
+extern int startUDP(SOCKET s, uint8_t* addr, uint16_t port);
+/*
+ @brief This function copies up to len bytes of data from buf into a UDP datagram to be
+ sent later by sendUDP. Allows datagrams to be built up from a series of bufferData calls.
+ @return Number of bytes successfully buffered
+*/
+uint16_t bufferData(SOCKET s, uint16_t offset, const uint8_t* buf, uint16_t len);
+/*
+ @brief Send a UDP datagram built up from a sequence of startUDP followed by one or more
+ calls to bufferData.
+ @return 1 if the datagram was successfully sent, or 0 if there was an error
+*/
+int sendUDP(SOCKET s);
+
+#endif
+/* _SOCKET_H_ */
diff --git a/Ethernet/utility/util.h b/Ethernet/utility/util.h
new file mode 100644
index 0000000..33d32a9
--- /dev/null
+++ b/Ethernet/utility/util.h
@@ -0,0 +1,14 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#define htons(x) ( ((x)<< 8 & 0xFF00) | \
+ ((x)>> 8 & 0x00FF) )
+#define ntohs(x) htons(x)
+
+#define htonl(x) ( ((x)<<24 & 0xFF000000UL) | \
+ ((x)<< 8 & 0x00FF0000UL) | \
+ ((x)>> 8 & 0x0000FF00UL) | \
+ ((x)>>24 & 0x000000FFUL) )
+#define ntohl(x) htonl(x)
+
+#endif
diff --git a/Ethernet/utility/w5100.cpp b/Ethernet/utility/w5100.cpp
new file mode 100644
index 0000000..d4b73bf
--- /dev/null
+++ b/Ethernet/utility/w5100.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2010 by Cristian Maglie
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#include
+#include
+
+#include "utility/w5100.h"
+
+// W5100 controller instance
+W5100Class W5100;
+
+#define TX_RX_MAX_BUF_SIZE 2048
+#define TX_BUF 0x1100
+#define RX_BUF (TX_BUF + TX_RX_MAX_BUF_SIZE)
+
+#define TXBUF_BASE 0x4000
+#define RXBUF_BASE 0x6000
+
+void W5100Class::init(void)
+{
+ delay(300);
+
+#if defined(ARDUINO_ARCH_AVR)
+ SPI.begin();
+ initSS();
+#else
+ SPI.begin(SPI_CS);
+ // Set clock to 4Mhz (W5100 should support up to about 14Mhz)
+ SPI.setClockDivider(SPI_CS, 21);
+ SPI.setDataMode(SPI_CS, SPI_MODE0);
+#endif
+ SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
+ writeMR(1< SSIZE)
+ {
+ // Wrap around circular buffer
+ uint16_t size = SSIZE - offset;
+ write(dstAddr, data, size);
+ write(SBASE[s], data + size, len - size);
+ }
+ else {
+ write(dstAddr, data, len);
+ }
+
+ ptr += len;
+ writeSnTX_WR(s, ptr);
+}
+
+
+void W5100Class::recv_data_processing(SOCKET s, uint8_t *data, uint16_t len, uint8_t peek)
+{
+ uint16_t ptr;
+ ptr = readSnRX_RD(s);
+ read_data(s, ptr, data, len);
+ if (!peek)
+ {
+ ptr += len;
+ writeSnRX_RD(s, ptr);
+ }
+}
+
+void W5100Class::read_data(SOCKET s, volatile uint16_t src, volatile uint8_t *dst, uint16_t len)
+{
+ uint16_t size;
+ uint16_t src_mask;
+ uint16_t src_ptr;
+
+ src_mask = src & RMASK;
+ src_ptr = RBASE[s] + src_mask;
+
+ if( (src_mask + len) > RSIZE )
+ {
+ size = RSIZE - src_mask;
+ read(src_ptr, (uint8_t *)dst, size);
+ dst += size;
+ read(RBASE[s], (uint8_t *) dst, len - size);
+ }
+ else
+ read(src_ptr, (uint8_t *) dst, len);
+}
+
+
+uint8_t W5100Class::write(uint16_t _addr, uint8_t _data)
+{
+#if defined(ARDUINO_ARCH_AVR)
+ setSS();
+ SPI.transfer(0xF0);
+ SPI.transfer(_addr >> 8);
+ SPI.transfer(_addr & 0xFF);
+ SPI.transfer(_data);
+ resetSS();
+#else
+ SPI.transfer(SPI_CS, 0xF0, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr >> 8, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr & 0xFF, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _data);
+#endif
+ return 1;
+}
+
+uint16_t W5100Class::write(uint16_t _addr, const uint8_t *_buf, uint16_t _len)
+{
+ for (uint16_t i=0; i<_len; i++)
+ {
+#if defined(ARDUINO_ARCH_AVR)
+ setSS();
+ SPI.transfer(0xF0);
+ SPI.transfer(_addr >> 8);
+ SPI.transfer(_addr & 0xFF);
+ _addr++;
+ SPI.transfer(_buf[i]);
+ resetSS();
+#else
+ SPI.transfer(SPI_CS, 0xF0, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr >> 8, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr & 0xFF, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _buf[i]);
+ _addr++;
+#endif
+ }
+ return _len;
+}
+
+uint8_t W5100Class::read(uint16_t _addr)
+{
+#if defined(ARDUINO_ARCH_AVR)
+ setSS();
+ SPI.transfer(0x0F);
+ SPI.transfer(_addr >> 8);
+ SPI.transfer(_addr & 0xFF);
+ uint8_t _data = SPI.transfer(0);
+ resetSS();
+#else
+ SPI.transfer(SPI_CS, 0x0F, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr >> 8, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr & 0xFF, SPI_CONTINUE);
+ uint8_t _data = SPI.transfer(SPI_CS, 0);
+#endif
+ return _data;
+}
+
+uint16_t W5100Class::read(uint16_t _addr, uint8_t *_buf, uint16_t _len)
+{
+ for (uint16_t i=0; i<_len; i++)
+ {
+#if defined(ARDUINO_ARCH_AVR)
+ setSS();
+ SPI.transfer(0x0F);
+ SPI.transfer(_addr >> 8);
+ SPI.transfer(_addr & 0xFF);
+ _addr++;
+ _buf[i] = SPI.transfer(0);
+ resetSS();
+#else
+ SPI.transfer(SPI_CS, 0x0F, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr >> 8, SPI_CONTINUE);
+ SPI.transfer(SPI_CS, _addr & 0xFF, SPI_CONTINUE);
+ _buf[i] = SPI.transfer(SPI_CS, 0);
+ _addr++;
+#endif
+ }
+ return _len;
+}
+
+void W5100Class::execCmdSn(SOCKET s, SockCMD _cmd) {
+ // Send command to socket
+ writeSnCR(s, _cmd);
+ // Wait for command to complete
+ while (readSnCR(s))
+ ;
+}
diff --git a/Ethernet/utility/w5100.h b/Ethernet/utility/w5100.h
new file mode 100644
index 0000000..c8f22b9
--- /dev/null
+++ b/Ethernet/utility/w5100.h
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) 2010 by Cristian Maglie
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef W5100_H_INCLUDED
+#define W5100_H_INCLUDED
+
+#include
+
+#define SPI_CS 10
+
+#if defined(ARDUINO_ARCH_AVR)
+#define SPI_ETHERNET_SETTINGS SPISettings(4000000, MSBFIRST, SPI_MODE0)
+#else
+#define SPI_ETHERNET_SETTINGS SPI_CS,SPISettings(4000000, MSBFIRST, SPI_MODE0)
+#endif
+
+#define MAX_SOCK_NUM 4
+
+typedef uint8_t SOCKET;
+
+#define IDM_OR 0x8000
+#define IDM_AR0 0x8001
+#define IDM_AR1 0x8002
+#define IDM_DR 0x8003
+/*
+class MR {
+public:
+ static const uint8_t RST = 0x80;
+ static const uint8_t PB = 0x10;
+ static const uint8_t PPPOE = 0x08;
+ static const uint8_t LB = 0x04;
+ static const uint8_t AI = 0x02;
+ static const uint8_t IND = 0x01;
+};
+*/
+/*
+class IR {
+public:
+ static const uint8_t CONFLICT = 0x80;
+ static const uint8_t UNREACH = 0x40;
+ static const uint8_t PPPoE = 0x20;
+ static const uint8_t SOCK0 = 0x01;
+ static const uint8_t SOCK1 = 0x02;
+ static const uint8_t SOCK2 = 0x04;
+ static const uint8_t SOCK3 = 0x08;
+ static inline uint8_t SOCK(SOCKET ch) { return (0x01 << ch); };
+};
+*/
+
+class SnMR {
+public:
+ static const uint8_t CLOSE = 0x00;
+ static const uint8_t TCP = 0x01;
+ static const uint8_t UDP = 0x02;
+ static const uint8_t IPRAW = 0x03;
+ static const uint8_t MACRAW = 0x04;
+ static const uint8_t PPPOE = 0x05;
+ static const uint8_t ND = 0x20;
+ static const uint8_t MULTI = 0x80;
+};
+
+enum SockCMD {
+ Sock_OPEN = 0x01,
+ Sock_LISTEN = 0x02,
+ Sock_CONNECT = 0x04,
+ Sock_DISCON = 0x08,
+ Sock_CLOSE = 0x10,
+ Sock_SEND = 0x20,
+ Sock_SEND_MAC = 0x21,
+ Sock_SEND_KEEP = 0x22,
+ Sock_RECV = 0x40
+};
+
+/*class SnCmd {
+public:
+ static const uint8_t OPEN = 0x01;
+ static const uint8_t LISTEN = 0x02;
+ static const uint8_t CONNECT = 0x04;
+ static const uint8_t DISCON = 0x08;
+ static const uint8_t CLOSE = 0x10;
+ static const uint8_t SEND = 0x20;
+ static const uint8_t SEND_MAC = 0x21;
+ static const uint8_t SEND_KEEP = 0x22;
+ static const uint8_t RECV = 0x40;
+};
+*/
+
+class SnIR {
+public:
+ static const uint8_t SEND_OK = 0x10;
+ static const uint8_t TIMEOUT = 0x08;
+ static const uint8_t RECV = 0x04;
+ static const uint8_t DISCON = 0x02;
+ static const uint8_t CON = 0x01;
+};
+
+class SnSR {
+public:
+ static const uint8_t CLOSED = 0x00;
+ static const uint8_t INIT = 0x13;
+ static const uint8_t LISTEN = 0x14;
+ static const uint8_t SYNSENT = 0x15;
+ static const uint8_t SYNRECV = 0x16;
+ static const uint8_t ESTABLISHED = 0x17;
+ static const uint8_t FIN_WAIT = 0x18;
+ static const uint8_t CLOSING = 0x1A;
+ static const uint8_t TIME_WAIT = 0x1B;
+ static const uint8_t CLOSE_WAIT = 0x1C;
+ static const uint8_t LAST_ACK = 0x1D;
+ static const uint8_t UDP = 0x22;
+ static const uint8_t IPRAW = 0x32;
+ static const uint8_t MACRAW = 0x42;
+ static const uint8_t PPPOE = 0x5F;
+};
+
+class IPPROTO {
+public:
+ static const uint8_t IP = 0;
+ static const uint8_t ICMP = 1;
+ static const uint8_t IGMP = 2;
+ static const uint8_t GGP = 3;
+ static const uint8_t TCP = 6;
+ static const uint8_t PUP = 12;
+ static const uint8_t UDP = 17;
+ static const uint8_t IDP = 22;
+ static const uint8_t ND = 77;
+ static const uint8_t RAW = 255;
+};
+
+class W5100Class {
+
+public:
+ void init();
+
+ /**
+ * @brief This function is being used for copy the data form Receive buffer of the chip to application buffer.
+ *
+ * It calculate the actual physical address where one has to read
+ * the data from Receive buffer. Here also take care of the condition while it exceed
+ * the Rx memory uper-bound of socket.
+ */
+ void read_data(SOCKET s, volatile uint16_t src, volatile uint8_t * dst, uint16_t len);
+
+ /**
+ * @brief This function is being called by send() and sendto() function also.
+ *
+ * This function read the Tx write pointer register and after copy the data in buffer update the Tx write pointer
+ * register. User should read upper byte first and lower byte later to get proper value.
+ */
+ void send_data_processing(SOCKET s, const uint8_t *data, uint16_t len);
+ /**
+ * @brief A copy of send_data_processing that uses the provided ptr for the
+ * write offset. Only needed for the "streaming" UDP API, where
+ * a single UDP packet is built up over a number of calls to
+ * send_data_processing_ptr, because TX_WR doesn't seem to get updated
+ * correctly in those scenarios
+ * @param ptr value to use in place of TX_WR. If 0, then the value is read
+ * in from TX_WR
+ * @return New value for ptr, to be used in the next call
+ */
+// FIXME Update documentation
+ void send_data_processing_offset(SOCKET s, uint16_t data_offset, const uint8_t *data, uint16_t len);
+
+ /**
+ * @brief This function is being called by recv() also.
+ *
+ * This function read the Rx read pointer register
+ * and after copy the data from receive buffer update the Rx write pointer register.
+ * User should read upper byte first and lower byte later to get proper value.
+ */
+ void recv_data_processing(SOCKET s, uint8_t *data, uint16_t len, uint8_t peek = 0);
+
+ inline void setGatewayIp(uint8_t *_addr);
+ inline void getGatewayIp(uint8_t *_addr);
+
+ inline void setSubnetMask(uint8_t *_addr);
+ inline void getSubnetMask(uint8_t *_addr);
+
+ inline void setMACAddress(uint8_t * addr);
+ inline void getMACAddress(uint8_t * addr);
+
+ inline void setIPAddress(uint8_t * addr);
+ inline void getIPAddress(uint8_t * addr);
+
+ inline void setRetransmissionTime(uint16_t timeout);
+ inline void setRetransmissionCount(uint8_t _retry);
+
+ void execCmdSn(SOCKET s, SockCMD _cmd);
+
+ uint16_t getTXFreeSize(SOCKET s);
+ uint16_t getRXReceivedSize(SOCKET s);
+
+
+ // W5100 Registers
+ // ---------------
+private:
+ static uint8_t write(uint16_t _addr, uint8_t _data);
+ static uint16_t write(uint16_t addr, const uint8_t *buf, uint16_t len);
+ static uint8_t read(uint16_t addr);
+ static uint16_t read(uint16_t addr, uint8_t *buf, uint16_t len);
+
+#define __GP_REGISTER8(name, address) \
+ static inline void write##name(uint8_t _data) { \
+ write(address, _data); \
+ } \
+ static inline uint8_t read##name() { \
+ return read(address); \
+ }
+#define __GP_REGISTER16(name, address) \
+ static void write##name(uint16_t _data) { \
+ write(address, _data >> 8); \
+ write(address+1, _data & 0xFF); \
+ } \
+ static uint16_t read##name() { \
+ uint16_t res = read(address); \
+ res = (res << 8) + read(address + 1); \
+ return res; \
+ }
+#define __GP_REGISTER_N(name, address, size) \
+ static uint16_t write##name(uint8_t *_buff) { \
+ return write(address, _buff, size); \
+ } \
+ static uint16_t read##name(uint8_t *_buff) { \
+ return read(address, _buff, size); \
+ }
+
+public:
+ __GP_REGISTER8 (MR, 0x0000); // Mode
+ __GP_REGISTER_N(GAR, 0x0001, 4); // Gateway IP address
+ __GP_REGISTER_N(SUBR, 0x0005, 4); // Subnet mask address
+ __GP_REGISTER_N(SHAR, 0x0009, 6); // Source MAC address
+ __GP_REGISTER_N(SIPR, 0x000F, 4); // Source IP address
+ __GP_REGISTER8 (IR, 0x0015); // Interrupt
+ __GP_REGISTER8 (IMR, 0x0016); // Interrupt Mask
+ __GP_REGISTER16(RTR, 0x0017); // Timeout address
+ __GP_REGISTER8 (RCR, 0x0019); // Retry count
+ __GP_REGISTER8 (RMSR, 0x001A); // Receive memory size
+ __GP_REGISTER8 (TMSR, 0x001B); // Transmit memory size
+ __GP_REGISTER8 (PATR, 0x001C); // Authentication type address in PPPoE mode
+ __GP_REGISTER8 (PTIMER, 0x0028); // PPP LCP Request Timer
+ __GP_REGISTER8 (PMAGIC, 0x0029); // PPP LCP Magic Number
+ __GP_REGISTER_N(UIPR, 0x002A, 4); // Unreachable IP address in UDP mode
+ __GP_REGISTER16(UPORT, 0x002E); // Unreachable Port address in UDP mode
+
+#undef __GP_REGISTER8
+#undef __GP_REGISTER16
+#undef __GP_REGISTER_N
+
+ // W5100 Socket registers
+ // ----------------------
+private:
+ static inline uint8_t readSn(SOCKET _s, uint16_t _addr);
+ static inline uint8_t writeSn(SOCKET _s, uint16_t _addr, uint8_t _data);
+ static inline uint16_t readSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t len);
+ static inline uint16_t writeSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t len);
+
+ static const uint16_t CH_BASE = 0x0400;
+ static const uint16_t CH_SIZE = 0x0100;
+
+#define __SOCKET_REGISTER8(name, address) \
+ static inline void write##name(SOCKET _s, uint8_t _data) { \
+ writeSn(_s, address, _data); \
+ } \
+ static inline uint8_t read##name(SOCKET _s) { \
+ return readSn(_s, address); \
+ }
+#define __SOCKET_REGISTER16(name, address) \
+ static void write##name(SOCKET _s, uint16_t _data) { \
+ writeSn(_s, address, _data >> 8); \
+ writeSn(_s, address+1, _data & 0xFF); \
+ } \
+ static uint16_t read##name(SOCKET _s) { \
+ uint16_t res = readSn(_s, address); \
+ uint16_t res2 = readSn(_s,address + 1); \
+ res = res << 8; \
+ res2 = res2 & 0xFF; \
+ res = res | res2; \
+ return res; \
+ }
+#define __SOCKET_REGISTER_N(name, address, size) \
+ static uint16_t write##name(SOCKET _s, uint8_t *_buff) { \
+ return writeSn(_s, address, _buff, size); \
+ } \
+ static uint16_t read##name(SOCKET _s, uint8_t *_buff) { \
+ return readSn(_s, address, _buff, size); \
+ }
+
+public:
+ __SOCKET_REGISTER8(SnMR, 0x0000) // Mode
+ __SOCKET_REGISTER8(SnCR, 0x0001) // Command
+ __SOCKET_REGISTER8(SnIR, 0x0002) // Interrupt
+ __SOCKET_REGISTER8(SnSR, 0x0003) // Status
+ __SOCKET_REGISTER16(SnPORT, 0x0004) // Source Port
+ __SOCKET_REGISTER_N(SnDHAR, 0x0006, 6) // Destination Hardw Addr
+ __SOCKET_REGISTER_N(SnDIPR, 0x000C, 4) // Destination IP Addr
+ __SOCKET_REGISTER16(SnDPORT, 0x0010) // Destination Port
+ __SOCKET_REGISTER16(SnMSSR, 0x0012) // Max Segment Size
+ __SOCKET_REGISTER8(SnPROTO, 0x0014) // Protocol in IP RAW Mode
+ __SOCKET_REGISTER8(SnTOS, 0x0015) // IP TOS
+ __SOCKET_REGISTER8(SnTTL, 0x0016) // IP TTL
+ __SOCKET_REGISTER16(SnTX_FSR, 0x0020) // TX Free Size
+ __SOCKET_REGISTER16(SnTX_RD, 0x0022) // TX Read Pointer
+ __SOCKET_REGISTER16(SnTX_WR, 0x0024) // TX Write Pointer
+ __SOCKET_REGISTER16(SnRX_RSR, 0x0026) // RX Free Size
+ __SOCKET_REGISTER16(SnRX_RD, 0x0028) // RX Read Pointer
+ __SOCKET_REGISTER16(SnRX_WR, 0x002A) // RX Write Pointer (supported?)
+
+#undef __SOCKET_REGISTER8
+#undef __SOCKET_REGISTER16
+#undef __SOCKET_REGISTER_N
+
+
+private:
+ static const uint8_t RST = 7; // Reset BIT
+
+ static const int SOCKETS = 4;
+ static const uint16_t SMASK = 0x07FF; // Tx buffer MASK
+ static const uint16_t RMASK = 0x07FF; // Rx buffer MASK
+public:
+ static const uint16_t SSIZE = 2048; // Max Tx buffer size
+private:
+ static const uint16_t RSIZE = 2048; // Max Rx buffer size
+ uint16_t SBASE[SOCKETS]; // Tx buffer base address
+ uint16_t RBASE[SOCKETS]; // Rx buffer base address
+
+private:
+#if defined(ARDUINO_ARCH_AVR)
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+ inline static void initSS() { DDRB |= _BV(4); };
+ inline static void setSS() { PORTB &= ~_BV(4); };
+ inline static void resetSS() { PORTB |= _BV(4); };
+#elif defined(__AVR_ATmega32U4__)
+ inline static void initSS() { DDRB |= _BV(6); };
+ inline static void setSS() { PORTB &= ~_BV(6); };
+ inline static void resetSS() { PORTB |= _BV(6); };
+#elif defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB162__)
+ inline static void initSS() { DDRB |= _BV(0); };
+ inline static void setSS() { PORTB &= ~_BV(0); };
+ inline static void resetSS() { PORTB |= _BV(0); };
+#else
+ inline static void initSS() { DDRB |= _BV(2); };
+ inline static void setSS() { PORTB &= ~_BV(2); };
+ inline static void resetSS() { PORTB |= _BV(2); };
+#endif
+#endif // ARDUINO_ARCH_AVR
+};
+
+extern W5100Class W5100;
+
+uint8_t W5100Class::readSn(SOCKET _s, uint16_t _addr) {
+ return read(CH_BASE + _s * CH_SIZE + _addr);
+}
+
+uint8_t W5100Class::writeSn(SOCKET _s, uint16_t _addr, uint8_t _data) {
+ return write(CH_BASE + _s * CH_SIZE + _addr, _data);
+}
+
+uint16_t W5100Class::readSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t _len) {
+ return read(CH_BASE + _s * CH_SIZE + _addr, _buf, _len);
+}
+
+uint16_t W5100Class::writeSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t _len) {
+ return write(CH_BASE + _s * CH_SIZE + _addr, _buf, _len);
+}
+
+void W5100Class::getGatewayIp(uint8_t *_addr) {
+ readGAR(_addr);
+}
+
+void W5100Class::setGatewayIp(uint8_t *_addr) {
+ writeGAR(_addr);
+}
+
+void W5100Class::getSubnetMask(uint8_t *_addr) {
+ readSUBR(_addr);
+}
+
+void W5100Class::setSubnetMask(uint8_t *_addr) {
+ writeSUBR(_addr);
+}
+
+void W5100Class::getMACAddress(uint8_t *_addr) {
+ readSHAR(_addr);
+}
+
+void W5100Class::setMACAddress(uint8_t *_addr) {
+ writeSHAR(_addr);
+}
+
+void W5100Class::getIPAddress(uint8_t *_addr) {
+ readSIPR(_addr);
+}
+
+void W5100Class::setIPAddress(uint8_t *_addr) {
+ writeSIPR(_addr);
+}
+
+void W5100Class::setRetransmissionTime(uint16_t _timeout) {
+ writeRTR(_timeout);
+}
+
+void W5100Class::setRetransmissionCount(uint8_t _retry) {
+ writeRCR(_retry);
+}
+
+#endif
diff --git a/MQTT/PubSubClient.cpp b/MQTT/PubSubClient.cpp
new file mode 100755
index 0000000..e2e049a
--- /dev/null
+++ b/MQTT/PubSubClient.cpp
@@ -0,0 +1,365 @@
+/*
+ PubSubClient.cpp - A simple client for MQTT.
+ Nicholas O'Leary
+ http://knolleary.net
+*/
+
+#include "PubSubClient.h"
+#include
+
+PubSubClient::PubSubClient(Client& client) {
+ this->_client = &client;
+}
+
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, void (*callback)(char*,uint8_t*,unsigned int), Client& client) {
+ this->_client = &client;
+ this->callback = callback;
+ this->ip = ip;
+ this->port = port;
+}
+
+PubSubClient::PubSubClient(char* domain, uint16_t port, void (*callback)(char*,uint8_t*,unsigned int), Client& client) {
+ this->_client = &client;
+ this->callback = callback;
+ this->domain = domain;
+ this->port = port;
+}
+
+boolean PubSubClient::connect(char *id) {
+ return connect(id,NULL,NULL,0,0,0,0);
+}
+
+boolean PubSubClient::connect(char *id, char *user, char *pass) {
+ return connect(id,user,pass,0,0,0,0);
+}
+
+boolean PubSubClient::connect(char *id, char* willTopic, uint8_t willQos, uint8_t willRetain, char* willMessage)
+{
+ return connect(id,NULL,NULL,willTopic,willQos,willRetain,willMessage);
+}
+
+boolean PubSubClient::connect(char *id, char *user, char *pass, char* willTopic, uint8_t willQos, uint8_t willRetain, char* willMessage) {
+// if (!connected()) {
+ if (true) {
+ int result = 0;
+
+ if (domain != NULL) {
+ result = _client->connect(this->domain, this->port);
+ } else {
+ result = _client->connect(this->ip, this->port);
+ }
+
+ if (result) {
+ nextMsgId = 1;
+ uint8_t d[9] = {0x00,0x06,'M','Q','I','s','d','p',MQTTPROTOCOLVERSION};
+ // Leave room in the buffer for header and variable length field
+ uint16_t length = 5;
+ unsigned int j;
+ for (j = 0;j<9;j++) {
+ buffer[length++] = d[j];
+ }
+
+ uint8_t v;
+ if (willTopic) {
+ v = 0x06|(willQos<<3)|(willRetain<<5);
+ } else {
+ v = 0x02;
+ }
+
+ if(user != NULL) {
+ v = v|0x80;
+
+ if(pass != NULL) {
+ v = v|(0x80>>1);
+ }
+ }
+
+ buffer[length++] = v;
+
+ buffer[length++] = ((MQTT_KEEPALIVE) >> 8);
+ buffer[length++] = ((MQTT_KEEPALIVE) & 0xFF);
+ length = writeString(id,buffer,length);
+ if (willTopic) {
+ length = writeString(willTopic,buffer,length);
+ length = writeString(willMessage,buffer,length);
+ }
+
+ if(user != NULL) {
+ length = writeString(user,buffer,length);
+ if(pass != NULL) {
+ length = writeString(pass,buffer,length);
+ }
+ }
+
+ write(MQTTCONNECT,buffer,length-5);
+
+ lastInActivity = lastOutActivity = millis();
+
+ while (!_client->available()) {
+ unsigned long t = millis();
+ if (t-lastInActivity > MQTT_KEEPALIVE*1000UL) {
+ _client->stop();
+ return false;
+ }
+ }
+ uint16_t len = readPacket();
+
+ if (len == 4 && buffer[3] == 0) {
+ lastInActivity = millis();
+ pingOutstanding = false;
+ return true;
+ }
+ }
+ _client->stop();
+ }
+ return false;
+}
+
+uint8_t PubSubClient::readByte() {
+ while(!_client->available()) {}
+ return _client->read();
+}
+
+uint16_t PubSubClient::readPacket() {
+ uint16_t len = 0;
+ buffer[len++] = readByte();
+ uint8_t multiplier = 1;
+ uint16_t length = 0;
+ uint8_t digit = 0;
+ do {
+ digit = readByte();
+ buffer[len++] = digit;
+ length += (digit & 127) * multiplier;
+ multiplier *= 128;
+ } while ((digit & 128) != 0);
+
+ for (uint16_t i = 0;i MQTT_KEEPALIVE*1000UL) || (t - lastOutActivity > MQTT_KEEPALIVE*1000UL)) {
+ if (pingOutstanding) {
+ _client->stop();
+ return false;
+ } else {
+ buffer[0] = MQTTPINGREQ;
+ buffer[1] = 0;
+ _client->write(buffer,2);
+ lastOutActivity = t;
+ lastInActivity = t;
+ pingOutstanding = true;
+ }
+ }
+ if (_client->available()) {
+ uint16_t len = readPacket();
+ if (len > 0) {
+ lastInActivity = t;
+ uint8_t type = buffer[0]&0xF0;
+ if (type == MQTTPUBLISH) {
+ if (callback) {
+ uint16_t tl = (buffer[2]<<8)+buffer[3];
+ char topic[tl+1];
+ for (uint16_t i=0;iwrite(buffer,2);
+ } else if (type == MQTTPINGRESP) {
+ pingOutstanding = false;
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+boolean PubSubClient::publish(char* topic, char* payload) {
+ return publish(topic,(uint8_t*)payload,strlen(payload),false);
+}
+
+boolean PubSubClient::publish(char* topic, uint8_t* payload, unsigned int plength) {
+ return publish(topic, payload, plength, false);
+}
+
+boolean PubSubClient::publish(char* topic, uint8_t* payload, unsigned int plength, boolean retained) {
+ if (connected()) {
+ // Leave room in the buffer for header and variable length field
+ uint16_t length = 5;
+ length = writeString(topic,buffer,length);
+ uint16_t i;
+ for (i=0;i 0) {
+ digit |= 0x80;
+ }
+ buffer[pos++] = digit;
+ llen++;
+ } while(len>0);
+
+ pos = writeString(topic,buffer,pos);
+
+ rc += _client->write(buffer,pos);
+
+ for (i=0;iwrite((char)pgm_read_byte_near(payload + i));
+ }
+
+ lastOutActivity = millis();
+ return rc == len + 1 + plength;
+}
+
+boolean PubSubClient::write(uint8_t header, uint8_t* buf, uint16_t length) {
+ uint8_t lenBuf[4];
+ uint8_t llen = 0;
+ uint8_t digit;
+ uint8_t pos = 0;
+ uint8_t rc;
+ uint16_t len = length;
+ do {
+ digit = len % 128;
+ len = len / 128;
+ if (len > 0) {
+ digit |= 0x80;
+ }
+ lenBuf[pos++] = digit;
+ llen++;
+ } while(len>0);
+
+ buf[4-llen] = header;
+ for (int i=0;iwrite(buf+(4-llen),length+1+llen);
+
+ const size_t SEND_AT_ONCE = 64;
+ size_t remains = length + 1 + llen;
+ // Serial.print("write len: "); Serial.println(remains);
+ const uint8_t *writebuf = buf + (4 - llen);
+ bool result = true;
+ while ((remains > 0) && result) {
+ size_t actuallySendChars = (remains > SEND_AT_ONCE) ? SEND_AT_ONCE : remains;
+ // Serial.print("tbs: "); Serial.println(actuallySendChars);
+ size_t sentChars = _client->write(writebuf, actuallySendChars);
+ result = sentChars == actuallySendChars;
+ remains -= sentChars;
+ writebuf += sentChars;
+ }
+
+
+ lastOutActivity = millis();
+// return (rc == 1+llen+length);
+ return result;
+}
+
+
+boolean PubSubClient::subscribe(char* topic) {
+ if (connected()) {
+ // Leave room in the buffer for header and variable length field
+ uint16_t length = 7;
+ nextMsgId++;
+ if (nextMsgId == 0) {
+ nextMsgId = 1;
+ }
+ buffer[0] = (nextMsgId >> 8);
+ buffer[1] = (nextMsgId & 0xFF);
+ length = writeString(topic, buffer,length);
+ buffer[length++] = 0; // Only do QoS 0 subs
+ return write(MQTTSUBSCRIBE|MQTTQOS1,buffer,length-5);
+ }
+ return false;
+}
+
+void PubSubClient::disconnect() {
+ buffer[0] = MQTTDISCONNECT;
+ buffer[1] = 0;
+ _client->write(buffer,2);
+ _client->stop();
+ lastInActivity = lastOutActivity = millis();
+}
+
+uint16_t PubSubClient::writeString(char* string, uint8_t* buf, uint16_t pos) {
+ char* idp = string;
+ uint16_t i = 0;
+ pos += 2;
+ while (*idp) {
+ buf[pos++] = *idp++;
+ i++;
+ }
+ buf[pos-i-2] = (i >> 8);
+ buf[pos-i-1] = (i & 0xFF);
+ return pos;
+}
+
+
+boolean PubSubClient::connected() {
+ int rc = (int)_client->connected();
+ //Serial.print("rc: "); Serial.println(rc);
+ if (!rc) {
+ //Serial.println("would stop");
+ _client->stop();
+ // while (true);
+ }
+ return rc;
+}
+
diff --git a/MQTT/PubSubClient.h b/MQTT/PubSubClient.h
new file mode 100755
index 0000000..539e411
--- /dev/null
+++ b/MQTT/PubSubClient.h
@@ -0,0 +1,75 @@
+/*
+ PubSubClient.h - A simple client for MQTT.
+ Nicholas O'Leary
+ http://knolleary.net
+*/
+
+#ifndef PubSubClient_h
+#define PubSubClient_h
+
+#include
+#include "Client.h"
+
+// MQTT_MAX_PACKET_SIZE : Maximum packet size
+#define MQTT_MAX_PACKET_SIZE 1024
+
+// MQTT_KEEPALIVE : keepAlive interval in Seconds
+#define MQTT_KEEPALIVE 15
+
+#define MQTTPROTOCOLVERSION 3
+#define MQTTCONNECT 1 << 4 // Client request to connect to Server
+#define MQTTCONNACK 2 << 4 // Connect Acknowledgment
+#define MQTTPUBLISH 3 << 4 // Publish message
+#define MQTTPUBACK 4 << 4 // Publish Acknowledgment
+#define MQTTPUBREC 5 << 4 // Publish Received (assured delivery part 1)
+#define MQTTPUBREL 6 << 4 // Publish Release (assured delivery part 2)
+#define MQTTPUBCOMP 7 << 4 // Publish Complete (assured delivery part 3)
+#define MQTTSUBSCRIBE 8 << 4 // Client Subscribe request
+#define MQTTSUBACK 9 << 4 // Subscribe Acknowledgment
+#define MQTTUNSUBSCRIBE 10 << 4 // Client Unsubscribe request
+#define MQTTUNSUBACK 11 << 4 // Unsubscribe Acknowledgment
+#define MQTTPINGREQ 12 << 4 // PING Request
+#define MQTTPINGRESP 13 << 4 // PING Response
+#define MQTTDISCONNECT 14 << 4 // Client is Disconnecting
+#define MQTTReserved 15 << 4 // Reserved
+
+#define MQTTQOS0 (0 << 1)
+#define MQTTQOS1 (1 << 1)
+#define MQTTQOS2 (2 << 1)
+
+class PubSubClient {
+private:
+ Client* _client;
+ uint8_t buffer[MQTT_MAX_PACKET_SIZE];
+ uint16_t nextMsgId;
+ unsigned long lastOutActivity;
+ unsigned long lastInActivity;
+ bool pingOutstanding;
+ void (*callback)(char*,uint8_t*,unsigned int);
+ uint16_t readPacket();
+ uint8_t readByte();
+ boolean write(uint8_t header, uint8_t* buf, uint16_t length);
+ uint16_t writeString(char* string, uint8_t* buf, uint16_t pos);
+ uint8_t *ip;
+ char* domain;
+ uint16_t port;
+public:
+ PubSubClient(Client& client);
+ PubSubClient(uint8_t *, uint16_t, void(*)(char*,uint8_t*,unsigned int),Client& client);
+ PubSubClient(char*, uint16_t, void(*)(char*,uint8_t*,unsigned int),Client& client);
+ boolean connect(char *);
+ boolean connect(char *, char *, char *);
+ boolean connect(char *, char *, uint8_t, uint8_t, char *);
+ boolean connect(char *, char *, char *, char *, uint8_t, uint8_t, char*);
+ void disconnect();
+ boolean publish(char *, char *);
+ boolean publish(char *, uint8_t *, unsigned int);
+ boolean publish(char *, uint8_t *, unsigned int, boolean);
+ boolean publish_P(char *, uint8_t PROGMEM *, unsigned int, boolean);
+ boolean subscribe(char *);
+ boolean loop();
+ boolean connected();
+};
+
+
+#endif
diff --git a/Metro/Metro.cpp b/Metro/Metro.cpp
new file mode 100644
index 0000000..3d13747
--- /dev/null
+++ b/Metro/Metro.cpp
@@ -0,0 +1,73 @@
+
+#if defined(ARDUINO) && ARDUINO >= 100
+#include "Arduino.h"
+#else
+#include "WProgram.h"
+#endif
+#include "Metro.h"
+
+
+Metro::Metro(unsigned long interval_millis)
+{
+ this->autoreset = 0;
+ interval(interval_millis);
+ reset();
+}
+
+// New creator so I can use either the original check behavior or benjamin.soelberg's
+// suggested one (see below).
+// autoreset = 0 is benjamin.soelberg's check behavior
+// autoreset != 0 is the original behavior
+
+Metro::Metro(unsigned long interval_millis, uint8_t autoreset)
+{
+ this->autoreset = autoreset; // Fix by Paul Bouchier
+ interval(interval_millis);
+ reset();
+}
+
+void Metro::interval(unsigned long interval_millis)
+{
+ this->interval_millis = interval_millis;
+}
+
+// Benjamin.soelberg's check behavior:
+// When a check is true, add the interval to the internal counter.
+// This should guarantee a better overall stability.
+
+// Original check behavior:
+// When a check is true, add the interval to the current millis() counter.
+// This method can add a certain offset over time.
+
+char Metro::check()
+{
+ if (millis() - this->previous_millis >= this->interval_millis) {
+ // As suggested by benjamin.soelberg@gmail.com, the following line
+ // this->previous_millis = millis();
+ // was changed to
+ // this->previous_millis += this->interval_millis;
+
+ // If the interval is set to 0 we revert to the original behavior
+ if (this->interval_millis <= 0 || this->autoreset ) {
+ this->previous_millis = millis();
+ } else {
+ this->previous_millis += this->interval_millis;
+ }
+
+ return 1;
+ }
+
+
+
+ return 0;
+
+}
+
+void Metro::reset()
+{
+
+ this->previous_millis = millis();
+
+}
+
+
diff --git a/Metro/Metro.h b/Metro/Metro.h
new file mode 100644
index 0000000..cb21776
--- /dev/null
+++ b/Metro/Metro.h
@@ -0,0 +1,26 @@
+
+
+#ifndef Metro_h
+#define Metro_h
+
+#include
+
+class Metro
+{
+
+public:
+ Metro(unsigned long interval_millis);
+ Metro(unsigned long interval_millis, uint8_t autoreset);
+ void interval(unsigned long interval_millis);
+ char check();
+ void reset();
+
+private:
+ uint8_t autoreset;
+ unsigned long previous_millis, interval_millis;
+
+};
+
+#endif
+
+
diff --git a/PString/PString.cpp b/PString/PString.cpp
new file mode 100644
index 0000000..e9a3044
--- /dev/null
+++ b/PString/PString.cpp
@@ -0,0 +1,60 @@
+/*
+ PString.cpp - Lightweight printable string class
+ Copyright (c) 2009-2012 Mikal Hart. All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#include "PString.h"
+
+void PString::begin()
+{
+ _cur = _buf;
+ if (_size > 0)
+ _buf[0] = '\0';
+}
+
+#if defined(ARDUINO) && ARDUINO >= 100
+size_t PString::write(uint8_t b)
+#else
+void PString::write(uint8_t b)
+#endif
+{
+ if (_cur + 1 < _buf + _size)
+ {
+ *_cur++ = (char)b;
+ *_cur = '\0';
+#if defined(ARDUINO) && ARDUINO >= 100
+ return 1;
+#endif
+ }
+
+#if defined(ARDUINO) && ARDUINO >= 100
+ return 0;
+#endif
+}
+
+int PString::format(char *str, ...)
+{
+ va_list argptr;
+ va_start(argptr, str);
+ int ret = vsnprintf(_cur, _size - (_cur - _buf), str, argptr);
+ if (_size)
+ while (*_cur)
+ ++_cur;
+ return ret;
+}
+
+
diff --git a/PString/PString.h b/PString/PString.h
new file mode 100644
index 0000000..5be6f06
--- /dev/null
+++ b/PString/PString.h
@@ -0,0 +1,87 @@
+/*
+ PString.h - Lightweight printable string class
+ Copyright (c) 2009-2012 Mikal Hart. All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef PString_h
+#define PString_h
+
+#include "Print.h"
+#include
+#include
+#include
+#include
+
+#define PSTRING_LIBRARY_VERSION 3
+
+class PString : public Print
+{
+private:
+ char *_buf, *_cur;
+ size_t _size;
+public:
+#if defined(ARDUINO) && ARDUINO >= 100
+ virtual size_t write(uint8_t);
+#else
+ virtual void write(uint8_t);
+#endif
+
+public:
+
+ // Basic constructor requires a preallocated buffer
+ PString(char *buf, size_t size) : _buf(buf), _size(size)
+ { begin(); }
+
+ // templated constructors allow inline renderings of this type: PString(buf, size, myfloat[, modifier]);
+ template PString(char *buf, size_t size, T arg) : _buf(buf), _size(size)
+ { begin(); print(arg); }
+
+ template PString(char *buf, size_t size, T arg, int modifier) : _buf(buf), _size(size)
+ { begin(); print(arg, modifier); }
+
+ // returns the length of the current string, not counting the 0 terminator
+ inline const size_t length()
+ { return _cur - _buf; }
+
+ // returns the capacity of the string
+ inline const size_t capacity()
+ { return _size; }
+
+ // gives access to the internal string
+ inline operator const char *()
+ { return _buf; }
+
+ // compare to another string
+ bool operator==(const char *str)
+ { return _size > 0 && !strcmp(_buf, str); }
+
+ // call this to re-use an existing string
+ void begin();
+
+ // This function allows assignment to an arbitrary scalar value like str = myfloat;
+ template inline PString &operator =(T arg)
+ { begin(); print(arg); return *this; }
+
+ // Concatenation str += myfloat;
+ template inline PString &operator +=(T arg)
+ { print(arg); return *this; }
+
+ // Safe access to sprintf-like formatting, e.g. str.format("Hi, my name is %s and I'm %d years old", name, age);
+ int format(char *str, ...);
+};
+
+#endif
\ No newline at end of file
diff --git a/RelayBox.cpp b/RelayBox.cpp
index 1a41272..d948964 100644
--- a/RelayBox.cpp
+++ b/RelayBox.cpp
@@ -1,15 +1,113 @@
#include "RelayBox.h"
#include "hardware.h"
#include
+#include
+#include
+#include
+#include
+#include
+#include
+uint8_t mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x51, 0x07 };
+
+EthernetClient ethClient;
+
+void callback(char* topic, byte* payload, unsigned int length);
+
+// char server[] = "mqttbroker";
+char server[] = "192.168.75.1";
+PubSubClient client(server, 1883, callback, ethClient);
+uint8_t disconnectState = 0;
+uint32_t disconnectTime = 0;
+
+
+Metro minute = Metro(60000);
+Metro second = Metro(1000);
+uint32_t uptime;
+
+
+
+
Switch switches[NUM_OF_LINES];
+
+void callback(char* topic, byte* payload, unsigned int length) {
+ const uint8_t BUFSIZE = 128;
+ if ((length + 1) >= BUFSIZE) { // 1 for terminating NUL
+ Serial << "Received message too long, ignore it" << endl;
+ } else {
+ char buffer[BUFSIZE];
+ memcpy(buffer, payload, length);
+ *(buffer + length) = 0;
+ Serial << "Received message: " << length << ", " << String(topic) << ", " << String(buffer) << endl;
+
+ char *paramPtr = buffer;
+ char *commandStr = 0;
+ char *indexStr = 0;
+ char *stateStr = 0;
+ if ((paramPtr != 0) && (*paramPtr != 0)){
+ // command
+ commandStr = strsep(¶mPtr, " ");
+ }
+ if ((paramPtr != 0) && (*paramPtr != 0)){
+ indexStr = strsep(¶mPtr, " ");
+ }
+ if ((paramPtr != 0) && (*paramPtr != 0)){
+ stateStr = strsep(¶mPtr, " ");
+ }
+
+ if ((commandStr != 0) && (*commandStr != 0) &&
+ (indexStr != 0) && (*indexStr != 0) &&
+ (stateStr != 0) && (*stateStr != 0)) {
+ String command = String(commandStr);
+ int index = atoi(indexStr);
+ String state = String(stateStr);
+ bool validCommand = command.equals("switch");
+ bool validIndex = ! ((index < 0) || (index >= NUM_OF_LINES));
+
+ if (validCommand && validIndex) {
+ if (state.equalsIgnoreCase("on")) {
+ switches[index].on();
+ } else if (state.equalsIgnoreCase("off")) {
+ switches[index].off();
+ } else if (state.equalsIgnoreCase("toggle")) {
+ switches[index].toggle();
+ } else {
+ Serial << "Invalid state " << state << endl;
+ }
+ } else {
+ if (! validCommand) {
+ Serial << "Invalid command " << commandStr << endl;
+ }
+ if (! validIndex) {
+ Serial << "Invalid index " << indexStr << endl;
+ }
+ }
+ }
+ }
+}
+
+
+
+
void setup() {
Serial.begin(9600);
+
+ Serial << "Starting ... " << endl;
+
+ Ethernet.begin(mac);
+ Serial << "Got IP address: " << Ethernet.localIP() << endl;
+
+ disconnectState = 3;
+ disconnectTime = millis();
+
+ uptime = 0;
+
+
for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
switches[i].begin(FEEDBACK_PIN[i], BUTTON_PIN[i], RELAY_PIN[i], LED_PIN[i]);
}
@@ -24,38 +122,116 @@ void loop() {
for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
switches[i].exec();
}
-#else
- for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
- digitalWrite(RELAY_PIN[i], false);
- digitalWrite(LED_PIN[i], false);
- }
- delay(500);
- for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
- digitalWrite(RELAY_PIN[i], true);
- delay(100);
- }
- delay(500);
- for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
- digitalWrite(RELAY_PIN[i], false);
- delay(100);
- }
- delay(500);
- for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
- digitalWrite(LED_PIN[i], true);
- delay(100);
- }
- delay(500);
- for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
- digitalWrite(LED_PIN[i], false);
- delay(100);
- }
- delay(100);
- while (true) {
- for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
- digitalWrite(LED_PIN[i], digitalRead(FEEDBACK_PIN[i]));
- digitalWrite(RELAY_PIN[i], digitalRead(BUTTON_PIN[i]));
+ if (minute.check() == 1) {
+ byte r = Ethernet.maintain();
+ Serial << "Ethernet.maintain: " << r << endl;
+ if ((r == DHCP_CHECK_REBIND_FAIL) || (r == DHCP_CHECK_RENEW_FAIL)) {
}
}
+
+ if ((disconnectState == 0) && (! client.loop())) {
+ disconnectState = 1;
+ }
+
+ switch (disconnectState) {
+ case 0:
+ // Serial.println("discState 0");
+ // everything fine
+ break;
+ case 1:
+ Serial.println("discState 1");
+ client.disconnect();
+ disconnectTime = millis();
+ disconnectState = 2;
+ break;
+ case 2:
+ Serial.println("discState 3");
+ if (disconnectTime + 2000 < millis()) {
+ disconnectState = 3;
+ }
+ break;
+ case 3:
+ Serial.println("discState 3");
+ if (client.connect("RelayBox")) {
+ client.subscribe("IoT/Command/RelayBox");
+ disconnectTime = millis();
+ disconnectState = 0;
+ } else {
+ disconnectState = 1;
+ }
+ break;
+ default:
+ disconnectState = 0;
+ break;
+ }
+
+
+
+ if (second.check() == 1) {
+ uptime++;
+
+ Serial.println("tick");
+
+ if (disconnectState == 0) {
+ String msg = String("{ \"metadata\": { \"device\": \"RelayBox\" }, \"data\": { \"uptime\": ") + uptime + String("}}");
+ client.publish("IoT/Heartbeat/RelayBox", (char*)msg.c_str());
+
+ char strbuf[768];
+ memset(strbuf, sizeof(strbuf), 0);
+ PString buf = PString(strbuf, sizeof(strbuf));
+ buf << "{ \"metadata\": { \"device\": \"RelayBox\" }, " <<
+ "\"data\": {" <<
+ "\"switchStates\": [";
+ for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ if (i != 0) {
+ buf << ", ";
+ }
+ buf << "{ \"index\": " << i << ", " <<
+ "\"state\": " << switches[i].getState() << ", " <<
+ "\"feedbackState\": " << switches[i].getFeedback() << ", " <<
+ "\"stateConflict\": " << switches[i].getStateConflict() << " }";
+ }
+ buf << "], " <<
+ "\"uptime\": " << uptime <<
+ "}" <<
+ "}" << endl;
+ //Serial << strbuf << endl;
+ client.publish("IoT/Status/RelayBox", strbuf);
+ }
+ }
+#else
+for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ digitalWrite(RELAY_PIN[i], false);
+ digitalWrite(LED_PIN[i], false);
+}
+delay(500);
+for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ digitalWrite(RELAY_PIN[i], true);
+ delay(100);
+}
+delay(500);
+for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ digitalWrite(RELAY_PIN[i], false);
+ delay(100);
+}
+delay(500);
+for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ digitalWrite(LED_PIN[i], true);
+ delay(100);
+}
+delay(500);
+for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ digitalWrite(LED_PIN[i], false);
+ delay(100);
+}
+delay(100);
+
+while (true) {
+ for (uint8_t i = 0; i < NUM_OF_LINES; i++) {
+ digitalWrite(LED_PIN[i], digitalRead(FEEDBACK_PIN[i]));
+ digitalWrite(RELAY_PIN[i], digitalRead(BUTTON_PIN[i]));
+ }
+}
#endif
}
diff --git a/SPI/SPI.cpp b/SPI/SPI.cpp
new file mode 100644
index 0000000..9e7a116
--- /dev/null
+++ b/SPI/SPI.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2010 by Cristian Maglie
+ * Copyright (c) 2014 by Paul Stoffregen (Transaction API)
+ * Copyright (c) 2014 by Matthijs Kooijman (SPISettings AVR)
+ * Copyright (c) 2014 by Andrew J. Kroll (atomicity fixes)
+ * SPI Master library for arduino.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#include "SPI.h"
+
+SPIClass SPI;
+
+uint8_t SPIClass::initialized = 0;
+uint8_t SPIClass::interruptMode = 0;
+uint8_t SPIClass::interruptMask = 0;
+uint8_t SPIClass::interruptSave = 0;
+#ifdef SPI_TRANSACTION_MISMATCH_LED
+uint8_t SPIClass::inTransactionFlag = 0;
+#endif
+
+void SPIClass::begin()
+{
+ uint8_t sreg = SREG;
+ noInterrupts(); // Protect from a scheduler and prevent transactionBegin
+ if (!initialized) {
+ // Set SS to high so a connected chip will be "deselected" by default
+ digitalWrite(SS, HIGH);
+
+ // When the SS pin is set as OUTPUT, it can be used as
+ // a general purpose output port (it doesn't influence
+ // SPI operations).
+ pinMode(SS, OUTPUT);
+
+ // Warning: if the SS pin ever becomes a LOW INPUT then SPI
+ // automatically switches to Slave, so the data direction of
+ // the SS pin MUST be kept as OUTPUT.
+ SPCR |= _BV(MSTR);
+ SPCR |= _BV(SPE);
+
+ // Set direction register for SCK and MOSI pin.
+ // MISO pin automatically overrides to INPUT.
+ // By doing this AFTER enabling SPI, we avoid accidentally
+ // clocking in a single bit since the lines go directly
+ // from "input" to SPI control.
+ // http://code.google.com/p/arduino/issues/detail?id=888
+ pinMode(SCK, OUTPUT);
+ pinMode(MOSI, OUTPUT);
+ }
+ initialized++; // reference count
+ SREG = sreg;
+}
+
+void SPIClass::end() {
+ uint8_t sreg = SREG;
+ noInterrupts(); // Protect from a scheduler and prevent transactionBegin
+ // Decrease the reference counter
+ if (initialized)
+ initialized--;
+ // If there are no more references disable SPI
+ if (!initialized) {
+ SPCR &= ~_BV(SPE);
+ interruptMode = 0;
+ #ifdef SPI_TRANSACTION_MISMATCH_LED
+ inTransactionFlag = 0;
+ #endif
+ }
+ SREG = sreg;
+}
+
+// mapping of interrupt numbers to bits within SPI_AVR_EIMSK
+#if defined(__AVR_ATmega32U4__)
+ #define SPI_INT0_MASK (1<
+ * Copyright (c) 2014 by Paul Stoffregen (Transaction API)
+ * Copyright (c) 2014 by Matthijs Kooijman (SPISettings AVR)
+ * Copyright (c) 2014 by Andrew J. Kroll (atomicity fixes)
+ * SPI Master library for arduino.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _SPI_H_INCLUDED
+#define _SPI_H_INCLUDED
+
+#include
+
+// SPI_HAS_TRANSACTION means SPI has beginTransaction(), endTransaction(),
+// usingInterrupt(), and SPISetting(clock, bitOrder, dataMode)
+#define SPI_HAS_TRANSACTION 1
+
+// SPI_HAS_NOTUSINGINTERRUPT means that SPI has notUsingInterrupt() method
+#define SPI_HAS_NOTUSINGINTERRUPT 1
+
+// SPI_ATOMIC_VERSION means that SPI has atomicity fixes and what version.
+// This way when there is a bug fix you can check this define to alert users
+// of your code if it uses better version of this library.
+// This also implies everything that SPI_HAS_TRANSACTION as documented above is
+// available too.
+#define SPI_ATOMIC_VERSION 1
+
+// Uncomment this line to add detection of mismatched begin/end transactions.
+// A mismatch occurs if other libraries fail to use SPI.endTransaction() for
+// each SPI.beginTransaction(). Connect an LED to this pin. The LED will turn
+// on if any mismatch is ever detected.
+//#define SPI_TRANSACTION_MISMATCH_LED 5
+
+#ifndef LSBFIRST
+#define LSBFIRST 0
+#endif
+#ifndef MSBFIRST
+#define MSBFIRST 1
+#endif
+
+#define SPI_CLOCK_DIV4 0x00
+#define SPI_CLOCK_DIV16 0x01
+#define SPI_CLOCK_DIV64 0x02
+#define SPI_CLOCK_DIV128 0x03
+#define SPI_CLOCK_DIV2 0x04
+#define SPI_CLOCK_DIV8 0x05
+#define SPI_CLOCK_DIV32 0x06
+
+#define SPI_MODE0 0x00
+#define SPI_MODE1 0x04
+#define SPI_MODE2 0x08
+#define SPI_MODE3 0x0C
+
+#define SPI_MODE_MASK 0x0C // CPOL = bit 3, CPHA = bit 2 on SPCR
+#define SPI_CLOCK_MASK 0x03 // SPR1 = bit 1, SPR0 = bit 0 on SPCR
+#define SPI_2XCLOCK_MASK 0x01 // SPI2X = bit 0 on SPSR
+
+// define SPI_AVR_EIMSK for AVR boards with external interrupt pins
+#if defined(EIMSK)
+ #define SPI_AVR_EIMSK EIMSK
+#elif defined(GICR)
+ #define SPI_AVR_EIMSK GICR
+#elif defined(GIMSK)
+ #define SPI_AVR_EIMSK GIMSK
+#endif
+
+class SPISettings {
+public:
+ SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) {
+ if (__builtin_constant_p(clock)) {
+ init_AlwaysInline(clock, bitOrder, dataMode);
+ } else {
+ init_MightInline(clock, bitOrder, dataMode);
+ }
+ }
+ SPISettings() {
+ init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0);
+ }
+private:
+ void init_MightInline(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) {
+ init_AlwaysInline(clock, bitOrder, dataMode);
+ }
+ void init_AlwaysInline(uint32_t clock, uint8_t bitOrder, uint8_t dataMode)
+ __attribute__((__always_inline__)) {
+ // Clock settings are defined as follows. Note that this shows SPI2X
+ // inverted, so the bits form increasing numbers. Also note that
+ // fosc/64 appears twice
+ // SPR1 SPR0 ~SPI2X Freq
+ // 0 0 0 fosc/2
+ // 0 0 1 fosc/4
+ // 0 1 0 fosc/8
+ // 0 1 1 fosc/16
+ // 1 0 0 fosc/32
+ // 1 0 1 fosc/64
+ // 1 1 0 fosc/64
+ // 1 1 1 fosc/128
+
+ // We find the fastest clock that is less than or equal to the
+ // given clock rate. The clock divider that results in clock_setting
+ // is 2 ^^ (clock_div + 1). If nothing is slow enough, we'll use the
+ // slowest (128 == 2 ^^ 7, so clock_div = 6).
+ uint8_t clockDiv;
+
+ // When the clock is known at compiletime, use this if-then-else
+ // cascade, which the compiler knows how to completely optimize
+ // away. When clock is not known, use a loop instead, which generates
+ // shorter code.
+ if (__builtin_constant_p(clock)) {
+ if (clock >= F_CPU / 2) {
+ clockDiv = 0;
+ } else if (clock >= F_CPU / 4) {
+ clockDiv = 1;
+ } else if (clock >= F_CPU / 8) {
+ clockDiv = 2;
+ } else if (clock >= F_CPU / 16) {
+ clockDiv = 3;
+ } else if (clock >= F_CPU / 32) {
+ clockDiv = 4;
+ } else if (clock >= F_CPU / 64) {
+ clockDiv = 5;
+ } else {
+ clockDiv = 6;
+ }
+ } else {
+ uint32_t clockSetting = F_CPU / 2;
+ clockDiv = 0;
+ while (clockDiv < 6 && clock < clockSetting) {
+ clockSetting /= 2;
+ clockDiv++;
+ }
+ }
+
+ // Compensate for the duplicate fosc/64
+ if (clockDiv == 6)
+ clockDiv = 7;
+
+ // Invert the SPI2X bit
+ clockDiv ^= 0x1;
+
+ // Pack into the SPISettings class
+ spcr = _BV(SPE) | _BV(MSTR) | ((bitOrder == LSBFIRST) ? _BV(DORD) : 0) |
+ (dataMode & SPI_MODE_MASK) | ((clockDiv >> 1) & SPI_CLOCK_MASK);
+ spsr = clockDiv & SPI_2XCLOCK_MASK;
+ }
+ uint8_t spcr;
+ uint8_t spsr;
+ friend class SPIClass;
+};
+
+
+class SPIClass {
+public:
+ // Initialize the SPI library
+ static void begin();
+
+ // If SPI is used from within an interrupt, this function registers
+ // that interrupt with the SPI library, so beginTransaction() can
+ // prevent conflicts. The input interruptNumber is the number used
+ // with attachInterrupt. If SPI is used from a different interrupt
+ // (eg, a timer), interruptNumber should be 255.
+ static void usingInterrupt(uint8_t interruptNumber);
+ // And this does the opposite.
+ static void notUsingInterrupt(uint8_t interruptNumber);
+ // Note: the usingInterrupt and notUsingInterrupt functions should
+ // not to be called from ISR context or inside a transaction.
+ // For details see:
+ // https://github.com/arduino/Arduino/pull/2381
+ // https://github.com/arduino/Arduino/pull/2449
+
+ // Before using SPI.transfer() or asserting chip select pins,
+ // this function is used to gain exclusive access to the SPI bus
+ // and configure the correct settings.
+ inline static void beginTransaction(SPISettings settings) {
+ if (interruptMode > 0) {
+ uint8_t sreg = SREG;
+ noInterrupts();
+
+ #ifdef SPI_AVR_EIMSK
+ if (interruptMode == 1) {
+ interruptSave = SPI_AVR_EIMSK;
+ SPI_AVR_EIMSK &= ~interruptMask;
+ SREG = sreg;
+ } else
+ #endif
+ {
+ interruptSave = sreg;
+ }
+ }
+
+ #ifdef SPI_TRANSACTION_MISMATCH_LED
+ if (inTransactionFlag) {
+ pinMode(SPI_TRANSACTION_MISMATCH_LED, OUTPUT);
+ digitalWrite(SPI_TRANSACTION_MISMATCH_LED, HIGH);
+ }
+ inTransactionFlag = 1;
+ #endif
+
+ SPCR = settings.spcr;
+ SPSR = settings.spsr;
+ }
+
+ // Write to the SPI bus (MOSI pin) and also receive (MISO pin)
+ inline static uint8_t transfer(uint8_t data) {
+ SPDR = data;
+ /*
+ * The following NOP introduces a small delay that can prevent the wait
+ * loop form iterating when running at the maximum speed. This gives
+ * about 10% more speed, even if it seems counter-intuitive. At lower
+ * speeds it is unnoticed.
+ */
+ asm volatile("nop");
+ while (!(SPSR & _BV(SPIF))) ; // wait
+ return SPDR;
+ }
+ inline static uint16_t transfer16(uint16_t data) {
+ union { uint16_t val; struct { uint8_t lsb; uint8_t msb; }; } in, out;
+ in.val = data;
+ if (!(SPCR & _BV(DORD))) {
+ SPDR = in.msb;
+ asm volatile("nop"); // See transfer(uint8_t) function
+ while (!(SPSR & _BV(SPIF))) ;
+ out.msb = SPDR;
+ SPDR = in.lsb;
+ asm volatile("nop");
+ while (!(SPSR & _BV(SPIF))) ;
+ out.lsb = SPDR;
+ } else {
+ SPDR = in.lsb;
+ asm volatile("nop");
+ while (!(SPSR & _BV(SPIF))) ;
+ out.lsb = SPDR;
+ SPDR = in.msb;
+ asm volatile("nop");
+ while (!(SPSR & _BV(SPIF))) ;
+ out.msb = SPDR;
+ }
+ return out.val;
+ }
+ inline static void transfer(void *buf, size_t count) {
+ if (count == 0) return;
+ uint8_t *p = (uint8_t *)buf;
+ SPDR = *p;
+ while (--count > 0) {
+ uint8_t out = *(p + 1);
+ while (!(SPSR & _BV(SPIF))) ;
+ uint8_t in = SPDR;
+ SPDR = out;
+ *p++ = in;
+ }
+ while (!(SPSR & _BV(SPIF))) ;
+ *p = SPDR;
+ }
+ // After performing a group of transfers and releasing the chip select
+ // signal, this function allows others to access the SPI bus
+ inline static void endTransaction(void) {
+ #ifdef SPI_TRANSACTION_MISMATCH_LED
+ if (!inTransactionFlag) {
+ pinMode(SPI_TRANSACTION_MISMATCH_LED, OUTPUT);
+ digitalWrite(SPI_TRANSACTION_MISMATCH_LED, HIGH);
+ }
+ inTransactionFlag = 0;
+ #endif
+
+ if (interruptMode > 0) {
+ #ifdef SPI_AVR_EIMSK
+ uint8_t sreg = SREG;
+ #endif
+ noInterrupts();
+ #ifdef SPI_AVR_EIMSK
+ if (interruptMode == 1) {
+ SPI_AVR_EIMSK = interruptSave;
+ SREG = sreg;
+ } else
+ #endif
+ {
+ SREG = interruptSave;
+ }
+ }
+ }
+
+ // Disable the SPI bus
+ static void end();
+
+ // This function is deprecated. New applications should use
+ // beginTransaction() to configure SPI settings.
+ inline static void setBitOrder(uint8_t bitOrder) {
+ if (bitOrder == LSBFIRST) SPCR |= _BV(DORD);
+ else SPCR &= ~(_BV(DORD));
+ }
+ // This function is deprecated. New applications should use
+ // beginTransaction() to configure SPI settings.
+ inline static void setDataMode(uint8_t dataMode) {
+ SPCR = (SPCR & ~SPI_MODE_MASK) | dataMode;
+ }
+ // This function is deprecated. New applications should use
+ // beginTransaction() to configure SPI settings.
+ inline static void setClockDivider(uint8_t clockDiv) {
+ SPCR = (SPCR & ~SPI_CLOCK_MASK) | (clockDiv & SPI_CLOCK_MASK);
+ SPSR = (SPSR & ~SPI_2XCLOCK_MASK) | ((clockDiv >> 2) & SPI_2XCLOCK_MASK);
+ }
+ // These undocumented functions should not be used. SPI.transfer()
+ // polls the hardware flag which is automatically cleared as the
+ // AVR responds to SPI's interrupt
+ inline static void attachInterrupt() { SPCR |= _BV(SPIE); }
+ inline static void detachInterrupt() { SPCR &= ~_BV(SPIE); }
+
+private:
+ static uint8_t initialized;
+ static uint8_t interruptMode; // 0=none, 1=mask, 2=global
+ static uint8_t interruptMask; // which interrupts to mask
+ static uint8_t interruptSave; // temp storage, to restore state
+ #ifdef SPI_TRANSACTION_MISMATCH_LED
+ static uint8_t inTransactionFlag;
+ #endif
+};
+
+extern SPIClass SPI;
+
+#endif