Picproje Elektronik Sitesi

Arkadaşlar merhabalar,

Bir projemizde stm32f407 + enc28j60, keil tcp net stack' i kullanıyoruz. Burada belli zaman sonra artık cihaza erişememe problemimiz oluyor. Acaba daha önce böyle bir problem yaşan birisi var mı?

Teşekkürler

Hakan bey merhaba aynı sıkıntıyı bende yaşıyorum çözüm bulabildiyseniz paylaşırsanız sevinirim iyi çalışmalar

startup lardaki daki stack limitlerinden olmasın?

Hocam config kodlarınızı paylaşırsanız yardımcı olabiliriz

#include "stm32f767xx.h"
#include "ENC28J60.h"
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include "main.h"

//#include "Net.h"

extern SPI_HandleTypeDef hspi1;
uint8_t Enc28j60Bank;
static int gNextPacketPtr;
uint8_t macaddr[6]=MAC_ADDR;

//Programda ilk çalışma anında arabellekteki belli başlı adresleri doğru bir şekilde kodlamak
void enc28j60_int(void)
{
   //Herhangi bir sorunun olmadığını belirtir
   LD_OFF;
   //soft reset
   enc28j60_writeOp(ENC28J60_SOFT_RESET,0,ENC28J60_SOFT_RESET);
   HAL_Delay(2);
   //clok ready
   while(!enc28j60_readOp(ENC28J60_READ_CTRL_REG,ESTAT)&ESTAT_CLKRDY);
   //ara bellekleri ayarlıyoruz
   //enc28j60_writeReg(ECOCON,0x02);
   enc28j60_writeReg(ERXST,RXSTART_INIT);
   enc28j60_writeReg(ERXRDPT,RXSTART_INIT);
   enc28j60_writeReg(ERXND,RXSTOP_INIT);
   enc28j60_writeReg(ETXST,TXSTART_INIT);
   enc28j60_writeReg(ETXND,TXSTOP_INIT);
    //uint8_t res=0;
    //  res=ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN|ERXFCON_BCEN;
    enc28j60_writeRegByte(ERXFCON,enc28j60_readRegByte(ERXFCON)|ERXFCON_BCEN);
    enc28j60_writeRegByte(MACON1,MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS);
    enc28j60_writeRegByte(MACON2,0x00);
    enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,MACON3,MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN);
    enc28j60_writeReg(MAIPG,0x0C12);
    enc28j60_writeRegByte(MABBIPG,0x12);
    enc28j60_writeReg(MAMXFL,MAX_FRAMELEN);
    enc28j60_writeRegByte(MAADR5,macaddr[0]);//Set MAC addres
    enc28j60_writeRegByte(MAADR4,macaddr[1]);
    enc28j60_writeRegByte(MAADR3,macaddr[2]);
    enc28j60_writeRegByte(MAADR2,macaddr[3]);
    enc28j60_writeRegByte(MAADR1,macaddr[4]);
    enc28j60_writeRegByte(MAADR0,macaddr[5]);

    enc28j60_writePhy(PHCON2,PHCON2_HDLDIS);//отключаем loopback

    enc28j60_writePhy(PHLCON,PHLCON_LACFG2| //светодиоды

    PHLCON_LBCFG2|PHLCON_LBCFG1|PHLCON_LBCFG0|

    PHLCON_LFRQ0|PHLCON_STRCH);

    enc28j60_SetBank(ECON1);

     enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,EIE,EIE_INTIE|EIE_PKTIE);

     enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,ECON1,ECON1_RXEN);

}

//Hatayı göstermek için Led yakma
void Error (void)
{
 LD_ON;
}


//Bayt okuma işlemi yapılır ve okunan bayt 0x00 ise if fonksiyonun içine girer ve EROR lambasını yakar.
//Eğer 0x00 da büyük bir değerse receivebyte değerini cevirir.
//Okuma ve yazma işlemi bu fonksiyonda yapılır.
//Okuma adresi0x00 dır.
uint8_t SPIx_WriteRead(uint8_t Byte)
{
  uint8_t receivedbyte = 0;
  if(HAL_SPI_TransmitReceive(&hspi1, (uint8_t*) &Byte,  (uint8_t*) &receivedbyte, 1, 0x100)!= HAL_OK)
  {
    Error();
  }
  //HAL_Delay(1);
   return receivedbyte;
}

//8bitli veri gönderme yapılır.
void SPI_SendByte(uint8_t bt)
{
 SPIx_WriteRead(bt);
}

//Bayt türünden okuma işlemi yapılır ve okunan değer bt olarak cevrilir.
//0xFF adresini okuruz.

uint8_t SPI_ReceiveByte(void)
{
 uint8_t bt = SPIx_WriteRead(0xFF);
 return bt; //вернём регистр данных
}

