Startseite>CGI-Quellcode>Andere Kategorien
Herunterladen

AsyncUDP_STM32-Bibliothek

Inhaltsverzeichnis

  • Wichtige Änderung gegenüber v1.3.0
  • Warum brauchen wir diese AsyncUDP_STM32-Bibliothek?
    • Merkmale
    • Warum Async besser ist
    • Derzeit unterstützte Boards
  • Änderungsprotokoll
  • Voraussetzungen
  • Installation
    • Verwenden Sie den Arduino Library Manager
    • Manuelle Installation
    • VS Code & PlatformIO
  • Patches für Pakete
    • 1. Für STM32-Karten zur Verwendung von LAN8720
    • 2. Für STM32-Karten zur Verwendung von Serial1
  • So beheben Sie den Linker-Fehler Multiple Definitions
  • HOWTO Einrichten des Async UDP-Clients
  • So verwenden Sie STM32F4 mit LAN8720
    • 1. Verkabelung
    • 2. HOWTO-Programmierung mit STLink V-2 oder V-3
    • 3. So verwenden Sie den seriellen Port zum Debuggen
  • Beispiele
    • 1. AsyncUDPClient
    • 2. AsyncUdpNTPClient
    • 3. AsyncUdpSendReceive
    • 4. AsyncUDPServer
    • 5. AsyncUDPMulticastServer
    • 6. AsyncUDPClient_LAN8720
    • 7. AsyncUdpNTPClient_LAN8720
    • 8. AsyncUdpSendReceive_LAN8720
    • 9. AsyncUDPServer_LAN8720
    • 10. AsyncUDPMulticastServer_LAN8720
    • 11. multiFileProject Neu
    • 12. multiFileProject_LAN8720 Neu
  • Beispiel AsyncUdpNTPClient
    • 1. Datei AsyncUdpNTPClient.ino
    • 2. Datei defines.h
  • Debug-Terminal-Ausgabebeispiele
    • 1. AsyncUdpNTPClient auf STM32F7 NUCLEO_F767ZI mit LAN8742A Ethernet unter Verwendung der STM32Ethernet-Bibliothek
    • 2. AsyncUdpNTPClient_LAN8720 auf STM32F4 BLACK_F407VE mit LAN8720-Ethernet unter Verwendung der STM32Ethernet-Bibliothek
  • Debuggen
  • Fehlerbehebung
  • Probleme
  • ZU TUN
  • ERLEDIGT
  • Beiträge und Dank
  • Mitwirken
  • Lizenz
  • Copyright

Wichtige Änderung gegenüber v1.3.0

Bitte schauen Sie sich an, wie Sie den Linker-Fehler Multiple Definitions beheben können

Für Generic STM32F4 series , wie z. B. STM32F407VE, die LAN8720 verwenden, verwenden Sie bitte STM32 Core v2.2.0 , da ein Bruch des Core v2.3.0 den Kompilierungsfehler verursacht. Wird in naher Zukunft behoben.

Warum brauchen wir diese AsyncUDP_STM32-Bibliothek?

Merkmale

Diese AsyncUDP_STM32-Bibliothek ist eine vollständig asynchrone UDP-Bibliothek, die für eine störungsfreie Netzwerkumgebung mit mehreren Verbindungen für STM32-Karten mit LAN8720 oder integriertem LAN8742A-Ethernet entwickelt wurde. Die Bibliothek ist einfach zu verwenden und unterstützt Unicast-, Broadcast- und Multicast-Umgebungen.

Diese Bibliothek basiert auf, modifiziert von:

  1. Hristo Gochkovs ESPAsyncUDP

um die bessere und schnellere asynchrone Funktion der leistungsstarken ESPAsyncUDP-Bibliothek auf STM32-Karten mit LAN8720 oder integriertem LAN8742A-Ethernet anzuwenden.

