stm32 enc28j60

[guillaume83]

Bonjour,
je souhait réaliser une liaison ethernet avec un stm32f103 et un module à base d'un enc28j60.
je fais des tests avec le code cijoint, mais ca marche pas quand je taoe l'adresse ip du serveur dans IE.
je fais les tests avec un cable croisé branché sur la prise réseau de mon pc,
les signaux cs et rest sont ok (testé au multimétre), la liaison spi semble bonne parcequ la led orange sur la prise du module ecn28J60 clignote
toutes les secondes . J' ai aussi baissé la vitesse spi au cas ou, j'ai également modifié les deux derniers chiffres de l'adresse ip .
Auriez vous d'autre pistes à me proposées?
@+

[katmai]

Bonjour,

Tu peux utiliser wireshark pour voir si le module ethernet répond effectivement, et par la suite déboguer tes communications.

A+

[guillaume83]

Merci pour votre réponse , je vais essaier wireshark.
@+

[guillaume83]

Aprés les premiers essais , il y a trois paquetsà la connection et parfois quelques autre aprés plusieur secondes , mais je sais pas si il sont émits par le pc ou par le module .
je vais essayer d'envoyer un seul paquet de format connu, pour voir si je le recoi bien .
il faut aussi que je vérifi si la sérigraphi du module est juste( j' ai moyennement confiance au chinois là dessus).
Je vous tiendrai en courant, dans quelque temps, des avancées car ma femme ma trouvé de la massonerie à faire
@+

[katmai]

Bonne maçonnerie alors .

Aufaite pour envoyer des paquets à ta cible facilement il existe le logiciel scapy.

Par contre il est assez difficile à prendre en main si mes souvenirs sont bons.

A+

[guillaume83]

Bonjour,
aprés une semaine de dur labeur, j ai repri mes essais .
le Hard semble fonctionner corectement , j' arrive à envoyer un buffer de 1000 paquets au pc (visualisés par wireshark)
J 'ai regardé scapy, vraiment au dessus de mes connaissances(pour l'instant).
@+

[guillaume83]

Pour envoyer des paquets j 'ai trouvé OSTINATO , c'est plus simple que scapy , donc moin de fonctions, mais pas mal de tutos.
J ai réussi à envoyer une requette ping (en regardant ce que voulai le programme)et donc générer la reponse .
@+

[guillaume83]

Bon j'ai fait une grande avancée.
j' ai configuré le pc en ip fixe , avec l'adresse de passerelle par defult , l'adresse ip ,du enc28J60.
Avec cette configue le module répond à une requette ping, Mais lors d'une requette http pour envoie de la page web je passe en hardfault, surement un souci dans le prog, je pense à un dépassement de mémoire ou un truc de ce genre.
Il faut auussi que je fouille sur g..le pour voir si il n'y a pas une réponce à faire au pc aprés sa requette de découverte réseaux.
Sa avance ............tout doucement , mais ca avance quand meme.
@+
.

[dida2013]

Bonjouur,

Je suis nouvelle sur ce forum et aussi débutante dans le monde de l'embarqué.
Bon , je dois réaliser une passerelle CPL Ethernet, j'utilise également le controleur Ethernet KSZ8851 avec STM32F103.
Je voudrais savoir si le ENC28J60 ressemble beaucoup à KSZ8851 au niveau de la config??


Mercii de me répondre

[guillaume83]

L'enc28J60 est beaucoup plus ancien et n'a pas toutes les fonctions du KSZ8851.
il semble peu probable que les registres de commande soit les meme.pour la config;
@+

[dida2013]

D'accord, mais le probleme qui se pose c'est au niveau de la documentation et des exemples . pour l enc28j60 y'en a plusieurs.
Par contre pour le ksz8851SNL je trouve que la datasheet , rien de plus !!! et en tant que débutante , je galère :s
t'aurais pas des exemples de projets ou n'importe ou meme des tuto explicant comment configurer les registres ??

Merci

[dida2013]

Bonjour ,

Merci de m'aider c est urg !!
J'arrive pas à communiquer avec le device ( ksz8851 snl) , mon microcontrolleur je rappelle c'est le stm32F103, au début de la communication je bloque à step 1 càd je dev_id est toujours différent du mask id .

Je me dis que c'est peut etre un pb de SPI mais j'ai beau vérifié , je ne vois pas l'erreur , merci de m'aider

voilà mon code :

/*
****************************** ****************************** ******************
* @file ethernet.c
* @brief Ethernet communication.
****************************** ****************************** ******************
*/


/*Description : This driver provides initialization and transmit/receive functions for the Micrel KSZ8851SNL 10/100 Ethernet Controller and PHY.
This chip is novel in that it is a full 10/100 MAC+PHY interface all in a 32-pin chip, using an SPI interface to the host processor.*/
/* Includes ------------------------------------------------------------------*/
#include "ethernet.h"
#include "config.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

#define SPI_BEGIN 0
#define SPI_CONTINUE 1
#define SPI_END 2
#define SPI_COMPLETE 3


/*---------------------------------------------------------------------------------------*/
void ETH_spi_init(void){

SPI_InitTypeDef SPI2_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB 1Periph_SPI2, ENABLE);
CS_HIGH();
// SPI_Cmd(SPI2,DISABLE);
/* Initialize the SPI_Direction member */
(&SPI2_InitStructure)->SPI_Direction = SPI_Direction_2Lines_FullDuple x;
/* initialize the SPI_Mode member */
(&SPI2_InitStructure)->SPI_Mode = SPI_Mode_Master;
/* initialize the SPI_DataSize member */
(&SPI2_InitStructure)->SPI_DataSize = SPI_DataSize_8b;
/* Initialize the SPI_CPOL member */
(&SPI2_InitStructure)->SPI_CPOL = SPI_CPOL_Low;
/* Initialize the SPI_CPHA member */
(&SPI2_InitStructure)->SPI_CPHA = SPI_CPHA_2Edge;
/* Initialize the SPI_NSS member */
//(&SPI2_InitStructure)->SPI_NSS = SPI_NSS_Hard;
(&SPI2_InitStructure)->SPI_NSS = SPI_NSS_Soft;
/* Initialize the SPI_BaudRatePrescaler member */
(&SPI2_InitStructure)->SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
/* Initialize the SPI_FirstBit member */
(&SPI2_InitStructure)->SPI_FirstBit = SPI_FirstBit_MSB;
/* Initialize the SPI_CRCPolynomial member */
(&SPI2_InitStructure)->SPI_CRCPolynomial =7;
SPI_Init(SPI2, &SPI2_InitStructure);
SPI_Cmd(SPI2,ENABLE);

// Enable SPI2 Receive and Transmit interrupts
// SPI_I2S_ITConfig(SPI2, SPI_IT_TXE,ENABLE);
// SPI_I2S_ITConfig(SPI2, SPI_IT_RXNE,ENABLE);


}

void ETH_GPIO_init(void){

GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB 2Periph_GPIO_ETH, ENABLE);


//CLK = PB13 (Alternative Function, Push Pull)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);

//SDI(MISO) = PB15 (Input Pull-Up)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init( GPIOB, &GPIO_InitStructure);

//SDO(MOSI) = PB14 (Alternative Function, Push Pull)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);

//CSN = PB12 (General Purpose Output)
GPIO_InitStructure.GPIO_Pin = KSZ8851_CSN_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
CS_HIGH();


//INTRN=PB11
GPIO_InitStructure.GPIO_Pin = KSZ8851_SPI_INTERN_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStructure);

//PME=PB10
GPIO_InitStructure.GPIO_Pin = KSZ8851_SPI_PME_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStructure);

//RSTN=PC6
GPIO_InitStructure.GPIO_Pin = KSZ8851_RESET_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIOC->BSRR = KSZ8851_RESET_PIN;
}

/*---------------------------------------------------------------------------------------*/
/* spi_send() sends one byte (outdat) and returns the received byte */
static uint8_t spi_send(uint8_t outdat)
{
CS_LOW();
SPI2->DR= outdat; // write data to be transmitted to the SPI data register

while(!(SPI2->SR & SPI_I2S_FLAG_TXE)); // Wait for SPI transmission to complete
SPI_I2S_SendData( SPI2, outdat );

while( !(SPI2->SR & SPI_I2S_FLAG_RXNE) ); // wait until receive complete

//indat = SPI2->DR; // return received data from SPI data register

//printf("spi_byte: writing 0x%.2x, reading 0x%.2x\n", outdat, indat);
CS_HIGH();
return SPI_I2S_ReceiveData( SPI2 );
}

/*---------------------------------------------------------------------------------------*/
/* spi_op() performs register reads, register writes, FIFO reads, and
* FIFO writes. It can also either:
* Do one complete SPI transfer (with CSN bracketing all of the SPI bytes),
* Start an SPI transfer (asserting CSN but not negating it),
* Continue an SPI transfer (leaving CSN in the asserted state), or
* End an SPI transfer (negating CSN at the end of the transfer).
*/

static void spi_op(uint8_t phase, uint16_t cmd, uint8_t *buf, uint16_t len)
{
uint16_t opcode;
uint16_t ii;

opcode = cmd & OPCODE_MASK;

if ((phase == SPI_BEGIN) || (phase == SPI_COMPLETE)) {

/* Drop CSN */
//GPIOB->BSRR |= GPIO_BSRR_BS12;
CS_LOW();//set pin PB12

/* Command phase */
spi_send(cmd >> 8);
if ((opcode == IO_RD) || (opcode == IO_WR)) {
/* Do extra byte for command phase */
spi_send(cmd & 0xff);
}

//GPIOB->BSRR &= GPIO_BSRR_BS12;
CS_HIGH(); // Reset PIN PB12
}

/* Data phase */
if ((opcode == IO_RD) || (opcode == FIFO_RD)) {
for (ii = 0; ii < len; ii++) {
*buf++ = spi_send(0);
}
} else {
for (ii = 0; ii < len; ii++) {
spi_send(*buf++);
}
}

if ((phase == SPI_END) || (phase == SPI_COMPLETE)) {
/* Negate CSN */
//GPIOB->BSRR |= GPIO_BSRR_BS12;
CS_LOW();
}
}

/*-------------------------------------------------------------------------------------------*/

/* ETH_REG_READ() will read one 16-bit word from reg. */

uint16_t ETH_REG_READ(uint16_t reg){

uint16_t cmd;
uint8_t inbuf[2];
uint16_t rddata;

/* Move register address to cmd bits 9-2, make 32-bit address */
cmd = (reg << 2) & 0x3f0;

/* Add byte enables to cmd */
if (reg & 2) {
/* Odd word address writes bytes 2 and 3 */
cmd |= (0xc << 10);
} else {
/* Even word address write bytes 0 and 1 */
cmd |= (0x3 << 10);
}

/* Add opcode to cmd */
cmd |= IO_RD;

spi_op(SPI_COMPLETE, cmd, inbuf, 2);

/* Byte 0 is first in, byte 1 is next */
rddata = (inbuf[1] << 8) | inbuf[0];

//printf("ksz8851_regrd: reading 0x%.4x from 0x%.4x\n", rddata, reg);

return rddata;
}

/*-------------------------------------------------------------------------------------------*/

/* ETH_REG_WRITE() will write one 16-bit word (wrdata) to reg. */

void ETH_REG_WRITE(uint16_t reg, uint16_t wrdata) {

uint16_t cmd;
uint8_t outbuf[2];

//printf("ksz8851_regwr: writing 0x%.4x to 0x%.4x\n", wrdata, reg);

/* Move register address to cmd bits 9-2, make 32-bit address */
cmd = (reg << 2) & 0x3f0;

/* Add byte enables to cmd */
if (reg & 2) {
/* Odd word address writes bytes 2 and 3 */
cmd |= (0xc << 10);
} else {
/* Even word address write bytes 0 and 1 */
cmd |= (0x3 << 10);
}

/* Add opcode to cmd */
cmd |= IO_WR;

/* Byte 0 is first out, byte 1 is next */
outbuf[0] = wrdata & 0xff;
outbuf[1] = wrdata >> 8;

spi_op(SPI_COMPLETE, cmd, outbuf, 2);
}


/*---------------------------------------------------------------------------------------*/

/* spi_setbits() will set all of the bits in bits_to_set in register reg. */

void spi_setbits(uint16_t reg, uint16_t bits_to_set){
uint16_t temp;

temp = ETH_REG_READ(reg);
temp |= bits_to_set;
ETH_REG_WRITE(reg, temp);
}
/*-------------------------------------------------------------------------------------------*/

/* spi_clrbits() will clear all of the bits in bits_to_clr in register reg. */

void spi_clrbits(uint16_t reg, uint16_t bits_to_clr){
uint16_t temp;

temp = ETH_REG_READ(reg);
temp &= ~bits_to_clr;
ETH_REG_WRITE(reg, temp);
}



