C++：两个类不同时运行

Question

这是我第一次来这里。我的代码假设使用 mbed 使两个超声波传感器同时工作。但是，我似乎无法使代码中的两个类 void us_right() 和 void us_left() 同时运行。请帮忙:(

#include "mbed.h"
DigitalOut triggerRight(p9); 
DigitalIn echoRight(p10);
DigitalOut triggerLeft(p13); 
DigitalIn echoLeft(p14);
//DigitalOut myled(LED1); //monitor trigger
//DigitalOut myled2(LED2); //monitor echo
PwmOut steering(p21);
PwmOut velocity(p22);
int distanceRight = 0, distanceLeft = 0;
int correctionRight = 0, correctionLeft = 0;
Timer sonarRight, sonarLeft;

float vo=0;

// Velocity expects -1 (reverse) to +1 (forward)
void Velocity(float v) {
    v=v+1;
    if (v>=0 && v<=2) {
        if (vo>=1 && v<1) {                 //
            velocity.pulsewidth(0.0014);    // this is required to
            wait(0.1);                      //
            velocity.pulsewidth(0.0015);    // move into reverse
            wait(0.1);                      //
        }                                   //
        velocity.pulsewidth(v/2000+0.001);
        vo=v;
    }
}

// Steering expects -1 (left) to +1 (right)
void Steering(float s) {
    s=s+1;
    if (s>=0 && s<=2) {
        steering.pulsewidth(s/2000+0.001);
    }
}

void us_right() {
    sonarRight.reset();
    sonarRight.start();
    while (echoRight==2) {};
    sonarRight.stop();
    correctionRight = sonarLeft.read_us();
    triggerRight = 1;
    sonarRight.reset();
    wait_us(10.0);
    triggerRight = 0;
    while (echoRight==0) {};
  //  myled2=echoRight;
    sonarRight.start();
    while (echoRight==1) {};
    sonarRight.stop();
    distanceRight = ((sonarRight.read_us()-correctionRight)/58.0);
    printf("Distance from Right is: %d cm \n\r",distanceRight);
}

void us_left() {
    sonarLeft.reset();
    sonarLeft.start();
    while (echoLeft==2) {};
    sonarLeft.stop();
    correctionLeft = sonarLeft.read_us();
    triggerLeft = 1;
    sonarLeft.reset();
    wait_us(10.0);
    triggerLeft = 0;
    while (echoLeft==0) {};
  //  myled2=echoLeft;
    sonarLeft.start();
    while (echoLeft==1) {};
    sonarLeft.stop();
    distanceLeft = (sonarLeft.read_us()-correctionLeft)/58.0;
    printf("Distance from Left is: %d cm \n\r",distanceLeft);
}

int main() {
    while(true) {
        us_right();
        us_left();
    }
   if (distanceLeft < 10 || distanceRight < 10) {
            if (distanceLeft < distanceRight) {
                for(int i=0; i>-100; i--) {       // Go left
                    Steering(i/100.0);
                    wait(0.1);
                }
            }
            if (distanceLeft > distanceRight) {
                for(int i=0; i>100; i++) {       // Go Right
                    Steering(i/100.0);
                    wait(0.1);
                }
            }              
    }
        wait(0.2);
}

Answer 1

您需要使用某种机制来创建新的线程或进程。您的实现是顺序的，您没有做任何事情来告诉代码同时运行。

你应该看看一些线程库（例如 pthreads，或者如果你可以访问 c++11，那里有线程功能）或者如何创建新进程以及某种消息传递接口这些过程。

Answer 2

创建两个线程，每个超声波传感器一个：

void read_left_sensor() {
    while (1) {
        // do the reading
        wait(0.5f);
    }
}

int main() {
    Thread left_thread;
    left_thread.start(&read_left_sensor);

    Thread right_thread;
    right_thread.start(&read_right_sensor);

    while (1) {
        // put your control code for the vehicle here
        wait(0.1f);
    }
}

您可以在读取传感器时使用全局变量进行写入，并在主循环中读取它们。内存是共享的。

Answer 3

您的第一个问题是您将代码置于无限 while(true) 循环之外。后面的代码将永远不会运行。但也许你知道这一点。

int main() {

    while(true) {
        us_right();
        us_left();
    } // <- Loops back to the start of while()

   // You Never pass this point!!!

   if (distanceLeft < 10 || distanceRight < 10) {
            // Do stuff etc.
   }
   wait(0.2);
}

但是，我认为您预计 us_right() 和 us_left() 会同时发生。您不能在顺序环境中执行此操作。

Jan Jongboom 建议您可以使用 Threads 是正确的。这允许“操作系统”指定运行每段代码的时间。但它仍然不是真正的平行。每个函数（类是不同的东西）都有机会运行。一个将运行，当它完成时（或在等待期间）另一个函数将有机会运行。

由于您使用的是 mbed，我建议您的项目是 MBED OS 5 项目 （当你开始一个新项目时选择这个）。否则，您将需要使用 RTOS 库。有一个使用线程的眨眼示例应该很好地总结出来。 Here is more info.

线程对于没有经验的人来说可能很危险。所以坚持一个简单的实现开始。确保您了解自己在做什么/为什么/如何做。

旁白：从硬件角度来看，并行运行超声波传感器实际上并不理想。他们都广播相同的频率，并且可以互相听到。同时触发它们，它们相互干扰。

想象两个人在一个封闭的房间里大喊大叫。如果他们轮流发言，他们在说什么就很明显了。如果两个人同时大喊，那就很难了！

所以实际上，不能并行运行可能是件好事。