//İlk cs pinini low moda çekeriz bu sayede yazma işlemine başlamış oluruz.
//SPI_SendByte fonksiyonunu çağırırız ve işlem kodo,argüman gönderilir.
//SPI_SendByte fonksiyonunu data yollama işlemi yapılır.
//Cs pinini high moda çekeriz ve yazma işlemi bitirilmiş olur.
void enc28j60_writeOp(uint8_t op,uint8_t addres, uint8_t data)
{
 SS_SELECT();
 SPI_SendByte(op|(addres&ADDR_MASK));
 SPI_SendByte(data);
 SS_DESELECT();
}



uint8_t enc28j60_readOp(uint8_t op,uint8_t addres)
{

 uint8_t result;
 SS_SELECT();
 SPI_SendByte(op|(addres&ADDR_MASK));
 SPI_SendByte(0x00);
  if(addres & 0x80){
     SPI_ReceiveByte();
  }
  result=SPI_ReceiveByte();
  SS_DESELECT();
  return result;
}

void enc28j60_readBuf(uint16_t len,uint8_t* data)
{
 SS_SELECT();
 SPI_SendByte(ENC28J60_READ_BUF_MEM);
 while(len--){
  *data++=SPIx_WriteRead(0x00);
 }
 SS_DESELECT();
}


void enc28j60_writeBuf(uint16_t len,uint8_t* data)
  {

    SS_SELECT();
    SPI_SendByte(ENC28J60_WRITE_BUF_MEM);
    while(len--)
    SPI_SendByte(*data++);
    SS_DESELECT();

  }

void enc28j60_SetBank(uint8_t addres)
{
 uint8_t Bank = addres&BANK_MASK;
 if ((Bank)!=Enc28j60Bank)
 {
  enc28j60_writeOp(ENC28J60_BIT_FIELD_CLR,ECON1,ECON1_BSEL1|ECON1_BSEL0);
  Enc28j60Bank = addres&BANK_MASK;
  enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,ECON1,Enc28j60Bank>>5);
 }
}

void enc28j60_writeRegByte(uint8_t addres,uint8_t data)
{
 enc28j60_SetBank(addres);
 enc28j60_writeOp(ENC28J60_WRITE_CTRL_REG,addres,data);
}


uint8_t enc28j60_readRegByte(uint8_t addres)
{
 enc28j60_SetBank(addres);
 return enc28j60_readOp(ENC28J60_READ_CTRL_REG,addres);
}

void enc28j60_writeReg(uint8_t addres,uint16_t data)
{
 enc28j60_writeRegByte(addres, data);
 enc28j60_writeRegByte(addres+1, data>>8);
}

void enc28j60_writePhy(uint8_t addres,uint16_t data)

{

  enc28j60_writeRegByte(MIREGADR, addres);

  enc28j60_writeReg(MIWR, data);

  while(enc28j60_readRegByte(MISTAT)&MISTAT_BUSY);

}

uint16_t enc28j60_packetReceive(uint8_t *buf,uint16_t buflen)

{

     uint16_t len=0;

   if(enc28j60_readRegByte(EPKTCNT)>0)
   {
      enc28j60_writeReg(ERDPT,gNextPacketPtr);
      struct{
        uint16_t nextPacket;
        uint16_t byteCount;
        uint16_t status;
      } header;
      enc28j60_readBuf(sizeof header,(uint8_t*)&header);
      gNextPacketPtr=header.nextPacket;
      len=header.byteCount-4;
      if(len>buflen)
      {
         len=buflen;
      }
      if((header.status&0x80)==0)
      {
         len=0;
      }

      else
      {
         enc28j60_readBuf(len, buf);
      }
      buf[len]=0;
      if(gNextPacketPtr-1>RXSTOP_INIT)
      {
         enc28j60_writeReg(ERXRDPT,RXSTOP_INIT);
      }

      else
      {
         enc28j60_writeReg(ERXRDPT,gNextPacketPtr-1);
      }
   }

      enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,ECON2,ECON2_PKTDEC);

   return len;
   }



void enc28j60_packetSend(uint8_t *buf,uint16_t buflen)
{

  while(enc28j60_readOp(ENC28J60_READ_CTRL_REG,ECON1)&ECON1_TXRTS)
  {
     if(enc28j60_readRegByte(EIR)&( EIR_TXERIF))
            {
              enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,ECON1,ECON1_TXRST);
              enc28j60_writeOp(ENC28J60_BIT_FIELD_CLR,ECON1,ECON1_TXRST);

            }
  }
  enc28j60_writeReg(EWRPT,TXSTART_INIT);
  enc28j60_writeReg(ETXND,TXSTART_INIT+buflen);
  //enc28j60_writeOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00);
  enc28j60_writeBuf(1,(uint8_t*)"x00");
  enc28j60_writeBuf(buflen,buf);
  enc28j60_writeOp(ENC28J60_BIT_FIELD_SET,ECON1,ECON1_TXRTS);

}





