通过PacketSender将Arduino ESP32微控制器连接到javafx 我们使用C++和ARDUIONESP32模块构建了无人机控制器。我们已经连接到了Tello无人机，并且能够成功地控制它。但是，现在我们想将控制器连接到一个javafx程序，该程序接收输入，然后在场景生成器中绘制画布

同时，问题是我们似乎无法通过PacketSender连接控制器。我们已经附加了我们的代码，包括先前构建的能够与无人机连接的代码。 最大的问题是如何在两个程序之间发送消息，并在画布上开始我们对无人机的虚拟描述，而不是实际的物理描述

问题似乎出现在案例1，第190行，我们将控制器连接到实际的无人机，但现在必须以某种方式建立一个新的连接

#include <Arduino.h>
#include "WiFi.h"
#include "AsyncUDP.h"

const char * ssid = "OnePlus 7 Pro";
const char * password = "hej12345";

//Connect button variables (Command)
int inPinLand = 18;
int valLand = 0;

//Ultra sonic sensor variables
#define trigPin 2
#define echoPin 21

//Land button variables (Land)
int inPin = 25;
int val = 0;

//Instantiate specific drone
const char * networkName = "TELLO-59F484";
const char * networkPswd = "";

//IP address to send UDP data to:
// either use the ip address of the server or
// a network broadcast address
const char * udpAddress = "10.60.0.227";
const int udpPort = 7000;
boolean connected = false;

char fromTello[256];

unsigned long timer;

//static const byte glyph[] = { B00010000, B00110100, B00110000, B00110100, B00010000 };
//static PCD8544 lcd;

uint8_t state = 0;

//Controller movement variables
int pitch = 0;
int roll = 0;
int yaw = 0;
int throttle = 0;
char cmd[256];

AsyncUDP udp;

void setup() {
  Serial.begin(9600);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("WiFi Failed");
    while (1) {
      delay(1000);
    }
  }
  pinMode(5, OUTPUT);
  digitalWrite(5, HIGH);

  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  pinMode(inPin, INPUT);
  pinMode(inPinLand, INPUT);

  //LCD screen initialization
  //lcd.begin(84, 48);

  Serial.begin(9600);

  //pinMode(trigPin, OUTPUT);
  //pinMode(echoPin, INPUT);

  //pinMode(BL, OUTPUT);
  //digitalWrite(BL, HIGH);

  if (udp.listen(7000)) {
    Serial.print("UDP Listening on IP: ");
    Serial.println(WiFi.localIP());
    udp.onPacket([](AsyncUDPPacket packet) {
      Serial.print("UDP Packet Type: ");
      Serial.print(packet.isBroadcast()
                       ? "Broadcast"
                       : packet.isMulticast() ? "Multicast" : "Unicast");
      Serial.print(", From: ");
      Serial.print(packet.remoteIP());
      Serial.print(":");
      Serial.print(packet.remotePort());
      Serial.print(", To: ");
      Serial.print(packet.localIP());
      Serial.print(":");
      Serial.print(packet.localPort());
      Serial.print(", Length: ");
      Serial.print(packet.length());
      Serial.print(", Data: ");
      Serial.write(packet.data(), packet.length());
      Serial.println();

      // reply to the client/sender
      packet.printf("Got %u bytes of data", packet.length());
    });
  }

  // Send unicast
  // udp.print("Hello Server!");
  // udp.
}

//WiFi connection function
void connectToWiFi(const char * ssid, const char * pwd) {
  Serial.println("Connecting to WiFi network: " + String(ssid));
  // delete old config
  WiFi.disconnect(true);

  //Initiate connection
  WiFi.begin(ssid, pwd);
  Serial.println("Waiting for WIFI connection...");
}

//Drone connection function
void TelloCommand(char *cmd) {
  //only send data when connected
  if (connected) {
    //Send a packet
    //udp.beginPacket(udpAddress, udpPort); OUTDATED has new name with ASync
    udp.printf(cmd);
    //udp.endPacket(); OUTDATED has new name with ASync
    Serial.printf("Send [%s] to Tello.\n", cmd);
  }
}

void sendMessage(String msg){
  udp.writeTo((const uint8_t *)msg.c_str(), msg.length(),
              IPAddress(169, 254, 107, 16), 4000);
}

