Biblioteca AsyncUDP_STM32
Índice
- Mudança importante da v1.3.0
- Por que precisamos desta biblioteca AsyncUDP_STM32
- Características
- Por que o Async é melhor
- Placas atualmente suportadas
- Registro de alterações
- Pré-requisitos
- Instalação
- Use o Gerenciador de Biblioteca Arduino
- Instalação manual
- Código VS e plataforma IO
- Patches de pacotes
- 1. Para placas STM32 usar LAN8720
- 2. Para placas STM32 usar Serial1
- COMO corrigir erro do vinculador
Multiple Definitions - COMO Configurar o cliente UDP assíncrono
- COMO usar STM32F4 com LAN8720
- 1. Fiação
- 2. Programa HOWTO usando STLink V-2 ou V-3
- 3. COMO usar a porta serial para depuração
- Exemplos
- 1. Cliente assíncronoUDPC
- 2. AsyncUdpNTPCliente
- 3. AsyncUdpSendReceive
- 4. Servidor assíncronoUDPS
- 5. Servidor AsyncUDPMulticast
- 6. AsyncUDPClient_LAN8720
- 7.AsyncUdpNTPClient_LAN8720
- 8.AsyncUdpSendReceive_LAN8720
- 9.AsyncUDPServer_LAN8720
- 10.AsyncUDPMulticastServer_LAN8720
- 11. multiFileProject Novo
- 12. multiFileProject_LAN8720 Novo
- Exemplo AsyncUdpNTPClient
- 1. Arquivo AsyncUdpNTPClient.ino
- 2. Arquivo define.h
- Amostras de saída de terminal de depuração
- 1. AsyncUdpNTPClient em STM32F7 NUCLEO_F767ZI com Ethernet LAN8742A usando biblioteca STM32Ethernet
- 2. AsyncUdpNTPClient_LAN8720 em STM32F4 BLACK_F407VE com LAN8720 Ethernet usando biblioteca STM32Ethernet
- Depurar
- Solução de problemas
- Problemas
- PENDÊNCIA
- FEITO
- Contribuições e agradecimentos
- Contribuindo
- Licença
- Direitos autorais
Mudança importante da v1.3.0
Por favor, dê uma olhada em COMO corrigir erro do vinculador Multiple Definitions
Para placas Generic STM32F4 series , como STM32F407VE, usando LAN8720, use o núcleo STM32 v2.2.0 , pois a quebra do núcleo v2.3.0 cria o erro de compilação. Será corrigido em um futuro próximo.
Por que precisamos desta biblioteca AsyncUDP_STM32
Características
Esta biblioteca AsyncUDP_STM32 é uma biblioteca UDP totalmente assíncrona, projetada para um ambiente de rede multi-conexão sem problemas, para placas STM32 usando LAN8720 ou Ethernet LAN8742A integrada. A biblioteca é fácil de usar e inclui suporte para ambientes Unicast, Broadcast e Multicast.
Esta biblioteca é baseada e modificada de:
- ESPAsyncUDP de Hristo Gochkov
para aplicar o recurso assíncrono melhor e mais rápido da poderosa biblioteca ESPAsyncUDP em placas STM32 usando LAN8720 ou Ethernet LAN8742A integrada.
Por que o Async é melhor
- Usar rede assíncrona significa que você pode lidar com mais de uma conexão ao mesmo tempo
- Você será chamado assim que a solicitação estiver pronta e analisada
- Ao enviar a resposta, você estará imediatamente pronto para lidar com outras conexões enquanto o servidor se encarrega de enviar a resposta em segundo plano
- A velocidade é meu Deus
- Depois de se conectar a um servidor UDP como um cliente assíncrono, você estará imediatamente pronto para lidar com outras conexões enquanto o cliente recebe os pacotes de resposta UDP em segundo plano.
- Você não é obrigado a verificar em um loop apertado() a chegada dos pacotes de resposta UDP para processá-los.
Placas atualmente suportadas
- Placas STM32 com Ethernet LAN8742A integrada, como:
- Núcleo-144 (F429ZI, F767ZI)
- Descoberta (STM32F746G-DISCOVERY)
- Todas as placas STM32 (STM32F/L/H/G/WB/MP1) com 32K+ Flash, com Ethernet integrada
- Consulte Suporte EthernetWebServer_STM32 e resultados de teste
- Placas STM32 usando Ethernet LAN8720, como:
- Núcleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
- Descoberta (DISCO_F746NG)
- Placas STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
Pré-requisitos
-
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 em (Nucleo-144, Discovery). -
LwIP library v2.1.2+ para Ethernet LAN8742A integrada em (Nucleo-144, Discovery).
Instalação
A maneira sugerida de instalação é:
Use o Gerenciador de Biblioteca Arduino
A melhor maneira é usar Arduino Library Manager . Procure AsyncUDP_STM32 e selecione/instale a versão mais recente. Você também pode usar este link para obter instruções mais detalhadas.
Instalação manual
- Navegue até a página AsyncUDP_STM32.
- Baixe a versão mais recente
AsyncUDP_STM32-master.zip . - Extraia o arquivo zip para o diretório
AsyncUDP_STM32-master - Copie toda a pasta
AsyncUDP_STM32-master para o diretório das bibliotecas do Arduino, como ~/Arduino/libraries/ .
Código VS e plataforma IO:
- Instale o código VS
- Instalar PlataformaIO
- Instale a biblioteca AsyncUDP_STM32 usando o Library Manager. Pesquise AsyncUDP_STM32 nas bibliotecas do autor do Platform.io
- Use o arquivo platformio.ini incluído nos exemplos para garantir que todas as bibliotecas dependentes serão instaladas automaticamente. Visite a documentação para outras opções e exemplos em Arquivo de configuração do projeto
Patches de pacotes
1. Para placas STM32 usar LAN8720
Para placas Generic STM32F4 series , como STM32F407VE , usando LAN8720 , use o núcleo STM32 v2.2.0 , pois a quebra do núcleo v2.3.0 cria o erro de compilação.
Para usar LAN8720 em algumas placas STM32
- Núcleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG)
- Descoberta (DISCO_F746NG)
- Placas STM32F4 (BLACK_F407VE, BLACK_F407VG, BLACK_F407ZE, BLACK_F407ZG, BLACK_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
você deve copiar os arquivos stm32f4xx_hal_conf_default.h e stm32f7xx_hal_conf_default.h no diretório STM32 stm32 (~/.arduino15/packages/STM32/hardware/stm32/2.2.0/system) para substituir os arquivos antigos.
Supondo que a versão principal do STM32 stm32 seja 2.2.0. Esses arquivos devem ser copiados para o diretório:
-
~/.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.
Sempre que uma nova versão for instalada, lembre-se de copiar este arquivo para o diretório da nova versão. Por exemplo, a nova versão é x.yy.zz, esses arquivos devem ser copiados para o diretório correspondente:
-
~/.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 placas STM32 usar Serial1
Para usar Serial1 em algumas placas STM32 sem definição de Serial1 (Nucleo-144 NUCLEO_F767ZI, Nucleo-64 NUCLEO_L053R8, etc.) , você deve copiar os arquivos STM32 variante.h para o diretório STM32 stm32 (~/.arduino15/packages/STM32/hardware/stm32/2.3.0). Você tem que modificar os arquivos correspondentes às suas placas, isso é apenas uma ilustração de como fazer.
Supondo que a versão principal do STM32 stm32 seja 2.3.0. Esses arquivos devem ser copiados para o diretório:
-
~/.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.
Sempre que uma nova versão for instalada, lembre-se de copiar este arquivo para o diretório da nova versão. Por exemplo, a nova versão é x.yy.zz, esses arquivos devem ser copiados para o diretório correspondente:
-
~/.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
COMO corrigir erro do vinculador Multiple Definitions
A implementação atual da biblioteca, usando xyz-Impl.h em vez do padrão xyz.cpp , possivelmente cria certos erros do vinculador Multiple Definitions em certos casos de uso.
Você pode incluir este arquivo .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
em muitos arquivos. Mas certifique-se de usar o seguinte arquivo .h em apenas 1 .h , .cpp ou .ino , que não deve ser incluído em nenhum outro arquivo , para evitar erro de 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
Verifique o novo exemplo multiFileProject para uma demonstração HOWTO .
COMO Configurar o cliente UDP assí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 );
}
COMO usar STM32F4 com LAN8720
1. Fiação
Esta é a fiação para STM32F4 (BLACK_F407VE, etc.) usando LAN8720
| LAN8720 FÍSICA | <---> | 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 |
| CDM | <---> | PC_1 |
| GND | <---> | GND |
| CCV | <---> | +3,3V |
2. Programa HOWTO usando STLink V-2 ou V-3
Conecte da seguinte maneira. Para programar, use STM32CubeProgrammer ou Arduino IDE com
- Suporte U(S)ART: "Ativado (série genérica)"
- Método de upload: "STM32CubeProgrammer (SWD)"
| ST Link | <---> | STM32F4 |
|---|
| SWCLK | <---> | SWCLK |
| SWDIO | <---> | SWDIO |
| RST | <---> | NRST |
| GND | <---> | GND |
| 5v | <---> | 5V |
3. COMO usar a porta serial para depuração
Conecte FDTI (USB para serial) da seguinte forma:
| FDTI | <---> | STM32F4 |
|---|
| RX | <---> | TX=PA_9 |
| Texas | <---> | RX=PA_10 |
| GND | <---> | GND |
Exemplos
- Cliente assíncronoUDPC
- AsyncUdpNTPClient
- AsyncUdpSendReceive
- Servidor assíncronoUDPS
- Servidor AsyncUDPMulticast
- AsyncUDPClient_LAN8720
- AsyncUdpNTPClient_LAN8720
- AsyncUdpSendReceive_LAN8720
- AsyncUDPServer_LAN8720
- AsyncUDPMulticastServer_LAN8720
- multiFileProject Novo
- multiFileProject_LAN8720 Novo
Exemplo AsyncUdpNTPClient
1. Arquivo AsyncUdpNTPClient.ino
| # include " define.h " |
| #inclui < hora.h > |
| |
| //0.ca.pool.ntp.org |
| Endereço IP timeServerIP = Endereço IP ( 208 , 81 , 1 , 244 ); |
| //time.nist.gov |
| // Endereço IP timeServerIP = EndereçoIP(132, 163, 96, 1); |
| |
| #define NTP_REQUEST_PORT 123 |
| |
| // char timeServer[] = "time.nist.gov"; //servidor NTP |
| char timeServer[] = " 0.ca.pool.ntp.org " ; |
| |
| const int NTP_PACKET_SIZE = 48 ; // O timestamp do NTP está nos primeiros 48 bytes da mensagem |
| |
| byte packetBuffer[NTP_PACKET_SIZE]; // buffer para armazenar pacotes de entrada e saída |
| |
| // Uma instância UDP para nos permitir enviar e receber pacotes via UDP |
| AsyncUDP Udp; |
| |
| // envia uma solicitação NTP para o servidor de horário no endereço fornecido |
| void createNTPpacket ( void ) |
| { |
| Serial. println ( " ============= createNTPpacket ============= " ); |
| |
| // define todos os bytes no buffer como 0 |
| memset (packetBuffer, 0 , NTP_PACKET_SIZE); |
| // Inicializa os valores necessários para formar a solicitação NTP |
| // (veja URL acima para detalhes sobre os pacotes) |
| |
| pacoteBuffer[ 0 ] = 0b11100011 ; // LI, versão, modo |
| pacoteBuffer[ 1 ] = 0 ; // Estrato, ou tipo de relógio |
| pacoteBuffer[ 2 ] = 6 ; // Intervalo de pesquisa |
| pacoteBuffer[ 3 ] = 0xEC ; // Precisão do relógio de mesmo nível |
| |
| // 8 bytes de zero para Root Delay e Root Dispersion |
| pacoteBuffer[ 12 ] = 49 ; |
| pacoteBuffer[ 13 ] = 0x4E ; |
| pacoteBuffer[ 14 ] = 49 ; |
| pacoteBuffer[ 15 ] = 52 ; |
| } |
| |
| void parsePacket (pacote AsyncUDPPacket) |
| { |
| estrutura tm ts; |
| char buf[ 80 ]; |
| |
| memcpy (packetBuffer, packet.data (), sizeof (packetBuffer)); |
| |
| Serial. print ( " Tipo de pacote UDP recebido: " ); |
| Serial. println ( packet.isBroadcast () ? " Broadcast " : packet.isMulticast () ? " Multicast " : " Unicast " ); |
| Serial. imprimir ( " De: " ); |
| Serial. imprimir ( pacote.remoteIP ()); |
| Serial. imprimir ( " : " ); |
| Serial. imprimir ( packet.remotePort ()); |
| Serial. imprimir ( " , Para: " ); |
| Serial. imprimir ( pacote.localIP ()); |
| Serial. imprimir ( " : " ); |
| Serial. imprimir ( pacote.localPort ()); |
| Serial. imprimir ( " , Comprimento: " ); |
| Serial. imprimir (pacote. comprimento ()); |
| Serial. println (); |
| |
| unsigned long highWord = word (packetBuffer[ 40 ], packetBuffer[ 41 ]); |
| unsigned long lowWord = word (packetBuffer[ 42 ], packetBuffer[ 43 ]); |
| |
| // combina os quatro bytes (duas palavras) em um inteiro longo |
| // este é o horário NTP (segundos desde 1º de janeiro de 1900): |
| não assinado longo secsSince1900 = highWord << 16 | palavra baixa; |
| |
| Serial. print ( F ( " Segundos desde 1º de janeiro de 1900 = " )); |
| Serial. println (secsSince1900); |
| |
| // agora converte o horário NTP em )horário diário: |
| Serial. print ( F ( " Época/Hora Unix = " )); |
| |
| // O tempo Unix começa em 1º de janeiro de 1970. Em segundos, isso é 2208988800: |
| const unsigned long setenta anos = 2208988800UL ; |
| |
| // subtrair setenta anos: |
| época longa não assinada = secsSince1900 - setenta anos; |
| tempo_t época_t = época; // secsSince1900 - setenta anos; |
| |
| // imprime a hora Unix: |
| Serial. println (época); |
| |
| // imprime a hora, minuto e segundo: |
| Serial. print ( F ( " O horário UTC/GMT é " )); // UTC é a hora no Meridiano de Greenwich (GMT) |
| |
| ts = * hora local (& época_t ); |
| strftime (buf, sizeof (buf), " %a %Y-%m-%d %H:%M:%S %Z " , &ts); |
| Serial. imprimir (buf); |
| } |
| |
| void enviarNTPPacket ( void ) |
| { |
| criarNTPpacket (); |
| // Envia unicast |
| UDP. escrever (packetBuffer, sizeof (packetBuffer)); |
| } |
| |
| configuração nula () |
| { |
| Serial. começar ( 115200 ); |
| enquanto (!Serial); |
| |
| Serial. print ( " nIniciar AsyncUdpNTPClient em " ); Serial. println (BOARD_NAME); |
| Serial. println (ASYNC_UDP_STM32_VERSION); |
| |
| # se (_ASYNC_UDP_STM32_LOGLEVEL_ > 2) |
| Serial. imprimir ( " STM32 Core versão v " ); Serial. imprimir (STM32_CORE_VERSION_MAJOR); |
| Serial. imprimir ( " . " ); Serial. imprimir (STM32_CORE_VERSION_MINOR); |
| Serial. imprimir ( " . " ); Serial. println (STM32_CORE_VERSION_PATCH); |
| #endif |
| |
| // inicia a conexão ethernet e o servidor |
| // Usa mac aleatório |
| índice uint16_t = milis ()% NUMBER_OF_MAC; |
| |
| // Usa IP estático |
| //Ethernet.begin(mac[índice ], ip); |
| // Use IP dinâmico DHCP e mac aleatório |
| Ethernet. começar (mac[ índice ]); |
| |
| // você está conectado agora, então imprima os dados |
| Serial. print ( F ( " Você está conectado à rede, IP= " )); |
| Serial. println ( Ethernet.localIP ()); |
| |
| // As solicitações NTP são para a porta NTP_REQUEST_PORT = 123 |
| if (Udp. conectar (timeServerIP, NTP_REQUEST_PORT)) |
| // if (Udp.connect(timeServer, NTP_REQUEST_PORT)) |
| { |
| Serial. println ( " UDP conectado " ); |
| |
| UDP. onPacket ([](pacote AsyncUDPPacket) |
| { |
| parsePacket (pacote); |
| }); |
| } |
| } |
| |
| loop vazio () |
| { |
| enviarNTPPacket (); |
| |
| // espere 60 segundos antes de perguntar a hora novamente |
| atraso ( 60000 ); |
| } |
2. Arquivo define.h
| /* |
| Atualmente suporte |
| 1) Placas STM32 com Ethernet integrada (para usar USE_BUILTIN_ETHERNET = true) como: |
| - Núcleo-144 (F429ZI, F767ZI) |
| - Descoberta (STM32F746G-DISCOVERY) |
| - Placas STM32 (STM32F/L/H/G/WB/MP1) com 32K+ Flash, com Ethernet integrada, |
| - Veja como usar Ethernet integrada em (https://github.com/khoih-prog/EthernetWebServer_STM32/issues/1) |
| 2) Placas STM32F/L/H/G/WB/MP1 (com 32+K Flash) executando escudos ENC28J60 (para usar USE_BUILTIN_ETHERNET = false) |
| 3) Placas STM32F/L/H/G/WB/MP1 (com 32+K Flash) executando escudos W5x00 |
| */ |
| |
| #ifndef define_h |
| #define define_h |
| |
| #if !( 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 foi projetado para ser executado na plataforma STM32F/L/H/G/WB/MP1! Por favor, verifique a configuração de Ferramentas-> Quadro. |
| #endif |
| |
| #define ASYNC_UDP_STM32_DEBUG_PORT Serial |
| |
| // Use de 0 a 4. Número maior, mais mensagens de depuração e uso de memória. |
| #define _ASYNC_UDP_STM32_LOGLEVEL_ 1 |
| |
| |
| #se definido( STM32F0 ) |
| #warning Placa STM32F0 selecionada |
| #define BOARD_TYPE "STM32F0" |
| #elif definido ( STM32F1 ) |
| #warning Placa STM32F1 selecionada |
| #define BOARD_TYPE "STM32F1" |
| #elif definido ( STM32F2 ) |
| #warning Placa STM32F2 selecionada |
| #define BOARD_TYPE "STM32F2" |
| #elif definido ( STM32F3 ) |
| #warning Placa STM32F3 selecionada |
| #define BOARD_TYPE "STM32F3" |
| #elif definido ( STM32F4 ) |
| #warning Placa STM32F4 selecionada |
| #define BOARD_TYPE "STM32F4" |
| #elif definido ( STM32F7 ) |
| #warning Placa STM32F7 selecionada |
| #define BOARD_TYPE "STM32F7" |
| #elif definido ( STM32L0 ) |
| #warning Placa STM32L0 selecionada |
| #define BOARD_TYPE "STM32L0" |
| #elif definido ( STM32L1 ) |
| #warning Placa STM32L1 selecionada |
| #define BOARD_TYPE "STM32L1" |
| #elif definido ( STM32L4 ) |
| #warning Placa STM32L4 selecionada |
| #define BOARD_TYPE "STM32L4" |
| #elif definido ( STM32H7 ) |
| #warning Placa STM32H7 selecionada |
| #define BOARD_TYPE "STM32H7" |
| #elif definido ( STM32G0 ) |
| #warning Placa STM32G0 selecionada |
| #define BOARD_TYPE "STM32G0" |
| #elif definido ( STM32G4 ) |
| #warning Placa STM32G4 selecionada |
| #define BOARD_TYPE "STM32G4" |
| #elif definido ( STM32WB ) |
| #warning Placa STM32WB selecionada |
| #define BOARD_TYPE "STM32WB" |
| #elif definido ( STM32MP1 ) |
| #warning Placa STM32MP1 selecionada |
| #define BOARD_TYPE "STM32MP1" |
| #outro |
| #warning Placa desconhecida STM32 selecionada |
| #define BOARD_TYPE "STM32 desconhecido" |
| #endif |
| |
| #ifndef BOARD_NAME |
| #define BOARD_NAME BOARD_TYPE |
| #endif |
| |
| #include <LwIP.h> |
| #include <STM32Ethernet.h> |
| |
| #include <AsyncUDP_STM32.h> |
| |
| // Insira um endereço MAC e um endereço IP para seu controlador abaixo. |
| #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 }, |
| }; |
| |
| //Selecione o endereço IP estático de acordo com sua rede local |
| Endereço IP ip ( 192 , 168 , 2 , 232 ); |
| |
| #endif //define_h |
Amostras de saída de terminal de depuração
1. AsyncUdpNTPClient em STM32F7 NUCLEO_F767ZI com Ethernet LAN8742A usando biblioteca STM32Ethernet
Esta é a saída de depuração do terminal ao executar AsyncUdpNTPClient em STM32F7 Nucleo-144 NUCLEO_F767ZI. . Ele se conecta ao servidor NTP time.windows.com (IP=13.86.101.172) usando a biblioteca AsyncUDP_STM32 e solicita o tempo NTP a cada 60s. O pacote é então recebido e processado de forma assíncrona para imprimir a hora UTC/GMT atual.
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 em STM32F4 BLACK_F407VE com LAN8720 Ethernet usando biblioteca STM32Ethernet
Esta é a saída de depuração do terminal ao executar AsyncUdpNTPClient_LAN8720 em STM32F4 BLACK_F407VE com LAN8720 Ethernet usando STM32Ethernet Library . Ele se conecta ao servidor NTP time.windows.com (IP=13.86.101.172) usando a biblioteca AsyncUDP_STM32 e solicita o tempo NTP a cada 60s. O pacote é então recebido e processado de forma assíncrona para imprimir a hora UTC/GMT atual.
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
A depuração está habilitada por padrão em Serial. Para desativar, use o nível 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
Você também pode alterar o nível de depuração 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
Solução de problemas
Se você receber erros de compilação, na maioria das vezes, pode ser necessário instalar uma versão mais recente do Arduino IDE, o núcleo do Arduino STM32 ou bibliotecas dependentes.
Às vezes, a biblioteca só funcionará se você atualizar o núcleo STM32 para a versão mais recente, porque estou sempre usando os núcleos/bibliotecas mais recentes.
Problemas
Envie problemas para: problemas AsyncUDP_STM32
PENDÊNCIA
- Corrigir bug. Adicionar aprimoramento
- Adicione suporte para mais escudo Ethernet/WiFi
- Adicione suporte a mais placas STM32.
FEITO
- Porta inicial para STM32 usando LAN8742A Etnernet integrado. Testado em STM32F7 Nucleo-144 F767ZI .
- Adicione mais exemplos.
- Adicione recursos de depuração.
- Adicione suporte para Ethernet LAN8720 usando a biblioteca STM32Ethernet, para placas como Nucleo-144 (F429ZI, NUCLEO_F746NG, NUCLEO_F746ZG, NUCLEO_F756ZG), Discovery (DISCO_F746NG) e placas STM32F4 (BLACK_F407VE, BLACK_F407VG, PRETO_F407ZE, PRETO_F407ZG, PRETO_F407VE_Mini, DIYMORE_F407VGT, FK407M1)
- Corrigir erro do vinculador de múltiplas definições
- Exemplos de atualização para o novo núcleo STM32 v2.3.0
- Adicione exemplos de multiFileProject e multiFileProject_LAN8720 à demonstração para projeto de vários arquivos para evitar erro de vinculador
multiple-definitions
Contribuições e agradecimentos
- Baseado e modificado no ESPAsyncUDP de Hristo Gochkov. Muito obrigado a Hristo Gochkov pela excelente biblioteca ESPAsyncUDP
- Confiou na biblioteca STM32duino LwIP de Frederic Pillon.
- Obrigado ao bom trabalho de Miguel Wisintainer por trabalhar, desenvolver, depurar e testar.
️️ Hristo Gochkov
| 
️Frédéric Pillon
| 
tcpipchip
|
Contribuindo
Se você quiser contribuir com este projeto:
- Reportar bugs e erros
- Peça melhorias
- Crie problemas e receba solicitações
- Conte a outras pessoas sobre esta biblioteca
Licença
- A biblioteca é licenciada pelo MIT
Direitos autorais
Copyright (c) 2020- Khoi Hoang