02 Aralık 2022, 21:47:47
hocam ping atabiliyordum ama şimdi onuda yapamıyorum

02 Aralık 2022, 21:49:07
ping attığımda mac dest ile ıp dest doğru okuyamıyor



02 Aralık 2022, 21:49:26
#include "Net.h"

extern uint8_t macaddr[6];

uint8_t net_buf[ENC28J60_MAXFRAME];
uint8_t ipaddr[4]=IP_ADDR;
char str1[60]={0};

void net_int(void)
{
   enc28j60_int();
}


uint8_t arp_read(enc28j60_frame_ptr *frame, uint16_t len)

{

   uint8_t res=0;
   arp_msg_ptr *msg=(void*)(frame->data);
   if(len > sizeof(arp_msg_ptr))
   {
      if ((msg->net_tp==ARP_ETH)&&(msg->proto_tp==ARP_IP))
      {
         if ((msg->op==ARP_REQUEST)&&(!memcmp(msg->ipaddr_dst,ipaddr,4)))
         {
            res=1;
         }

      }
   }

      return res;
}


void eth_read(enc28j60_frame_ptr *frame, uint16_t len)

{
   if(frame->type == ETH_ARP)
   {
      if(arp_read(frame,len-sizeof(enc28j60_frame_ptr)))
        {

          arp_send(frame);

        }

   }
   else if(frame->type==ETH_IP)
   {

       ip_read(frame,len-sizeof(ip_pkt_ptr));

   }
}
void net_pool(void)
{

   uint16_t len;
   enc28j60_frame_ptr *frame = (void*)net_buf;

    while ((len=enc28j60_packetReceive(net_buf, (sizeof(net_buf))))>0)
     {

       eth_read(frame,len);

     }
}

void eth_send(enc28j60_frame_ptr *frame, uint16_t len)
{
  memcpy(frame->addr_dest,frame->addr_src,6);
  memcpy(frame->addr_src,macaddr,6);
  enc28j60_packetSend((void*)frame, len + sizeof(enc28j60_frame_ptr));

}

void arp_send(enc28j60_frame_ptr *frame)

{
   arp_msg_ptr *msg = (void*)frame->data;
    msg->op = ARP_REPLY;
    memcpy(msg->macaddr_dst,msg->macaddr_src,6);
    memcpy(msg->macaddr_src,macaddr,6);
    memcpy(msg->ipaddr_dst,msg->ipaddr_src,4);
    memcpy(msg->ipaddr_src,ipaddr,4);
    eth_send(frame,sizeof(arp_msg_ptr));

}

uint8_t ip_read(enc28j60_frame_ptr *frame, uint16_t len)
{
   uint8_t res=0;
    ip_pkt_ptr *ip_pkt = (void*)(frame->data);
    if((ip_pkt->verlen==0x45)&&(!memcmp(ip_pkt->ipaddr_dst,ipaddr,4)))

      {
       len = be16toword(ip_pkt->len) - sizeof(ip_pkt_ptr);
       if (ip_pkt->prt==IP_ICMP)
       {
          icmp_read(frame,len);
       }

       else if (ip_pkt->prt==IP_TCP)
       {

          tcp_read(frame,len);
       }

       else if (ip_pkt->prt==IP_UDP)
       {

       }
      }

      return res;
}

uint16_t checksum(uint8_t *ptr, uint16_t len,uint8_t type)
{
   uint32_t sum=0;

   if(type==1)
   {
     sum+=IP_UDP;
     sum+=len-8;
   }

   if(type==2)
   {
     sum+=IP_TCP;
     sum+=len-8;
   }

   while(len>1)
   {
      sum += (uint16_t) (((uint32_t)*ptr<<8)|*(ptr+1));
      ptr+=2;
        len-=2;
   }
   if(len)
   {
       sum+=((uint32_t)*ptr)<<8;
   }
   while (sum>>16)
   {
      sum=(uint16_t)sum+(sum>>16);
   }
   return ~be16toword((uint16_t)sum);
}

uint8_t icmp_read(enc28j60_frame_ptr *frame, uint16_t len)