Warum Async besser ist

  • Die Verwendung eines asynchronen Netzwerks bedeutet, dass Sie mehr als eine Verbindung gleichzeitig verarbeiten können
  • Sie werden angerufen, sobald die Anfrage fertig und analysiert ist
  • Wenn Sie die Antwort senden, sind Sie sofort bereit , andere Verbindungen zu verarbeiten, während der Server im Hintergrund für das Senden der Antwort zuständig ist
  • Geschwindigkeit ist OMG
  • Nachdem Sie als Async-Client eine Verbindung zu einem UDP-Server hergestellt haben, sind Sie sofort bereit, andere Verbindungen abzuwickeln, während der Client sich im Hintergrund um den Empfang der UDP-Antwortpakete kümmert.
  • Sie müssen nicht in einem Tight Loop() die Ankunft der UDP-Antwortpakete überprüfen, um sie zu verarbeiten.

Derzeit unterstützte Boards

  1. STM32-Boards mit integriertem Ethernet LAN8742A wie:
  • Nukleo-144 (F429ZI, F767ZI)
  • Entdeckung (STM32F746G-DISCOVERY)
  • Alle STM32-Boards (STM32F/L/H/G/WB/MP1) mit 32K+ Flash und integriertem Ethernet
  • Siehe EthernetWebServer_STM32-Unterstützung und Testergebnisse
  1. STM32-Karten mit Ethernet LAN8720 wie:
  • Nucleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
  • Entdeckung (DISCO_F746NG)
  • STM32F4-Platinen (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)

Voraussetzungen

  1. Arduino IDE 1.8.19+ für Arduino.
  2. Arduino Core for STM32 v2.3.0+ für STM32-Boards.
  3. STM32Ethernet library v1.3.0+ für integriertes LAN8742A-Ethernet auf (Nucleo-144, Discovery).
  4. LwIP library v2.1.2+ für integriertes LAN8742A-Ethernet auf (Nucleo-144, Discovery).

Installation

Die empfohlene Installationsmethode ist:

Verwenden Sie den Arduino Library Manager

Am besten verwenden Sie Arduino Library Manager . Suchen Sie nach AsyncUDP_STM32 und wählen Sie dann die neueste Version aus bzw. installieren Sie sie. Sie können auch diesen Link für detailliertere Anweisungen verwenden.

Manuelle Installation

  1. Navigieren Sie zur Seite „AsyncUDP_STM32“.
  2. Laden Sie die neueste Version AsyncUDP_STM32-master.zip herunter.
  3. Extrahieren Sie die ZIP-Datei in das Verzeichnis AsyncUDP_STM32-master
  4. Kopieren Sie den gesamten Ordner AsyncUDP_STM32-master in das Verzeichnis der Arduino-Bibliotheken, z. B. ~/Arduino/libraries/ .

VS-Code und PlattformIO:

  1. Installieren Sie VS-Code
  2. Installieren Sie PlatformIO
  3. Installieren Sie die AsyncUDP_STM32- Bibliothek mithilfe des Bibliotheksmanagers. Suchen Sie in den Autorenbibliotheken von Platform.io nach AsyncUDP_STM32
  4. Verwenden Sie die mitgelieferte Datei „platformio.ini“ aus den Beispielen, um sicherzustellen, dass alle abhängigen Bibliotheken automatisch installiert werden. Weitere Optionen und Beispiele finden Sie in der Dokumentation unter Projektkonfigurationsdatei

Patches für Pakete

1. Für STM32-Karten zur Verwendung von LAN8720

Für Generic STM32F4 series , wie z. B. STM32F407VE , LAN8720 verwenden, verwenden Sie bitte STM32 Core v2.2.0 , da ein Bruch des Core v2.3.0 den Kompilierungsfehler verursacht.

Zur Verwendung von LAN8720 auf einigen STM32-Boards

  • Nucleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
  • Entdeckung (DISCO_F746NG)
  • STM32F4-Platinen (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)

Sie müssen die Dateien stm32f4xx_hal_conf_default.h und stm32f7xx_hal_conf_default.h in das STM32-Verzeichnis stm32 (~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system) kopieren, um die alten Dateien zu überschreiben.

Angenommen, die STM32-Kernversion ist 2.2.0. Diese Dateien müssen in das Verzeichnis kopiert werden:

  • ~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system/STM32F4xx/stm32f4xx_hal_conf_default.h für STM32F4.
  • ~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system/STM32F7xx/stm32f7xx_hal_conf_default.h für Nucleo-144 STM32F7.

