stm32f4xx lan8720 uip

[dicovery (Gast)]

guten Tag,
gibt es denn irgendwo ein example für den stm32f4 und Lan8720 mit 
uip,was ich bisher gesehen hab ist alles mit Lwip.

vielleicht kann mir jemand weiterhelfen
mfg

[dicovery (Gast)]

Ist denn das soweit richtig
anstatt: uip_len = enc28j60PacketReceive(UIP_CONF_BUFFER_SIZE, 
&uip_buf[0]);

STM32eth: ETH_HandleRxPkt(uip_buf);

  //uip_len = enc28j60PacketReceive(UIP_CONF_BUFFER_SIZE, &uip_buf[0]); // Paket aus dem ENC28J60 auslesen und in den Buffer zwischenspeichern
 
//uip_len = ETH_HandleRxPkt(uip_buf);
     
    if(uip_len > 0) // Falls ein Paket empfangen wurde
      { 
      

        
       if(BUF->type == htons(UIP_ETHTYPE_IP)) // Falls IP-Paket empfangen wurde
        {

        uip_arp_ipin(); // IP-Paket empfangen und ARP-Tabelle aktualisieren
        uip_input(); // Prozesse für die Abarbeitung des Paketes starten
  
          if(uip_len > 0) // Falls Paketlänge größer 0 ist
              {
              uip_arp_out(); // ARP-Paket schicken und ausfragen, welchen Client diese IP-Pakete gehören
              TransmitPacket(); // IP-Pakete dem Client schicken  
           //enc28j60PacketSend(uip_len,uip_buf); // IP-Pakete dem Client schicken
            }
              } 
          
        else if(BUF->type == htons(UIP_ETHTYPE_ARP)) // Falls ARP-Paket empfangen wurde
            {
        uip_arp_arpin(); // ARP-Paket in den uIP-Stack lesen 
  
         if(uip_len > 0) // Falls der Inhalt des ARP-Pakets nicht 0 ist
          {
            TransmitPacket(); // Auf ARP-Paket vom Client antworten
          //enc28j60PacketSend(uip_len,uip_buf); // IP-Pakete dem Client schicken
          }
              }
      } 
      
      else if(timer_expired(&periodic_timer)) // Falls Periodentimer abgelaufen ist, Paket-Weiterleitung
      {

      timer_reset(&periodic_timer); // Periodentimer reseten
              
        for(n = 0; n < UIP_CONNS; n++)  // Für alle aktiven TCP-Verbindungen 
         {
         uip_periodic(n); // Jeweilige TCP-Verbindung abfragen ob noch Pakete für diese Verbindng vorhanden sind
  
           if(uip_len > 0) // Falls welche vorhanden sind
            {
              uip_arp_out(); // ARP-Paket schicken und ausfragen, welchen Client diese Pakete gehören
              TransmitPacket(); // Pakete dem Client schicken
            //enc28j60PacketSend(uip_len,uip_buf); // IP-Pakete dem Client schicken
            }
               }

     if(timer_expired(&arp_timer)) // Falls ARP-Timer abgelaufen ist, Eintrag in der ARP-Tabelle nicht mehr aktuell
      {

    
      timer_reset(&arp_timer); // ARP-Timer reseten
      uip_arp_timer(); // Alte Einträge in der ARP-Tabelle löschen
          }
       }




void TransmitPacket(void)
{
      int i;
     u8 data[1500];

      // Copy the header portion part
      for(i=0; i < (UIP_LLH_LEN + 40); ++i) {
         data[i] =  uip_buf[i];
      }

      // Copy the data portion part
      for(; i < uip_len; ++i) {
          data[i] =  uip_appdata[i - UIP_LLH_LEN - 40 ];
      }

      ETH_HandleTxPkt(data,uip_len);
}

[dicovery (Gast)]

ich bekomme das nicht zum laufen mit dem Lan8720
ETH_HandleRxPkt ETH_HandleTxPkt gibst in dem Treiber nicht vom f4eth.

Könnte mir denn wer weiterhelfen
mfg

[dicovery (Gast)]

kann mir hier niemand weiterhelfen

[nosilent (Gast)]

Der Lan8720 ist ja ein (R)MII PHY, im Gegensatz zum ENC und die haben 
komplett verschiedene Schnittstellen.
Klappt den die Initialisierung vom Lan8720 ? Schau mal ob du die 
Register vom PHY auslesen kannst...

Warum willst du eigt. den uip verwenden?
Ich habe auf dem STM32F4xx (genauer uC fällt mir jetzt nicht ein) die 
Performance gemessen und ich würde her zum LwIP tendieren. Ist zwar 
größer, kann dafür mehr und man kann den wirklich gut optimieren (in 
Bezug auf Datendurchsatz, Anzahl der TCP/UDP Verbindungen, Latenz, ...).

[dicovery (Gast)]

Die Initialisierung vom Lan8720 klappt einwandfrei.

ich wollte gerne den uip weiter verwenden da hab ich nun meine 
verschiedenen Webpage .

Beim Lwip muss ich ja nun wieder komplett von vorne anfangen.

Der ETH vom stm32_f4x7 läuft ja im DMA.

Es muss doch eine Schnittstelle geben um: uip_len = 
enc28j60PacketReceive(UIP_CONF_BUFFER_SIZE, &uip_buf[0]);

daran scheiterte ich .

[dicovery (Gast)]

Hallo,
gibt es denn garkein beispiel mit lan8720 und uip???

[Little B. (lil-b)]

Du kannst vieleicht etwa sowas schreiben:

uint16_t stm32eth_Receive (uint8_t* pbuf) {
  uint8_t i;
  stm32eth_ReceiveDescriptor_t *pdesc;

  // get the least recent buffer
  pdesc = (stm32eth_ReceiveDescriptor_t*)(ETH->DMACHRDR);
  // and check all buffers to the most recent buffer
  for (i=0; i<STM32ETH_NR_OF_INPUT_FRAMES; i++) {
    if (pdesc->RDES0.bits.Own == 0) {
      // cpu owns this descriptor, process it!
      memcpy(pbuf, pdesc->Buffer1, pdesc->RDES1.bits.TransmitBuffer1Size);
      // return buffer to hardware
      pdesc->RDES0.bits.Own = 1;
      // activate dma, if it was suspended
      ETH->DMARPDR = 0xFFFFFFFF;
      return pdesc->RDES1.bits.TransmitBuffer1Size;
    }
    pdesc = (stm32eth_ReceiveDescriptor_t*)(pdesc->NextDescriptor);
  }
  return 0;
}

Dies impliziert allerdings, dass du deine Buffer entsprechend 
initialisiert hast. Zum Beispiel so:

  ETH->DMARDLAR = (uint32_t)stm32eth_ReceiveDescriptor;    // first receive descriptor
  // initialization of receive buffers
  stm32eth_ReceiveDescriptor[0].RDES0.u32 = 0;
  stm32eth_ReceiveDescriptor[0].RDES0.bits.Own = 1;
  stm32eth_ReceiveDescriptor[0].RDES1.u32 = 0;
  stm32eth_ReceiveDescriptor[0].RDES1.bits.SecondAddressChained = 1;
  stm32eth_ReceiveDescriptor[0].RDES1.bits.TransmitBuffer1Size = 1518;
  for (i=1; i<STM32ETH_NR_OF_INPUT_FRAMES; i++)
    stm32eth_ReceiveDescriptor[i] = stm32eth_ReceiveDescriptor[0];

  for (i=0; i<STM32ETH_NR_OF_INPUT_FRAMES; i++) {
    // for easier access of transmit buffers, receive buffers are located behind transmit buffers
    stm32eth_ReceiveDescriptor[i].Buffer1 = stm32eth_EthernetFrames[i];
    stm32eth_ReceiveDescriptor[i].NextDescriptor = (uint8_t*)(stm32eth_ReceiveDescriptor + i + 1);
  }
  // last descriptor must point back to first descriptor!
  stm32eth_ReceiveDescriptor[i-1].NextDescriptor = (uint8_t*)(stm32eth_ReceiveDescriptor);

mit

/**
 * @brief  DMA information for receiving frames
 * @ingroup  Drivers
 * @details
 * The dedicated DMA for transferring frames from external phy to memory needs
 * this struct as information source of the frame location in RAM. After
 * receiving the frame, status and length information are stored in it. Refer to
 * STM32F4 Family Data Sheet page 961 and following for more information.
 */
