Bibliothèque AsyncUDP_STM32
Table des matières
- Changement important par rapport à la v1.3.0
- Pourquoi avons-nous besoin de cette bibliothèque AsyncUDP_STM32
- Caractéristiques
- Pourquoi Async est meilleur
- Cartes actuellement prises en charge
- Journal des modifications
- Conditions préalables
- Installation
- Utiliser le gestionnaire de bibliothèque Arduino
- Installation manuelle
- VS Code et PlateformeIO
- Correctifs des packages
- 1. Pour que les cartes STM32 utilisent LAN8720
- 2. Pour que les cartes STM32 utilisent Serial1
- HOWTO Corriger l'erreur de l'éditeur de liens
Multiple Definitions - HOWTO Configuration du client UDP asynchrone
- COMMENT utiliser STM32F4 avec LAN8720
- 1. Câblage
- 2. Programme HOWTO utilisant STLink V-2 ou V-3
- 3. COMMENT utiliser le port série pour le débogage
- Exemples
- 1. AsyncUDPClient
- 2. AsyncUdpNTPClient
- 3. AsyncUdpSendReceive
- 4. AsyncUDPServeur
- 5. AsyncUDPMulticastServer
- 6. AsyncUDPClient_LAN8720
- 7. AsyncUdpNTPClient_LAN8720
- 8. AsyncUdpSendReceive_LAN8720
- 9. AsyncUDPServer_LAN8720
- 10. AsyncUDPMulticastServer_LAN8720
- 11. multiFileProjectNouveau
- 12. multiFileProject_LAN8720 Nouveau
- Exemple AsyncUdpNTPClient
- 1. Fichier AsyncUdpNTPClient.ino
- 2. Le fichier définit.h
- Exemples de sortie du terminal de débogage
- 1. AsyncUdpNTPClient sur STM32F7 NUCLEO_F767ZI avec Ethernet LAN8742A utilisant la bibliothèque STM32Ethernet
- 2. AsyncUdpNTPClient_LAN8720 sur STM32F4 BLACK_F407VE avec Ethernet LAN8720 utilisant la bibliothèque STM32Ethernet
- Déboguer
- Dépannage
- Problèmes
- FAIRE
- FAIT
- Contributions et remerciements
- Contribuer
- Licence
- Droit d'auteur
Changement important par rapport à la v1.3.0
Veuillez consulter HOWTO Corriger l'erreur de l'éditeur de liens Multiple Definitions
Pour les cartes Generic STM32F4 series , telles que STM32F407VE, utilisant LAN8720, veuillez utiliser le noyau STM32 v2.2.0 car la rupture du noyau v2.3.0 crée une erreur de compilation. Sera corrigé dans un avenir proche.
Pourquoi avons-nous besoin de cette bibliothèque AsyncUDP_STM32
Caractéristiques
Cette bibliothèque AsyncUDP_STM32 est une bibliothèque UDP entièrement asynchrone, conçue pour un environnement réseau multi-connexion sans problème, pour les cartes STM32 utilisant LAN8720 ou Ethernet LAN8742A intégré. La bibliothèque est facile à utiliser et inclut la prise en charge des environnements Unicast, Broadcast et Multicast.
Cette bibliothèque est basée sur, modifiée à partir de :
- ESPAsyncUDP de Hristo Gochkov
pour appliquer la fonctionnalité asynchrone meilleure et plus rapide de la puissante bibliothèque ESPAsyncUDP dans les cartes STM32 utilisant LAN8720 ou Ethernet LAN8742A intégré.
Pourquoi Async est meilleur
- L'utilisation d'un réseau asynchrone signifie que vous pouvez gérer plusieurs connexions en même temps
- Vous êtes appelé une fois la demande prête et analysée
- Lorsque vous envoyez la réponse, vous êtes immédiatement prêt à gérer d'autres connexions pendant que le serveur s'occupe d'envoyer la réponse en arrière-plan.
- La vitesse est OMG
- Après vous être connecté à un serveur UDP en tant que client asynchrone, vous êtes immédiatement prêt à gérer d'autres connexions pendant que le client s'occupe de recevoir les paquets de réponse UDP en arrière-plan.
- Vous n'êtes pas obligé de vérifier dans une boucle serrée() l'arrivée des paquets de réponse UDP pour les traiter.
Cartes actuellement prises en charge
- Cartes STM32 avec Ethernet LAN8742A intégré telles que :
- Nucléo-144 (F429ZI, F767ZI)
- Découverte (STM32F746G-DISCOVERY)
- Toutes les cartes STM32 (STM32F/L/H/G/WB/MP1) avec 32K+ Flash, avec Ethernet intégré
- Voir la prise en charge EthernetWebServer_STM32 et les résultats des tests
- Cartes STM32 utilisant Ethernet LAN8720 telles que :
- Nucléo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
- Découverte (DISCO_F746NG)
- Cartes STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
Conditions préalables
-
Arduino IDE 1.8.19+ pour Arduino. -
Arduino Core for STM32 v2.3.0+ pour les cartes STM32. -
STM32Ethernet library v1.3.0+ pour Ethernet LAN8742A intégré (Nucleo-144, Discovery). -
LwIP library v2.1.2+ pour Ethernet LAN8742A intégré (Nucleo-144, Discovery).
Installation
La méthode d'installation suggérée est la suivante :
Utiliser le gestionnaire de bibliothèque Arduino
La meilleure façon est d'utiliser Arduino Library Manager . Recherchez AsyncUDP_STM32 , puis sélectionnez/installez la dernière version. Vous pouvez également utiliser ce lien pour des instructions plus détaillées.
Installation manuelle
- Accédez à la page AsyncUDP_STM32.
- Téléchargez la dernière version
AsyncUDP_STM32-master.zip . - Extrayez le fichier zip dans le répertoire
AsyncUDP_STM32-master - Copiez l'intégralité du dossier
AsyncUDP_STM32-master dans le répertoire des bibliothèques Arduino tel que ~/Arduino/libraries/ .
VS Code et PlateformeIO :
- Installer VSCode
- Installer PlatformIO
- Installez la bibliothèque AsyncUDP_STM32 à l'aide de Library Manager. Recherchez AsyncUDP_STM32 dans les bibliothèques de l'auteur Platform.io
- Utilisez le fichier platformio.ini inclus à partir d’exemples pour vous assurer que toutes les bibliothèques dépendantes seront installées automatiquement. Veuillez consulter la documentation pour les autres options et exemples dans le fichier de configuration du projet.
Correctifs des packages
1. Pour que les cartes STM32 utilisent LAN8720
Pour les cartes Generic STM32F4 series , telles que STM32F407VE , utilisant LAN8720 , veuillez utiliser le noyau STM32 v2.2.0 car la rupture du noyau v2.3.0 crée une erreur de compilation.
Pour utiliser LAN8720 sur certaines cartes STM32
- Nucléo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
- Découverte (DISCO_F746NG)
- Cartes STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
vous devez copier les fichiers stm32f4xx_hal_conf_default.h et stm32f7xx_hal_conf_default.h dans le répertoire STM32 stm32 (~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system) pour écraser les anciens fichiers.
Supposons que la version principale de STM32 stm32 soit la 2.2.0. Ces fichiers doivent être copiés dans le répertoire :
-
~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system/STM32F4xx/stm32f4xx_hal_conf_default.h pour STM32F4. -
~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system/STM32F7xx/stm32f7xx_hal_conf_default.h pour Nucleo-144 STM32F7.
Chaque fois qu'une nouvelle version est installée, pensez à copier ce fichier dans le répertoire de la nouvelle version. Par exemple, la nouvelle version est x.yy.zz, ces fichiers doivent être copiés dans le répertoire correspondant :
-
~/.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. Pour que les cartes STM32 utilisent Serial1
Pour utiliser Serial1 sur certaines cartes STM32 sans définition Serial1 (Nucleo-144 NUCLEO_F767ZI, Nucleo-64 NUCLEO_L053R8, etc.) , vous devez copier les fichiers STM32 variant.h dans le répertoire STM32 stm32 (~/.arduino15/packages/STM32/ matériel/stm32/2.3.0). Vous devez modifier les fichiers correspondant à vos cartes, ceci n'est qu'une illustration de la marche à suivre.
Supposons que la version principale de STM32 stm32 soit la 2.3.0. Ces fichiers doivent être copiés dans le répertoire :
-
~/.arduino15/packages/STM32/hardware/stm32/2.3.0/variants/NUCLEO_F767ZI/variant.h pour Nucleo-144 NUCLEO_F767ZI. -
~/.arduino15/packages/STM32/hardware/stm32/2.3.0/variants/NUCLEO_L053R8/variant.h pour Nucleo-64 NUCLEO_L053R8.
Chaque fois qu'une nouvelle version est installée, pensez à copier ce fichier dans le répertoire de la nouvelle version. Par exemple, la nouvelle version est x.yy.zz, ces fichiers doivent être copiés dans le répertoire correspondant :
-
~/.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
HOWTO Corriger l'erreur de l'éditeur de liens Multiple Definitions
L'implémentation actuelle de la bibliothèque, utilisant xyz-Impl.h au lieu du standard xyz.cpp , crée éventuellement certaines erreurs Multiple Definitions Linker dans certains cas d'utilisation.
Vous pouvez inclure ce fichier .hpp
// Can be included as many times as necessary, without `Multiple Definitions` Linker Error
# include " AsyncUDP_STM32.hpp " // https://github.com/khoih-prog/AsyncUDP_STM32
dans de nombreux fichiers. Mais assurez-vous d'utiliser le fichier .h suivant dans seulement 1 fichier .h , .cpp ou .ino , qui ne doit être inclus dans aucun autre fichier , pour éviter une erreur d'éditeur de liens Multiple Definitions
// 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
Consultez le nouvel exemple multiFileProject pour une démo HOWTO .
HOWTO Configuration du client UDP asynchrone
# 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 );
}
COMMENT utiliser STM32F4 avec LAN8720
1. Câblage
Il s'agit du câblage pour STM32F4 (BLACK_F407VE, etc.) utilisant LAN8720
| LAN8720 PHY | <---> | STM32F4 |
|---|
| TX1 | <---> | PB_13 |
| TX_FR | <---> | 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. Programme HOWTO utilisant STLink V-2 ou V-3
Connectez-vous comme suit. Pour programmer, utilisez STM32CubeProgrammer ou Arduino IDE avec
- Prise en charge U(S)ART : "Activé (série générique)"
- Méthode de téléchargement : "STM32CubeProgrammer (SWD)"
| STLink | <---> | STM32F4 |
|---|
| SWCLK | <---> | SWCLK |
| SWDIO | <---> | SWDIO |
| TVD | <---> | NRST |
| GND | <---> | GND |
| 5v | <---> | 5V |
3. COMMENT utiliser le port série pour le débogage
Connectez le FDTI (USB vers série) comme suit :
| FDTI | <---> | STM32F4 |
|---|
| RX | <---> | TX=PA_9 |
| Émission | <---> | RX=PA_10 |
| GND | <---> | GND |
Exemples
- AsyncUDPClient
- AsyncUdpNTPClient
- AsyncUdpSendReceive
- AsyncUDPServer
- AsyncUDPMulticastServer
- AsyncUDPClient_LAN8720
- AsyncUdpNTPClient_LAN8720
- AsyncUdpSendReceive_LAN8720
- AsyncUDPServer_LAN8720
- AsyncUDPMulticastServer_LAN8720
- multiFileProject Nouveau
- multiFileProject_LAN8720 Nouveau
Exemple AsyncUdpNTPClient
1. Fichier AsyncUdpNTPClient.ino
| # inclut " définit.h " |
| #inclut < time.h > |
| |
| // 0.ca.pool.ntp.org |
| Adresse IP timeServerIP = Adresse IP ( 208 , 81 , 1 , 244 ); |
| // time.nist.gov |
| // Adresse IP timeServerIP = Adresse IP (132, 163, 96, 1); |
| |
| # définir NTP_REQUEST_PORT 123 |
| |
| // char timeServer[] = "time.nist.gov"; // Serveur NTP |
| char timeServer[] = " 0.ca.pool.ntp.org " ; |
| |
| const int NTP_PACKET_SIZE = 48 ; // L'horodatage NTP se trouve dans les 48 premiers octets du message |
| |
| octet packetBuffer[NTP_PACKET_SIZE] ; // tampon pour contenir les paquets entrants et sortants |
| |
| // Une instance UDP pour nous permettre d'envoyer et de recevoir des paquets via UDP |
| AsyncUDP Udp ; |
| |
| // envoie une requête NTP au serveur de temps à l'adresse indiquée |
| void createNTPpacket ( void ) |
| { |
| En série. println ( " ============= createNTPpacket ============= " ); |
| |
| // met tous les octets du tampon à 0 |
| memset (packetBuffer, 0 , NTP_PACKET_SIZE); |
| // Initialise les valeurs nécessaires pour former la requête NTP |
| // (voir URL ci-dessus pour plus de détails sur les paquets) |
| |
| packetBuffer[ 0 ] = 0b11100011 ; // LI, Version, Mode |
| paquetBuffer[ 1 ] = 0 ; // Strate, ou type d'horloge |
| paquetBuffer[ 2 ] = 6 ; // Intervalle d'interrogation |
| packetBuffer[ 3 ] = 0xEC ; // Précision de l'horloge homologue |
| |
| // 8 octets de zéro pour Root Delay et Root Dispersion |
| paquetBuffer[ 12 ] = 49 ; |
| packetBuffer[ 13 ] = 0x4E ; |
| packetBuffer[ 14 ] = 49 ; |
| paquetBuffer[ 15 ] = 52 ; |
| } |
| |
| void parsePacket (paquet AsyncUDPPacket) |
| { |
| structure tm ts ; |
| char buf[ 80 ]; |
| |
| memcpy (packetBuffer, packet. data (), sizeof (packetBuffer)); |
| |
| En série. print ( " Type de paquet UDP reçu : " ); |
| En série. println (packet. isBroadcast () ? " Broadcast " : packet. isMulticast () ? " Multicast " : " Unicast " ); |
| En série. print ( " De : " ); |
| En série. imprimer (paquet. remoteIP ()); |
| En série. imprimer ( " : " ); |
| En série. imprimer (paquet. remotePort ()); |
| En série. imprimer ( " , À : " ); |
| En série. print (paquet. localIP ()); |
| En série. imprimer ( " : " ); |
| En série. print (paquet. localPort ()); |
| En série. imprimer ( " , Longueur : " ); |
| En série. imprimer (paquet. longueur ()); |
| En série. println (); |
| |
| unsigned long highWord = mot (packetBuffer[ 40 ], packetBuffer[ 41 ]); |
| unsigned long lowWord = mot (packetBuffer[ 42 ], packetBuffer[ 43 ]); |
| |
| // combine les quatre octets (deux mots) en un entier long |
| // c'est l'heure NTP (secondes depuis le 1er janvier 1900) : |
| secondes longues non signéesDepuis1900 = highWord << 16 | mot bas ; |
| |
| En série. print ( F ( " Secondes depuis le 1er janvier 1900 = " )); |
| En série. println (secsDepuis1900); |
| |
| // convertit maintenant l'heure NTP en heure quotidienne : |
| En série. print ( F ( " Époque/heure Unix = " )); |
| |
| // L'heure Unix commence le 1er janvier 1970. En secondes, cela fait 2208988800 : |
| const non signé long soixante-dix ans = 2208988800UL ; |
| |
| // soustraire soixante-dix ans : |
| époque longue non signée = secsSince1900 - soixante-dix ans ; |
| time_t époque_t = époque ; // secsDepuis1900 - soixante-dix ans ; |
| |
| // affiche l'heure Unix : |
| En série. println (époque); |
| |
| // affiche l'heure, la minute et la seconde : |
| En série. print ( F ( " L'heure UTC/GMT est " )); // UTC est l'heure du méridien de Greenwich (GMT) |
| |
| ts = * heure locale (& epoch_t ); |
| strftime (buf, sizeof (buf), " %a %Y-%m-%d %H:%M:%S %Z " , &ts); |
| En série. println (buf); |
| } |
| |
| void sendNTPPacket ( void ) |
| { |
| créer un paquet NTP (); |
| // Envoyer une monodiffusion |
| UDP. écrire (packetBuffer, sizeof (packetBuffer)); |
| } |
| |
| annuler la configuration () |
| { |
| En série. commencer ( 115200 ); |
| tandis que (!Série); |
| |
| En série. print ( " n Démarrez AsyncUdpNTPClient sur " ); En série. println (BOARD_NAME); |
| En série. println (ASYNC_UDP_STM32_VERSION); |
| |
| # si (_ASYNC_UDP_STM32_LOGLEVEL_ > 2) |
| En série. print ( " Version STM32 Core v " ); En série. imprimer (STM32_CORE_VERSION_MAJOR); |
| En série. imprimer ( " . " ); En série. imprimer (STM32_CORE_VERSION_MINOR); |
| En série. imprimer ( " . " ); En série. println (STM32_CORE_VERSION_PATCH); |
| # fin si |
| |
| // démarre la connexion Ethernet et le serveur |
| // Utiliser un Mac aléatoire |
| uint16_t index = millis () % NUMBER_OF_MAC ; |
| |
| // Utiliser une IP statique |
| // Ethernet.begin(mac[index], ip); |
| // Utiliser une IP dynamique DHCP et un Mac aléatoire |
| Ethernet. commencer (mac[ index ]); |
| |
| // vous êtes connecté maintenant, alors imprimez les données |
| En série. print ( F ( " Vous êtes connecté au réseau, IP = " )); |
| En série. println (Ethernet. localIP ()); |
| |
| // Les requêtes NTP doivent être adressées au port NTP_REQUEST_PORT = 123 |
| if ( Udp.connect (timeServerIP, NTP_REQUEST_PORT)) |
| // si (Udp.connect(timeServer, NTP_REQUEST_PORT)) |
| { |
| En série. println ( " UDP connecté " ); |
| |
| UDP. onPacket ([](paquet AsyncUDPPacket) |
| { |
| parsePacket (paquet); |
| }); |
| } |
| } |
| |
| boucle vide ( ) |
| { |
| envoyerNTPPacket (); |
| |
| // attends 60 secondes avant de demander à nouveau l'heure |
| retard ( 60000 ); |
| } |
2. Le fichier définit.h
| /* |
| Supporte actuellement |
| 1) Cartes STM32 avec Ethernet intégré (à utiliser USE_BUILTIN_ETHERNET = true) telles que : |
| - Nucléo-144 (F429ZI, F767ZI) |
| - Découverte (STM32F746G-DISCOVERY) |
| -Cartes STM32 (STM32F/L/H/G/WB/MP1) avec 32K+ Flash, avec Ethernet intégré, |
| - Voir Comment utiliser Ethernet intégré sur (https://github.com/khoih-prog/EthernetWebServer_STM32/issues/1) |
| 2) Cartes STM32F/L/H/G/WB/MP1 (avec Flash 32+K) exécutant des boucliers ENC28J60 (pour utiliser USE_BUILTIN_ETHERNET = false) |
| 3) Cartes STM32F/L/H/G/WB/MP1 (avec Flash 32+K) exécutant des boucliers W5x00 |
| */ |
| |
| #ifndef définit_h |
| #define définit_h |
| |
| #if !( défini( STM32F0 ) || défini( STM32F1 ) || défini( STM32F2 ) || défini( STM32F3 ) || défini( STM32F4 ) || défini( STM32F7 ) || |
| défini( STM32L0 ) || défini( STM32L1 ) || défini( STM32L4 ) || défini( STM32H7 ) || défini( STM32G0 ) || défini ( STM32G4 ) || |
| défini( STM32WB ) || défini ( STM32MP1 ) ) |
| #error Ce code est conçu pour fonctionner sur la plateforme STM32F/L/H/G/WB/MP1 ! Veuillez vérifier vos paramètres Outils-> Tableau. |
| #endif |
| |
| #define ASYNC_UDP_STM32_DEBUG_PORT Série |
| |
| // Utilisation de 0 à 4. Nombre plus élevé, plus de messages de débogage et d'utilisation de la mémoire. |
| #define _ASYNC_UDP_STM32_LOGLEVEL_ 1 |
| |
| |
| #si défini( STM32F0 ) |
| #warning Carte STM32F0 sélectionnée |
| #définir BOARD_TYPE "STM32F0" |
| #elif défini ( STM32F1 ) |
| #warning Carte STM32F1 sélectionnée |
| #définir BOARD_TYPE "STM32F1" |
| #elif défini ( STM32F2 ) |
| #warning Carte STM32F2 sélectionnée |
| #définir BOARD_TYPE "STM32F2" |
| #elif défini ( STM32F3 ) |
| #warning Carte STM32F3 sélectionnée |
| #définir BOARD_TYPE "STM32F3" |
| #elif défini ( STM32F4 ) |
| #warning Carte STM32F4 sélectionnée |
| #définir BOARD_TYPE "STM32F4" |
| #elif défini ( STM32F7 ) |
| #warning Carte STM32F7 sélectionnée |
| #définir BOARD_TYPE "STM32F7" |
| #elif défini ( STM32L0 ) |
| #warning Carte STM32L0 sélectionnée |
| #définir BOARD_TYPE "STM32L0" |
| #elif défini ( STM32L1 ) |
| #warning Carte STM32L1 sélectionnée |
| #définir BOARD_TYPE "STM32L1" |
| #elif défini ( STM32L4 ) |
| #warning Carte STM32L4 sélectionnée |
| #définir BOARD_TYPE "STM32L4" |
| #elif défini ( STM32H7 ) |
| #warning Carte STM32H7 sélectionnée |
| #définir BOARD_TYPE "STM32H7" |
| #elif défini ( STM32G0 ) |
| #warning Carte STM32G0 sélectionnée |
| #définir BOARD_TYPE "STM32G0" |
| #elif défini ( STM32G4 ) |
| #warning Carte STM32G4 sélectionnée |
| #définir BOARD_TYPE "STM32G4" |
| #elif défini ( STM32WB ) |
| #warning Carte STM32WB sélectionnée |
| #définir BOARD_TYPE "STM32WB" |
| #elif défini ( STM32MP1 ) |
| #warning Carte STM32MP1 sélectionnée |
| #définir BOARD_TYPE "STM32MP1" |
| #autre |
| #warning Carte inconnue STM32 sélectionnée |
| #define BOARD_TYPE "STM32 inconnu" |
| #endif |
| |
| #ifndef BOARD_NAME |
| #définir BOARD_NAME BOARD_TYPE |
| #endif |
| |
| #include <LwIP.h> |
| #include <STM32Ethernet.h> |
| |
| #include <AsyncUDP_STM32.h> |
| |
| // Entrez ci-dessous une adresse MAC et une adresse IP pour votre contrôleur. |
| #définir NUMBER_OF_MAC 20 |
| |
| octet 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 }, |
| } ; |
| |
| // Sélectionnez l'adresse IP statique en fonction de votre réseau local |
| Adresse IP IP ( 192 , 168 , 2 , 232 ); |
| |
| #endif //définit_h |
Exemples de sortie du terminal de débogage
1. AsyncUdpNTPClient sur STM32F7 NUCLEO_F767ZI avec Ethernet LAN8742A utilisant la bibliothèque STM32Ethernet
Il s'agit de la sortie de débogage du terminal lors de l'exécution d'AsyncUdpNTPClient sur STM32F7 Nucleo-144 NUCLEO_F767ZI. . Il se connecte au serveur NTP time.windows.com (IP=13.86.101.172) à l'aide de la bibliothèque AsyncUDP_STM32 et demande l'heure NTP toutes les 60 secondes. Le paquet est ensuite reçu et traité de manière asynchrone pour imprimer l'heure UTC/GMT actuelle.
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 sur STM32F4 BLACK_F407VE avec Ethernet LAN8720 utilisant la bibliothèque STM32Ethernet
Il s'agit de la sortie de débogage du terminal lors de l'exécution d'AsyncUdpNTPClient_LAN8720 sur STM32F4 BLACK_F407VE avec LAN8720 Ethernet à l'aide de la bibliothèque STM32Ethernet . Il se connecte au serveur NTP time.windows.com (IP=13.86.101.172) à l'aide de la bibliothèque AsyncUDP_STM32 et demande l'heure NTP toutes les 60 secondes. Le paquet est ensuite reçu et traité de manière asynchrone pour imprimer l'heure UTC/GMT actuelle.
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
Déboguer
Le débogage est activé par défaut sur Serial. Pour désactiver, utilisez le niveau 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
Vous pouvez également changer le niveau de débogage de 0 à 4
# 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
Dépannage
Si vous obtenez le plus souvent des erreurs de compilation, vous devrez peut-être installer une version plus récente de l'IDE Arduino, du noyau Arduino STM32 ou des bibliothèques dépendantes.
Parfois, la bibliothèque ne fonctionnera que si vous mettez à jour le noyau STM32 vers la dernière version, car j'utilise toujours les derniers cœurs/bibliothèques.
Problèmes
Soumettre les problèmes à : Problèmes AsyncUDP_STM32
FAIRE
- Correction d'un bug. Ajouter une amélioration
- Ajoutez la prise en charge de davantage de boucliers Ethernet/WiFi
- Ajoutez la prise en charge de davantage de cartes STM32.
FAIT
- Port initial vers STM32 à l’aide d’Etnernet LAN8742A intégré. Testé sur STM32F7 Nucleo-144 F767ZI .
- Ajoutez plus d'exemples.
- Ajoutez des fonctionnalités de débogage.
- Ajoutez la prise en charge d'Ethernet LAN8720 à l'aide de la bibliothèque STM32Ethernet, pour les cartes telles que Nucleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG), Discovery (DISCO_F746NG) et les cartes STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
- Correction d'une erreur de l'éditeur de liens à définitions multiples
- Exemples de mise à jour pour le nouveau noyau STM32 v2.3.0
- Ajoutez les exemples multiFileProject et multiFileProject_LAN8720 à la démo pour un projet à plusieurs fichiers afin d'éviter une erreur de l'éditeur de liens
multiple-definitions
Contributions et remerciements
- Basé sur et modifié à partir de ESPAsyncUDP de Hristo Gochkov. Un grand merci à Hristo Gochkov pour l'excellente bibliothèque ESPAsyncUDP
- S'appuie sur la bibliothèque STM32duino LwIP de Frédéric Pillon.
- Merci au bon travail de Miguel Wisintainer pour son travail, son développement, son débogage et ses tests.
️️ Christo Gochkov
| 
️ Frédéric Pillon
| 
tcpipchip
|
Contribuer
Si vous souhaitez contribuer à ce projet :
- Signaler les bugs et les erreurs
- Demandez des améliorations
- Créer des problèmes et des demandes d'extraction
- Parlez de cette bibliothèque à d'autres personnes
Licence
- La bibliothèque est sous licence MIT
Droit d'auteur
Copyright (c) 2020- Khoi Hoang