Denken Sie bei der Installation einer neuen Version daran, diese Datei in das neue Versionsverzeichnis zu kopieren. Die neue Version ist beispielsweise x.yy.zz, diese Dateien müssen in das entsprechende Verzeichnis kopiert werden:

  • ~/.arduino15/packages/STM32/hardware/stm32/x.yy.zz/system/STM32F4xx/stm32f4xx_hal_conf_default.h
  • `~/.arduino15/packages/STM32/hardware/stm32/x.yy.zz/system/STM32F7xx/stm32f7xx_hal_conf_default.h

2. Für STM32-Karten zur Verwendung von Serial1

Um Serial1 auf einigen STM32-Boards ohne Serial1-Definition (Nucleo-144 NUCLEO_F767ZI, Nucleo-64 NUCLEO_L053R8 usw.) zu verwenden , müssen Sie die Dateien STM32 variant.h in das STM32 stm32-Verzeichnis kopieren (~/.arduino15/packages/STM32/ hardware/stm32/2.3.0). Sie müssen die Dateien entsprechend Ihren Boards ändern. Dies ist nur eine Veranschaulichung der Vorgehensweise.

Angenommen, die STM32-Kernversion ist 2.3.0. Diese Dateien müssen in das Verzeichnis kopiert werden:

  • ~/.arduino15/packages/STM32/hardware/stm32/2.3.0/variants/NUCLEO_F767ZI/variant.h für Nucleo-144 NUCLEO_F767ZI.
  • ~/.arduino15/packages/STM32/hardware/stm32/2.3.0/variants/NUCLEO_L053R8/variant.h für Nucleo-64 NUCLEO_L053R8.

Denken Sie bei der Installation einer neuen Version daran, diese Datei in das neue Versionsverzeichnis zu kopieren. Die neue Version ist beispielsweise x.yy.zz, diese Dateien müssen in das entsprechende Verzeichnis kopiert werden:

  • ~/.arduino15/packages/STM32/hardware/stm32/x.yy.zz/variants/NUCLEO_F767ZI/variant.h
  • ~/.arduino15/packages/STM32/hardware/stm32/x.yy.zz/variants/NUCLEO_L053R8/variant.h

So beheben Sie den Linker-Fehler Multiple Definitions

Die aktuelle Bibliotheksimplementierung, xyz-Impl.h anstelle des standardmäßigen xyz.cpp verwendet, führt möglicherweise in bestimmten Anwendungsfällen zu bestimmten Multiple Definitions Linker-Fehlern.

Sie können diese .hpp Datei einschließen 

 // Can be included as many times as necessary, without `Multiple Definitions` Linker Error
# include " AsyncUDP_STM32.hpp "     // https://github.com/khoih-prog/AsyncUDP_STM32

in vielen Dateien. Stellen Sie jedoch sicher, dass Sie die folgende .h Datei nur in einer .h , .cpp oder .ino Datei verwenden, die in keiner anderen Datei enthalten sein darf, um Multiple Definitions Linker-Fehler zu vermeiden 

 // To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
# include " AsyncUDP_STM32.h "       // https://github.com/khoih-prog/AsyncUDP_STM32

Sehen Sie sich das neue multiFileProject -Beispiel für eine HOWTO Demo an.

HOWTO Einrichten des Async UDP-Clients 

# include < LwIP.h >
# include < STM32Ethernet.h >
# include < AsyncUDP_STM32.h >

byte mac[] =  { 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x01 };

IPAddress timeWindowsCom = IPAddress( 13 , 86 , 101 , 172 );

# define NTP_REQUEST_PORT      123

const int NTP_PACKET_SIZE = 48 ;       // NTP timestamp is in the first 48 bytes of the message

byte packetBuffer[NTP_PACKET_SIZE];   // buffer to hold incoming and outgoing packets

// A UDP instance to let us send and receive packets over UDP
AsyncUDP Udp;

// send an NTP request to the time server at the given address
void createNTPpacket ( void )
{
  ...
}

void sendNTPPacket ( void )
{
  createNTPpacket ();
  // Send unicast
  Udp. write (packetBuffer, sizeof (packetBuffer));
}

void parsePacket (AsyncUDPPacket packet)
{
  ...
}

void setup ()
{
  ...
  
  // NTP requests are to port NTP_REQUEST_PORT = 123
  if (Udp. connect (timeWindowsCom, NTP_REQUEST_PORT))
  {
    // Setting up Async packet Handler
    Udp. onPacket ([](AsyncUDPPacket packet)
    {
      parsePacket (packet);
    });
  }
}

void loop ()
{
  sendNTPPacket ();

  // wait 60 seconds before asking for the time again
  delay ( 60000 );
}

So verwenden Sie STM32F4 mit LAN8720

1. Verkabelung

Dies ist die Verkabelung für STM32F4 (BLACK_F407VE usw.) mit LAN8720

LAN8720 PHY <---> STM32F4
TX1 <---> PB_13
TX_EN <---> PB_11
TX0 <---> PB_12
RX0 <---> PC_4
RX1 <---> PC_5
nINT/RETCLK <---> PA_1
CRS <---> PA_7
MDIO <---> PA_2
MDC <---> PC_1
GND <---> GND
VCC <---> +3,3V

2. HOWTO-Programmierung mit STLink V-2 oder V-3

Verbinden Sie sich wie folgt. Verwenden Sie zum Programmieren STM32CubeProgrammer oder Arduino IDE mit

  • U(S)ART-Unterstützung: „Aktiviert (generische Seriell)“
  • Upload-Methode: „STM32CubeProgrammer (SWD)“
STLink <---> STM32F4
SWCLK <---> SWCLK
SWDIO <---> SWDIO
RST <---> NRST
GND <---> GND
5v <---> 5V

3. So verwenden Sie den seriellen Port zum Debuggen

Schließen Sie FDTI (USB an Seriell) wie folgt an:

FDTI <---> STM32F4
RX <---> TX=PA_9
TX <---> RX=PA_10
GND <---> GND

Beispiele

  1. AsyncUDPClient
  2. AsyncUdpNTPClient
  3. AsyncUdpSendReceive
  4. AsyncUDPServer
  5. AsyncUDPMulticastServer
  6. AsyncUDPClient_LAN8720
  7. AsyncUdpNTPClient_LAN8720
  8. AsyncUdpSendReceive_LAN8720
  9. AsyncUDPServer_LAN8720
  10. AsyncUDPMulticastServer_LAN8720
  11. multiFileProject Neu
  12. multiFileProject_LAN8720 Neu

Beispiel AsyncUdpNTPClient

1. Datei AsyncUdpNTPClient.ino

AsyncUDP_STM32/examples/AsyncUdpNTPClient/AsyncUdpNTPClient.ino

Zeilen 13 bis 160 in 5adf5c9

# include " defines.h "
# include < time.h >
// 0.ca.pool.ntp.org
IPAddress timeServerIP = IPAddress( 208 , 81 , 1 , 244 );
// time.nist.gov
// IPAddress timeServerIP = IPAddress(132, 163, 96, 1);
# Definieren Sie NTP_REQUEST_PORT 123
// char timeServer[] = "time.nist.gov"; // NTP-Server
char timeServer[] = " 0.ca.pool.ntp.org " ;
const int NTP_PACKET_SIZE = 48 ; // Der NTP-Zeitstempel befindet sich in den ersten 48 Bytes der Nachricht
Byte packetBuffer[NTP_PACKET_SIZE]; // Puffer zur Speicherung eingehender und ausgehender Pakete
// Eine UDP-Instanz, mit der wir Pakete über UDP senden und empfangen können
AsyncUDP Udp;
// eine NTP-Anfrage an den Zeitserver unter der angegebenen Adresse senden
void createNTPpacket ( void )
{
Seriell. println ( " ============= createNTPpacket ============= " );
// alle Bytes im Puffer auf 0 setzen
memset (packetBuffer, 0 , NTP_PACKET_SIZE);
// Werte initialisieren, die zum Erstellen einer NTP-Anfrage erforderlich sind
// (siehe URL oben für Details zu den Paketen)
packetBuffer[ 0 ] = 0b11100011 ; // LI, Version, Modus
packetBuffer[ 1 ] = 0 ; // Stratum oder Art der Uhr
packetBuffer[ 2 ] = 6 ; // Abfrageintervall
packetBuffer[ 3 ] = 0xEC ; // Peer-Clock-Präzision
// 8 Bytes Null für Root Delay und Root Dispersion
packetBuffer[ 12 ] = 49 ;
packetBuffer[ 13 ] = 0x4E ;
packetBuffer[ 14 ] = 49 ;
packetBuffer[ 15 ] = 52 ;
}
void parsePacket (AsyncUDPPacket-Paket)
{
struct tm ts;
char buf[ 80 ];
memcpy (packetBuffer, packet. data (), sizeof (packetBuffer));
Seriell. print ( " Empfangener UDP-Pakettyp: " );
Seriell. println (packet. isBroadcast () ? „ Broadcast “ : packet. isMulticast ()? „ Multicast “ : „ Unicast “ );
Seriell. print ( " Von: " );
Seriell. print (packet. remoteIP ());
Seriell. print ( " : " );
Seriell. print (packet. remotePort ());
Seriell. print ( " , An: " );
Seriell. print (packet. localIP ());
Seriell. print ( " : " );
Seriell. print (packet. localPort ());
Seriell. print ( " , Länge: " );
Seriell. print ( Paketlänge ());
Seriell. println ();
unsigned long highWord = word (packetBuffer[ 40 ], packetBuffer[ 41 ]);
unsigned long lowWord = word (packetBuffer[ 42 ], packetBuffer[ 43 ]);
// kombiniere die vier Bytes (zwei Wörter) zu einer langen Ganzzahl
// das ist die NTP-Zeit (Sekunden seit dem 1. Januar 1900):
unsigned long secsSince1900 = highWord << 16 | lowWord;
Seriell. print ( F ( „ Sekunden seit dem 1. Januar 1900 = “ ));
Seriell. println (secsSince1900);
// Jetzt NTP-Zeit in Alltagszeit umwandeln:
Seriell. print ( F ( " Epoch/Unix time = " ));
// Die Unix-Zeit beginnt am 1. Januar 1970. In Sekunden ist das 2208988800:
const unsigned long seventyYears = 2208988800UL ;
// subtrahiere siebzig Jahre:
unsigned long epoch = secsSince1900 - seventyYears;
time_t epoch_t = epoch; // secsSince1900 - seventyYears;
// Unix-Zeit ausgeben:
Seriell. println (Epoche);
// Stunde, Minute und Sekunde ausgeben:
Seriell. print ( F ( " Die UTC/GMT-Zeit ist " )); // UTC ist die Zeit am Greenwich Meridian (GMT)
ts = * Ortszeit (& epoch_t );
strftime (buf, sizeof (buf), " %a %Y-%m-%d %H:%M:%S %Z " , &ts);
Seriell. println (buf);
}
void sendNTPPacket ( void )
{
createNTPpacket ();
// Unicast senden
Udp. write (packetBuffer, sizeof (packetBuffer));
}
void setup ()
{
Seriell. beginnen ( 115200 );
while (!Serial);
Seriell. print ( " n AsyncUdpNTPClient starten auf " ); Seriell. println (BOARD_NAME);
Seriell. println (ASYNC_UDP_STM32_VERSION);
# if (_ASYNC_UDP_STM32_LOGLEVEL_ > 2)
Seriell. print ( " STM32 Core version v " ); Seriell. drucken (STM32_CORE_VERSION_MAJOR);
Seriell. drucken ( " . " ); Seriell. drucken (STM32_CORE_VERSION_MINOR);
Seriell. drucken ( " . " ); Seriell. println (STM32_CORE_VERSION_PATCH);
# endif
// Starten Sie die Ethernet-Verbindung und den Server
// Zufälligen Mac verwenden
uint16_t index = millis () % NUMBER_OF_MAC;
// Statische IP verwenden
// Ethernet.begin(mac[index], ip);
// Dynamische DHCP-IP und zufälligen Mac verwenden
Ethernet. begin (mac[ index ]);
// Sie sind jetzt verbunden, also drucken Sie die Daten aus
Seriell. print ( F ( " Sie sind mit dem Netzwerk verbunden, IP = " ));
Seriell. println (Ethernet. localIP ());
// NTP-Anfragen erfolgen an Port NTP_REQUEST_PORT = 123
if (Udp. connect (timeServerIP, NTP_REQUEST_PORT))
// if (Udp.connect(timeServer, NTP_REQUEST_PORT))
{
Seriell. println ( „ UDP verbunden “ );
Udp. onPacket ([](AsyncUDPPacket-Paket)
{
parsePacket (Paket);
});
}
}
Leere Schleife ()
{
sendNTPPacket ();
// 60 Sekunden warten, bevor erneut nach der Uhrzeit gefragt wird
Verzögerung ( 60000 );
}

2. Datei defines.h

AsyncUDP_STM32/examples/AsyncUdpNTPClient/defines.h

Zeilen 12 bis 124 in 5adf5c9

/*
Derzeit unterstützt
1) STM32-Boards mit integriertem Ethernet (zur Verwendung von USE_BUILTIN_ETHERNET = true), wie zum Beispiel:
- Nucleo-144 (F429ZI, F767ZI)
- Entdeckung (STM32F746G-DISCOVERY)
- STM32-Boards (STM32F/L/H/G/WB/MP1) mit 32K+ Flash, mit integriertem Ethernet,
- Sehen Sie sich an, wie Sie integriertes Ethernet verwenden unter (https://github.com/khoih-prog/EthernetWebServer_STM32/issues/1).
2) STM32F/L/H/G/WB/MP1-Boards (mit 32+K Flash) mit ENC28J60-Shields (zur Verwendung von USE_BUILTIN_ETHERNET = false)
3) STM32F/L/H/G/WB/MP1-Boards (mit 32+K Flash) mit W5x00-Shields
*/
#ifndef definiert_h
#define definiert_h
#if !( definiert( STM32F0 ) || definiert( STM32F1 ) || definiert( STM32F2 ) || definiert( STM32F3 ) || definiert( STM32F4 ) || definiert( STM32F7 ) ||
definiert( STM32L0 ) || definiert( STM32L1 ) || definiert( STM32L4 ) || definiert( STM32H7 ) || definiert( STM32G0 ) || definiert( STM32G4 ) ||
definiert( STM32WB ) || definiert( STM32MP1 ) )
#error Dieser Code ist für die Ausführung auf der STM32F/L/H/G/WB/MP1-Plattform konzipiert! Bitte überprüfen Sie Ihre Tools->Board-Einstellung.
#endif
#define ASYNC_UDP_STM32_DEBUG_PORT Serial
// Von 0 bis 4 verwenden. Höhere Zahl, mehr Debugging-Meldungen und Speicherverbrauch.
#define _ASYNC_UDP_STM32_LOGLEVEL_ 1
#if definiert( STM32F0 )
#Warnung STM32F0-Board ausgewählt
#define BOARD_TYPE „STM32F0“
#elif definiert( STM32F1 )
#Warnung STM32F1-Board ausgewählt
#define BOARD_TYPE „STM32F1“
#elif definiert( STM32F2 )
#Warnung STM32F2-Board ausgewählt
#define BOARD_TYPE „STM32F2“
#elif definiert( STM32F3 )
#Warnung STM32F3-Board ausgewählt
#define BOARD_TYPE „STM32F3“
#elif definiert( STM32F4 )
#Warnung STM32F4-Board ausgewählt
#define BOARD_TYPE „STM32F4“
#elif definiert( STM32F7 )
#Warnung STM32F7-Board ausgewählt
#define BOARD_TYPE „STM32F7“
#elif definiert( STM32L0 )
#Warnung STM32L0-Board ausgewählt
#define BOARD_TYPE „STM32L0“
#elif definiert( STM32L1 )
#Warnung STM32L1-Board ausgewählt
#define BOARD_TYPE „STM32L1“
#elif definiert( STM32L4 )
#Warnung STM32L4-Board ausgewählt
#define BOARD_TYPE „STM32L4“
#elif definiert( STM32H7 )
#Warnung STM32H7-Board ausgewählt
#define BOARD_TYPE „STM32H7“
#elif definiert( STM32G0 )
#warning STM32G0-Board ausgewählt
#define BOARD_TYPE „STM32G0“
#elif definiert( STM32G4 )
#warning STM32G4-Board ausgewählt
#define BOARD_TYPE „STM32G4“
#elif definiert ( STM32WB )
#Warnung STM32WB-Board ausgewählt
#define BOARD_TYPE „STM32WB“
#elif definiert( STM32MP1 )
#Warnung STM32MP1-Board ausgewählt
#define BOARD_TYPE „STM32MP1“
#anders
#Warnung STM32 unbekanntes Board ausgewählt
#define BOARD_TYPE „STM32 Unbekannt“
#endif
#ifndef BOARD_NAME
#define BOARD_NAME BOARD_TYPE
#endif
#include <LwIP.h>
#include <STM32Ethernet.h>
#include <AsyncUDP_STM32.h>
// Geben Sie unten eine MAC-Adresse und eine IP-Adresse für Ihren Controller ein.
#define NUMBER_OF_MAC 20
Byte mac [][ NUMBER_OF_MAC ] =
{
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x01 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x02 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x03 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x04 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x05 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x06 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x07 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x08 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x09 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x0A },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x0B },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x0C },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x0D },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x0E },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x0F },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x10 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x11 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x12 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x13 },
{ 0xDE , 0xAD , 0xBE , 0xEF , 0x32 , 0x14 },
};
// Wählen Sie die statische IP-Adresse entsprechend Ihrem lokalen Netzwerk aus
IP-Adresse IP ( 192 , 168 , 2 , 232 );
#endif //defines_h

Debug-Terminal-Ausgabebeispiele

1. AsyncUdpNTPClient auf STM32F7 NUCLEO_F767ZI mit LAN8742A Ethernet unter Verwendung der STM32Ethernet-Bibliothek

Dies ist die Terminal-Debug-Ausgabe, wenn AsyncUdpNTPClient auf STM32F7 Nucleo-144 NUCLEO_F767ZI ausgeführt wird. . Es stellt mithilfe der AsyncUDP_STM32-Bibliothek eine Verbindung zum NTP-Server time.windows.com (IP=13.86.101.172) her und fordert alle 60 Sekunden die NTP-Zeit an. Das Paket wird dann empfangen und asynchron verarbeitet, um die aktuelle UTC/GMT-Zeit auszudrucken. 

Start AsyncUdpNTPClient on NUCLEO_F767ZI
AsyncUdp_STM32 v1 .3.0
STM32 Core version v2 .3.0
You ' re connected to the network, IP = 192.168.2.157
UDP connected
============= createNTPpacket =============
Received UDP Packet Type: Unicast
From: 208.81.1.244:123, To: 192.168.2.157:62510, Length: 48
Seconds since Jan 1 1900 = 3864858437
Epoch/Unix time = 1655869637
The UTC/GMT time is Wed 2022-06-22 03:47:17 GMT
============= createNTPpacket =============
Received UDP Packet Type: Unicast
From: 208.81.1.244:123, To: 192.168.2.157:62510, Length: 48
Seconds since Jan 1 1900 = 3864858497
Epoch/Unix time = 1655869697
The UTC/GMT time is Wed 2022-06-22 03:48:17 GMT
============= createNTPpacket =============
Received UDP Packet Type: Unicast
From: 208.81.1.244:123, To: 192.168.2.157:62510, Length: 48
Seconds since Jan 1 1900 = 3864858557
Epoch/Unix time = 1655869757
The UTC/GMT time is Wed 2022-06-22 03:49:17 GMT

2. AsyncUdpNTPClient_LAN8720 auf STM32F4 BLACK_F407VE mit LAN8720-Ethernet unter Verwendung der STM32Ethernet-Bibliothek

Dies ist die Terminal-Debug-Ausgabe, wenn AsyncUdpNTPClient_LAN8720 auf STM32F4 BLACK_F407VE mit LAN8720-Ethernet unter Verwendung der STM32Ethernet-Bibliothek ausgeführt wird. Es stellt mithilfe der AsyncUDP_STM32-Bibliothek eine Verbindung zum NTP-Server time.windows.com (IP=13.86.101.172) her und fordert alle 60 Sekunden die NTP-Zeit an. Das Paket wird dann empfangen und asynchron verarbeitet, um die aktuelle UTC/GMT-Zeit auszudrucken. 

Start AsyncUdpNTPClient_LAN8720 on BLACK_F407VE
AsyncUdp_STM32 v1 .3.0
STM32 Core version v2 .3.0
You ' re connected to the network, IP = 192.168.2.151
UDP connected
============= createNTPpacket =============
Received UDP Packet Type: Unicast
From: 208.81.1.244:123, To: 192.168.2.157:62510, Length: 48
Seconds since Jan 1 1900 = 3864858616
Epoch/Unix time = 1655869816
The UTC/GMT time is Wed 2022-06-22 03:50:16 GMT
============= createNTPpacket =============
Received UDP Packet Type: Unicast
From: 208.81.1.244:123, To: 192.168.2.157:62510, Length: 48
Seconds since Jan 1 1900 = 3864858676
Epoch/Unix time = 1655869876
The UTC/GMT time is Wed 2022-06-22 03:51:16 GMT
============= createNTPpacket =============
Received UDP Packet Type: Unicast
From: 208.81.1.244:123, To: 192.168.2.157:62510, Length: 48
Seconds since Jan 1 1900 = 3864858735
Epoch/Unix time = 1655869935
The UTC/GMT time is Wed 2022-06-22 03:52:15 GMT

Debuggen

Debug ist bei Serial standardmäßig aktiviert. Zum Deaktivieren verwenden Sie Stufe 0 

# define ASYNC_UDP_STM32_DEBUG_PORT      Serial

// Use from 0 to 4. Higher number, more debugging messages and memory usage.
# define _ASYNC_UDP_STM32_LOGLEVEL_      0

Sie können die Debugging-Stufe auch von 0 auf 4 ändern 

# define ASYNC_UDP_STM32_DEBUG_PORT      Serial


// Use from 0 to 4. Higher number, more debugging messages and memory usage.
# define _ASYNC_UDP_STM32_LOGLEVEL_    4

Fehlerbehebung

Wenn Kompilierungsfehler auftreten, müssen Sie in den meisten Fällen eine neuere Version der Arduino IDE, des Arduino STM32 Kerns oder abhängiger Bibliotheken installieren.

Manchmal funktioniert die Bibliothek nur, wenn Sie den STM32 Kern auf die neueste Version aktualisieren, da ich immer die neuesten Kerne/Bibliotheken verwende.

Probleme

Senden Sie Probleme an: AsyncUDP_STM32-Probleme

ZU TUN

  1. Fehler beheben. Erweiterung hinzufügen
  2. Fügen Sie Unterstützung für mehr Ethernet/WiFi-Schild hinzu
  3. Fügen Sie Unterstützung für weitere STM32-Boards hinzu.

ERLEDIGT

  1. Erster Port auf STM32 mit integriertem LAN8742A Etnernet. Getestet auf STM32F7 Nucleo-144 F767ZI .
  2. Fügen Sie weitere Beispiele hinzu.
  3. Fügen Sie Debugging-Funktionen hinzu.
  4. Fügen Sie Unterstützung für Ethernet LAN8720 mithilfe der STM32Ethernet-Bibliothek hinzu, für Karten wie Nucleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG), Discovery (DISCO_F746NG) und STM32F4-Karten (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
  5. Fehler beim Linker mit mehreren Definitionen behoben
  6. Update-Beispiele für den neuen STM32-Kern v2.3.0
  7. Fügen Sie das Beispiel multiFileProject und multiFileProject_LAN8720 zur Demo für ein Projekt mit mehreren Dateien hinzu, um Linkerfehler multiple-definitions zu vermeiden

Beiträge und Dank

  1. Basierend auf und modifiziert von Hristo Gochkovs ESPAsyncUDP. Vielen Dank an Hristo Gochkov für die großartige ESPAsyncUDP-Bibliothek
  2. Verließ sich auf die STM32duino LwIP-Bibliothek von Frederic Pillon.
  3. Vielen Dank an Miguel Wisintainer für die gute Arbeit, die Entwicklung, das Debuggen und das Testen.
ich-kein-dev
️️ Hristo Gochkov
fpistm
️ Frederic Pillon
tcpipchip
tcpipchip

Mitwirken

Wenn Sie zu diesem Projekt beitragen möchten:

  • Melden Sie Bugs und Fehler
  • Bitten Sie um Verbesserungen
  • Erstellen Sie Issues und Pull Requests
  • Erzählen Sie anderen von dieser Bibliothek

Lizenz

  • Die Bibliothek ist unter MIT lizenziert

Copyright

Copyright (c) 2020 – Khoi Hoang

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle