同一代码在不同设备上的不同行为

Question

I'm baffled. I have an identical program being uploaded to two different Arduino boards. It's in C++.

It's a much larger program, but I'm cutting it down to only the problematic part. Basically, I have a "host" Arduino and a "rover" Arduino communicating wirelessly. There are multiple rover units, but the problem is only happening on one of them. The rovers have motors that need to be calibrated, so I have static variables in my Motor namespace to hold those calibration values. To prevent having to change these values in the source code, recompile and reupload every time I want to calibrate it, I'm using the wireless system to allow the host to send calibration values to the rover at runtime.

Here's the problem: on one rover, the values aren't being updated if I call the ChangeSpeed method, but they do get updated if I modify the variables directly.

Let me stress that it works fine on four out of five rovers . The problem is happening on exactly one rover. The code being uploaded to each rover is identical.

The following code is causing a problem:

Motor.h:

namespace Motor
{
    static unsigned char left_speed = 0;
    static unsigned char right_speed = 0;

    void ChangeSpeed(unsigned char, unsigned char);
}

Motor.cpp:

void Motor::ChangeSpeed(unsigned char l_speed, unsigned char r_speed)
{
    left_speed = l_speed;
    right_speed = r_speed; 

    soft.println("Change speed: " + String(left_speed) + ", " + String(right_speed));
}

Main.cpp:

void UpdateSpeedValuesBad(unsigned char l_speed, unsigned char r_speed)
{
    Motor::ChangeSpeed(l_speed, r_speed);
    soft.println("Motor write: " + String(l_speed) + ", " + String(r_speed));
}

void UpdateSpeedValuesGood(unsigned char l_speed, unsigned char r_speed)
{
    Motor::left_speed = l_speed;
    Motor::right_speed = r_speed;
    soft.println("Motor write: " + String(l_speed) + ", " + String(r_speed));
}

void ReturnSpeedValues()
{
    soft.println("Motor read: " + String(Motor::left_speed) + ", " + String(Motor::right_speed));
}

Case 1:

On the bad rover, the host invokes UpdateSpeedValuesBad(5, 5) , and then invokes ReturnSpeedValues . The output is:

Change speed: 5, 5
Motor write: 5, 5
Motor read: 0, 0

Case 2:

On the bad rover, the host invokes UpdateSpeedValuesGood(5, 5) , and then invokes ReturnSpeedValues . The output is:

Motor write: 5, 5
Motor read: 5, 5

Case 3:

On a good rover, the host invokes UpdateSpeedValuesBad(5, 5) , and then invokes ReturnSpeedValues . The output is:

Change speed: 5, 5
Motor write: 5, 5
Motor read: 5, 5

---

Am I doing something fundamentally wrong? I come from a C# background so C++ is pretty alien to me. I have no idea if I'm doing something that has undefined behaviour.

---

Edit: If I shove everything into one single file, it works fine. It only fails once I split it up across a header file and a cpp file.

Main.cpp:

#include <SoftwareSerial.h>

SoftwareSerial soft(9, 10);

namespace Motor
{
  static int left_speed = 0;

  void ChangeSpeed(unsigned char);
}

void Motor::ChangeSpeed(unsigned char l_speed)
{
  left_speed = l_speed;
  soft.println("Change speed: " + String(left_speed));
}

void setup()
{
  soft.begin(9600);

  soft.println("Before: " + String(Motor::left_speed));

  Motor::ChangeSpeed(5);
  soft.println("Bad attempt: " + String(Motor::left_speed));

  Motor::left_speed = 5;
  soft.println("Good attempt: " + String(Motor::left_speed));
}

void loop()
{
}

Output:

Before: 0
Change speed: 5
Bad attempt: 5
Good attempt: 5

---

Edit 2: I dove into the assembly and found this for the bad case. It's using different memory addresses based on whether I call ChangeSpeed or I update the values directly. Anyone know why that would be? Is it a compiler bug or is it not guaranteed that the addresses will be the same?

000000a8 <setup>:
{ 
    Motor::ChangeSpeed(5, 6);
  a8:   85 e0           ldi r24, 0x05   ; 5
  aa:   66 e0           ldi r22, 0x06   ; 6
  ac:   0e 94 5f 00     call    0xbe    ; 0xbe <_ZN5Motor11ChangeSpeedEhh>

    Motor::left_speed = 5;
  b0:   85 e0           ldi r24, 0x05   ; 5
  b2:   80 93 00 01     sts 0x0100, r24

    Motor::right_speed = 6;
  b6:   86 e0           ldi r24, 0x06   ; 6
  b8:   80 93 01 01     sts 0x0101, r24
}
  bc:   08 95           ret

000000be <_ZN5Motor11ChangeSpeedEhh>:

void Motor::ChangeSpeed( unsigned char l_speed, unsigned char r_speed )
{
    left_speed = l_speed;
  be:   80 93 02 01     sts 0x0102, r24
    right_speed = r_speed; 
  c2:   60 93 03 01     sts 0x0103, r22
  c6:   08 95           ret

Answer 1

You should not make these variables static. A static global variable means the variable is local to the compilation unit (generally, the .cpp file that is being compiled) so if you have the static variable declared in a header file and include that header file in 3 different .cpp files that are compiled separately then you will have 3 independent versions of that variable, one for each .cpp file.

Instead, in the header file declare them as

namespace Motor {
  extern unsigned char left_speed;
  extern unsigned char right_speed;

  void ChangeSpeed(unsigned char, unsigned char);
}

This tells the compiler that some file will provide a definition for these variables and to use that common shared definition.

Then, since the variables need to be defined exactly once (this is called the one definition rule ) you should add the definition to Motor.cpp :

unsigned char Motor::left_speed = 0;
unsigned char Motor::right_speed = 0;

I chose Motor.cpp to hold the definition since this is where the definition of the ChangeSpeed function is.

In C++, the static keyword works much differently than in C#. It might be somewhat similar when used inside a class definition, but that is where the similarities end.

Answer 2

By declaring the variables static , you limit their range to the current code unit. In other words, by having static variables in your .h , you cause Motor.cpp and Main.cpp to have separate copies of those two variables.

Your case 1 modifies the Motor.cpp copies of those variables while outputs the ones from Main.cpp . Case 2 works only on Main.cpp copies so it works as expected. And if you shove everything into a single file, you just get one copy of those variables.

You should either:

1. Declare the variables as extern unsigned char left_speed, right_speed; in the header, and then declare the values as unsigned char left_speed = 0; in one of the .cpp files;
2. Declare the static variables in one of the .cpp files directly (eg Rotor.cpp ) and use functions to get their values like you use one to set them.