cassyarduino cassyarduino / UIPEthernet

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

utility/Enc28J60Network.cpp@20:fe5026169ec6, 2017-01-14 (annotated)

Committer:
cassyarduino
Date:
Sat Jan 14 19:51:58 2017 +0100
Revision:
20:fe5026169ec6
Parent:
19:e416943f7119
Child:
25:ef941d560208
Changes

Who changed what in which revision?

UserRevisionLine numberNew contents of line
cassyarduino 0:e3fb1267e3c3 1 /*
cassyarduino 0:e3fb1267e3c3 2 Enc28J60NetworkClass.h
cassyarduino 0:e3fb1267e3c3 3 UIPEthernet network driver for Microchip ENC28J60 Ethernet Interface.
cassyarduino 0:e3fb1267e3c3 4
cassyarduino 0:e3fb1267e3c3 5 Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
cassyarduino 0:e3fb1267e3c3 6 All rights reserved.
cassyarduino 0:e3fb1267e3c3 7
cassyarduino 0:e3fb1267e3c3 8 based on enc28j60.c file from the AVRlib library by Pascal Stang.
cassyarduino 0:e3fb1267e3c3 9 For AVRlib See http://www.procyonengineering.com/
cassyarduino 0:e3fb1267e3c3 10
cassyarduino 0:e3fb1267e3c3 11 This program is free software: you can redistribute it and/or modify
cassyarduino 0:e3fb1267e3c3 12 it under the terms of the GNU General Public License as published by
cassyarduino 0:e3fb1267e3c3 13 the Free Software Foundation, either version 3 of the License, or
cassyarduino 0:e3fb1267e3c3 14 (at your option) any later version.
cassyarduino 0:e3fb1267e3c3 15
cassyarduino 0:e3fb1267e3c3 16 This program is distributed in the hope that it will be useful,
cassyarduino 0:e3fb1267e3c3 17 but WITHOUT ANY WARRANTY; without even the implied warranty of
cassyarduino 0:e3fb1267e3c3 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
cassyarduino 0:e3fb1267e3c3 19 GNU General Public License for more details.
cassyarduino 0:e3fb1267e3c3 20
cassyarduino 0:e3fb1267e3c3 21 You should have received a copy of the GNU General Public License
cassyarduino 0:e3fb1267e3c3 22 along with this program. If not, see <http://www.gnu.org/licenses/>.
cassyarduino 0:e3fb1267e3c3 23 */
cassyarduino 0:e3fb1267e3c3 24
cassyarduino 0:e3fb1267e3c3 25 #include "Enc28J60Network.h"
cassyarduino 0:e3fb1267e3c3 26 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 27 #include "Arduino.h"
cassyarduino 0:e3fb1267e3c3 28 #endif
cassyarduino 0:e3fb1267e3c3 29 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 30 #include <mbed.h>
cassyarduino 20:fe5026169ec6 31 #include "mbed/millis.h"
cassyarduino 0:e3fb1267e3c3 32 #define delay(x) wait_ms(x)
cassyarduino 0:e3fb1267e3c3 33 #endif
cassyarduino 0:e3fb1267e3c3 34 #include "logging.h"
cassyarduino 0:e3fb1267e3c3 35
cassyarduino 0:e3fb1267e3c3 36 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 37 #if defined(ARDUINO)
cassyarduino 19:e416943f7119 38 #if !defined(STM32F3)
cassyarduino 19:e416943f7119 39 #include <SPI.h>
cassyarduino 19:e416943f7119 40 extern SPIClass SPI;
cassyarduino 19:e416943f7119 41 #else
cassyarduino 19:e416943f7119 42 #include "HardwareSPI.h"
cassyarduino 19:e416943f7119 43 extern HardwareSPI SPI(1);
cassyarduino 19:e416943f7119 44 #endif
cassyarduino 0:e3fb1267e3c3 45 #endif
cassyarduino 0:e3fb1267e3c3 46 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 47 SPI _spi(SPI_MOSI,SPI_MISO,SPI_SCK);
cassyarduino 0:e3fb1267e3c3 48 DigitalOut _cs(ENC28J60_CONTROL_CS);
cassyarduino 0:e3fb1267e3c3 49 Serial LogObject(SERIAL_TX,SERIAL_RX);
cassyarduino 0:e3fb1267e3c3 50 #endif
cassyarduino 0:e3fb1267e3c3 51 #endif
cassyarduino 0:e3fb1267e3c3 52
cassyarduino 0:e3fb1267e3c3 53 extern "C" {
cassyarduino 0:e3fb1267e3c3 54 #if defined(ARDUINO_ARCH_AVR)
cassyarduino 0:e3fb1267e3c3 55 // AVR-specific code
cassyarduino 0:e3fb1267e3c3 56 #include <avr/io.h>
cassyarduino 0:e3fb1267e3c3 57 #elif defined(ARDUINO_ARCH_SAM)
cassyarduino 0:e3fb1267e3c3 58 // SAM-specific code
cassyarduino 0:e3fb1267e3c3 59 #else
cassyarduino 0:e3fb1267e3c3 60 // generic, non-platform specific code
cassyarduino 0:e3fb1267e3c3 61 #endif
cassyarduino 0:e3fb1267e3c3 62 #include "enc28j60.h"
cassyarduino 0:e3fb1267e3c3 63 #include "uip.h"
cassyarduino 0:e3fb1267e3c3 64 }
cassyarduino 0:e3fb1267e3c3 65
cassyarduino 0:e3fb1267e3c3 66 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 67 // set CS to 0 = active
cassyarduino 0:e3fb1267e3c3 68 #define CSACTIVE digitalWrite(ENC28J60_CONTROL_CS, LOW)
cassyarduino 0:e3fb1267e3c3 69 // set CS to 1 = passive
cassyarduino 0:e3fb1267e3c3 70 #define CSPASSIVE digitalWrite(ENC28J60_CONTROL_CS, HIGH)
cassyarduino 0:e3fb1267e3c3 71 #endif
cassyarduino 0:e3fb1267e3c3 72 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 73 // set CS to 0 = active
cassyarduino 0:e3fb1267e3c3 74 #define CSACTIVE _cs=0
cassyarduino 0:e3fb1267e3c3 75 // set CS to 1 = passive
cassyarduino 0:e3fb1267e3c3 76 #define CSPASSIVE _cs=1
cassyarduino 0:e3fb1267e3c3 77 #endif
cassyarduino 0:e3fb1267e3c3 78
cassyarduino 0:e3fb1267e3c3 79 //
cassyarduino 0:e3fb1267e3c3 80 #if defined(ARDUINO_ARCH_AVR)
cassyarduino 0:e3fb1267e3c3 81 #define waitspi() while(!(SPSR&(1<<SPIF)))
cassyarduino 0:e3fb1267e3c3 82 #elif defined(ARDUINO_ARCH_SAM)
cassyarduino 0:e3fb1267e3c3 83 #if ENC28J60_CONTROL_CS==BOARD_SPI_SS0 or ENC28J60_CONTROL_CS==BOARD_SPI_SS1 or ENC28J60_CONTROL_CS==BOARD_SPI_SS2 or ENC28J60_CONTROL_CS==BOARD_SPI_SS3
cassyarduino 0:e3fb1267e3c3 84 #define ENC28J60_USE_SPILIB_EXT 1
cassyarduino 0:e3fb1267e3c3 85 #endif
cassyarduino 0:e3fb1267e3c3 86 #endif
cassyarduino 0:e3fb1267e3c3 87
cassyarduino 0:e3fb1267e3c3 88 uint16_t Enc28J60Network::nextPacketPtr;
cassyarduino 0:e3fb1267e3c3 89 uint8_t Enc28J60Network::bank=0xff;
cassyarduino 0:e3fb1267e3c3 90 uint8_t Enc28J60Network::erevid=0;
cassyarduino 0:e3fb1267e3c3 91
cassyarduino 0:e3fb1267e3c3 92 struct memblock Enc28J60Network::receivePkt;
cassyarduino 0:e3fb1267e3c3 93
cassyarduino 0:e3fb1267e3c3 94 bool Enc28J60Network::broadcast_enabled = false;
cassyarduino 0:e3fb1267e3c3 95
cassyarduino 0:e3fb1267e3c3 96
cassyarduino 0:e3fb1267e3c3 97 void Enc28J60Network::init(uint8_t* macaddr)
cassyarduino 0:e3fb1267e3c3 98 {
cassyarduino 0:e3fb1267e3c3 99 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 100 LogObject.uart_send_strln(F("Enc28J60Network::init(uint8_t* macaddr) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 101 #endif
cassyarduino 0:e3fb1267e3c3 102 receivePkt.begin = 0;
cassyarduino 0:e3fb1267e3c3 103 receivePkt.size = 0;
cassyarduino 0:e3fb1267e3c3 104
cassyarduino 0:e3fb1267e3c3 105 unsigned int timeout = 15;
cassyarduino 0:e3fb1267e3c3 106 MemoryPool::init(); // 1 byte in between RX_STOP_INIT and pool to allow prepending of controlbyte
cassyarduino 0:e3fb1267e3c3 107 // initialize I/O
cassyarduino 0:e3fb1267e3c3 108 // ss as output:
cassyarduino 0:e3fb1267e3c3 109 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 110 pinMode(ENC28J60_CONTROL_CS, OUTPUT);
cassyarduino 0:e3fb1267e3c3 111 #endif
cassyarduino 20:fe5026169ec6 112 #if defined(__MBED__)
cassyarduino 20:fe5026169ec6 113 millis_start();
cassyarduino 20:fe5026169ec6 114 #endif
cassyarduino 0:e3fb1267e3c3 115 CSPASSIVE; // ss=0
cassyarduino 0:e3fb1267e3c3 116 //
cassyarduino 0:e3fb1267e3c3 117
cassyarduino 0:e3fb1267e3c3 118 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 0:e3fb1267e3c3 119 LogObject.uart_send_str(F("ENC28J60::init DEBUG:csPin = "));
cassyarduino 0:e3fb1267e3c3 120 LogObject.uart_send_decln(ENC28J60_CONTROL_CS);
cassyarduino 0:e3fb1267e3c3 121 LogObject.uart_send_str(F("ENC28J60::init DEBUG:miso = "));
cassyarduino 0:e3fb1267e3c3 122 LogObject.uart_send_decln(SPI_MISO);
cassyarduino 0:e3fb1267e3c3 123 LogObject.uart_send_str(F("ENC28J60::init DEBUG:mosi = "));
cassyarduino 0:e3fb1267e3c3 124 LogObject.uart_send_decln(SPI_MOSI);
cassyarduino 0:e3fb1267e3c3 125 LogObject.uart_send_str(F("ENC28J60::init DEBUG:sck = "));
cassyarduino 0:e3fb1267e3c3 126 LogObject.uart_send_decln(SPI_SCK);
cassyarduino 0:e3fb1267e3c3 127 #endif
cassyarduino 0:e3fb1267e3c3 128 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 129 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 0:e3fb1267e3c3 130 LogObject.uart_send_strln(F("ENC28J60::init DEBUG:Use SPI lib SPI.begin()"));
cassyarduino 0:e3fb1267e3c3 131 #endif
cassyarduino 0:e3fb1267e3c3 132 #if defined(ARDUINO)
cassyarduino 19:e416943f7119 133 #if defined(__STM32F3__) || defined(STM32F3)
cassyarduino 19:e416943f7119 134 SPI.begin(SPI_9MHZ, MSBFIRST, 0);
cassyarduino 19:e416943f7119 135 #else
cassyarduino 19:e416943f7119 136 SPI.begin();
cassyarduino 19:e416943f7119 137 #endif
cassyarduino 0:e3fb1267e3c3 138 #endif
cassyarduino 0:e3fb1267e3c3 139 #if defined(ARDUINO_ARCH_AVR)
cassyarduino 0:e3fb1267e3c3 140 // AVR-specific code
cassyarduino 0:e3fb1267e3c3 141 SPI.setClockDivider(SPI_CLOCK_DIV2); //results in 8MHZ at 16MHZ system clock.
cassyarduino 0:e3fb1267e3c3 142 #elif defined(ARDUINO_ARCH_SAM)
cassyarduino 0:e3fb1267e3c3 143 // SAM-specific code
cassyarduino 0:e3fb1267e3c3 144 SPI.setClockDivider(10); //defaults to 21 which results in aprox. 4MHZ. A 10 should result in a little more than 8MHZ.
cassyarduino 0:e3fb1267e3c3 145 #elif defined(__STM32F1__) || defined(__STM32F3__) || defined(__STM32F4__)
cassyarduino 0:e3fb1267e3c3 146 // generic, non-platform specific code
cassyarduino 0:e3fb1267e3c3 147 #define USE_STM32F1_DMAC 1 //on STM32
cassyarduino 0:e3fb1267e3c3 148 // BOARD_NR_SPI >= 1 BOARD_SPI1_NSS_PIN, BOARD_SPI1_SCK_PIN, BOARD_SPI1_MISO_PIN, BOARD_SPI1_MOSI_PIN
cassyarduino 0:e3fb1267e3c3 149 SPI.setBitOrder(MSBFIRST);
cassyarduino 0:e3fb1267e3c3 150 SPI.setDataMode(SPI_MODE0);
cassyarduino 0:e3fb1267e3c3 151 SPI.setClockDivider(SPI_CLOCK_DIV8); //value 8 the result is 9MHz at 72MHz clock.
cassyarduino 0:e3fb1267e3c3 152 #else
cassyarduino 0:e3fb1267e3c3 153 #if defined(ARDUINO)
cassyarduino 19:e416943f7119 154 #if !defined(__STM32F3__) && !defined(STM32F3)
cassyarduino 19:e416943f7119 155 SPI.setBitOrder(MSBFIRST);
cassyarduino 19:e416943f7119 156 #endif
cassyarduino 20:fe5026169ec6 157 //Settings for ESP8266
cassyarduino 0:e3fb1267e3c3 158 //SPI.setDataMode(SPI_MODE0);
cassyarduino 0:e3fb1267e3c3 159 //SPI.setClockDivider(SPI_CLOCK_DIV16);
cassyarduino 0:e3fb1267e3c3 160 #endif
cassyarduino 0:e3fb1267e3c3 161 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 162 _spi.format(8, 0); // 8bit, mode 0
cassyarduino 0:e3fb1267e3c3 163 _spi.frequency(7000000); // 7MHz
cassyarduino 0:e3fb1267e3c3 164 #endif
cassyarduino 0:e3fb1267e3c3 165 #endif
cassyarduino 0:e3fb1267e3c3 166 #else
cassyarduino 0:e3fb1267e3c3 167 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 0:e3fb1267e3c3 168 LogObject.uart_send_strln(F("ENC28J60::init DEBUG:Use Native hardware SPI"));
cassyarduino 0:e3fb1267e3c3 169 #endif
cassyarduino 0:e3fb1267e3c3 170 pinMode(SPI_MOSI, OUTPUT);
cassyarduino 0:e3fb1267e3c3 171 pinMode(SPI_SCK, OUTPUT);
cassyarduino 0:e3fb1267e3c3 172 pinMode(SPI_MISO, INPUT);
cassyarduino 0:e3fb1267e3c3 173 //Hardware SS must be configured as OUTPUT to enable SPI-master (regardless of which pin is configured as ENC28J60_CONTROL_CS)
cassyarduino 0:e3fb1267e3c3 174 //pinMode(ENC28J60_CONTROL_CS, OUTPUT);
cassyarduino 0:e3fb1267e3c3 175
cassyarduino 0:e3fb1267e3c3 176 digitalWrite(SPI_MOSI, LOW);
cassyarduino 0:e3fb1267e3c3 177 digitalWrite(SPI_SCK, LOW);
cassyarduino 0:e3fb1267e3c3 178
cassyarduino 0:e3fb1267e3c3 179 // initialize SPI interface
cassyarduino 0:e3fb1267e3c3 180 // master mode and Fosc/2 clock:
cassyarduino 0:e3fb1267e3c3 181 SPCR = (1<<SPE)|(1<<MSTR);
cassyarduino 0:e3fb1267e3c3 182 SPSR |= (1<<SPI2X);
cassyarduino 0:e3fb1267e3c3 183 #endif
cassyarduino 0:e3fb1267e3c3 184
cassyarduino 0:e3fb1267e3c3 185 // perform system reset
cassyarduino 0:e3fb1267e3c3 186 writeOp(ENC28J60_SOFT_RESET, 0, ENC28J60_SOFT_RESET);
cassyarduino 0:e3fb1267e3c3 187 delay(2); // errata B7/2
cassyarduino 0:e3fb1267e3c3 188 delay(50);
cassyarduino 0:e3fb1267e3c3 189 // check CLKRDY bit to see if reset is complete
cassyarduino 0:e3fb1267e3c3 190 // The CLKRDY does not work. See Rev. B4 Silicon Errata point. Just wait.
cassyarduino 0:e3fb1267e3c3 191 //while(!(readReg(ESTAT) & ESTAT_CLKRDY));
cassyarduino 0:e3fb1267e3c3 192 // do bank 0 stuff
cassyarduino 0:e3fb1267e3c3 193 // initialize receive buffer
cassyarduino 0:e3fb1267e3c3 194 // 16-bit transfers, must write low byte first
cassyarduino 0:e3fb1267e3c3 195 // set receive buffer start address
cassyarduino 0:e3fb1267e3c3 196 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 197 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:Before readOp(ENC28J60_READ_CTRL_REG, ESTAT)"));
cassyarduino 0:e3fb1267e3c3 198 #endif
cassyarduino 0:e3fb1267e3c3 199 nextPacketPtr = RXSTART_INIT;
cassyarduino 0:e3fb1267e3c3 200 while ((!readOp(ENC28J60_READ_CTRL_REG, ESTAT) & ESTAT_CLKRDY) && (timeout>0))
cassyarduino 0:e3fb1267e3c3 201 {
cassyarduino 0:e3fb1267e3c3 202 timeout=timeout-1;
cassyarduino 0:e3fb1267e3c3 203 delay(10);
cassyarduino 0:e3fb1267e3c3 204 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 205 wdt_reset();
cassyarduino 0:e3fb1267e3c3 206 #endif
cassyarduino 0:e3fb1267e3c3 207 }
cassyarduino 0:e3fb1267e3c3 208 #if ACTLOGLEVEL>=LOG_ERR
cassyarduino 0:e3fb1267e3c3 209 if (timeout==0) {LogObject.uart_send_strln(F("ENC28J60::init ERROR:TIMEOUT !!!"));}
cassyarduino 0:e3fb1267e3c3 210 #endif
cassyarduino 0:e3fb1267e3c3 211 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 212 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:After readOp(ENC28J60_READ_CTRL_REG, ESTAT)"));
cassyarduino 0:e3fb1267e3c3 213 #endif
cassyarduino 0:e3fb1267e3c3 214 // Rx start
cassyarduino 0:e3fb1267e3c3 215 writeRegPair(ERXSTL, RXSTART_INIT);
cassyarduino 0:e3fb1267e3c3 216 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 217 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:After writeRegPair(ERXSTL, RXSTART_INIT)"));
cassyarduino 0:e3fb1267e3c3 218 #endif
cassyarduino 0:e3fb1267e3c3 219 // set receive pointer address
cassyarduino 0:e3fb1267e3c3 220 writeRegPair(ERXRDPTL, RXSTART_INIT);
cassyarduino 0:e3fb1267e3c3 221 // RX end
cassyarduino 0:e3fb1267e3c3 222 writeRegPair(ERXNDL, RXSTOP_INIT);
cassyarduino 0:e3fb1267e3c3 223 // TX start
cassyarduino 0:e3fb1267e3c3 224 //writeRegPair(ETXSTL, TXSTART_INIT);
cassyarduino 0:e3fb1267e3c3 225 // TX end
cassyarduino 0:e3fb1267e3c3 226 //writeRegPair(ETXNDL, TXSTOP_INIT);
cassyarduino 0:e3fb1267e3c3 227 // do bank 1 stuff, packet filter:
cassyarduino 0:e3fb1267e3c3 228 // For broadcast packets we allow only ARP packtets
cassyarduino 0:e3fb1267e3c3 229 // All other packets should be unicast only for our mac (MAADR)
cassyarduino 0:e3fb1267e3c3 230 //
cassyarduino 0:e3fb1267e3c3 231 // The pattern to match on is therefore
cassyarduino 0:e3fb1267e3c3 232 // Type ETH.DST
cassyarduino 0:e3fb1267e3c3 233 // ARP BROADCAST
cassyarduino 0:e3fb1267e3c3 234 // 06 08 -- ff ff ff ff ff ff -> ip checksum for theses bytes=f7f9
cassyarduino 0:e3fb1267e3c3 235 // in binary these poitions are:11 0000 0011 1111
cassyarduino 0:e3fb1267e3c3 236 // This is hex 303F->EPMM0=0x3f,EPMM1=0x30
cassyarduino 0:e3fb1267e3c3 237 //TODO define specific pattern to receive dhcp-broadcast packages instead of setting ERFCON_BCEN!
cassyarduino 0:e3fb1267e3c3 238 // enableBroadcast(); // change to add ERXFCON_BCEN recommended by epam
cassyarduino 0:e3fb1267e3c3 239 writeReg(ERXFCON, ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN|ERXFCON_BCEN);
cassyarduino 0:e3fb1267e3c3 240 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 241 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:After writeReg(ERXFCON, ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN|ERXFCON_BCEN)"));
cassyarduino 0:e3fb1267e3c3 242 #endif
cassyarduino 0:e3fb1267e3c3 243 writeRegPair(EPMM0, 0x303f);
cassyarduino 0:e3fb1267e3c3 244 writeRegPair(EPMCSL, 0xf7f9);
cassyarduino 0:e3fb1267e3c3 245 //
cassyarduino 0:e3fb1267e3c3 246 //
cassyarduino 0:e3fb1267e3c3 247 // do bank 2 stuff
cassyarduino 0:e3fb1267e3c3 248 // enable MAC receive
cassyarduino 0:e3fb1267e3c3 249 // and bring MAC out of reset (writes 0x00 to MACON2)
cassyarduino 0:e3fb1267e3c3 250 writeRegPair(MACON1, MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS);
cassyarduino 0:e3fb1267e3c3 251 // enable automatic padding to 60bytes and CRC operations
cassyarduino 0:e3fb1267e3c3 252 writeOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN);
cassyarduino 0:e3fb1267e3c3 253 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 254 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:After writeOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN)"));
cassyarduino 0:e3fb1267e3c3 255 #endif
cassyarduino 0:e3fb1267e3c3 256 // set inter-frame gap (non-back-to-back)
cassyarduino 0:e3fb1267e3c3 257 writeRegPair(MAIPGL, 0x0C12);
cassyarduino 0:e3fb1267e3c3 258 // set inter-frame gap (back-to-back)
cassyarduino 0:e3fb1267e3c3 259 writeReg(MABBIPG, 0x12);
cassyarduino 0:e3fb1267e3c3 260 // Set the maximum packet size which the controller will accept
cassyarduino 0:e3fb1267e3c3 261 // Do not send packets longer than MAX_FRAMELEN:
cassyarduino 0:e3fb1267e3c3 262 writeRegPair(MAMXFLL, MAX_FRAMELEN);
cassyarduino 0:e3fb1267e3c3 263 // do bank 3 stuff
cassyarduino 0:e3fb1267e3c3 264 // write MAC address
cassyarduino 0:e3fb1267e3c3 265 // NOTE: MAC address in ENC28J60 is byte-backward
cassyarduino 0:e3fb1267e3c3 266 writeReg(MAADR5, macaddr[0]);
cassyarduino 0:e3fb1267e3c3 267 writeReg(MAADR4, macaddr[1]);
cassyarduino 0:e3fb1267e3c3 268 writeReg(MAADR3, macaddr[2]);
cassyarduino 0:e3fb1267e3c3 269 writeReg(MAADR2, macaddr[3]);
cassyarduino 0:e3fb1267e3c3 270 writeReg(MAADR1, macaddr[4]);
cassyarduino 0:e3fb1267e3c3 271 writeReg(MAADR0, macaddr[5]);
cassyarduino 0:e3fb1267e3c3 272 // no loopback of transmitted frames
cassyarduino 0:e3fb1267e3c3 273 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 274 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:Before phyWrite(PHCON2, PHCON2_HDLDIS)"));
cassyarduino 0:e3fb1267e3c3 275 #endif
cassyarduino 0:e3fb1267e3c3 276 phyWrite(PHCON2, PHCON2_HDLDIS);
cassyarduino 0:e3fb1267e3c3 277 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 278 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:After phyWrite(PHCON2, PHCON2_HDLDIS)"));
cassyarduino 0:e3fb1267e3c3 279 #endif
cassyarduino 0:e3fb1267e3c3 280 // switch to bank 0
cassyarduino 0:e3fb1267e3c3 281 setBank(ECON1);
cassyarduino 0:e3fb1267e3c3 282 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 283 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:After setBank(ECON1)"));
cassyarduino 0:e3fb1267e3c3 284 #endif
cassyarduino 0:e3fb1267e3c3 285 // enable interrutps
cassyarduino 0:e3fb1267e3c3 286 writeOp(ENC28J60_BIT_FIELD_SET, EIE, EIE_INTIE|EIE_PKTIE);
cassyarduino 0:e3fb1267e3c3 287 // enable packet reception
cassyarduino 0:e3fb1267e3c3 288 writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN);
cassyarduino 0:e3fb1267e3c3 289 //Configure leds
cassyarduino 0:e3fb1267e3c3 290 phyWrite(PHLCON,0x476);
cassyarduino 0:e3fb1267e3c3 291
cassyarduino 0:e3fb1267e3c3 292 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 293 LogObject.uart_send_strln(F("ENC28J60::init DEBUG_V3:Before readReg(EREVID);"));
cassyarduino 0:e3fb1267e3c3 294 #endif
cassyarduino 0:e3fb1267e3c3 295 erevid=readReg(EREVID);
cassyarduino 0:e3fb1267e3c3 296 if (erevid==0xFF) {erevid=0;}
cassyarduino 0:e3fb1267e3c3 297 // microchip forgot to step the number on the silcon when they
cassyarduino 0:e3fb1267e3c3 298 // released the revision B7. 6 is now rev B7. We still have
cassyarduino 0:e3fb1267e3c3 299 // to see what they do when they release B8. At the moment
cassyarduino 0:e3fb1267e3c3 300 // there is no B8 out yet
cassyarduino 0:e3fb1267e3c3 301 //if (erevid > 5) ++erevid;
cassyarduino 0:e3fb1267e3c3 302 #if ACTLOGLEVEL>=LOG_INFO
cassyarduino 0:e3fb1267e3c3 303 LogObject.uart_send_str(F("ENC28J60::init INFO: Chip erevid="));
cassyarduino 0:e3fb1267e3c3 304 LogObject.uart_send_dec(erevid);
cassyarduino 0:e3fb1267e3c3 305 LogObject.uart_send_strln(F(" initialization completed."));
cassyarduino 0:e3fb1267e3c3 306 #endif
cassyarduino 0:e3fb1267e3c3 307
cassyarduino 0:e3fb1267e3c3 308 // return Enc28J60Network::erevid;
cassyarduino 0:e3fb1267e3c3 309 }
cassyarduino 0:e3fb1267e3c3 310
cassyarduino 0:e3fb1267e3c3 311 memhandle
cassyarduino 0:e3fb1267e3c3 312 Enc28J60Network::receivePacket(void)
cassyarduino 0:e3fb1267e3c3 313 {
cassyarduino 0:e3fb1267e3c3 314 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 315 LogObject.uart_send_strln(F("Enc28J60Network::receivePacket(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 316 #endif
cassyarduino 0:e3fb1267e3c3 317 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 318 wdt_reset();
cassyarduino 0:e3fb1267e3c3 319 #endif
cassyarduino 0:e3fb1267e3c3 320 uint8_t rxstat;
cassyarduino 0:e3fb1267e3c3 321 uint16_t len;
cassyarduino 0:e3fb1267e3c3 322 // check if a packet has been received and buffered
cassyarduino 0:e3fb1267e3c3 323 //if( !(readReg(EIR) & EIR_PKTIF) ){
cassyarduino 0:e3fb1267e3c3 324 // The above does not work. See Rev. B4 Silicon Errata point 6.
cassyarduino 0:e3fb1267e3c3 325 #if ACTLOGLEVEL>=LOG_ERR
cassyarduino 0:e3fb1267e3c3 326 if (erevid==0)
cassyarduino 0:e3fb1267e3c3 327 {
cassyarduino 0:e3fb1267e3c3 328 LogObject.uart_send_strln(F("Enc28J60Network::receivePacket(void) ERROR:ENC28j50 Device not found !!! Bypass receivePacket function !!!"));
cassyarduino 0:e3fb1267e3c3 329 }
cassyarduino 0:e3fb1267e3c3 330 #endif
cassyarduino 0:e3fb1267e3c3 331 uint8_t epktcnt=readReg(EPKTCNT);
cassyarduino 16:66225c1d660c 332 if ((erevid!=0) && (epktcnt!=0))
cassyarduino 0:e3fb1267e3c3 333 {
cassyarduino 0:e3fb1267e3c3 334 uint16_t readPtr = nextPacketPtr+6 > RXSTOP_INIT ? nextPacketPtr+6-RXSTOP_INIT+RXSTART_INIT : nextPacketPtr+6;
cassyarduino 0:e3fb1267e3c3 335 // Set the read pointer to the start of the received packet
cassyarduino 0:e3fb1267e3c3 336 writeRegPair(ERDPTL, nextPacketPtr);
cassyarduino 0:e3fb1267e3c3 337 // read the next packet pointer
cassyarduino 0:e3fb1267e3c3 338 nextPacketPtr = readOp(ENC28J60_READ_BUF_MEM, 0);
cassyarduino 0:e3fb1267e3c3 339 nextPacketPtr |= readOp(ENC28J60_READ_BUF_MEM, 0) << 8;
cassyarduino 0:e3fb1267e3c3 340 // read the packet length (see datasheet page 43)
cassyarduino 0:e3fb1267e3c3 341 len = readOp(ENC28J60_READ_BUF_MEM, 0);
cassyarduino 0:e3fb1267e3c3 342 len |= readOp(ENC28J60_READ_BUF_MEM, 0) << 8;
cassyarduino 0:e3fb1267e3c3 343 len -= 4; //remove the CRC count
cassyarduino 0:e3fb1267e3c3 344 // read the receive status (see datasheet page 43)
cassyarduino 0:e3fb1267e3c3 345 rxstat = readOp(ENC28J60_READ_BUF_MEM, 0);
cassyarduino 0:e3fb1267e3c3 346 //rxstat |= readOp(ENC28J60_READ_BUF_MEM, 0) << 8;
cassyarduino 0:e3fb1267e3c3 347 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 0:e3fb1267e3c3 348 LogObject.uart_send_str(F("Enc28J60Network::receivePacket(void) DEBUG:receivePacket ["));
cassyarduino 0:e3fb1267e3c3 349 LogObject.uart_send_hex(readPtr);
cassyarduino 0:e3fb1267e3c3 350 LogObject.uart_send_str(F("-"));
cassyarduino 0:e3fb1267e3c3 351 LogObject.uart_send_hex((readPtr+len) % (RXSTOP_INIT+1));
cassyarduino 0:e3fb1267e3c3 352 LogObject.uart_send_str(F("], next: "));
cassyarduino 0:e3fb1267e3c3 353 LogObject.uart_send_hex(nextPacketPtr);
cassyarduino 0:e3fb1267e3c3 354 LogObject.uart_send_str(F(", stat: "));
cassyarduino 0:e3fb1267e3c3 355 LogObject.uart_send_hex(rxstat);
cassyarduino 0:e3fb1267e3c3 356 LogObject.uart_send_str(F(", Packet count: "));
cassyarduino 0:e3fb1267e3c3 357 LogObject.uart_send_dec(epktcnt);
cassyarduino 0:e3fb1267e3c3 358 LogObject.uart_send_str(F(" -> "));
cassyarduino 0:e3fb1267e3c3 359 LogObject.uart_send_strln((rxstat & 0x80)!=0 ? "OK" : "failed");
cassyarduino 0:e3fb1267e3c3 360 #endif
cassyarduino 0:e3fb1267e3c3 361 // decrement the packet counter indicate we are done with this packet
cassyarduino 0:e3fb1267e3c3 362 writeOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PKTDEC);
cassyarduino 0:e3fb1267e3c3 363 // check CRC and symbol errors (see datasheet page 44, table 7-3):
cassyarduino 0:e3fb1267e3c3 364 // The ERXFCON.CRCEN is set by default. Normally we should not
cassyarduino 0:e3fb1267e3c3 365 // need to check this.
cassyarduino 0:e3fb1267e3c3 366 if (((rxstat & 0x80) != 0) && (nextPacketPtr<=RXSTOP_INIT))
cassyarduino 0:e3fb1267e3c3 367 {
cassyarduino 0:e3fb1267e3c3 368 receivePkt.begin = readPtr;
cassyarduino 0:e3fb1267e3c3 369 receivePkt.size = len;
cassyarduino 0:e3fb1267e3c3 370 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 0:e3fb1267e3c3 371 LogObject.uart_send_str(F("Enc28J60Network::receivePacket(void) DEBUG: rxstat OK. receivePkt.size="));
cassyarduino 0:e3fb1267e3c3 372 LogObject.uart_send_decln(len);
cassyarduino 0:e3fb1267e3c3 373 #endif
cassyarduino 0:e3fb1267e3c3 374 return UIP_RECEIVEBUFFERHANDLE;
cassyarduino 0:e3fb1267e3c3 375 }
cassyarduino 0:e3fb1267e3c3 376 // Move the RX read pointer to the start of the next received packet
cassyarduino 0:e3fb1267e3c3 377 // This frees the memory we just read out
cassyarduino 0:e3fb1267e3c3 378 setERXRDPT();
cassyarduino 0:e3fb1267e3c3 379 }
cassyarduino 0:e3fb1267e3c3 380 return (NOBLOCK);
cassyarduino 0:e3fb1267e3c3 381 }
cassyarduino 0:e3fb1267e3c3 382
cassyarduino 0:e3fb1267e3c3 383 void
cassyarduino 0:e3fb1267e3c3 384 Enc28J60Network::setERXRDPT(void)
cassyarduino 0:e3fb1267e3c3 385 {
cassyarduino 0:e3fb1267e3c3 386 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 387 LogObject.uart_send_strln(F("Enc28J60Network::setERXRDPT(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 388 #endif
cassyarduino 17:be34a75aa9a7 389 uint16_t actnextPacketPtr;
cassyarduino 17:be34a75aa9a7 390 nextPacketPtr == RXSTART_INIT ? actnextPacketPtr=RXSTOP_INIT : actnextPacketPtr=nextPacketPtr-1;
cassyarduino 17:be34a75aa9a7 391 if (actnextPacketPtr>RXSTOP_INIT) {actnextPacketPtr=RXSTART_INIT;}
cassyarduino 17:be34a75aa9a7 392 if ((actnextPacketPtr&1)!=0) {actnextPacketPtr--;}
cassyarduino 16:66225c1d660c 393 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 17:be34a75aa9a7 394 LogObject.uart_send_str(F("Enc28J60Network::setERXRDPT(void) DEBUG:Set actnextPacketPtr:"));
cassyarduino 17:be34a75aa9a7 395 LogObject.uart_send_hexln(actnextPacketPtr);
cassyarduino 0:e3fb1267e3c3 396 #endif
cassyarduino 17:be34a75aa9a7 397 writeRegPair(ERXRDPTL, actnextPacketPtr);
cassyarduino 0:e3fb1267e3c3 398 }
cassyarduino 0:e3fb1267e3c3 399
cassyarduino 0:e3fb1267e3c3 400 memaddress
cassyarduino 0:e3fb1267e3c3 401 Enc28J60Network::blockSize(memhandle handle)
cassyarduino 0:e3fb1267e3c3 402 {
cassyarduino 0:e3fb1267e3c3 403 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 404 LogObject.uart_send_strln(F("Enc28J60Network::blockSize(memhandle handle) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 405 #endif
cassyarduino 0:e3fb1267e3c3 406 return ((handle == NOBLOCK) || (erevid==0)) ? 0 : handle == UIP_RECEIVEBUFFERHANDLE ? receivePkt.size : blocks[handle].size;
cassyarduino 0:e3fb1267e3c3 407 }
cassyarduino 0:e3fb1267e3c3 408
cassyarduino 0:e3fb1267e3c3 409 void
cassyarduino 0:e3fb1267e3c3 410 Enc28J60Network::sendPacket(memhandle handle)
cassyarduino 0:e3fb1267e3c3 411 {
cassyarduino 0:e3fb1267e3c3 412 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 413 LogObject.uart_send_strln(F("Enc28J60Network::sendPacket(memhandle handle) INFO:Function started"));
cassyarduino 0:e3fb1267e3c3 414 #endif
cassyarduino 0:e3fb1267e3c3 415 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 416 wdt_reset();
cassyarduino 0:e3fb1267e3c3 417 #endif
cassyarduino 0:e3fb1267e3c3 418 memblock *packet = &blocks[handle];
cassyarduino 0:e3fb1267e3c3 419 uint16_t start = packet->begin-1;
cassyarduino 0:e3fb1267e3c3 420 uint16_t end = start + packet->size;
cassyarduino 0:e3fb1267e3c3 421
cassyarduino 0:e3fb1267e3c3 422 // backup data at control-byte position
cassyarduino 0:e3fb1267e3c3 423 uint8_t data = readByte(start);
cassyarduino 0:e3fb1267e3c3 424 // write control-byte (if not 0 anyway)
cassyarduino 0:e3fb1267e3c3 425 if (data)
cassyarduino 0:e3fb1267e3c3 426 writeByte(start, 0);
cassyarduino 0:e3fb1267e3c3 427
cassyarduino 0:e3fb1267e3c3 428 #if ACTLOGLEVEL>=LOG_DEBUG
cassyarduino 0:e3fb1267e3c3 429 LogObject.uart_send_str(F("Enc28J60Network::sendPacket(memhandle handle) DEBUG:sendPacket("));
cassyarduino 0:e3fb1267e3c3 430 LogObject.uart_send_dec(handle);
cassyarduino 0:e3fb1267e3c3 431 LogObject.uart_send_str(F(") ["));
cassyarduino 0:e3fb1267e3c3 432 LogObject.uart_send_hex(start);
cassyarduino 0:e3fb1267e3c3 433 LogObject.uart_send_str(F("-"));
cassyarduino 0:e3fb1267e3c3 434 LogObject.uart_send_hex(end);
cassyarduino 0:e3fb1267e3c3 435 LogObject.uart_send_str(F("]: "));
cassyarduino 0:e3fb1267e3c3 436 for (uint16_t i=start; i<=end; i++)
cassyarduino 0:e3fb1267e3c3 437 {
cassyarduino 0:e3fb1267e3c3 438 LogObject.uart_send_hex(readByte(i));
cassyarduino 0:e3fb1267e3c3 439 LogObject.uart_send_str(F(" "));
cassyarduino 0:e3fb1267e3c3 440 }
cassyarduino 0:e3fb1267e3c3 441 LogObject.uart_send_strln(F(""));
cassyarduino 0:e3fb1267e3c3 442 #endif
cassyarduino 0:e3fb1267e3c3 443
cassyarduino 0:e3fb1267e3c3 444 // TX start
cassyarduino 0:e3fb1267e3c3 445 writeRegPair(ETXSTL, start);
cassyarduino 0:e3fb1267e3c3 446 // Set the TXND pointer to correspond to the packet size given
cassyarduino 0:e3fb1267e3c3 447 writeRegPair(ETXNDL, end);
cassyarduino 0:e3fb1267e3c3 448 // send the contents of the transmit buffer onto the network
cassyarduino 0:e3fb1267e3c3 449 writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);
cassyarduino 0:e3fb1267e3c3 450 // Reset the transmit logic problem. See Rev. B4 Silicon Errata point 12.
cassyarduino 0:e3fb1267e3c3 451 if( (readReg(EIR) & EIR_TXERIF) )
cassyarduino 0:e3fb1267e3c3 452 {
cassyarduino 0:e3fb1267e3c3 453 writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_TXRTS);
cassyarduino 0:e3fb1267e3c3 454 }
cassyarduino 0:e3fb1267e3c3 455
cassyarduino 0:e3fb1267e3c3 456 //restore data on control-byte position
cassyarduino 0:e3fb1267e3c3 457 if (data)
cassyarduino 0:e3fb1267e3c3 458 writeByte(start, data);
cassyarduino 0:e3fb1267e3c3 459 }
cassyarduino 0:e3fb1267e3c3 460
cassyarduino 0:e3fb1267e3c3 461 uint16_t
cassyarduino 0:e3fb1267e3c3 462 Enc28J60Network::setReadPtr(memhandle handle, memaddress position, uint16_t len)
cassyarduino 0:e3fb1267e3c3 463 {
cassyarduino 0:e3fb1267e3c3 464 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 465 LogObject.uart_send_strln(F("Enc28J60Network::setReadPtr(memhandle handle, memaddress position, uint16_t len) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 466 #endif
cassyarduino 0:e3fb1267e3c3 467 memblock *packet = handle == UIP_RECEIVEBUFFERHANDLE ? &receivePkt : &blocks[handle];
cassyarduino 0:e3fb1267e3c3 468 memaddress start = handle == UIP_RECEIVEBUFFERHANDLE && packet->begin + position > RXSTOP_INIT ? packet->begin + position-RXSTOP_INIT+RXSTART_INIT : packet->begin + position;
cassyarduino 0:e3fb1267e3c3 469
cassyarduino 0:e3fb1267e3c3 470 writeRegPair(ERDPTL, start);
cassyarduino 0:e3fb1267e3c3 471
cassyarduino 0:e3fb1267e3c3 472 if (len > packet->size - position)
cassyarduino 0:e3fb1267e3c3 473 len = packet->size - position;
cassyarduino 0:e3fb1267e3c3 474 return len;
cassyarduino 0:e3fb1267e3c3 475 }
cassyarduino 0:e3fb1267e3c3 476
cassyarduino 0:e3fb1267e3c3 477 uint16_t
cassyarduino 0:e3fb1267e3c3 478 Enc28J60Network::readPacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len)
cassyarduino 0:e3fb1267e3c3 479 {
cassyarduino 0:e3fb1267e3c3 480 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 481 LogObject.uart_send_strln(F("Enc28J60Network::readPacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 482 #endif
cassyarduino 0:e3fb1267e3c3 483 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 484 wdt_reset();
cassyarduino 0:e3fb1267e3c3 485 #endif
cassyarduino 0:e3fb1267e3c3 486 len = setReadPtr(handle, position, len);
cassyarduino 0:e3fb1267e3c3 487 readBuffer(len, buffer);
cassyarduino 20:fe5026169ec6 488 #if ACTLOGLEVEL>=LOG_DEBUG_V2
cassyarduino 20:fe5026169ec6 489 LogObject.uart_send_str(F("Enc28J60Network::readPacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len) DEBUG_V2: Read bytes:"));
cassyarduino 20:fe5026169ec6 490 LogObject.uart_send_dec(len);
cassyarduino 20:fe5026169ec6 491 LogObject.uart_send_str(F(" save to block("));
cassyarduino 20:fe5026169ec6 492 LogObject.uart_send_dec(handle);
cassyarduino 20:fe5026169ec6 493 LogObject.uart_send_str(F(") ["));
cassyarduino 20:fe5026169ec6 494 LogObject.uart_send_hex(position);
cassyarduino 20:fe5026169ec6 495 LogObject.uart_send_str(F("]: "));
cassyarduino 20:fe5026169ec6 496 for (uint16_t i=0; i<len; i++)
cassyarduino 20:fe5026169ec6 497 {
cassyarduino 20:fe5026169ec6 498 LogObject.uart_send_hex(buffer[i]);
cassyarduino 20:fe5026169ec6 499 LogObject.uart_send_str(F(" "));
cassyarduino 20:fe5026169ec6 500 }
cassyarduino 20:fe5026169ec6 501 LogObject.uart_send_strln(F(""));
cassyarduino 20:fe5026169ec6 502 #endif
cassyarduino 0:e3fb1267e3c3 503 return len;
cassyarduino 0:e3fb1267e3c3 504 }
cassyarduino 0:e3fb1267e3c3 505
cassyarduino 0:e3fb1267e3c3 506 uint16_t
cassyarduino 0:e3fb1267e3c3 507 Enc28J60Network::writePacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len)
cassyarduino 0:e3fb1267e3c3 508 {
cassyarduino 0:e3fb1267e3c3 509 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 510 LogObject.uart_send_str(F("Enc28J60Network::writePacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len) DEBUG_V3:Function started with len:"));
cassyarduino 0:e3fb1267e3c3 511 LogObject.uart_send_decln(len);
cassyarduino 0:e3fb1267e3c3 512 #endif
cassyarduino 0:e3fb1267e3c3 513 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 514 wdt_reset();
cassyarduino 0:e3fb1267e3c3 515 #endif
cassyarduino 0:e3fb1267e3c3 516 memblock *packet = &blocks[handle];
cassyarduino 0:e3fb1267e3c3 517 uint16_t start = packet->begin + position;
cassyarduino 0:e3fb1267e3c3 518
cassyarduino 0:e3fb1267e3c3 519 writeRegPair(EWRPTL, start);
cassyarduino 0:e3fb1267e3c3 520
cassyarduino 0:e3fb1267e3c3 521 if (len > packet->size - position)
cassyarduino 0:e3fb1267e3c3 522 len = packet->size - position;
cassyarduino 0:e3fb1267e3c3 523 writeBuffer(len, buffer);
cassyarduino 20:fe5026169ec6 524 #if ACTLOGLEVEL>=LOG_DEBUG_V2
cassyarduino 20:fe5026169ec6 525 LogObject.uart_send_str(F("Enc28J60Network::writePacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len) DEBUG_V2: Write bytes:"));
cassyarduino 20:fe5026169ec6 526 LogObject.uart_send_dec(len);
cassyarduino 20:fe5026169ec6 527 LogObject.uart_send_str(F(" save to block("));
cassyarduino 20:fe5026169ec6 528 LogObject.uart_send_dec(handle);
cassyarduino 20:fe5026169ec6 529 LogObject.uart_send_str(F(") ["));
cassyarduino 20:fe5026169ec6 530 LogObject.uart_send_hex(start);
cassyarduino 20:fe5026169ec6 531 LogObject.uart_send_str(F("]: "));
cassyarduino 20:fe5026169ec6 532 for (uint16_t i=0; i<len; i++)
cassyarduino 20:fe5026169ec6 533 {
cassyarduino 20:fe5026169ec6 534 LogObject.uart_send_hex(buffer[i]);
cassyarduino 20:fe5026169ec6 535 LogObject.uart_send_str(F(" "));
cassyarduino 20:fe5026169ec6 536 }
cassyarduino 20:fe5026169ec6 537 LogObject.uart_send_strln(F(""));
cassyarduino 20:fe5026169ec6 538 #endif
cassyarduino 0:e3fb1267e3c3 539 return len;
cassyarduino 0:e3fb1267e3c3 540 }
cassyarduino 0:e3fb1267e3c3 541
cassyarduino 0:e3fb1267e3c3 542
cassyarduino 0:e3fb1267e3c3 543 void Enc28J60Network::enableBroadcast (bool temporary) {
cassyarduino 0:e3fb1267e3c3 544 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 545 LogObject.uart_send_strln(F("Enc28J60Network::enableBroadcast (bool temporary) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 546 #endif
cassyarduino 0:e3fb1267e3c3 547 writeRegByte(ERXFCON, readRegByte(ERXFCON) | ERXFCON_BCEN);
cassyarduino 0:e3fb1267e3c3 548 if(!temporary)
cassyarduino 0:e3fb1267e3c3 549 broadcast_enabled = true;
cassyarduino 0:e3fb1267e3c3 550 }
cassyarduino 0:e3fb1267e3c3 551
cassyarduino 0:e3fb1267e3c3 552 void Enc28J60Network::disableBroadcast (bool temporary) {
cassyarduino 0:e3fb1267e3c3 553 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 554 LogObject.uart_send_strln(F("Enc28J60Network::disableBroadcast (bool temporary) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 555 #endif
cassyarduino 0:e3fb1267e3c3 556 if(!temporary)
cassyarduino 0:e3fb1267e3c3 557 broadcast_enabled = false;
cassyarduino 0:e3fb1267e3c3 558 if(!broadcast_enabled)
cassyarduino 0:e3fb1267e3c3 559 writeRegByte(ERXFCON, readRegByte(ERXFCON) & ~ERXFCON_BCEN);
cassyarduino 0:e3fb1267e3c3 560 }
cassyarduino 0:e3fb1267e3c3 561
cassyarduino 0:e3fb1267e3c3 562 void Enc28J60Network::enableMulticast (void) {
cassyarduino 0:e3fb1267e3c3 563 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 564 LogObject.uart_send_strln(F("Enc28J60Network::enableMulticast (void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 565 #endif
cassyarduino 0:e3fb1267e3c3 566 writeRegByte(ERXFCON, readRegByte(ERXFCON) | ERXFCON_MCEN);
cassyarduino 0:e3fb1267e3c3 567 }
cassyarduino 0:e3fb1267e3c3 568
cassyarduino 0:e3fb1267e3c3 569 void Enc28J60Network::disableMulticast (void) {
cassyarduino 0:e3fb1267e3c3 570 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 571 LogObject.uart_send_strln(F("Enc28J60Network::disableMulticast (void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 572 #endif
cassyarduino 0:e3fb1267e3c3 573 writeRegByte(ERXFCON, readRegByte(ERXFCON) & ~ERXFCON_MCEN);
cassyarduino 0:e3fb1267e3c3 574 }
cassyarduino 0:e3fb1267e3c3 575
cassyarduino 0:e3fb1267e3c3 576 uint8_t Enc28J60Network::readRegByte (uint8_t address) {
cassyarduino 0:e3fb1267e3c3 577 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 578 LogObject.uart_send_strln(F("Enc28J60Network::readRegByte (uint8_t address) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 579 #endif
cassyarduino 0:e3fb1267e3c3 580 setBank(address);
cassyarduino 0:e3fb1267e3c3 581 return readOp(ENC28J60_READ_CTRL_REG, address);
cassyarduino 0:e3fb1267e3c3 582 }
cassyarduino 0:e3fb1267e3c3 583
cassyarduino 0:e3fb1267e3c3 584 void Enc28J60Network::writeRegByte (uint8_t address, uint8_t data) {
cassyarduino 0:e3fb1267e3c3 585 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 586 LogObject.uart_send_strln(F("Enc28J60Network::writeRegByte (uint8_t address, uint8_t data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 587 #endif
cassyarduino 0:e3fb1267e3c3 588 setBank(address);
cassyarduino 0:e3fb1267e3c3 589 writeOp(ENC28J60_WRITE_CTRL_REG, address, data);
cassyarduino 0:e3fb1267e3c3 590 }
cassyarduino 0:e3fb1267e3c3 591
cassyarduino 0:e3fb1267e3c3 592
cassyarduino 0:e3fb1267e3c3 593 uint8_t Enc28J60Network::readByte(uint16_t addr)
cassyarduino 0:e3fb1267e3c3 594 {
cassyarduino 0:e3fb1267e3c3 595 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 596 LogObject.uart_send_strln(F("Enc28J60Network::readByte(uint16_t addr) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 597 #endif
cassyarduino 0:e3fb1267e3c3 598 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 599 wdt_reset();
cassyarduino 0:e3fb1267e3c3 600 #endif
cassyarduino 0:e3fb1267e3c3 601 writeRegPair(ERDPTL, addr);
cassyarduino 0:e3fb1267e3c3 602
cassyarduino 0:e3fb1267e3c3 603 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 604 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 605 // issue read command
cassyarduino 0:e3fb1267e3c3 606 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 607 SPI.transfer(ENC28J60_READ_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 608 // read data
cassyarduino 0:e3fb1267e3c3 609 uint8_t c = SPI.transfer(0x00);
cassyarduino 0:e3fb1267e3c3 610 #endif
cassyarduino 0:e3fb1267e3c3 611 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 612 _spi.write(ENC28J60_READ_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 613 // read data
cassyarduino 0:e3fb1267e3c3 614 uint8_t c = _spi.write(0x00);
cassyarduino 0:e3fb1267e3c3 615 #endif
cassyarduino 0:e3fb1267e3c3 616 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 617 return (c);
cassyarduino 0:e3fb1267e3c3 618 #else
cassyarduino 0:e3fb1267e3c3 619 // issue read command
cassyarduino 0:e3fb1267e3c3 620 SPDR = ENC28J60_READ_BUF_MEM;
cassyarduino 0:e3fb1267e3c3 621 waitspi();
cassyarduino 0:e3fb1267e3c3 622 // read data
cassyarduino 0:e3fb1267e3c3 623 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 624 waitspi();
cassyarduino 0:e3fb1267e3c3 625 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 626 return (SPDR);
cassyarduino 0:e3fb1267e3c3 627 #endif
cassyarduino 0:e3fb1267e3c3 628 }
cassyarduino 0:e3fb1267e3c3 629
cassyarduino 0:e3fb1267e3c3 630 void Enc28J60Network::writeByte(uint16_t addr, uint8_t data)
cassyarduino 0:e3fb1267e3c3 631 {
cassyarduino 0:e3fb1267e3c3 632 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 633 LogObject.uart_send_strln(F("Enc28J60Network::writeByte(uint16_t addr, uint8_t data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 634 #endif
cassyarduino 0:e3fb1267e3c3 635 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 636 wdt_reset();
cassyarduino 0:e3fb1267e3c3 637 #endif
cassyarduino 0:e3fb1267e3c3 638 writeRegPair(EWRPTL, addr);
cassyarduino 0:e3fb1267e3c3 639
cassyarduino 0:e3fb1267e3c3 640 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 641 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 642 // issue write command
cassyarduino 0:e3fb1267e3c3 643 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 644 SPI.transfer(ENC28J60_WRITE_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 645 // write data
cassyarduino 0:e3fb1267e3c3 646 SPI.transfer(data);
cassyarduino 0:e3fb1267e3c3 647 #endif
cassyarduino 0:e3fb1267e3c3 648 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 649 _spi.write(ENC28J60_WRITE_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 650 // write data
cassyarduino 0:e3fb1267e3c3 651 _spi.write(data);
cassyarduino 0:e3fb1267e3c3 652 #endif
cassyarduino 0:e3fb1267e3c3 653 #else
cassyarduino 0:e3fb1267e3c3 654 // issue write command
cassyarduino 0:e3fb1267e3c3 655 SPDR = ENC28J60_WRITE_BUF_MEM;
cassyarduino 0:e3fb1267e3c3 656 waitspi();
cassyarduino 0:e3fb1267e3c3 657 // write data
cassyarduino 0:e3fb1267e3c3 658 SPDR = data;
cassyarduino 0:e3fb1267e3c3 659 waitspi();
cassyarduino 0:e3fb1267e3c3 660 #endif
cassyarduino 0:e3fb1267e3c3 661 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 662 }
cassyarduino 0:e3fb1267e3c3 663
cassyarduino 0:e3fb1267e3c3 664 void
cassyarduino 0:e3fb1267e3c3 665 Enc28J60Network::copyPacket(memhandle dest_pkt, memaddress dest_pos, memhandle src_pkt, memaddress src_pos, uint16_t len)
cassyarduino 0:e3fb1267e3c3 666 {
cassyarduino 0:e3fb1267e3c3 667 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 668 LogObject.uart_send_strln(F("Enc28J60Network::copyPacket(memhandle dest_pkt, memaddress dest_pos, memhandle src_pkt, memaddress src_pos, uint16_t len) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 669 #endif
cassyarduino 0:e3fb1267e3c3 670 memblock *dest = &blocks[dest_pkt];
cassyarduino 0:e3fb1267e3c3 671 memblock *src = src_pkt == UIP_RECEIVEBUFFERHANDLE ? &receivePkt : &blocks[src_pkt];
cassyarduino 0:e3fb1267e3c3 672 memaddress start = src_pkt == UIP_RECEIVEBUFFERHANDLE && src->begin + src_pos > RXSTOP_INIT ? src->begin + src_pos-RXSTOP_INIT+RXSTART_INIT : src->begin + src_pos;
cassyarduino 0:e3fb1267e3c3 673 enc28J60_mempool_block_move_callback(dest->begin+dest_pos,start,len);
cassyarduino 0:e3fb1267e3c3 674 // Move the RX read pointer to the start of the next received packet
cassyarduino 0:e3fb1267e3c3 675 // This frees the memory we just read out
cassyarduino 0:e3fb1267e3c3 676 setERXRDPT();
cassyarduino 0:e3fb1267e3c3 677 }
cassyarduino 0:e3fb1267e3c3 678
cassyarduino 0:e3fb1267e3c3 679 void
cassyarduino 0:e3fb1267e3c3 680 enc28J60_mempool_block_move_callback(memaddress dest, memaddress src, memaddress len)
cassyarduino 0:e3fb1267e3c3 681 {
cassyarduino 0:e3fb1267e3c3 682 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 683 LogObject.uart_send_strln(F("enc28J60_mempool_block_move_callback(memaddress dest, memaddress src, memaddress len) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 684 #endif
cassyarduino 0:e3fb1267e3c3 685 //void
cassyarduino 0:e3fb1267e3c3 686 //Enc28J60Network::memblock_mv_cb(uint16_t dest, uint16_t src, uint16_t len)
cassyarduino 0:e3fb1267e3c3 687 //{
cassyarduino 0:e3fb1267e3c3 688 //as ENC28J60 DMA is unable to copy single bytes:
cassyarduino 0:e3fb1267e3c3 689 if (len == 1)
cassyarduino 0:e3fb1267e3c3 690 {
cassyarduino 0:e3fb1267e3c3 691 Enc28J60Network::writeByte(dest,Enc28J60Network::readByte(src));
cassyarduino 0:e3fb1267e3c3 692 }
cassyarduino 0:e3fb1267e3c3 693 else
cassyarduino 0:e3fb1267e3c3 694 {
cassyarduino 0:e3fb1267e3c3 695 // calculate address of last byte
cassyarduino 0:e3fb1267e3c3 696 len += src - 1;
cassyarduino 0:e3fb1267e3c3 697
cassyarduino 0:e3fb1267e3c3 698 /* 1. Appropriately program the EDMAST, EDMAND
cassyarduino 0:e3fb1267e3c3 699 and EDMADST register pairs. The EDMAST
cassyarduino 0:e3fb1267e3c3 700 registers should point to the first byte to copy
cassyarduino 0:e3fb1267e3c3 701 from, the EDMAND registers should point to the
cassyarduino 0:e3fb1267e3c3 702 last byte to copy and the EDMADST registers
cassyarduino 0:e3fb1267e3c3 703 should point to the first byte in the destination
cassyarduino 0:e3fb1267e3c3 704 range. The destination range will always be
cassyarduino 0:e3fb1267e3c3 705 linear, never wrapping at any values except from
cassyarduino 0:e3fb1267e3c3 706 8191 to 0 (the 8-Kbyte memory boundary).
cassyarduino 0:e3fb1267e3c3 707 Extreme care should be taken when
cassyarduino 0:e3fb1267e3c3 708 programming the start and end pointers to
cassyarduino 0:e3fb1267e3c3 709 prevent a never ending DMA operation which
cassyarduino 0:e3fb1267e3c3 710 would overwrite the entire 8-Kbyte buffer.
cassyarduino 0:e3fb1267e3c3 711 */
cassyarduino 0:e3fb1267e3c3 712 Enc28J60Network::writeRegPair(EDMASTL, src);
cassyarduino 0:e3fb1267e3c3 713 Enc28J60Network::writeRegPair(EDMADSTL, dest);
cassyarduino 0:e3fb1267e3c3 714
cassyarduino 0:e3fb1267e3c3 715 if ((src <= RXSTOP_INIT)&& (len > RXSTOP_INIT))len -= (RXSTOP_INIT-RXSTART_INIT);
cassyarduino 0:e3fb1267e3c3 716 Enc28J60Network::writeRegPair(EDMANDL, len);
cassyarduino 0:e3fb1267e3c3 717
cassyarduino 0:e3fb1267e3c3 718 /*
cassyarduino 0:e3fb1267e3c3 719 2. If an interrupt at the end of the copy process is
cassyarduino 0:e3fb1267e3c3 720 desired, set EIE.DMAIE and EIE.INTIE and
cassyarduino 0:e3fb1267e3c3 721 clear EIR.DMAIF.
cassyarduino 0:e3fb1267e3c3 722
cassyarduino 0:e3fb1267e3c3 723 3. Verify that ECON1.CSUMEN is clear. */
cassyarduino 0:e3fb1267e3c3 724 Enc28J60Network::writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_CSUMEN);
cassyarduino 0:e3fb1267e3c3 725
cassyarduino 0:e3fb1267e3c3 726 /* 4. Start the DMA copy by setting ECON1.DMAST. */
cassyarduino 0:e3fb1267e3c3 727 Enc28J60Network::writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_DMAST);
cassyarduino 0:e3fb1267e3c3 728
cassyarduino 0:e3fb1267e3c3 729 // wait until runnig DMA is completed
cassyarduino 0:e3fb1267e3c3 730 while (Enc28J60Network::readOp(ENC28J60_READ_CTRL_REG, ECON1) & ECON1_DMAST)
cassyarduino 0:e3fb1267e3c3 731 {
cassyarduino 0:e3fb1267e3c3 732 delay(1);
cassyarduino 0:e3fb1267e3c3 733 }
cassyarduino 0:e3fb1267e3c3 734 }
cassyarduino 0:e3fb1267e3c3 735 }
cassyarduino 0:e3fb1267e3c3 736
cassyarduino 0:e3fb1267e3c3 737 void
cassyarduino 0:e3fb1267e3c3 738 Enc28J60Network::freePacket(void)
cassyarduino 0:e3fb1267e3c3 739 {
cassyarduino 0:e3fb1267e3c3 740 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 741 LogObject.uart_send_strln(F("Enc28J60Network::freePacket(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 742 #endif
cassyarduino 0:e3fb1267e3c3 743 setERXRDPT();
cassyarduino 0:e3fb1267e3c3 744 }
cassyarduino 0:e3fb1267e3c3 745
cassyarduino 0:e3fb1267e3c3 746 uint8_t
cassyarduino 0:e3fb1267e3c3 747 Enc28J60Network::readOp(uint8_t op, uint8_t address)
cassyarduino 0:e3fb1267e3c3 748 {
cassyarduino 0:e3fb1267e3c3 749 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 750 LogObject.uart_send_strln(F("Enc28J60Network::readOp(uint8_t op, uint8_t address) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 751 #endif
cassyarduino 0:e3fb1267e3c3 752 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 753 // issue read command
cassyarduino 0:e3fb1267e3c3 754 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 755 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 756 SPI.transfer(op | (address & ADDR_MASK));
cassyarduino 0:e3fb1267e3c3 757 // read data
cassyarduino 0:e3fb1267e3c3 758 if(address & 0x80)
cassyarduino 0:e3fb1267e3c3 759 {
cassyarduino 0:e3fb1267e3c3 760 // do dummy read if needed (for mac and mii, see datasheet page 29)
cassyarduino 0:e3fb1267e3c3 761 SPI.transfer(0x00);
cassyarduino 0:e3fb1267e3c3 762 }
cassyarduino 0:e3fb1267e3c3 763 uint8_t c = SPI.transfer(0x00);
cassyarduino 0:e3fb1267e3c3 764 #endif
cassyarduino 0:e3fb1267e3c3 765 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 766 _spi.write(op | (address & ADDR_MASK));
cassyarduino 0:e3fb1267e3c3 767 // read data
cassyarduino 0:e3fb1267e3c3 768 if(address & 0x80)
cassyarduino 0:e3fb1267e3c3 769 {
cassyarduino 0:e3fb1267e3c3 770 // do dummy read if needed (for mac and mii, see datasheet page 29)
cassyarduino 0:e3fb1267e3c3 771 _spi.write(0x00);
cassyarduino 0:e3fb1267e3c3 772 }
cassyarduino 0:e3fb1267e3c3 773 uint8_t c = _spi.write(0x00);
cassyarduino 0:e3fb1267e3c3 774 #endif
cassyarduino 0:e3fb1267e3c3 775 // release CS
cassyarduino 0:e3fb1267e3c3 776 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 777 return(c);
cassyarduino 0:e3fb1267e3c3 778 #else
cassyarduino 0:e3fb1267e3c3 779 // issue read command
cassyarduino 0:e3fb1267e3c3 780 SPDR = op | (address & ADDR_MASK);
cassyarduino 0:e3fb1267e3c3 781 waitspi();
cassyarduino 0:e3fb1267e3c3 782 // read data
cassyarduino 0:e3fb1267e3c3 783 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 784 waitspi();
cassyarduino 0:e3fb1267e3c3 785 // do dummy read if needed (for mac and mii, see datasheet page 29)
cassyarduino 0:e3fb1267e3c3 786 if(address & 0x80)
cassyarduino 0:e3fb1267e3c3 787 {
cassyarduino 0:e3fb1267e3c3 788 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 789 waitspi();
cassyarduino 0:e3fb1267e3c3 790 }
cassyarduino 0:e3fb1267e3c3 791 // release CS
cassyarduino 0:e3fb1267e3c3 792 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 793 return(SPDR);
cassyarduino 0:e3fb1267e3c3 794 #endif
cassyarduino 0:e3fb1267e3c3 795 }
cassyarduino 0:e3fb1267e3c3 796
cassyarduino 0:e3fb1267e3c3 797 void
cassyarduino 0:e3fb1267e3c3 798 Enc28J60Network::writeOp(uint8_t op, uint8_t address, uint8_t data)
cassyarduino 0:e3fb1267e3c3 799 {
cassyarduino 0:e3fb1267e3c3 800 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 801 LogObject.uart_send_strln(F("Enc28J60Network::writeOp(uint8_t op, uint8_t address, uint8_t data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 802 #endif
cassyarduino 0:e3fb1267e3c3 803 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 804 // issue write command
cassyarduino 0:e3fb1267e3c3 805 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 806 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 807 SPI.transfer(op | (address & ADDR_MASK));
cassyarduino 0:e3fb1267e3c3 808 // write data
cassyarduino 0:e3fb1267e3c3 809 SPI.transfer(data);
cassyarduino 0:e3fb1267e3c3 810 #endif
cassyarduino 0:e3fb1267e3c3 811 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 812 _spi.write(op | (address & ADDR_MASK));
cassyarduino 0:e3fb1267e3c3 813 // write data
cassyarduino 0:e3fb1267e3c3 814 _spi.write(data);
cassyarduino 0:e3fb1267e3c3 815 #endif
cassyarduino 0:e3fb1267e3c3 816 #else
cassyarduino 0:e3fb1267e3c3 817 // issue write command
cassyarduino 0:e3fb1267e3c3 818 SPDR = op | (address & ADDR_MASK);
cassyarduino 0:e3fb1267e3c3 819 waitspi();
cassyarduino 0:e3fb1267e3c3 820 // write data
cassyarduino 0:e3fb1267e3c3 821 SPDR = data;
cassyarduino 0:e3fb1267e3c3 822 waitspi();
cassyarduino 0:e3fb1267e3c3 823 #endif
cassyarduino 0:e3fb1267e3c3 824 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 825 }
cassyarduino 0:e3fb1267e3c3 826
cassyarduino 0:e3fb1267e3c3 827 void
cassyarduino 0:e3fb1267e3c3 828 Enc28J60Network::readBuffer(uint16_t len, uint8_t* data)
cassyarduino 0:e3fb1267e3c3 829 {
cassyarduino 0:e3fb1267e3c3 830 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 831 LogObject.uart_send_strln(F("Enc28J60Network::readBuffer(uint16_t len, uint8_t* data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 832 #endif
cassyarduino 0:e3fb1267e3c3 833 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 834 // issue read command
cassyarduino 0:e3fb1267e3c3 835 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 836 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 837 SPI.transfer(ENC28J60_READ_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 838 #endif
cassyarduino 0:e3fb1267e3c3 839 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 840 _spi.write(ENC28J60_READ_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 841 #endif
cassyarduino 0:e3fb1267e3c3 842 #else
cassyarduino 0:e3fb1267e3c3 843 SPDR = ENC28J60_READ_BUF_MEM;
cassyarduino 0:e3fb1267e3c3 844 waitspi();
cassyarduino 0:e3fb1267e3c3 845 #endif
cassyarduino 0:e3fb1267e3c3 846 while(len)
cassyarduino 0:e3fb1267e3c3 847 {
cassyarduino 0:e3fb1267e3c3 848 len--;
cassyarduino 0:e3fb1267e3c3 849 // read data
cassyarduino 0:e3fb1267e3c3 850 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 851 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 852 *data = SPI.transfer(0x00);
cassyarduino 0:e3fb1267e3c3 853 #endif
cassyarduino 0:e3fb1267e3c3 854 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 855 *data = _spi.write(0x00);
cassyarduino 0:e3fb1267e3c3 856 #endif
cassyarduino 0:e3fb1267e3c3 857 #else
cassyarduino 0:e3fb1267e3c3 858 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 859 waitspi();
cassyarduino 0:e3fb1267e3c3 860 *data = SPDR;
cassyarduino 0:e3fb1267e3c3 861 #endif
cassyarduino 0:e3fb1267e3c3 862 data++;
cassyarduino 0:e3fb1267e3c3 863 }
cassyarduino 0:e3fb1267e3c3 864 //*data='\0';
cassyarduino 0:e3fb1267e3c3 865 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 866 }
cassyarduino 0:e3fb1267e3c3 867
cassyarduino 0:e3fb1267e3c3 868 void
cassyarduino 0:e3fb1267e3c3 869 Enc28J60Network::writeBuffer(uint16_t len, uint8_t* data)
cassyarduino 0:e3fb1267e3c3 870 {
cassyarduino 0:e3fb1267e3c3 871 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 872 LogObject.uart_send_strln(F("Enc28J60Network::writeBuffer(uint16_t len, uint8_t* data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 873 #endif
cassyarduino 0:e3fb1267e3c3 874 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 875 // issue write command
cassyarduino 0:e3fb1267e3c3 876 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 877 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 878 SPI.transfer(ENC28J60_WRITE_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 879 #endif
cassyarduino 0:e3fb1267e3c3 880 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 881 _spi.write(ENC28J60_WRITE_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 882 #endif
cassyarduino 0:e3fb1267e3c3 883 #else
cassyarduino 0:e3fb1267e3c3 884 SPDR = ENC28J60_WRITE_BUF_MEM;
cassyarduino 0:e3fb1267e3c3 885 waitspi();
cassyarduino 0:e3fb1267e3c3 886 #endif
cassyarduino 0:e3fb1267e3c3 887 while(len)
cassyarduino 0:e3fb1267e3c3 888 {
cassyarduino 0:e3fb1267e3c3 889 len--;
cassyarduino 0:e3fb1267e3c3 890 // write data
cassyarduino 0:e3fb1267e3c3 891 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 892 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 893 SPI.transfer(*data);
cassyarduino 0:e3fb1267e3c3 894 #endif
cassyarduino 0:e3fb1267e3c3 895 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 896 _spi.write(*data);
cassyarduino 0:e3fb1267e3c3 897 #endif
cassyarduino 0:e3fb1267e3c3 898 data++;
cassyarduino 0:e3fb1267e3c3 899 #else
cassyarduino 0:e3fb1267e3c3 900 SPDR = *data;
cassyarduino 0:e3fb1267e3c3 901 data++;
cassyarduino 0:e3fb1267e3c3 902 waitspi();
cassyarduino 0:e3fb1267e3c3 903 #endif
cassyarduino 0:e3fb1267e3c3 904 }
cassyarduino 0:e3fb1267e3c3 905 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 906 }
cassyarduino 0:e3fb1267e3c3 907
cassyarduino 0:e3fb1267e3c3 908 void
cassyarduino 0:e3fb1267e3c3 909 Enc28J60Network::setBank(uint8_t address)
cassyarduino 0:e3fb1267e3c3 910 {
cassyarduino 0:e3fb1267e3c3 911 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 912 LogObject.uart_send_strln(F("Enc28J60Network::setBank(uint8_t address) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 913 #endif
cassyarduino 0:e3fb1267e3c3 914 // set the bank (if needed)
cassyarduino 0:e3fb1267e3c3 915 if((address & BANK_MASK) != bank)
cassyarduino 0:e3fb1267e3c3 916 {
cassyarduino 0:e3fb1267e3c3 917 // set the bank
cassyarduino 0:e3fb1267e3c3 918 writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, (ECON1_BSEL1|ECON1_BSEL0));
cassyarduino 0:e3fb1267e3c3 919 writeOp(ENC28J60_BIT_FIELD_SET, ECON1, (address & BANK_MASK)>>5);
cassyarduino 0:e3fb1267e3c3 920 bank = (address & BANK_MASK);
cassyarduino 0:e3fb1267e3c3 921 }
cassyarduino 0:e3fb1267e3c3 922 }
cassyarduino 0:e3fb1267e3c3 923
cassyarduino 0:e3fb1267e3c3 924 uint8_t
cassyarduino 0:e3fb1267e3c3 925 Enc28J60Network::readReg(uint8_t address)
cassyarduino 0:e3fb1267e3c3 926 {
cassyarduino 0:e3fb1267e3c3 927 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 928 LogObject.uart_send_strln(F("Enc28J60Network::readReg(uint8_t address) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 929 #endif
cassyarduino 0:e3fb1267e3c3 930 // set the bank
cassyarduino 0:e3fb1267e3c3 931 setBank(address);
cassyarduino 0:e3fb1267e3c3 932 // do the read
cassyarduino 0:e3fb1267e3c3 933 return readOp(ENC28J60_READ_CTRL_REG, address);
cassyarduino 0:e3fb1267e3c3 934 }
cassyarduino 0:e3fb1267e3c3 935
cassyarduino 0:e3fb1267e3c3 936 void
cassyarduino 0:e3fb1267e3c3 937 Enc28J60Network::writeReg(uint8_t address, uint8_t data)
cassyarduino 0:e3fb1267e3c3 938 {
cassyarduino 0:e3fb1267e3c3 939 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 940 LogObject.uart_send_strln(F("Enc28J60Network::writeReg(uint8_t address, uint8_t data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 941 #endif
cassyarduino 0:e3fb1267e3c3 942 // set the bank
cassyarduino 0:e3fb1267e3c3 943 setBank(address);
cassyarduino 0:e3fb1267e3c3 944 // do the write
cassyarduino 0:e3fb1267e3c3 945 writeOp(ENC28J60_WRITE_CTRL_REG, address, data);
cassyarduino 0:e3fb1267e3c3 946 }
cassyarduino 0:e3fb1267e3c3 947
cassyarduino 0:e3fb1267e3c3 948 void
cassyarduino 0:e3fb1267e3c3 949 Enc28J60Network::writeRegPair(uint8_t address, uint16_t data)
cassyarduino 0:e3fb1267e3c3 950 {
cassyarduino 0:e3fb1267e3c3 951 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 952 LogObject.uart_send_strln(F("Enc28J60Network::writeRegPair(uint8_t address, uint16_t data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 953 #endif
cassyarduino 0:e3fb1267e3c3 954 // set the bank
cassyarduino 0:e3fb1267e3c3 955 setBank(address);
cassyarduino 0:e3fb1267e3c3 956 // do the write
cassyarduino 0:e3fb1267e3c3 957 writeOp(ENC28J60_WRITE_CTRL_REG, address, (data&0xFF));
cassyarduino 0:e3fb1267e3c3 958 writeOp(ENC28J60_WRITE_CTRL_REG, address+1, (data) >> 8);
cassyarduino 0:e3fb1267e3c3 959 }
cassyarduino 0:e3fb1267e3c3 960
cassyarduino 0:e3fb1267e3c3 961 void
cassyarduino 0:e3fb1267e3c3 962 Enc28J60Network::phyWrite(uint8_t address, uint16_t data)
cassyarduino 0:e3fb1267e3c3 963 {
cassyarduino 0:e3fb1267e3c3 964 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 965 LogObject.uart_send_strln(F("Enc28J60Network::phyWrite(uint8_t address, uint16_t data) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 966 #endif
cassyarduino 0:e3fb1267e3c3 967 unsigned int timeout = 15;
cassyarduino 0:e3fb1267e3c3 968 // set the PHY register address
cassyarduino 0:e3fb1267e3c3 969 writeReg(MIREGADR, address);
cassyarduino 0:e3fb1267e3c3 970 // write the PHY data
cassyarduino 0:e3fb1267e3c3 971 writeRegPair(MIWRL, data);
cassyarduino 0:e3fb1267e3c3 972 // wait until the PHY write completes
cassyarduino 0:e3fb1267e3c3 973 while (readReg(MISTAT) & MISTAT_BUSY)
cassyarduino 0:e3fb1267e3c3 974 {
cassyarduino 0:e3fb1267e3c3 975 delay(10);
cassyarduino 0:e3fb1267e3c3 976 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 977 wdt_reset();
cassyarduino 0:e3fb1267e3c3 978 #endif
cassyarduino 0:e3fb1267e3c3 979 if (--timeout == 0)
cassyarduino 0:e3fb1267e3c3 980 {
cassyarduino 0:e3fb1267e3c3 981 #if ACTLOGLEVEL>=LOG_ERR
cassyarduino 0:e3fb1267e3c3 982 LogObject.uart_send_strln(F("Enc28J60Network::phyWrite ERROR:TIMEOUT !!!"));
cassyarduino 0:e3fb1267e3c3 983 #endif
cassyarduino 0:e3fb1267e3c3 984 return;
cassyarduino 0:e3fb1267e3c3 985 }
cassyarduino 0:e3fb1267e3c3 986 }
cassyarduino 0:e3fb1267e3c3 987 }
cassyarduino 0:e3fb1267e3c3 988
cassyarduino 0:e3fb1267e3c3 989 uint16_t
cassyarduino 0:e3fb1267e3c3 990 Enc28J60Network::phyRead(uint8_t address)
cassyarduino 0:e3fb1267e3c3 991 {
cassyarduino 0:e3fb1267e3c3 992 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 993 LogObject.uart_send_strln(F("Enc28J60Network::phyRead(uint8_t address) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 994 #endif
cassyarduino 0:e3fb1267e3c3 995 unsigned int timeout = 15;
cassyarduino 0:e3fb1267e3c3 996 writeReg(MIREGADR,address);
cassyarduino 0:e3fb1267e3c3 997 writeReg(MICMD, MICMD_MIIRD);
cassyarduino 0:e3fb1267e3c3 998 // wait until the PHY read completes
cassyarduino 0:e3fb1267e3c3 999 while(readReg(MISTAT) & MISTAT_BUSY)
cassyarduino 0:e3fb1267e3c3 1000 {
cassyarduino 0:e3fb1267e3c3 1001 delay(10);
cassyarduino 0:e3fb1267e3c3 1002 #if defined(ESP8266)
cassyarduino 0:e3fb1267e3c3 1003 wdt_reset();
cassyarduino 0:e3fb1267e3c3 1004 #endif
cassyarduino 0:e3fb1267e3c3 1005 if (--timeout == 0)
cassyarduino 0:e3fb1267e3c3 1006 {
cassyarduino 0:e3fb1267e3c3 1007 #if ACTLOGLEVEL>=LOG_ERR
cassyarduino 0:e3fb1267e3c3 1008 LogObject.uart_send_strln(F("Enc28J60Network::phyRead ERROR:TIMEOUT !!!"));
cassyarduino 0:e3fb1267e3c3 1009 #endif
cassyarduino 0:e3fb1267e3c3 1010 return 0;
cassyarduino 0:e3fb1267e3c3 1011 }
cassyarduino 0:e3fb1267e3c3 1012 }
cassyarduino 0:e3fb1267e3c3 1013 writeReg(MICMD, 0);
cassyarduino 0:e3fb1267e3c3 1014 return (readReg(MIRDL) | readReg(MIRDH) << 8);
cassyarduino 0:e3fb1267e3c3 1015 }
cassyarduino 0:e3fb1267e3c3 1016
cassyarduino 0:e3fb1267e3c3 1017 void
cassyarduino 0:e3fb1267e3c3 1018 Enc28J60Network::clkout(uint8_t clk)
cassyarduino 0:e3fb1267e3c3 1019 {
cassyarduino 0:e3fb1267e3c3 1020 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1021 LogObject.uart_send_strln(F("Enc28J60Network::clkout(uint8_t clk) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 1022 #endif
cassyarduino 0:e3fb1267e3c3 1023 //setup clkout: 2 is 12.5MHz:
cassyarduino 0:e3fb1267e3c3 1024 writeReg(ECOCON, clk & 0x7);
cassyarduino 0:e3fb1267e3c3 1025 }
cassyarduino 0:e3fb1267e3c3 1026
cassyarduino 0:e3fb1267e3c3 1027 uint16_t
cassyarduino 0:e3fb1267e3c3 1028 Enc28J60Network::chksum(uint16_t sum, memhandle handle, memaddress pos, uint16_t len)
cassyarduino 0:e3fb1267e3c3 1029 {
cassyarduino 0:e3fb1267e3c3 1030 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1031 LogObject.uart_send_strln(F("Enc28J60Network::chksum(uint16_t sum, memhandle handle, memaddress pos, uint16_t len) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 1032 #endif
cassyarduino 0:e3fb1267e3c3 1033 uint16_t t;
cassyarduino 0:e3fb1267e3c3 1034 len = setReadPtr(handle, pos, len)-1;
cassyarduino 0:e3fb1267e3c3 1035 CSACTIVE;
cassyarduino 0:e3fb1267e3c3 1036 // issue read command
cassyarduino 0:e3fb1267e3c3 1037 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 1038 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 1039 SPI.transfer(ENC28J60_READ_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 1040 #endif
cassyarduino 0:e3fb1267e3c3 1041 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 1042 _spi.write(ENC28J60_READ_BUF_MEM);
cassyarduino 0:e3fb1267e3c3 1043 #endif
cassyarduino 0:e3fb1267e3c3 1044 #else
cassyarduino 0:e3fb1267e3c3 1045 SPDR = ENC28J60_READ_BUF_MEM;
cassyarduino 0:e3fb1267e3c3 1046 waitspi();
cassyarduino 0:e3fb1267e3c3 1047 #endif
cassyarduino 0:e3fb1267e3c3 1048 uint16_t i;
cassyarduino 0:e3fb1267e3c3 1049 for (i = 0; i < len; i+=2)
cassyarduino 0:e3fb1267e3c3 1050 {
cassyarduino 0:e3fb1267e3c3 1051 // read data
cassyarduino 0:e3fb1267e3c3 1052 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 1053 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 1054 t = SPI.transfer(0x00) << 8;
cassyarduino 0:e3fb1267e3c3 1055 t += SPI.transfer(0x00);
cassyarduino 0:e3fb1267e3c3 1056 #endif
cassyarduino 0:e3fb1267e3c3 1057 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 1058 t = _spi.write(0x00) << 8;
cassyarduino 0:e3fb1267e3c3 1059 t += _spi.write(0x00);
cassyarduino 0:e3fb1267e3c3 1060 #endif
cassyarduino 0:e3fb1267e3c3 1061 #else
cassyarduino 0:e3fb1267e3c3 1062 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 1063 waitspi();
cassyarduino 0:e3fb1267e3c3 1064 t = SPDR << 8;
cassyarduino 0:e3fb1267e3c3 1065 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 1066 waitspi();
cassyarduino 0:e3fb1267e3c3 1067 t += SPDR;
cassyarduino 0:e3fb1267e3c3 1068 #endif
cassyarduino 0:e3fb1267e3c3 1069 sum += t;
cassyarduino 0:e3fb1267e3c3 1070 if(sum < t)
cassyarduino 0:e3fb1267e3c3 1071 {
cassyarduino 0:e3fb1267e3c3 1072 sum++; /* carry */
cassyarduino 0:e3fb1267e3c3 1073 }
cassyarduino 0:e3fb1267e3c3 1074 }
cassyarduino 0:e3fb1267e3c3 1075 if(i == len)
cassyarduino 0:e3fb1267e3c3 1076 {
cassyarduino 0:e3fb1267e3c3 1077 #if ENC28J60_USE_SPILIB
cassyarduino 0:e3fb1267e3c3 1078 #if defined(ARDUINO)
cassyarduino 0:e3fb1267e3c3 1079 t = (SPI.transfer(0x00) << 8) + 0;
cassyarduino 0:e3fb1267e3c3 1080 #endif
cassyarduino 0:e3fb1267e3c3 1081 #if defined(__MBED__)
cassyarduino 0:e3fb1267e3c3 1082 t = (_spi.write(0x00) << 8) + 0;
cassyarduino 0:e3fb1267e3c3 1083 #endif
cassyarduino 0:e3fb1267e3c3 1084 #else
cassyarduino 0:e3fb1267e3c3 1085 SPDR = 0x00;
cassyarduino 0:e3fb1267e3c3 1086 waitspi();
cassyarduino 0:e3fb1267e3c3 1087 t = (SPDR << 8) + 0;
cassyarduino 0:e3fb1267e3c3 1088 #endif
cassyarduino 0:e3fb1267e3c3 1089 sum += t;
cassyarduino 0:e3fb1267e3c3 1090 if(sum < t)
cassyarduino 0:e3fb1267e3c3 1091 {
cassyarduino 0:e3fb1267e3c3 1092 sum++; /* carry */
cassyarduino 0:e3fb1267e3c3 1093 }
cassyarduino 0:e3fb1267e3c3 1094 }
cassyarduino 0:e3fb1267e3c3 1095 CSPASSIVE;
cassyarduino 0:e3fb1267e3c3 1096
cassyarduino 0:e3fb1267e3c3 1097 /* Return sum in host byte order. */
cassyarduino 0:e3fb1267e3c3 1098 return sum;
cassyarduino 0:e3fb1267e3c3 1099 }
cassyarduino 0:e3fb1267e3c3 1100
cassyarduino 0:e3fb1267e3c3 1101 void
cassyarduino 0:e3fb1267e3c3 1102 Enc28J60Network::powerOff(void)
cassyarduino 0:e3fb1267e3c3 1103 {
cassyarduino 0:e3fb1267e3c3 1104 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1105 LogObject.uart_send_strln(F("Enc28J60Network::powerOff(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 1106 #endif
cassyarduino 0:e3fb1267e3c3 1107 writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_RXEN);
cassyarduino 0:e3fb1267e3c3 1108 delay(50);
cassyarduino 0:e3fb1267e3c3 1109 writeOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_VRPS);
cassyarduino 0:e3fb1267e3c3 1110 delay(50);
cassyarduino 0:e3fb1267e3c3 1111 writeOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PWRSV);
cassyarduino 0:e3fb1267e3c3 1112 }
cassyarduino 0:e3fb1267e3c3 1113
cassyarduino 0:e3fb1267e3c3 1114 void
cassyarduino 0:e3fb1267e3c3 1115 Enc28J60Network::powerOn(void)
cassyarduino 0:e3fb1267e3c3 1116 {
cassyarduino 0:e3fb1267e3c3 1117 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1118 LogObject.uart_send_strln(F("Enc28J60Network::powerOn(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 1119 #endif
cassyarduino 0:e3fb1267e3c3 1120 writeOp(ENC28J60_BIT_FIELD_CLR, ECON2, ECON2_PWRSV);
cassyarduino 0:e3fb1267e3c3 1121 delay(50);
cassyarduino 0:e3fb1267e3c3 1122 writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN);
cassyarduino 0:e3fb1267e3c3 1123 delay(50);
cassyarduino 0:e3fb1267e3c3 1124 }
cassyarduino 0:e3fb1267e3c3 1125
cassyarduino 0:e3fb1267e3c3 1126 // read erevid from object:
cassyarduino 0:e3fb1267e3c3 1127 uint8_t
cassyarduino 0:e3fb1267e3c3 1128 Enc28J60Network::geterevid(void)
cassyarduino 0:e3fb1267e3c3 1129 {
cassyarduino 0:e3fb1267e3c3 1130 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1131 LogObject.uart_send_str(F("Enc28J60Network::geterevid(void) DEBUG_V3:Function started and return:"));
cassyarduino 0:e3fb1267e3c3 1132 LogObject.uart_send_decln(erevid);
cassyarduino 0:e3fb1267e3c3 1133 #endif
cassyarduino 0:e3fb1267e3c3 1134 return(erevid);
cassyarduino 0:e3fb1267e3c3 1135 }
cassyarduino 0:e3fb1267e3c3 1136
cassyarduino 0:e3fb1267e3c3 1137 // read the phstat2 of the chip:
cassyarduino 0:e3fb1267e3c3 1138 uint16_t
cassyarduino 0:e3fb1267e3c3 1139 Enc28J60Network::PhyStatus(void)
cassyarduino 0:e3fb1267e3c3 1140 {
cassyarduino 0:e3fb1267e3c3 1141 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1142 LogObject.uart_send_str(F("Enc28J60Network::PhyStatus(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 1143 LogObject.uart_send_decln(erevid);
cassyarduino 0:e3fb1267e3c3 1144 #endif
cassyarduino 0:e3fb1267e3c3 1145 uint16_t phstat2;
cassyarduino 0:e3fb1267e3c3 1146 phstat2=phyRead(PHSTAT2);
cassyarduino 0:e3fb1267e3c3 1147 if ((phstat2 & 0x20) > 0) {phstat2=phstat2 &0x100;}
cassyarduino 0:e3fb1267e3c3 1148 phstat2=(phstat2 & 0xFF00) | erevid;
cassyarduino 0:e3fb1267e3c3 1149 if ((phstat2 & 0x8000) > 0) {phstat2=0;}
cassyarduino 0:e3fb1267e3c3 1150 return phstat2;
cassyarduino 0:e3fb1267e3c3 1151 }
cassyarduino 0:e3fb1267e3c3 1152
cassyarduino 0:e3fb1267e3c3 1153 bool
cassyarduino 0:e3fb1267e3c3 1154 Enc28J60Network::linkStatus(void)
cassyarduino 0:e3fb1267e3c3 1155 {
cassyarduino 0:e3fb1267e3c3 1156 #if ACTLOGLEVEL>=LOG_DEBUG_V3
cassyarduino 0:e3fb1267e3c3 1157 LogObject.uart_send_strln(F("Enc28J60Network::linkStatus(void) DEBUG_V3:Function started"));
cassyarduino 0:e3fb1267e3c3 1158 #endif
cassyarduino 0:e3fb1267e3c3 1159 return (phyRead(PHSTAT2) & 0x0400) > 0;
cassyarduino 0:e3fb1267e3c3 1160 }
cassyarduino 0:e3fb1267e3c3 1161
cassyarduino 0:e3fb1267e3c3 1162 Enc28J60Network Enc28J60;