typedef struct __attribute__ ((__packed__)) {
  union {
    struct {
      uint8_t PayloadChecksumError:1;
      uint8_t CrcError:1;
      uint8_t DribbleBitError:1;
      uint8_t ReceiveError:1;
      uint8_t ReceiveWatchdogTimeout:1;
      uint8_t FrameType:1;
      uint8_t LateCollision:1;
      uint8_t IpHeaderChecksumError:1;
      uint8_t LastDescriptor:1;
      uint8_t FirstDescriptor:1;
      uint8_t VlanTag:1;
      uint8_t OverflowError:1;
      uint8_t LengthError:1;
      uint8_t SourceAddressFilterFail:1;
      uint8_t DescriptorError:1;
      uint8_t ErrorSummary:1;
      uint16_t FrameLength:14;
      uint8_t DestinationAddressFIlterFail:1;
      uint8_t Own:1;
    } bits;
    uint32_t u32;
  } RDES0;
  union {
    struct {
      uint16_t TransmitBuffer1Size:13;
      uint8_t reserved1:1;
      uint8_t SecondAddressChained:1;
      uint8_t ReceiveEndOfRing:1;
      uint16_t TransmitBuffer2Size:13;
      uint8_t reserved2:2;
      uint8_t DisableInterruptOnCompletion:1;
    } bits;
    uint32_t u32;
  } RDES1;
  uint8_t *Buffer1;
  uint8_t *NextDescriptor;
  union {
    struct {
      uint8_t IpPayloadType:3;
      uint8_t IpHeaderError:1;
      uint8_t IpPayloadError:1;
      uint8_t IpChecksumBypassed:1;
      uint8_t Ipv4PacketReceived:1;
      uint8_t Ipv6PacketReceived:1;
      uint8_t PtpMessageType:4;
      uint8_t PtpFrametype:1;
      uint8_t PtpVersion:1;
      uint32_t reserved:18;
    } bits;
    uint32_t u32;
  } RDES4;
  uint32_t reserved;
  uint32_t ReceiveFrameTimestampLow;
  uint32_t ReceiveFrameTimestampHigh;
}stm32eth_ReceiveDescriptor_t;

/**
 * @brief  DMA receive descriptors
 * @ingroup  Drivers
 * @details
 * Each input frame buffer has its DMA receive descriptor. These descriptors are
 * chained as a ring buffer.
 */
stm32eth_ReceiveDescriptor_t stm32eth_ReceiveDescriptor[STM32ETH_NR_OF_INPUT_FRAMES];

/**
 * @brief  Ethernet frame buffers
 * @ingroup  Drivers
 * @details
 * This is the static allocation of all receive buffers. Each buffer
 * can store one standard Ethernet frame, which has 1500 bytes Data and 18 bytes
 * mac information.
 */
uint8_t stm32eth_EthernetFrames[STM32ETH_NR_OF_INPUT_FRAMES][1518];

und

#define STM32ETH_NR_OF_INPUT_FRAMES      10

Dies ist nur ein Beispiel, eine Variation dessen, was ich mit meinem 
selbst geschriebenen TCP/IP Stack verwende. Alle RTOS Sachen sind 
hoffentlich drausen. Ich übernehme keinerlei Haftung für diesen Code und 
behaupte auch nicht, dass er funktioniert. Bei Fehlern darf gerne selber 
nachgedacht werden. Supportanfragen werden in Rechnung gestellt.

[dicovery (Gast)]

anbei die Treiber

[dicovery (Gast)]

scheint wohl niemand mit zuarbeiten uip stm32f4

[itzztitz (Gast)]

nimm aus einem beispiel mit LwIP den ethernet treiber heraus und nutze 
die transmit/Receive funktionen bei dir

der empfang/ senden der daten ist dann das selbe


ich würde dir auch empfehlen  den LwIP zu nutzen...
mit einem freeRTOS zusammen hast da ordetlich luft
zb auch für TLS verbindungen


schnapp dir ein RTOS LwIP demoprojekt und portiere deine kleine seite 
und fetrig.

[dicovery (Gast)]