void loop() {
  delay(5000);

  // Send broadcast on port 4000
  udp.broadcastTo("Anyone here?", 4000);

  // Serial.println("waiting for udp message...");
  int x = 100;
  int y = 100;
  sendMessage("init " + String(x) + " " + String(y));
}
void loop() {
  long duration, distance;
  val = digitalRead(inPin);  // read input value

  //Ultra sonic sensor
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  duration = pulseIn(echoPin, HIGH);
  distance = (duration / 2) / 29.1;

  //LCD screen line 2
  // lcd.setCursor(0, 1);
  // lcd.print(distance, DEC);

  //State machine that connects the drone to WiFi and the controller
  switch (state)
  {

    case 0:   //Idle not connected
      //LCD screen line 1
      //lcd.setCursor(0, 0);
      //lcd.print("Controller");

      if (val == HIGH)
      {
        state = 1;
        connectToWiFi(networkName, networkPswd);
        timer = millis() + 5000;
      }
      break;
    case 1: //Trying to connect
      if (WiFi.status() == WL_CONNECTED)
      {
        Serial.print("Connected to: ");
        Serial.println(networkName);

        udp.begin(WiFi.localIP(), udpPort);
        connected = true;
        TelloCommand("command");
        timer = millis() + 2000;
        state = 2;
      }

      if (millis() > timer)
      {
        state = 0;
      }
      break;

    case 2:   //Connected on ground
      //lcd.setCursor(0, 0);
      //lcd.print("Connected ");

      if (WiFi.status() != WL_CONNECTED)
      {
        WiFi.disconnect(true);
        Serial.println("Disconnected");
        state = 0;
      }

      if (distance < 10)
      {
        TelloCommand("takeoff");
        timer = millis() + 1000;
        state = 3;
        Serial.println("takeoff");
      }
      break;

    case 3:   //In air
      //lcd.setCursor(0, 0);
      //lcd.print("In air       ");

      if (millis() > timer)
      {
        timer = millis() + 20;
        pitch = map(analogRead(34) - 1890, -2000, 2000, -100, 100);
        roll = map(analogRead(35) - 1910, -2000, 2000, -100, 100);
        throttle = map(analogRead(33) - 1910, -2000, 2000, -100, 100);
        yaw = map(analogRead(32) - 1910, -2000, 2000, -100, 100);

        sprintf(cmd, "rc %d %d %d %d", roll, pitch, throttle, yaw);
        TelloCommand(cmd);
      }

      if (val == HIGH) {
        TelloCommand("land");
        timer = millis() + 1000;
        state = 0;
        Serial.println("land");
      }
      break;
  }
  delay(200);
}

