cassyarduino cassyarduino / UIPEthernet

UIPEthernet library for Arduino IDE, Eclipse with arduino plugin and MBED/SMeshStudio (AVR,STM32F,ESP8266,Intel ARC32,Nordic nRF51,Teensy boards,Realtek Ameba(RTL8195A,RTL8710)), ENC28j60 network chip. Compatible with Wiznet W5100 Ethernet library API. Compiled and tested on Nucleo-F302R8. Master repository is: https://github.com/UIPEthernet/UIPEthernet/

utility/Enc28J60Network.cpp@39:deeb00b81cc9, 2018-01-23 (annotated)

Committer:
cassyarduino
Date:
Tue Jan 23 15:08:43 2018 +0100
Revision:
39:deeb00b81cc9
Parent:
36:689bcc358067 
Release: 2.0.4

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