Biblioteca AsyncUDP_STM32
Tabla de contenido
- Cambio importante desde v1.3.0
- ¿Por qué necesitamos esta biblioteca AsyncUDP_STM32?
- Características
- Por qué Async es mejor
- Tableros actualmente soportados
- Registro de cambios
- Requisitos previos
- Instalación
- Utilice el Administrador de biblioteca Arduino
- Instalación manual
- Código VS y plataformaIO
- Parches de paquetes
- 1. Para que las placas STM32 utilicen LAN8720
- 2. Para que las placas STM32 utilicen Serial1
- CÓMO solucionar el error del vinculador
Multiple Definitions - CÓMO Configurar el cliente UDP asíncrono
- CÓMO usar STM32F4 con LAN8720
- 1. Cableado
- 2. Programa HOWTO usando STLink V-2 o V-3
- 3. CÓMO utilizar el puerto serie para la depuración
- Ejemplos
- 1. Cliente AsyncUDPC
- 2. Cliente AsyncUdpNTPC
- 3. AsyncUdpSendReceive
- 4. Servidor AsyncUDP
- 5. Servidor de multidifusión AsyncUDP
- 6. AsyncUDPClient_LAN8720
- 7. AsyncUdpNTPClient_LAN8720
- 8. AsyncUdpSendReceive_LAN8720
- 9. AsyncUDPServer_LAN8720
- 10. AsyncUDPMulticastServer_LAN8720
- 11. multiFileProject Nuevo
- 12. multiFileProject_LAN8720 Nuevo
- Ejemplo AsyncUdpNTPClient
- 1. Archivo AsyncUdpNTPClient.ino
- 2. El archivo define.h
- Ejemplos de salida del terminal de depuración
- 1. AsyncUdpNTPClient en STM32F7 NUCLEO_F767ZI con LAN8742A Ethernet usando la biblioteca STM32Ethernet
- 2. AsyncUdpNTPClient_LAN8720 en STM32F4 BLACK_F407VE con LAN8720 Ethernet usando la biblioteca STM32Ethernet
- Depurar
- Solución de problemas
- Asuntos
- HACER
- HECHO
- Aportes y agradecimientos
- Contribuyendo
- Licencia
- Derechos de autor
Cambio importante desde v1.3.0
Eche un vistazo a CÓMO solucionar el error del vinculador Multiple Definitions
Para las placas Generic STM32F4 series , como STM32F407VE, que utilizan LAN8720, utilice STM32 core v2.2.0 ya que romper el core v2.3.0 crea el error de compilación. Se solucionará en un futuro próximo.
¿Por qué necesitamos esta biblioteca AsyncUDP_STM32?
Características
Esta biblioteca AsyncUDP_STM32 es una biblioteca UDP totalmente asíncrona, diseñada para un entorno de red de múltiples conexiones sin problemas, para placas STM32 que utilizan LAN8720 o Ethernet LAN8742A incorporada. La biblioteca es fácil de usar e incluye soporte para entornos Unicast, Broadcast y Multicast.
Esta biblioteca se basa en, modificada de:
- ESPAsyncUDP de Hristo Gochkov
para aplicar la característica asincrónica mejor y más rápida de la poderosa biblioteca ESPAsyncUDP en placas STM32 usando LAN8720 o Ethernet LAN8742A incorporada.
Por qué Async es mejor
- Usar una red asíncrona significa que puedes manejar más de una conexión al mismo tiempo
- Se le llamará una vez que la solicitud esté lista y analizada.
- Cuando envía la respuesta, está inmediatamente listo para manejar otras conexiones mientras el servidor se encarga de enviar la respuesta en segundo plano.
- La velocidad es Dios mío.
- Después de conectarse a un servidor UDP como Cliente asíncrono, estará inmediatamente listo para manejar otras conexiones mientras el Cliente se encarga de recibir los paquetes de respuesta UDP en segundo plano.
- No es necesario verificar en un bucle cerrado() la llegada de los paquetes de respuesta UDP para procesarlos.
Tableros actualmente soportados
- Placas STM32 con Ethernet LAN8742A incorporada como:
- Núcleo-144 (F429ZI, F767ZI)
- Descubrimiento (STM32F746G-DISCOVERY)
- Todas las placas STM32 (STM32F/L/H/G/WB/MP1) con 32K+ Flash, con Ethernet incorporado
- Consulte el soporte de EthernetWebServer_STM32 y los resultados de las pruebas.
- Placas STM32 que utilizan Ethernet LAN8720 como:
- Núcleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
- Descubrimiento (DISCO_F746NG)
- Placas STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
Requisitos previos
-
Arduino IDE 1.8.19+ para Arduino. -
Arduino Core for STM32 v2.3.0+ para placas STM32. -
STM32Ethernet library v1.3.0+ para Ethernet LAN8742A integrada en (Nucleo-144, Discovery). -
LwIP library v2.1.2+ para Ethernet LAN8742A incorporada (Nucleo-144, Discovery).
Instalación
La forma sugerida de instalación es:
Utilice el Administrador de biblioteca Arduino
La mejor manera es utilizar Arduino Library Manager . Busque AsyncUDP_STM32 y luego seleccione/instale la última versión. También puede utilizar este enlace para obtener instrucciones más detalladas.
Instalación manual
- Navegue a la página AsyncUDP_STM32.
- Descargue la última versión
AsyncUDP_STM32-master.zip . - Extraiga el archivo zip al directorio
AsyncUDP_STM32-master - Copie toda la carpeta
AsyncUDP_STM32-master en el directorio de bibliotecas de Arduino, como ~/Arduino/libraries/ .
Código VS y plataforma IO:
- Instalar código VS
- Instalar plataforma IO
- Instale la biblioteca AsyncUDP_STM32 utilizando el Administrador de biblioteca. Busque AsyncUDP_STM32 en las bibliotecas del autor de Platform.io
- Utilice el archivo platformio.ini incluido de los ejemplos para asegurarse de que todas las bibliotecas dependientes se instalen automáticamente. Visite la documentación para conocer otras opciones y ejemplos en Archivo de configuración del proyecto.
Parches de paquetes
1. Para que las placas STM32 utilicen LAN8720
Para las placas Generic STM32F4 series , como STM32F407VE , que utilizan LAN8720 , utilice STM32 core v2.2.0 ya que romper el core v2.3.0 crea el error de compilación.
Para usar LAN8720 en algunas placas STM32
- Núcleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
- Descubrimiento (DISCO_F746NG)
- Placas STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
debe copiar los archivos stm32f4xx_hal_conf_default.h y stm32f7xx_hal_conf_default.h en el directorio STM32 stm32 (~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system) para sobrescribir los archivos antiguos.
Suponiendo que la versión principal de STM32 stm32 es 2.2.0. Estos archivos deben copiarse en el directorio:
-
~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system/STM32F4xx/stm32f4xx_hal_conf_default.h para STM32F4. -
~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system/STM32F7xx/stm32f7xx_hal_conf_default.h para Nucleo-144 STM32F7.
Siempre que instale una nueva versión, recuerde copiar este archivo en el directorio de la nueva versión. Por ejemplo, la nueva versión es x.yy.zz, estos archivos deben copiarse en el directorio correspondiente:
-
~/.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. Para que las placas STM32 utilicen Serial1
Para usar Serial1 en algunas placas STM32 sin definición Serial1 (Nucleo-144 NUCLEO_F767ZI, Nucleo-64 NUCLEO_L053R8, etc.) , debe copiar los archivos STM32 variante.h en el directorio STM32 stm32. (~/.arduino15/packages/STM32/hardware/stm32/2.3.0). Tienes que modificar los archivos correspondientes a tus tableros, esto es solo una ilustración de cómo hacerlo.
Suponiendo que la versión principal de STM32 stm32 es 2.3.0. Estos archivos deben copiarse en el directorio:
-
~/.arduino15/packages/STM32/hardware/stm32/2.3.0/variants/NUCLEO_F767ZI/variant.h para Nucleo-144 NUCLEO_F767ZI. -
~/.arduino15/packages/STM32/hardware/stm32/2.3.0/variants/NUCLEO_L053R8/variant.h para Nucleo-64 NUCLEO_L053R8.
Siempre que instale una nueva versión, recuerde copiar este archivo en el directorio de la nueva versión. Por ejemplo, la nueva versión es x.yy.zz, estos archivos deben copiarse en el directorio correspondiente:
-
~/.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
CÓMO solucionar el error del vinculador Multiple Definitions
La implementación actual de la biblioteca, que utiliza xyz-Impl.h en lugar del xyz.cpp estándar, posiblemente cree cierto error del vinculador Multiple Definitions en ciertos casos de uso.
Puede incluir este archivo .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
en muchos archivos. Pero asegúrese de utilizar el siguiente archivo .h en solo 1 archivo .h , .cpp o .ino , que no debe incluirse en ningún otro archivo , para evitar el error del vinculador 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
Consulte el nuevo ejemplo de multiFileProject para ver una demostración HOWTO .
CÓMO Configurar el cliente UDP asíncrono
# 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 );
}
CÓMO usar STM32F4 con LAN8720
1. Cableado
Este es el cableado para STM32F4 (BLACK_F407VE, etc.) usando LAN8720
| LAN8720 FÍSICA | <---> | STM32F4 |
|---|
| TX1 | <---> | PB_13 |
| TX_ES | <---> | PB_11 |
| TX0 | <---> | PB_12 |
| RX0 | <---> | ordenador_4 |
| RX1 | <---> | ordenador_5 |
| nINT/RETCLK | <---> | PA_1 |
| CRS | <---> | PA_7 |
| MDIO | <---> | PA_2 |
| MDC | <---> | ordenador_1 |
| Tierra | <---> | Tierra |
| VCC | <---> | +3.3V |
2. Programa HOWTO usando STLink V-2 o V-3
Conéctese de la siguiente manera. Para programar, utilice STM32CubeProgrammer o Arduino IDE con
- Soporte U(S)ART: "Habilitado (serie genérica)"
- Método de carga: "STM32CubeProgrammer (SWD)"
| STEnlace | <---> | STM32F4 |
|---|
| SWCLK | <---> | SWCLK |
| SWDIO | <---> | SWDIO |
| primero | <---> | NRST |
| Tierra | <---> | Tierra |
| 5v | <---> | 5V |
3. CÓMO utilizar el puerto serie para la depuración
Conecte FDTI (USB a serie) de la siguiente manera:
| IEDD | <---> | STM32F4 |
|---|
| RX | <---> | TX=PA_9 |
| Texas | <---> | RX=PA_10 |
| Tierra | <---> | Tierra |
Ejemplos
- Cliente AsyncUDPC
- Cliente AsyncUdpNTPC
- AsyncUdpEnviarRecibir
- Servidor AsyncUDPServidor
- AsyncUDPServidor de multidifusión
- AsyncUDPClient_LAN8720
- AsyncUdpNTPClient_LAN8720
- AsyncUdpSendReceive_LAN8720
- AsyncUDPServer_LAN8720
- AsyncUDPMulticastServer_LAN8720
- multiFileProject Nuevo
- multiFileProject_LAN8720 Nuevo
Ejemplo AsyncUdpNTPClient
1. Archivo AsyncUdpNTPClient.ino
| # incluir " define.h " |
| # incluir < tiempo.h > |
| |
| // 0.ca.pool.ntp.org |
| Dirección IP timeServerIP = Dirección IP ( 208 , 81 , 1 , 244 ); |
| // tiempo.nist.gov |
| // Dirección IP timeServerIP = Dirección IP(132, 163, 96, 1); |
| |
| # definir NTP_REQUEST_PORT 123 |
| |
| // char timeServer[] = "time.nist.gov"; // servidor NTP |
| char timeServer[] = " 0.ca.pool.ntp.org " ; |
| |
| constanteint NTP_PACKET_SIZE = 48 ; // La marca de tiempo NTP está en los primeros 48 bytes del mensaje |
| |
| paquete de bytesBuffer[NTP_PACKET_SIZE]; // buffer para contener paquetes entrantes y salientes |
| |
| // Una instancia UDP que nos permitirá enviar y recibir paquetes a través de UDP |
| AsyncUDP UDP; |
| |
| // envía una solicitud NTP al servidor de hora en la dirección proporcionada |
| anular crear paquete NTP ( anular ) |
| { |
| De serie. println ( " ============== crear paquete NTP ============= " ); |
| |
| // establece todos los bytes en el buffer a 0 |
| memset (packetBuffer, 0 , NTP_PACKET_SIZE); |
| // Inicializa los valores necesarios para formar la solicitud NTP |
| // (consulte la URL anterior para obtener detalles sobre los paquetes) |
| |
| paqueteBuffer[ 0 ] = 0b11100011 ; // LI, Versión, Modo |
| paqueteBuffer[ 1 ] = 0 ; // Estrato o tipo de reloj |
| paqueteBuffer[ 2 ] = 6 ; // Intervalo de sondeo |
| paqueteBuffer[ 3 ] = 0xEC ; // Precisión del reloj del mismo nivel |
| |
| // 8 bytes de cero para Root Delay y Root Dispersion |
| paqueteBuffer[ 12 ] = 49 ; |
| paqueteBuffer[ 13 ] = 0x4E ; |
| paqueteBuffer[ 14 ] = 49 ; |
| paqueteBuffer[ 15 ] = 52 ; |
| } |
| |
| parsePacket vacío (paquete AsyncUDPPacket) |
| { |
| estructura tm ts; |
| char buf[ 80 ]; |
| |
| memcpy (packetBuffer, paquete. data (), tamaño de (packetBuffer)); |
| |
| De serie. print ( " Tipo de paquete UDP recibido: " ); |
| De serie. println (packet. isBroadcast () ? " Broadcast " : paquete. isMulticast ( ) ? " Multicast " : " Unicast " ); |
| De serie. imprimir ( " De: " ); |
| De serie. imprimir (paquete.IP remota ()); |
| De serie. imprimir ( " : " ); |
| De serie. imprimir ( paquete.remotePort ()); |
| De serie. imprimir ( " , Para: " ); |
| De serie. imprimir ( paquete.localIP ()); |
| De serie. imprimir ( " : " ); |
| De serie. imprimir (paquete. localPort ()); |
| De serie. imprimir ( " , Longitud: " ); |
| De serie. imprimir (paquete. longitud ()); |
| De serie. imprimir (); |
| |
| palabra alta larga sin firmar = palabra (packetBuffer[ 40 ], paqueteBuffer[ 41 ]); |
| palabra baja larga sin firmar = palabra (packetBuffer[ 42 ], paqueteBuffer[ 43 ]); |
| |
| // combina los cuatro bytes (dos palabras) en un entero largo |
| // esta es la hora NTP (segundos desde el 1 de enero de 1900): |
| segundos largos sin firmar desde 1900 = palabra alta << 16 | palabra baja; |
| |
| De serie. print ( F ( " Segundos desde el 1 de enero de 1900 = " )); |
| De serie. println (segundos desde 1900); |
| |
| // ahora convierte la hora NTP en) hora diaria: |
| De serie. print ( F ( " Época/Tiempo Unix = " )); |
| |
| // El tiempo Unix comienza el 1 de enero de 1970. En segundos, eso es 2208988800: |
| const unsigned long setenta años = 2208988800UL ; |
| |
| // restar setenta años: |
| época larga sin firmar = segundos desde 1900 - setenta años; |
| time_t epoch_t = época; // segundos desde 1900 - setenta años; |
| |
| // imprime la hora Unix: |
| De serie. println (época); |
| |
| // imprime la hora, minuto y segundo: |
| De serie. print ( F ( " La hora UTC/GMT es " )); // UTC es la hora en el meridiano de Greenwich (GMT) |
| |
| ts = * hora local (& epoch_t ); |
| strftime (buf, tamaño de (buf), " %a %Y-%m-%d %H:%M:%S %Z " , &ts); |
| De serie. imprimirln (buf); |
| } |
| |
| envío nuloNTPPacket ( nulo ) |
| { |
| crear paquete NTP (); |
| // Enviar unidifusión |
| Udp. escribir (packetBuffer, tamaño de (packetBuffer)); |
| } |
| |
| configuración nula () |
| { |
| De serie. comenzar ( 115200 ); |
| mientras (! Serie); |
| |
| De serie. print ( " n Iniciar AsyncUdpNTPClient en " ); De serie. imprimirln (BOARD_NAME); |
| De serie. imprimirln (ASYNC_UDP_STM32_VERSION); |
| |
| # si (_ASYNC_UDP_STM32_LOGLEVEL_ > 2) |
| De serie. imprimir ( " STM32 Core versión v " ); De serie. imprimir (STM32_CORE_VERSION_MAJOR); |
| De serie. imprimir ( " . " ); De serie. imprimir (STM32_CORE_VERSION_MINOR); |
| De serie. imprimir ( " . " ); De serie. println (STM32_CORE_VERSION_PATCH); |
| # fin |
| |
| // inicia la conexión ethernet y el servidor |
| // Usa mac aleatorio |
| índice uint16_t = milis () % NUMBER_OF_MAC; |
| |
| // Usar IP estática |
| // Ethernet.begin(mac[índice], ip); |
| // Usa IP dinámica DHCP y mac aleatorio |
| Ethernet. comenzar (mac[ índice ]); |
| |
| // ya estás conectado, así que imprime los datos |
| De serie. print ( F ( " Estás conectado a la red, IP= " )); |
| De serie. println ( Ethernet.localIP ()); |
| |
| // Las solicitudes NTP son al puerto NTP_REQUEST_PORT = 123 |
| if (Udp. conectar (timeServerIP, NTP_REQUEST_PORT)) |
| // si (Udp.connect(servidor de tiempo, NTP_REQUEST_PORT)) |
| { |
| De serie. println ( " UDP conectado " ); |
| |
| Udp. onPacket ([](paquete AsyncUDPPacket) |
| { |
| parsePacket (paquete); |
| }); |
| } |
| } |
| |
| bucle vacío () |
| { |
| enviarNTPPacket (); |
| |
| // espera 60 segundos antes de volver a preguntar la hora |
| retraso ( 60000 ); |
| } |
2. El archivo define.h
| /* |
| Actualmente soporte |
| 1) Placas STM32 con Ethernet incorporado (para usar USE_BUILTIN_ETHERNET = true) como: |
| - Núcleo-144 (F429ZI, F767ZI) |
| - Descubrimiento (STM32F746G-DISCOVERY) |
| - Placas STM32 (STM32F/L/H/G/WB/MP1) con 32K+ Flash, con Ethernet incorporado, |
| - Consulte Cómo utilizar Ethernet integrado en (https://github.com/khoih-prog/EthernetWebServer_STM32/issues/1) |
| 2) Placas STM32F/L/H/G/WB/MP1 (con Flash 32+K) que ejecutan escudos ENC28J60 (para usar USE_BUILTIN_ETHERNET = falso) |
| 3) Placas STM32F/L/H/G/WB/MP1 (con Flash 32+K) con escudos W5x00 |
| */ |
| |
| #ifndef define_h |
| #definir define_h |
| |
| #si !( definido( STM32F0 ) || definido( STM32F1 ) || definido( STM32F2 ) || definido( STM32F3 ) || definido( STM32F4 ) || definido( STM32F7 ) || |
| definido ( STM32L0 ) || definido ( STM32L1 ) || definido ( STM32L4 ) || definido ( STM32H7 ) || definido ( STM32G0 ) || definido ( STM32G4 ) || |
| definido ( STM32WB ) || definido ( STM32MP1 )) |
| #error ¡ Este código está diseñado para ejecutarse en la plataforma STM32F/L/H/G/WB/MP1! Verifique su configuración de Herramientas->Tablero. |
| #endif |
| |
| #definir ASYNC_UDP_STM32_DEBUG_PORT Serie |
| |
| // Usar de 0 a 4. Cuanto mayor sea el número, más mensajes de depuración y uso de memoria. |
| #definir _ASYNC_UDP_STM32_LOGLEVEL_ 1 |
| |
| |
| #si está definido ( STM32F0 ) |
| #advertencia Placa STM32F0 seleccionada |
| #definir BOARD_TYPE "STM32F0" |
| #elif definido ( STM32F1 ) |
| #advertencia Placa STM32F1 seleccionada |
| #definir BOARD_TYPE "STM32F1" |
| #elif definido ( STM32F2 ) |
| #advertencia Placa STM32F2 seleccionada |
| #definir BOARD_TYPE "STM32F2" |
| #elif definido ( STM32F3 ) |
| #advertencia Placa STM32F3 seleccionada |
| #definir BOARD_TYPE "STM32F3" |
| #elif definido ( STM32F4 ) |
| #advertencia Placa STM32F4 seleccionada |
| #definir BOARD_TYPE "STM32F4" |
| #elif definido ( STM32F7 ) |
| #advertencia Placa STM32F7 seleccionada |
| #definir BOARD_TYPE "STM32F7" |
| #elif definido ( STM32L0 ) |
| #advertencia Placa STM32L0 seleccionada |
| #definir BOARD_TYPE "STM32L0" |
| #elif definido ( STM32L1 ) |
| #advertencia Placa STM32L1 seleccionada |
| #definir BOARD_TYPE "STM32L1" |
| #elif definido ( STM32L4 ) |
| #advertencia Placa STM32L4 seleccionada |
| #definir BOARD_TYPE "STM32L4" |
| #elif definido ( STM32H7 ) |
| #advertencia Placa STM32H7 seleccionada |
| #definir BOARD_TYPE "STM32H7" |
| #elif definido ( STM32G0 ) |
| #advertencia Placa STM32G0 seleccionada |
| #definir BOARD_TYPE "STM32G0" |
| #elif definido ( STM32G4 ) |
| #advertencia Placa STM32G4 seleccionada |
| #definir BOARD_TYPE "STM32G4" |
| #elif definido ( STM32WB ) |
| #advertencia Placa STM32WB seleccionada |
| #definir BOARD_TYPE "STM32WB" |
| #elif definido ( STM32MP1 ) |
| #advertencia Placa STM32MP1 seleccionada |
| #definir BOARD_TYPE "STM32MP1" |
| #demás |
| #advertencia Placa desconocida STM32 seleccionada |
| #define BOARD_TYPE "STM32 Desconocido" |
| #endif |
| |
| #ifndef BOARD_NAME |
| #definir BOARD_NAME BOARD_TYPE |
| #endif |
| |
| #incluir <LwIP.h> |
| #incluir <STM32Ethernet.h> |
| |
| #incluir <AsyncUDP_STM32.h> |
| |
| // Ingrese una dirección MAC y una dirección IP para su controlador a continuación. |
| #definir NUMBER_OF_MAC 20 |
| |
| bytes 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 }, |
| }; |
| |
| //Selecciona la dirección IP estática según tu red local |
| Dirección IP ip ( 192 , 168 , 2 , 232 ); |
| |
| #endif //define_h |
Ejemplos de salida del terminal de depuración
1. AsyncUdpNTPClient en STM32F7 NUCLEO_F767ZI con LAN8742A Ethernet usando la biblioteca STM32Ethernet
Esta es la salida de depuración del terminal cuando se ejecuta AsyncUdpNTPClient en STM32F7 Nucleo-144 NUCLEO_F767ZI. . Se conecta al servidor NTP time.windows.com (IP=13.86.101.172) utilizando la biblioteca AsyncUDP_STM32 y solicita la hora NTP cada 60 segundos. Luego, el paquete se recibe y procesa de forma asincrónica para imprimir la hora UTC/GMT actual.
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 en STM32F4 BLACK_F407VE con LAN8720 Ethernet usando la biblioteca STM32Ethernet
Esta es la salida de depuración del terminal cuando se ejecuta AsyncUdpNTPClient_LAN8720 en STM32F4 BLACK_F407VE con LAN8720 Ethernet usando la biblioteca STM32Ethernet . Se conecta al servidor NTP time.windows.com (IP=13.86.101.172) utilizando la biblioteca AsyncUDP_STM32 y solicita la hora NTP cada 60 segundos. Luego, el paquete se recibe y procesa de forma asincrónica para imprimir la hora UTC/GMT actual.
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
Depurar
La depuración está habilitada de forma predeterminada en Serial. Para desactivarlo, utilice el nivel 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
También puedes cambiar el nivel de depuración de 0 a 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
Solución de problemas
Si recibe errores de compilación, la mayoría de las veces, es posible que deba instalar una versión más reciente de Arduino IDE, el núcleo Arduino STM32 o las bibliotecas dependientes.
A veces, la biblioteca solo funcionará si actualiza el núcleo STM32 a la última versión porque siempre estoy usando los últimos núcleos/bibliotecas.
Asuntos
Enviar problemas a: problemas de AsyncUDP_STM32
HACER
- Corregir error. Agregar mejora
- Agregue soporte a más escudos Ethernet/WiFi
- Agregue soporte a más placas STM32.
HECHO
- Puerto inicial a STM32 usando LAN8742A Etnernet incorporado. Probado en STM32F7 Nucleo-144 F767ZI .
- Añade más ejemplos.
- Agregue funciones de depuración.
- Agregue soporte a Ethernet LAN8720 usando la biblioteca STM32Ethernet, para placas como Nucleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG), Discovery (DISCO_F746NG) y placas STM32F4 (BLACK_F407VE, BLACK_F407VG, NEGRO_F407ZE, NEGRO_F407ZG, NEGRO_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
- Solucionar el error del vinculador de múltiples definiciones
- Ejemplos de actualización para el nuevo núcleo STM32 v2.3.0
- Agregue ejemplos de multiFileProject y multiFileProject_LAN8720 a la demostración de un proyecto de múltiples archivos para evitar errores del vinculador
multiple-definitions
Aportes y agradecimientos
- Basado y modificado del ESPAsyncUDP de Hristo Gochkov. Muchas gracias a Hristo Gochkov por la gran biblioteca ESPAsyncUDP
- Se basó en la biblioteca STM32duino LwIP de Frederic Pillon.
- Gracias al buen trabajo de Miguel Wisintainer por trabajar, desarrollar, depurar y probar.
️️ Hristo Gochkov
| 
️ Federico Pillon
| 
tcpipchip
|
Contribuyendo
Si quieres contribuir a este proyecto:
- Informar errores y errores
- Preguntar por mejoras
- Crear incidencias y solicitudes de extracción
- Cuéntale a otras personas sobre esta biblioteca
Licencia
- La biblioteca tiene licencia del MIT.
Derechos de autor
Copyright (c) 2020- Khoi Hoang