/*-------------------------------------------------------------------------------------------*/
void ksz8851_init(void){
uint16_t dev_id=0;

ETH_spi_init();


/*-------------------------- Step 1 ------------------------------------*/
/* verify device chip ID */
/*Read the device chip ID, make sure it is correct ID (0x8870 for KSZ8851);*/
/*otherwise there are some errors on the host bus interface. */
/*-------------------------------------------------------------------------*/


/* Make sure we get a valid chip ID before going on */
do {
#if USE_KSZ8851_HW_RESET
GPIOC->BSRR = KSZ8851_RESET_PIN;;
delay_ms(10);
GPIOC->BRR = KSZ8851_RESET_PIN;;
#else
/* Perform Global Soft Reset */
spi_setbits(REG_RESET_CTRL, GLOBAL_SOFTWARE_RESET);
spi_clrbits(REG_RESET_CTRL, GLOBAL_SOFTWARE_RESET);
#endif

/* Read device chip ID */
dev_id=ETH_REG_READ(REG_CHIP_I D);
if ((dev_id & CHIP_ID_MASK) != CHIP_ID_8851_16) {
printf("Expected Device ID 0x%x, got 0x%x\n",0x8870, dev_id);
}
}
while (dev_id != CHIP_ID_8851_16);


/*-------------------------- Step 2 ------------------------------------*/
/* MAC address is generally expressed in */
/* the form of 01:23:45:67:89:AB. (we use this MAC as an example) */
/*-------------------------------------------------------------------------*/

/* Write QMU MAC address (low) */
ETH_REG_WRITE(0x10, (ETH_MAC_4 << 8) | ETH_MAC_5);
/* Write QMU MAC address (middle) */
ETH_REG_WRITE(0x12, (ETH_MAC_2 << 8) | ETH_MAC_3);
/* Write QMU MAC address (high) */
ETH_REG_WRITE(0x14, (ETH_MAC_0 << 8) | ETH_MAC_1);


/*-------------------------- Step 3 ------------------------------------*/
/* - Enable QMU Transmit & Receive Frame Data Pointer Auto Increment. */
/*-------------------------------------------------------------------------*/

ETH_REG_WRITE(REG_TX_ADDR_PTR, ADDR_PTR_AUTO_INC);

/*-------------------------- Step 4 ------------------------------------*/
/*Enable QMU Transmit flow control / Transmit padding /Transmit CRC, and
IP/TCP/UDP/ICMP checksum generation. */
/*-------------------------------------------------------------------------*/

ETH_REG_WRITE(REG_TX_CTRL, DEFAULT_TX_CTRL);

/*-------------------------- Step 5 ------------------------------------*/
/* - Configure Receive Frame Threshold for one frame. */
/*-------------------------------------------------------------------------*/

ETH_REG_WRITE(REG_RX_FRAME_CNT _THRES, 1);

/*-------------------------- Step 6A ------------------------------------*/
/* Enable QMU Receive flow control / Receive all broadcastframes */
/* Receive unicast frames, and IP/TCP/UDP checksum verification etc. */
/*-------------------------------------------------------------------------*/

ETH_REG_WRITE(REG_RX_CTRL1, DEFAULT_RX_CTRL1);

/*-------------------------- Step 6B ------------------------------------*/
/*6B - Enable QMU Receive ICMP /UDP Lite frame checksum verification, */
/* UDP Lite frame checksum generation, IPv6 UDP fragment frame pass, */
/* single frame data burst if SPI master controller could read a single */
/* frame data in one SPI CSN activate */
/*-------------------------------------------------------------------------*/

ETH_REG_WRITE(REG_RX_CTRL2, DEFAULT_RX_CTRL2 | RX_CTRL_BURST_LEN_FRAME);


/*-------------------------- Step 7 ------------------------------------*/
/* Enable QMU Receive IP Header Two-Byte Offset/Receive Frame Count */
/* Threshold/RXQ Auto-Dequeue frame */
/*-------------------------------------------------------------------------*/

ETH_REG_WRITE(REG_RXQ_CMD, RXQ_CMD_CNTL);


/*-------------------------- Step 8 ------------------------------------*/
/* Restart Port 1 auto-negotiation. */
/*-------------------------------------------------------------------------*/

spi_setbits(REG_PORT_CTRL, PORT_AUTO_NEG_RESTART);


/*-------------------------- Step 10 ------------------------------------*/
/* 10A - Clear Interrupt status */
/* 10B - Enable Link Change\Transmit\Receive\Receiv e Overrun\Transmit */
/* Process Stop\Receive Process Stop interrupt */
/*-------------------------------------------------------------------------*/


ETH_REG_WRITE(REG_INT_STATUS, 0xffff);


/*-------------------------- Step 11 ------------------------------------*/
/* Enable QMU Transmit. */
/*-------------------------------------------------------------------------*/

spi_setbits(REG_TX_CTRL, TX_CTRL_ENABLE);

/*-------------------------- Step 12 ------------------------------------*/
/* Enable QMU Receive. */
/*-------------------------------------------------------------------------*/

spi_setbits(REG_RX_CTRL1, RX_CTRL_ENABLE);
}


/**
* @brief Initialize ethernet peripheral
* @param None
* @retval None
*/

void ETH_init(void){

ETH_GPIO_init();

ETH_spi_init();

ksz8851_init();

}