wäre das so richtig wie von ihnen vorgeschlagen.

 
uip_len = ethernetif_input(uip_buf);
     
    if(uip_len > 0) // Falls ein Paket empfangen wurde
      { 
      

        
       if(BUF->type == htons(UIP_ETHTYPE_IP)) // Falls IP-Paket empfangen wurde
        {

        uip_arp_ipin(); // IP-Paket empfangen und ARP-Tabelle aktualisieren
        uip_input(); // Prozesse für die Abarbeitung des Paketes starten
  
          if(uip_len > 0) // Falls Paketlänge größer 0 ist
              {
              uip_arp_out(); // ARP-Paket schicken und ausfragen, welchen Client diese IP-Pakete gehören
              low_level_output(); // IP-Pakete dem Client schicken  
           //enc28j60PacketSend(uip_len,uip_buf); // IP-Pakete dem Client schicken
            }
              } 
          
        else if(BUF->type == htons(UIP_ETHTYPE_ARP)) // Falls ARP-Paket empfangen wurde
            {
        uip_arp_arpin(); // ARP-Paket in den uIP-Stack lesen 
  
         if(uip_len > 0) // Falls der Inhalt des ARP-Pakets nicht 0 ist
          {
            low_level_output(); // Auf ARP-Paket vom Client antworten
          //enc28j60PacketSend(uip_len,uip_buf); // IP-Pakete dem Client schicken
          }
              }
      } 
      
      else if(timer_expired(&periodic_timer)) // Falls Periodentimer abgelaufen ist, Paket-Weiterleitung
      {

      timer_reset(&periodic_timer); // Periodentimer reseten
              
        for(n = 0; n < UIP_CONNS; n++)  // Für alle aktiven TCP-Verbindungen 
         {
         uip_periodic(n); // Jeweilige TCP-Verbindung abfragen ob noch Pakete für diese Verbindng vorhanden sind
  
           if(uip_len > 0) // Falls welche vorhanden sind
            {
              uip_arp_out(); // ARP-Paket schicken und ausfragen, welchen Client diese Pakete gehören
              low_level_output(); // Pakete dem Client schicken
            //enc28j60PacketSend(uip_len,uip_buf); // IP-Pakete dem Client schicken
            }
               }

     if(timer_expired(&arp_timer)) // Falls ARP-Timer abgelaufen ist, Eintrag in der ARP-Tabelle nicht mehr aktuell
      {

    
      timer_reset(&arp_timer); // ARP-Timer reseten
      uip_arp_timer(); // Alte Einträge in der ARP-Tabelle löschen
          }
       }

[dicovery (Gast)]

itzztitz schrieb:
> nimm aus einem beispiel mit LwIP den ethernet treiber heraus und
> nutze
> die transmit/Receive funktionen bei dir
>
> der empfang/ senden der daten ist dann das selbe
>
> ich würde dir auch empfehlen  den LwIP zu nutzen...
> mit einem freeRTOS zusammen hast da ordetlich luft
> zb auch für TLS verbindungen
>
> schnapp dir ein RTOS LwIP demoprojekt und portiere deine kleine seite
> und fetrig.

welche sind das

kann mir denn niemand hier weiterhelfen ?

[dicovery (Gast)]

es gibt anscheinend Niemand der den uip mit stm32f4  nutzt. sehr schade

[♪Geist (Gast)]

dicovery schrieb:
> es gibt anscheinend Niemand der den uip mit stm32f4  nutzt. sehr schade

Ja, wozu auch, wenn LwIP läuft? Ich meine uIP ist zwar schmaller, aber 
LwIP bitet mehr Performance und ist ST aus gleich portiert.

[dicovery (Gast)]

♪Geist schrieb:
> dicovery schrieb:
> es gibt anscheinend Niemand der den uip mit stm32f4  nutzt. sehr schade
>
> Ja, wozu auch, wenn LwIP läuft? Ich meine uIP ist zwar schmaller, aber
> LwIP bitet mehr Performance und ist ST aus gleich portiert.

ja das ja alles gut und schön aber nirgends gibs ein Beispiel wenn ich 
zum Beispiel auf der Webseite ein button drücke led ein das mir ein Bild 
angezeigt wird led ein.

wo gibst solch ein Beispiel

[Helmut (Gast)]

itzztitz schrieb:
> nimm aus einem beispiel mit LwIP den ethernet treiber heraus und
> nutze die transmit/Receive funktionen bei dir
> der empfang/ senden der daten ist dann das selbe
>


Ich bin nicht vom Fach,dennoch habe ich im Lwip1.4 mal geschaut nach der 
Sende/Empfangs Funktion aber nicht gefunden.

Der TO hat offenbar Probleme das umzusetzen wie vorgeschlagen, dennoch 
wäre es vielleicht Hilfreich ihm zu zeigen wo diese Funktion sind.