3

我正在做一个项目，我从电阻式触摸屏获取模拟值并将它们变成交叉点。

这是一个例子：在此处输入图像描述

这是我使用 Arduino Uno 收集数据并使用称为处理的工具构建点的代码。

#define side1 2
#define side2 3
#define side3 4
#define side4 5
#define contact A0

void setup() {
  pinMode(contact, INPUT); 
  pinMode(side1, OUTPUT);  
  pinMode(side2, OUTPUT);  
  pinMode(side3, OUTPUT);  
  pinMode(side4, OUTPUT);  
  Serial.begin(9600);
}

void loop() {
  int sensorValue1;
  int sensorValue2;
  int sensorValue3;
  int sensorValue4;

  // SENSOR VALUE 1:
  digitalWrite(side1, LOW);
  digitalWrite(side2, HIGH);
  digitalWrite(side3, HIGH);
  digitalWrite(side4, HIGH);
  delay(5);
  for (int i = 0; i < 10; i++){
    sensorValue1 = analogRead(contact);
  }


  // SENSOR VALUE 2:
  digitalWrite(side2, LOW);
  digitalWrite(side3, HIGH);
  digitalWrite(side4, HIGH);
  digitalWrite(side1, HIGH);
  delay(5);
  for (int i = 0; i < 10; i++){
    sensorValue2 = analogRead(contact);
  }


  // SENSOR VALUE 3:
  digitalWrite(side3, LOW);
  digitalWrite(side2, HIGH);
  digitalWrite(side4, HIGH);
  digitalWrite(side1, HIGH);
  delay(5);
  for (int i = 0; i < 10; i++){
    sensorValue3 = analogRead(contact);
  }


  // SENSOR VALUE 2:
  digitalWrite(side4, LOW);
  digitalWrite(side3, HIGH);
  digitalWrite(side2, HIGH);  
  digitalWrite(side1, HIGH);
  delay(5);
  for (int i = 0; i < 10; i++){
    sensorValue4 = analogRead(contact);
  }

  Serial.print(sensorValue1);
  Serial.print(",");
  Serial.print(sensorValue2);
  Serial.print(",");
  Serial.print(sensorValue3);
  Serial.print(",");
  Serial.print(sensorValue4);
  Serial.println();
}

这是构建图的处理代码。

import processing.serial.*;


Serial myPort;  // The serial port
int maxNumberOfSensors = 4;   
float[] sensorValues = new float[maxNumberOfSensors];
float sensorValueX;
float sensorValueX1;
float sensorValueY;
float sensorValueY1;
int scaleValue = 2;

void setup () { 
  size(600, 600);  // set up the window to whatever size you want
  //println(Serial.list());  // List all the available serial ports
  String portName = "COM5";
  myPort = new Serial(this, portName, 9600);
  myPort.clear();
  myPort.bufferUntil('\n');  // don't generate a serialEvent() until you get a newline (\n) byte
  background(255);    // set inital background
  smooth();  // turn on antialiasing
}


void draw () {
  //background(255);
  //noFill();
  fill(100,100,100,100);
  ellipse(height,0, scaleValue*sensorValues[0], scaleValue*sensorValues[0]);

  ellipse(0,width, scaleValue*sensorValues[1], scaleValue*sensorValues[1]);
  ellipse(height,width, scaleValue*sensorValues[2], scaleValue*sensorValues[2]);
  ellipse(0,0, scaleValue*sensorValues[3], scaleValue*sensorValues[3]);
  //ellipse(sensorValueY, sensorValueX, 10,10);
  //println(sensorValueY,sensorValueX);
  sensorValueX = ((sensorValues[3]*sensorValues[3])-(sensorValues[2]*sensorValues[2])+600*600)/2000;
  sensorValueX1 = ((sensorValues[0]*sensorValues[0])-(sensorValues[1]*sensorValues[1])+600*600)/2000;
sensorValueY = ((sensorValues[3]*sensorValues[3])-(sensorValues[2]*sensorValues[2])+(600*600))/2000;
  sensorValueY1 = ((sensorValues[1]*sensorValues[1])-(sensorValues[0]*sensorValues[0])+(600*600))/2000;

  line(0, scaleValue*sensorValueX, height,scaleValue* sensorValueX);
  line(scaleValue*sensorValueY, 0, scaleValue*sensorValueY, width);
  ellipse(scaleValue*sensorValueY, scaleValue*sensorValueX, 20,20);
  line(0, scaleValue*sensorValueX1, height,scaleValue* sensorValueX1);
  line(scaleValue*sensorValueY1, 0, scaleValue*sensorValueY1, width);
  ellipse(scaleValue*sensorValueY1, scaleValue*sensorValueX1, 20,20);
  println(scaleValue*sensorValueX,scaleValue*sensorValueY);
}


void serialEvent (Serial myPort) {
  String inString = myPort.readStringUntil('\n');  // get the ASCII string

  if (inString != null) {  // if it's not empty
    inString = trim(inString);  // trim off any whitespace
    int incomingValues[] = int(split(inString, ","));  // convert to an array of ints

    if (incomingValues.length <= maxNumberOfSensors && incomingValues.length > 0) {
      for (int i = 0; i < incomingValues.length; i++) {
        // map the incoming values (0 to  1023) to an appropriate gray-scale range (0-255):

        sensorValues[i] = map(incomingValues[i], 0, 1023, 0, width);
        //println(incomingValues[i]+ " " + sensorValues[i]);
      }
    }
  }
}

我想知道如何将这些点的交点转换为坐标？示例：在图像中，我向您展示了，我将尺寸的参数设置为 (600,600)。是否可以将该交叉点更改为坐标值？目前，我的代码正在打印出坐标，但是它们是对角线，例如 x 和 y 值相等。我希望 x 和 y 的坐标具有不同的数量，以便我可以获得正方形不同边的坐标。有人可以帮忙吗？