{
   uint8_t res=0;
   ip_pkt_ptr *ip_pkt = (void*)frame->data;
   icmp_pkt_ptr *icmp_pkt = (void*)ip_pkt->data;
   if ((len>=sizeof(icmp_pkt_ptr))&&(icmp_pkt->msg_tp==ICMP_REQ))
   {
      icmp_pkt->msg_tp=ICMP_REPLY;
      icmp_pkt->cs=0;
      icmp_pkt->cs=checksum((void*)icmp_pkt,len,0);
      ip_send(frame,len+sizeof(ip_pkt_ptr));
   }
     return res;

}



uint8_t ip_send(enc28j60_frame_ptr *frame, uint16_t len)
{

uint8_t res=0;
ip_pkt_ptr *ip_pkt = (void*)frame->data;
ip_pkt->len=be16toword(len);
ip_pkt->fl_frg_of=0;
ip_pkt->ttl=128;
ip_pkt->cs = 0;
memcpy(ip_pkt->ipaddr_dst,ip_pkt->ipaddr_src,4);
memcpy(ip_pkt->ipaddr_src,ipaddr,4);
ip_pkt->cs = checksum((void*)ip_pkt,sizeof(ip_pkt_ptr),0);
eth_send(frame,len);
return res;

}






02 Aralık 2022, 21:51:51

#ifndef INC_NET_H_
#define INC_NET_H_
#include "stm32f767xx.h"
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include "ENC28J60.h"
#define IP_ADDR {192,168,1,180}

typedef struct enc28j60_frame{

  uint8_t addr_dest[6];

  uint8_t addr_src[6];

  uint16_t type;

  uint8_t data[];

} enc28j60_frame_ptr;

typedef struct arp_msg{

  uint16_t net_tp;

  uint16_t proto_tp;

  uint8_t macaddr_len;

  uint8_t ipaddr_len;

  uint16_t op;

  uint8_t macaddr_src[6];

  uint8_t ipaddr_src[4];

  uint8_t macaddr_dst[6];

  uint8_t ipaddr_dst[4];

} arp_msg_ptr;

typedef struct ip_pkt{

uint8_t verlen;//версия протокола и длина заголовка

uint8_t ts;//тип севриса

uint16_t len;//длина

uint16_t id;//идентификатор пакета

uint16_t fl_frg_of;//флаги и смещение фрагмента

uint8_t ttl;//время жизни

uint8_t prt;//тип протокола

uint16_t cs;//контрольная сумма заголовка

uint8_t ipaddr_src[4];//IP-адрес отправителя

uint8_t ipaddr_dst[4];//IP-адрес получателя

uint8_t data[];//данные

} ip_pkt_ptr;

typedef struct icmp_pkt{

uint8_t msg_tp;

uint8_t msg_cd;

uint16_t cs;

uint16_t id;

uint16_t num;

uint8_t data[];

} icmp_pkt_ptr;



#define IP_ICMP 1
#define IP_TCP 6
#define IP_UDP 17

#define ICMP_REQ 8
#define ICMP_REPLY 0

#define be16toword(a) ((((a)>>8)&0xff)|(((a)<<8)&0xff00))
#define be32todword(a) ((((a)>>24)&0xff)|(((a)>>8)&0xff00)|(((a)<<8)&0xff0000)|(((a)<<24)&0xff000000))
#define ETH_ARP be16toword(0x0806)
#define ETH_IP be16toword(0x0800)
#define ARP_ETH be16toword(0x0001)
#define ARP_IP be16toword(0x0800)
#define ARP_REQUEST be16toword(1)
#define ARP_REPLY be16toword(2)

void net_int(void);
void net_pool(void);
void eth_read(enc28j60_frame_ptr *frame, uint16_t len);
uint8_t arp_read(enc28j60_frame_ptr *frame, uint16_t len);
void arp_send(enc28j60_frame_ptr *frame);
void eth_send(enc28j60_frame_ptr *frame, uint16_t len);
uint8_t ip_read(enc28j60_frame_ptr *frame, uint16_t len);
uint16_t checksum(uint8_t *ptr, uint16_t len,uint8_t type);
uint8_t icmp_read(enc28j60_frame_ptr *frame, uint16_t len);
uint8_t tcp_read(enc28j60_frame_ptr *frame, uint16_t len);
uint8_t ip_send(enc28j60_frame_ptr *frame, uint16_t len);

#endif /* INC_NET_H_ */

bu iş beni çok yordu ve çözüm bulamıyorum bana yardımcı olursanız sevinirim

Alıntı yapılan: ercan_t - 02 Aralık 2022, 16:05:47startup lardaki daki stack limitlerinden olmasın?

siz söyledikten sonra burada bir hata olabileceğini düşünüyorum
struct{
        uint16_t nextPacket;
        uint16_t byteCount;
        uint16_t status;
      } header;
struct yapısını header dosyasında değil de src de çağırıyorum buda önceden remde yer ayarlayamadığı için hata oluşturuyor olabilir mi