Vor mir gab es einmal die Aufgabe, auf dem STM32 den Zugang zum Internet mit nur einem COM-Port zu ermöglichen. Um dieses Problem zu lösen, benötigte ich PPP oder genauer gesagt PPPoS (Point-to-Point-Protokoll über seriell - eine der Möglichkeiten zur Implementierung von PPP, die bei der Verbindung über den COM-Port verwendet wird).
Bei der Lösung der vor mir liegenden Aufgabe stieß ich auf einige Schwierigkeiten, von denen eine meiner Meinung nach darin bestand, dass Probleme im Zusammenhang mit PPPoS im Internet nicht ausreichend behandelt wurden. Mit diesem Beitrag werde ich versuchen, die vorgesehene Lücke zu schließen, soweit mein bescheidenes Wissen dies zulässt.
Dieser Artikel beschreibt, wie Sie ein Projekt für System Workbench für STM32 von Grund auf neu erstellen. Zeigt ein Beispiel für die Arbeit mit UART. Es gibt Codebeispiele für die Implementierung von PPP. Und natürlich ein Beispiel für das Senden einer Nachricht an einen benachbarten Computer.
Einführung
PPP (Point-to-Point-Protokoll) ist ein Zweipunkt-Datenverbindungsprotokoll des OSI-Netzwerkmodells. Es wird normalerweise verwendet, um eine direkte Kommunikation zwischen zwei Netzwerkknoten herzustellen, und es kann Verbindungsauthentifizierung, -verschlüsselung und Datenkomprimierung bereitstellen. Wird in vielen Arten von physischen Netzwerken verwendet: Nullmodemkabel, Telefonleitung, Mobilfunk usw.
Häufig gibt es Unterarten des PPP-Protokolls, z. B. das Punkt-zu-Punkt-Protokoll über Ethernet (PPPoE), das für die Verbindung über Ethernet und manchmal über DSL verwendet wird. und Punkt-zu-Punkt-Protokoll über ATM (PPPoA), das für die Verbindung über ATM Adaptation Layer 5 (AAL5) verwendet wird, die die wichtigste PPPoE-Alternative für DSL darstellt.
PPP ist eine Protokollfamilie: Link Control Protocol (LCP), Network Control Protocol (NCP), Authentifizierungsprotokolle (PAP, CHAP), Multichannel PPP (MLPPP).
Aus Wikipedia .
Vorbereitung
Um das Problem zu lösen, brauchen wir:
Eisen:
- Debugboard stm32f4_discovery:
- USB-zu-Mini-USB-Adapter zum Anschließen der Karte an einen Computer.
- Zwei USBtoUART FT232-Adapter:
- Zwei USB-Verlängerungskabel sind ebenfalls nützlich, nicht unbedingt, aber nur praktisch.
Weich:
- Virtuelle Maschine VirtualBox. Sie können es hier herunterladen. Wir laden auch das Extension Pack für VirtualBox herunter und installieren es.
- Zwei Installationsdisketten mit den Betriebssystemen Windows und Linux. Wir nehmen Windows hier , Linux hier .
Nach der Installation des Betriebssystems müssen Sie Add-Ons für das Gastbetriebssystem installieren. Für die Aufgabe haben wir genug 32x-Systeme, die Sie mit der Einbeziehung der Virtualisierung nicht täuschen können. - Für Windows benötigen wir ein Programm, das Anforderungen annehmen und über TCP / IP beantworten kann, sowie ein Terminalprogramm für die Arbeit mit einem COM-Port. Laden Sie PacketSender hier herunter (klicken Sie auf "Nein, danke, lassen Sie mich einfach herunterladen."). Das Terminal ist hier . Zusätzlich benötigen wir STM32CubeMX für die Ersteinrichtung des Projekts. Download von st.com (nach der Registrierung erfolgt der Link per E-Mail).
- Wir haben System Workbench für STM32 auf dem Hauptbetriebssystem installiert. Hier herunterladen (Anmeldung erforderlich).
Phase 1. Erstellen eines Projekts
Öffnen Sie zunächst STM32CubeMX und erstellen Sie dort ein neues Projekt für unser stm32f4-Discovery-Board. Schalten Sie RCC, Ethernet (ETH), SYS, USART2, USART3 und dann FREERTOS und LWIP ein.
Für die Diagnose benötigen wir LEDs auf der Platine. Konfigurieren Sie dazu die Beine von PD12-PD15 als GPIO_Output.
Stellen Sie auf der Registerkarte Uhrenkonfiguration die Frequenz wie in der Abbildung unten ein.
Konfigurieren Sie als Nächstes auf der Registerkarte Konfiguration die USART-Ports. Wir werden mit ihnen im DMA-Modus arbeiten. Wir haben zwei USART-Ports, einen zum Senden und Empfangen von Daten über PPP und einen zum Protokollieren. Damit sie funktionieren, müssen wir DMA auf RX und TX für beide Ports konfigurieren. Stellen Sie für alle DMA-Tuning-Beine Mittel auf Priorität ein. Stellen Sie für USART2 leg RX den Modus auf "Circular". Die restlichen Einstellungen bleiben standardmäßig erhalten.
Sie müssen auch den globalen Interrupt für beide Ports auf der Registerkarte "NVIC-Einstellungen" aktivieren.
Damit ist die Ersteinrichtung des Projekts in STM32CubeMX abgeschlossen. Wir speichern die Projektdatei und führen die Codegenerierung für System Workbench für STM32 durch.
Implementierung
Lassen Sie uns nun überprüfen, ob der heruntergeladene Code kompiliert und funktioniert. Zu diesem Zweck ersetzen wir in der Datei main.c in der Funktion "StartDefaultTask" den Körper der Endlosschleife für (;;) durch den LED-Ein- und Ausschaltcode.
Es sollte so sein:
void StartDefaultTask(void const * argument) { MX_LWIP_Init(); for(;;) { HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_SET); osDelay(1000); HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_RESET); osDelay(1000); } }
Wir kompilieren die Firmware und schauen. Alle vier LEDs sollten auf der Platine blinken.
Stufe 2. Arbeiten Sie mit USART
Unsere nächste Aufgabe ist es, den korrekten Betrieb unseres USART zu überprüfen.
Als erstes müssen wir unseren FT232 mit Discovery verbinden. Überprüfen Sie dazu, auf welchen Beinen die USART-Schnittstellen geschieden sind. Ich habe es PD6 und PD5 für USART2_RX bzw. USART2_TX.
Sowie PD9 und PD8 für USART3_RX bzw. USART3_TX.
Außerdem brauchen wir einen GND-Fuß.
Wir finden diese Pins auf der Platine und verbinden sie mit den FT232-Pins, während der GND-Pin auf der Platine beliebig sein kann, der RX-Pin auf der Platine mit dem TX-Pin auf dem FT232 verbunden sein muss und der TX-Pin auf der Platine mit dem RX-Pin auf dem FT232 verbunden sein muss. Die übrigen Schlussfolgerungen werden nicht verwendet.
Es bleibt, unseren FT232 an die USB-Anschlüsse des Computers anzuschließen und die Discovery-Karte selbst über den Mini-USB-Anschluss an den Computer anzuschließen (nicht zu verwechseln mit Micro-USB).
Nach dem Anschließen von FT232 installiert das Hauptbetriebssystem die Treiber für diese. Anschließend müssen diese Geräte an den Windows-Gast auf der virtuellen Maschine weitergeleitet werden.
Jetzt fügen wir den Programmcode hinzu, der für den Betrieb unseres USART benötigt wird. Dazu fügen wir vier Dateien hinzu: usart.h, usart.c, logger.h, logger.c.
Dateiinhalt:
Datei usart.h #ifndef _USART_ #define _USART_ #include "stm32f4xx_hal.h" void usart_Open(void); bool usart_Send(char* bArray, int size_bArray); uint16_t usart_Recv(char* bArray, uint16_t maxLength); #endif
Datei usart.c #include "usart.h" #include "logger.h" #include "cmsis_os.h" #define Q_USART2_SIZE 200 xQueueHandle g_qUsart; osThreadId g_usart_rxTaskHandle; extern UART_HandleTypeDef huart2; void usart_rxTask(void); uint8_t bGet[Q_USART2_SIZE] = {0}; uint16_t g_tail = 0; void usart_Open(void) { g_qUsart = xQueueCreate( Q_USART2_SIZE, sizeof( unsigned char ) ); osThreadDef(usart_rxTask_NAME, usart_rxTask, osPriorityNormal, 0, Q_USART2_SIZE/4+128); g_usart_rxTaskHandle = osThreadCreate(osThread(usart_rxTask_NAME), NULL); HAL_UART_Receive_DMA(&huart2, bGet, Q_USART2_SIZE); } void usart_rxTask(void) { for(;;) { uint16_t length = Q_USART2_SIZE - huart2.hdmarx->Instance->NDTR; while(length - g_tail) { uint8_t tmp = bGet[g_tail]; xQueueSendToBack( g_qUsart, &tmp, 100 ); g_tail++; if (g_tail == Q_USART2_SIZE) g_tail = 0; } } } bool usart_Send(char* bArray, int size_bArray) { HAL_StatusTypeDef status; status = HAL_UART_Transmit_DMA(&huart2, bArray, size_bArray); while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY) { if (HAL_UART_GetState(&huart2) == HAL_UART_STATE_BUSY_RX) break; osDelay(1); } if (status == HAL_OK) return true; return false; } uint16_t usart_Recv(char* bArray, uint16_t maxLength) { uint8_t tmp = 0; uint16_t length = 0; while(uxQueueMessagesWaiting(g_qUsart)) { xQueueReceive( g_qUsart, &tmp, 100 ); bArray[length] = tmp; length++; if (length >= maxLength) break; } return length; }
logger.h Datei #ifndef _LOGGER_ #define _LOGGER_ void logger(const char *format, ...); #endif
logger.c Datei #include "logger.h" #include "stm32f4xx_hal.h" #include <stdarg.h> extern UART_HandleTypeDef huart3; #define MAX_STRING_SIZE 1024 HAL_StatusTypeDef logger_Send(char* bArray, uint32_t size_bArray) { HAL_StatusTypeDef status; for(int i=0;i<5;i++) { status = HAL_UART_Transmit_DMA(&huart3, bArray, size_bArray); if (status == HAL_OK) break; osDelay(2); } while (HAL_UART_GetState(&huart3) != HAL_UART_STATE_READY) { osDelay(1); } return status; } void logger(const char *format, ...) { char buffer[MAX_STRING_SIZE]; va_list args; va_start (args, format); vsprintf(buffer, format, args); va_end(args); buffer[MAX_STRING_SIZE-1]=0; logger_Send(buffer, strlen(buffer)); }
Wir brauchen usart, um Daten auf usart2 zu senden und zu empfangen. Es wird unsere Hauptschnittstelle für die Kommunikation mit einem PPP-Server sein.
Wir benötigen Logger, um die Protokollierung durch Senden von Nachrichten an das Terminal zu implementieren. Die Funktion void usart_Open (void) bildet eine Warteschlange und startet die Wartung dieser Warteschlange. Diese Funktion muss abgeschlossen sein, bevor USART verwendet werden kann. Dann ist alles einfach, die Funktion bool usart_Send (char * bArray, int size_bArray) sendet Daten an den Port und
uint16_t usart_Recv (char * bArray, uint16_t maxLength) ruft sie aus der Warteschlange ab, in die die Funktion void usart_rxTask (void) sie freundlicherweise hinzugefügt hat.
Für den Logger ist es noch einfacher, da keine Daten abgerufen werden müssen. Daher werden weder die Warteschlangen- noch die Warteschlangenwartungsaufgabe benötigt.
Am Anfang der Datei
main.h müssen Sie mehrere
Definitionen hinzufügen, die den Bool-Typ beschreiben, der in C nicht verfügbar ist.
typedef unsigned char bool; #define true 1 #define false 0
Jetzt ist es Zeit, die Funktionalität des resultierenden Codes zu überprüfen.
Ändern Sie dazu in der Datei
main.c den Code der bereits bekannten Task "StartDefaultTask".
#include "usart.h" #include "logger.h" #define MAX_MESSAGE_LENGTH 100 void StartDefaultTask(void const * argument) { MX_LWIP_Init(); usart_Open(); uint8_t send[] = "Send message\r\n"; uint8_t recv[MAX_MESSAGE_LENGTH] = {0}; uint16_t recvLength = 0; for(;;) { HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_SET); osDelay(1000); HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_RESET); osDelay(1000); if (usart_Send(send, sizeof(send)-1)) logger("SEND - %s", send); recvLength = usart_Recv(recv, MAX_MESSAGE_LENGTH-1); if (recvLength) { recv[recvLength] = 0; logger("RECV - %s\r\n", recv); } } }
Außerdem müssen wir dem Stapel unserer Aufgabe mehr Speicher geben. Dazu müssen Sie beim Aufruf der Funktion osThreadDef (), der Datei main.c, 128 x 128 * 10 korrigieren, um Folgendes zu erhalten:
osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, <b>128*10</b>)
Wir kompilieren und flashen. Die LEDs blinken auf die gleiche Weise wie in der vorherigen Aufgabe.
Um das Ergebnis unserer Arbeit zu sehen, müssen Sie das Terminal-Programm in unserer virtuellen Maschine ausführen. Eine Instanz des Programms für den Protokollierungsport, die zweite für den Hauptport. Überprüfen Sie im Geräte-Manager, welche Portnummern Ihrem FT232 zugewiesen wurden. Wenn mehr als 10 Nummern zugewiesen wurden, weisen Sie sie neu zu.
Wenn Sie die zweite Instanz des Programms starten, kann ein Fehler auftreten. Schließen Sie das Fenster mit dem Fehler und arbeiten Sie weiter mit dem Programm.
Für beide Ports stellen wir eine Verbindung mit 115200 Baud her, Datenbits - 8, Parität - keine, Stoppbits - 1, Handshake - keine.
Wenn Sie alles richtig gemacht haben, wird im Terminalfenster für usart2 die Nachricht „Nachricht senden“ gesendet. Dieselbe Nachricht wird im Terminalfenster für den Logger nur mit dem Präfix "SEND -" dupliziert.
Wenn Sie im Terminalfenster für usart2 Text in das Feld "Senden" eingeben und auf die entsprechende Schaltfläche rechts neben diesem Feld klicken, wird im Protokollierungsfenster dieselbe Meldung mit dem Präfix "RECV -" angezeigt.
Im Bild unten: Links ist der Logger, rechts ist usart2.
Phase 3. Erste Schritte mit PPP
Im Rahmen dieser Aufgabe werden wir eine PPP-Verbindung herstellen. Aktivieren Sie zunächst die Verwendung von PPP und ändern Sie den Wert der PPP_SUPPORT-Definition in der Datei ppp_opts.h in 1. Anschließend definieren wir die erforderlichen Definitionen in der Datei lwipopts.h neu.
#define MEMP_NUM_SYS_TIMEOUT 8 #define CHECKSUM_GEN_IP 1 #define CHECKSUM_GEN_TCP 1
Gleichzeitig müssen alte Definitionen auskommentiert werden.
Jetzt ändern wir die Datei lwip.c und fügen den folgenden Code in den Block "/ * USER CODE BEGIN 0 * /" ein:
#include "usart.h" #include "pppos.h" #include "sio.h" #include "dns.h" #include "ppp.h" static ppp_pcb *ppp; struct netif pppos_netif; void PppGetTask(void const * argument) { uint8_t recv[2048]; uint16_t length = 0; for(;;) { length=usart_Recv(recv, 2048); if (length) { pppos_input(ppp, recv, length); logger("read - PppGetTask() len = %d\n", length); } osDelay(10); } } #include "ip4_addr.h" #include "dns.h" static void ppp_link_status_cb(ppp_pcb *pcb, int err_code, void *ctx) { struct netif *pppif = ppp_netif(pcb); LWIP_UNUSED_ARG(ctx); switch(err_code) { case PPPERR_NONE: { logger("ppp_link_status_cb: PPPERR_NONE\n\r"); logger(" our_ip4addr = %s\n\r", ip4addr_ntoa(netif_ip4_addr(pppif))); logger(" his_ipaddr = %s\n\r", ip4addr_ntoa(netif_ip4_gw(pppif))); logger(" netmask = %s\n\r", ip4addr_ntoa(netif_ip4_netmask(pppif))); } break; case PPPERR_PARAM: logger("ppp_link_status_cb: PPPERR_PARAM\n"); break; case PPPERR_OPEN: logger("ppp_link_status_cb: PPPERR_OPEN\n"); break; case PPPERR_DEVICE: logger("ppp_link_status_cb: PPPERR_DEVICE\n"); break; case PPPERR_ALLOC: logger("ppp_link_status_cb: PPPERR_ALLOC\n"); break; case PPPERR_USER: logger("ppp_link_status_cb: PPPERR_USER\n"); break; case PPPERR_CONNECT: logger("ppp_link_status_cb: PPPERR_CONNECT\n"); break; case PPPERR_AUTHFAIL: logger("ppp_link_status_cb: PPPERR_AUTHFAIL\n"); break; case PPPERR_PROTOCOL: logger("ppp_link_status_cb: PPPERR_PROTOCOL\n"); break; case PPPERR_PEERDEAD: logger("ppp_link_status_cb: PPPERR_PEERDEAD\n"); break; case PPPERR_IDLETIMEOUT: logger("ppp_link_status_cb: PPPERR_IDLETIMEOUT\n"); break; case PPPERR_CONNECTTIME: logger("ppp_link_status_cb: PPPERR_CONNECTTIME\n"); break; case PPPERR_LOOPBACK: logger("ppp_link_status_cb: PPPERR_LOOPBACK\n"); break; default: logger("ppp_link_status_cb: unknown errCode %d\n", err_code); break; } }
Dann fügen wir in der Funktion MX_LWIP_Init () im Block „/ * USER CODE BEGIN 3 * /“ der Funktion pppConnect () einen Aufruf hinzu.
Außerdem müssen Sie die Heap-Größe erhöhen. Dazu müssen Sie in der Datei FreeRTOSConfig.h die Definition configTOTAL_HEAP_SIZE auskommentieren und am Ende der Datei im Block / * USER CODE BEGIN Defines * / mit einem neuen Wert deklarieren.
#define configTOTAL_HEAP_SIZE ((size_t)1024*30)
Ändern Sie außerdem in der Datei usart.c den Wert der Definition Q_USART2_SIZE in 2048.
Der Verbindungsaufbau beginnt mit der Funktion MX_LWIP_Init (), die automatisch erstellt wurde. Wir haben der Funktion pppConnect () gerade einen Aufruf hinzugefügt. In dieser Funktion werden Aufgaben gestartet, die die PPPOS-Verbindung bedienen. Den Funktionen pppos_create () müssen die Adressen der Funktionen übergeben werden, die zum Senden von Nachrichten und zum Ausgeben von Informationen zum Ändern des Verbindungsstatus dienen. Für uns sind dies die Funktionen ppp_output_cb () bzw. ppp_link_status_cb (). Darüber hinaus startet die Funktion pppConnect () die Bearbeitung empfangener Nachrichten. Am Ende des Betriebs wartet die Funktion pppConnect () darauf, dass eine Verbindung zum Server hergestellt wird, und schließt dann den Betrieb ab.
Die Arbeit mit dem Netzwerk wird auf einer höheren Ebene ausgeführt. Sobald LWIP entscheidet, dass eine Nachricht an das Netzwerk gesendet werden muss, wird die Funktion ppp_output_cb () automatisch aufgerufen. Die Antwort vom Netzwerk wird von der Funktion PppGetTask () als Teil der Aufgabe der Bearbeitung eingehender Nachrichten empfangen und an den Darm von LWIP übertragen. Wenn sich der Verbindungsstatus ändert, wird die Funktion ppp_link_status_cb () automatisch aufgerufen.
Schließlich werden wir die StartDefaultTask-Aufgabe ändern. Jetzt sollte es so aussehen:
void StartDefaultTask(void const * argument) {
Fertig, Sie können kompilieren und flashen.
Zu diesem Zeitpunkt müssen Sie den PPP-Server starten. Dazu müssen Sie zuerst eine virtuelle Maschine unter Linux bereitstellen. Ich habe Ubuntu 16.04 x32 verwendet. Nach der Installation des Betriebssystems müssen Sie die Verwendung des COM-Anschlusses konfigurieren.
In diesem Teil benötigen wir keine virtuelle Maschine mit Windows, wir können sie sicher deaktivieren. Wir verbinden beide FT232 unter Linux.
Bevor Sie unter Linux mit einem COM-Port arbeiten, müssen Sie dem Benutzer erlauben, ihn zu verwenden. Führen Sie dazu den folgenden Befehl aus:
sudo addgroup USERNAME dialout
Dabei ist USERNAME der Name des aktuellen Benutzers.
Um die verfügbaren Ports im COM-System anzuzeigen, müssen Sie den folgenden Befehl ausführen:
dmesg | grep tty
Wir sehen, dass es zwei ttyUSB-Ports im System gibt. Wir können nicht sofort sagen, welcher Logger und welcher usart2 ist. Sie müssen sie nur der Reihe nach überprüfen.
Führen Sie zunächst die Befehle aus, die von einem Port gelesen werden sollen:
stty -F /dev/ttyUSB0 115200 cat /dev/ttyUSB0
dann von einem anderen:
stty -F /dev/ttyUSB1 115200 cat /dev/ttyUSB1
Wo wir so ein Bild sehen, ist das Logger.
Sie können dieses Fenster verlassen, es wird uns nicht stören.
Als nächstes müssen Sie zulassen, dass von unserem Board gesendete Pakete die Grenzen ihres Subnetzes verlassen. Konfigurieren Sie dazu iptables. Wir führen folgende Aktionen durch:
1. Öffnen Sie ein neues Konsolenfenster
2. Sie müssen Ihre IP und den Namen der Netzwerkschnittstelle herausfinden (führen Sie den Befehl
ifconfig aus ).
3. Führen Sie die nat-Konfigurationsbefehle aus
sudo echo 1 | sudo tee -a /proc/sys/net/ipv4/ip_forward > /dev/null sudo echo 1 | sudo tee -a /proc/sys/net/ipv4/ip_dynaddr > /dev/null sudo iptables -F FORWARD sudo iptables -F -t nat sudo iptables -t nat -A POSTROUTING -o enp0s3 -j SNAT --to-source 192.168.10.196 sudo iptables -t nat -L
Dabei ist enp0s3 der Name der Netzwerkschnittstelle
192.168.10.196 - Ihre IP-Adresse
/ proc / sys / net / ipv4 / - Pfad zur entsprechenden Datei.
Diese Befehle können in eine Batchdatei umgeschrieben und jedes Mal ausgeführt werden, bevor der PPP-Server gestartet wird. Sie können es zu Autorun hinzufügen, aber ich habe es nicht getan.
Jetzt können wir den Server starten. Es bleibt nur noch eine Einstellungsdatei zu erstellen. Ich habe es "
pppd.conf " genannt, ich schlage vor, die folgenden Einstellungen zu verwenden:
nodetach noauth passive local debug lock 192.168.250.1:192.168.250.2 /dev/ttyUSB1 115200 lcp-echo-interval 10 lcp-echo-failure 1 cdtrcts
Wir schreiben die Einstellungen in eine Datei und dann können Sie den Server starten. Dies erfolgt mit dem
Befehl sudo pppd file ./pppd.confDer PPPD-Server muss vor dem Start der Erkennung gestartet werden. Nach dem Start von PPPD müssen Sie auf die Schaltfläche "Zurücksetzen" auf der Karte klicken.
Wenn Sie alles richtig gemacht haben, sehen Sie das folgende Bild:
Links pppd ausführen, rechts Logger.
Stufe 4. Wir schicken eine Tasche
Zu diesem Zeitpunkt benötigen wir beide virtuellen Maschinen. Linux für pppd und Windows, um das Paket zu erhalten. Um die Aufgabe zu vereinfachen, müssen sich beide Computer im selben Subnetz befinden. Die ideale Lösung besteht darin, in den VirtualBox-Netzwerkeinstellungen eine Network Bridge-Verbindung für beide Computer anzugeben und die Firewall in Windows zu deaktivieren.
Wir starten die virtuellen Maschinen und konfigurieren die ppp-Verbindung des Discovery Boards mit pppd. Unter Windows finden wir die IP-Adresse des Computers heraus (Befehl ipconfig), ich habe sie 192.168.10.97 erhalten.
Starten Sie Packet Sender und konfigurieren Sie es wie folgt:
Ändern Sie nun erneut die StartDefaultTask-Task in der Datei
main.c. #include "logger.h" #include "sockets.h" typedef uint32_t SOCKET; void StartDefaultTask(void const * argument) {
Als Wert der Variablen addr verwenden wir die Adresse des Windows-Computers, Portnummer 6565.
Gesendete Nachricht "Testnachricht TCP / IP.", Antwort "Die Nachricht wird empfangen."
Hier sehen Sie, dass PPP-Funktionen nicht direkt zum Senden und Empfangen von Nachrichten verwendet werden. Alle Arbeiten finden auf einer höheren Ebene statt und unsere Funktionen werden automatisch aufgerufen.
Wir kompilieren und flashen.
Das Ergebnis der Verbindung zu pppd ist auf einem Linux-Computer sichtbar:
Empfangene Anforderungen und gesendete Antworten werden im Paketsender-Programm auf einem Windows-Computer angezeigt:
Nun, das ist alles, das von uns vom Discovery Board gesendete Paket ging an den COM-Port, ging an den pppd-Server, wurde an den Windows-Port 6565 des Computers gesendet, dort wurde es erfolgreich empfangen, als Antwort darauf wurde ein anderes Paket gesendet, das dies bestanden hat Weg in die entgegengesetzte Richtung und wurde erfolgreich in den Vorstand übernommen. Sie können auch Nachrichten an jeden Computer im Internet senden.
→ Den vollständigen Projektcode können Sie hier herunterladen