4

2 回答 2

2

通过阅读您的代码，我假设您知道所有 n 个传感器的位置以及每个 n 个传感器到目标的距离。因此，您实际上要做的是三边测量（如 Nico Schertler 所述）。换言之，根据n个点之间的距离确定相对位置。

只是一个快速的定义说明，以防混淆：

三边测量至少需要 3 个点和距离。

  • 1 个传感器为您提供目标与传感器之间的距离
  • 2 个传感器为您提供 2 个可能的目标位置
  • 3 个传感器告诉您目标在 2 个位置中的哪一个

可能想到的第一个解决方案是计算 3 个传感器之间的交点，将它们视为圆。鉴于距离可能存在一些误差，这意味着圆圈可能并不总是相交。这排除了这个解决方案。

以下代码已全部在Processing中完成。

我冒昧地制作了一个class Sensor.

class Sensor {
    public PVector p; // position
    public float d; // distance from sensor to target (radius of the circle)

    public Sensor(float x, float y) {
        this.p = new PVector(x, y);
        this.d = 0;
    }
}

现在要计算和近似传感器/圆之间的交点，请执行以下操作：

PVector trilateration(Sensor s1, Sensor s2, Sensor s3) { 
    PVector s = PVector.sub(s2.p, s1.p).div(PVector.sub(s2.p, s1.p).mag());
    float a = s.dot(PVector.sub(s3.p, s1.p));

    PVector t = PVector.sub(s3.p, s1.p).sub(PVector.mult(s, a)).div(PVector.sub(s3.p, s1.p).sub(PVector.mult(s, a)).mag());
    float b = t.dot(PVector.sub(s3.p, s1.p));
    float c = PVector.sub(s2.p, s1.p).mag();

    float x = (sq(s1.d) - sq(s2.d) + sq(c)) / (c * 2);
    float y = ((sq(s1.d) - sq(s3.d) + sq(a) + sq(b)) / (b * 2)) - ((a / b) * x);

    s.mult(x);
    t.mult(y);

    return PVector.add(s1.p, s).add(t);
}

其中s1, s2,s3是您的 3 个传感器中的任何一个，请执行以下操作来计算给定传感器之间的交点：

PVector target = trilateration(s1, s2, s3);

虽然可以计算任意数量的传感器之间的交集。您想要包含的传感器越多，它就会变得越来越复杂。尤其是因为你是自己做的。如果您能够使用外部 Java 库，那么它会容易得多。

如果您能够使用外部 Java 库，那么我强烈建议您使用com.lemmingapex.trilateration。然后，您可以通过执行以下操作来计算 4 个传感器之间的交点：

考虑s1, s2, s3,s4作为前面提到的实例class Sensor。

double[][] positions = new double[][] { { s1.x, s1.y }, { s2.x, s2.y }, { s3.x, s3.y }, { s4.x, s4.y } };
double[] distances = new double[] { s1.d, s2.d, s3.d, s4.d };

NonLinearLeastSquaresSolver solver = new NonLinearLeastSquaresSolver(
            new TrilaterationFunction(positions, distances),
            new LevenbergMarquardtOptimizer());
Optimum optimum = solver.solve();

double[] target = optimum.getPoint().toArray();
double x = target[0];
double y = target[1];

以下示例是trilateration()我编写的方法的示例，而不是上述库的示例。

示例 1 - 无传感器错误

3 个大圆圈是任意 3 个传感器，单个红色圆圈是近似点。

示例 1

示例 2 - 传感器错误

3 个大圆圈是任意 3 个传感器，单个红色圆圈是近似点。

示例 2

于 2017-03-18T07:43:38.060 回答
0

您需要计算的是它最接近一组圆的点，用 (x1,y1)、(x2,y2)、(x3,y3)、(x4,y4) 表示它们的中心，它们的半径用r1,r2,r3,r4。

您想找到最小化的 (x,y)

F(x,y) = Sum_i [ square( d2( (x,y), (xi,yi)) - ri) ]

这可以通过使用牛顿算法来实现。牛顿算法从“初始猜测”（假设在屏幕中心）开始工作，通过求解一系列线性系统（在这种情况下，有 2 个变量，易于求解）迭代改进。MP = -G

其中 M 是 F 关于 x 和 y 的二阶导数的 (2x2) 矩阵（称为Hessian），而 G 是 F 关于 x 和 y 的一阶导数的向量（梯度）。这给出了“更新”向量 P，它告诉如何移动坐标：

然后 (x,y) 由 x = x + Px、y = y + Py 更新，依此类推（重新计算 M 和 G，求解 P，更新 x 和 y，重新计算 M 和 G，求解 P , 更新 x 和 y)。在您的情况下，它可能会在几次迭代中收敛。

由于您只有两个变量，因此 2x2 线性求解是微不足道的，并且 F 及其导数的表达式很简单，因此您可以在不需要外部库的情况下实现它。

注意1：另一个答案中提到的Levenberg-Marquardt算法是牛顿算法的一种变体（专门用于平方和，就像这里一样，它忽略了一些项，并且通过向其对角系数添加小数来正则化矩阵M）。更多关于这个here。

注意2：一个简单的梯度下降也可能会起作用（实现起来更简单，因为它只使用一阶导数），但鉴于您只有两个变量要实现，2x2 线性求解是微不足道的，所以牛顿可能是值得的（收敛所需的迭代次数要少得多，如果您的系统是交互式的，这可能是至关重要的）。

于 2017-03-19T07:40:54.230 回答