#包括
#包括“WiFi.h”
#包括“AsyncUDP.h”
const char*ssid=“OnePlus 7 Pro”；
const char*password=“hej12345”；
//连接按钮变量（命令）
int inPinLand=18；
int valLand=0；
//超声波传感器变量
#定义trigPin 2
#定义echoPin 21
//Land按钮变量（Land）
int-inPin=25；
int-val=0；
//实例化特定的无人机
const char*networkName=“TELLO-59F484”；
const char*networkPswd=“”；
//要将UDP数据发送到的IP地址：
//使用服务器的ip地址或
//网络广播地址
const char*udpAddress=“10.60.0.227”；
常量int udpPort=7000；
布尔连接=假；
char fromTello[256]；
无符号长定时器；
//静态常量字节标志符[]={B00010000、B0011010、B0011000、B0011010、B0011010、B00010000}；
//静态PCD8544液晶显示器；
uint8_t state=0；
//控制器运动变量
int节距=0；
int roll=0；
int偏航=0；
int节流阀=0；
char-cmd[256]；
异步udp；
无效设置（）{
Serial.begin（9600）；
WiFi.模式（WiFi_STA）；
WiFi.begin（ssid，密码）；
如果（WiFi.waitForConnectResult（）！=WL_已连接）{
Serial.println（“WiFi失败”）；
而(1){
延迟（1000）；
}
}
pinMode（5，输出）；
数字写入（5，高）；
引脚模式（trigPin，输出）；
pinMode（echoPin，输入）；
pinMode（inPin，输入）；
pinMode（输入内地，输入）；
//LCD屏幕初始化
//lcd.begin（84,48）；
Serial.begin（9600）；
//引脚模式（trigPin，输出）；
//pinMode（echoPin，输入）；
//pinMode（BL，输出）；
//数字写入（BL，高）；
if（udp.listen（7000））{
Serial.print（“IP上的UDP侦听：”）；
Serial.println（WiFi.localIP（））；
udp.onPacket（[]（异步udppacket数据包）{
串行打印（“UDP数据包类型：”）；
Serial.print（packet.isBroadcast（）文件）
？“广播”
：packet.isMulticast（）？“多播”：“单播”）；
序列号。打印（“，从：”）；
Serial.print（packet.remoteIP（））；
连续打印（“：”）；
Serial.print（packet.remotePort（））；
序列号。打印（“，至：”）；
Serial.print（packet.localIP（））；
连续打印（“：”）；
Serial.print（packet.localPort（））；
连续打印（“，长度：”）；
Serial.print（packet.length（））；
串行打印（“，数据：”）；
Serial.write（packet.data（），packet.length（））；
Serial.println（）；
//回复客户/发件人
packet.printf（“获取了%u字节的数据”，packet.length（））；
});
}
//发送单播
//打印（“你好服务器！”）；
//udp。
}
//WiFi连接功能
void connectToWiFi（常量字符*ssid，常量字符*pwd）{
Serial.println（“连接到WiFi网络：+字符串（ssid））；
//删除旧配置
WiFi。断开连接（正确）；
//启动连接
WiFi.begin（ssid、pwd）；
Serial.println（“等待WIFI连接…”）；
}
//无人机连接功能
void tellocomand（char*cmd）{
//仅在连接时发送数据
如果（已连接）{
//寄包裹
//baginpacket（udpAddress，udpPort）；过时的有一个新名称，带有ASync
udp.printf（cmd）；
//udp.endPacket（）；已过时，新名称为ASync
Serial.printf（“发送[%s]到Tello.\n”，cmd）；
}
}
无效发送消息（字符串消息）{
udp.writeTo（（const uint8_t*）msg.c_str（），msg.length（），
IPAddress（169254 107 16），4000；
}
void循环（）{
延迟（5000）；
//在端口4000上发送广播
udp.broadcastTo（“这里有人吗？”，4000）；
//Serial.println（“等待udp消息…”）；
int x=100；
int y=100；
sendMessage（“init”+字符串（x）+“+字符串（y））；
}
void循环（）{
长时间、远距离；
val=digitalRead（inPin）；//读取输入值
//超声波传感器
数字写入（trigPin，低电平）；
延迟微秒（2）；
数字写入（trigPin，高）；
延迟微秒（10）；
数字写入（trigPin，低电平）；
持续时间=脉冲强度（echoPin，高）；
距离=（持续时间/2）/29.1；
//液晶屏生产线2
//lcd.setCursor（0,1）；
//lcd.打印（距离，十二月）；
//将无人机连接到WiFi和控制器的状态机
开关（状态）
{
案例0://空闲未连接
//液晶屏生产线1
//lcd.setCursor（0,0）；
//lcd.打印（“控制器”）；
如果（val==高）
{
状态=1；
connectToWiFi（networkName，networkPswd）；
定时器=毫秒（）+5000；
}
打破
案例1://尝试连接
如果（WiFi.status（）==WL_已连接）
{
Serial.print（“连接到：”）；
Serial.println（网络名称）；
udp.begin（WiFi.localIP（），udpPort）；
连接=真；
TelloCommand（“命令”）；
定时器=millis（）+2000；
状态=2；
}
如果（毫秒（）>计时器）
{
状态=0；
}
打破
案例2://接地
//lcd.setCursor（0,0）；
//lcd.打印（“连接”）；
如果（WiFi.status（）！=WL_已连接）
{
WiFi。断开连接（正确）；
Serial.println（“断开”）；
状态=0；
}
如果（距离<10）
{
电视命令（“起飞”）；
定时器=毫秒（）+1000；
状态=3；
连续打印（“起飞”）；
}
打破
案例3://空气中
//lcd.setCursor（0,0）；
//液晶显示器