串行监视器显示来自 Arduino Mega 的意外输入

Question

我正在使用 Arduino Mega 来控制 CS1237 ADC。根据我找到的datasheet（通过https://github.com/SiBangkotan/CS1237-ADC-cpp-library），我正在向时钟引脚发送一个信号，并在每个时钟脉冲之后等待1ms，然后读取响应。这似乎在某种程度上起作用，因为当我为接收到的每个位和结果数据字执行Serial.println() 时，我得到一个与我得到的 24 个单独位匹配的 24 位数据字。但是，当我取出Serial.println() 的额外调试用途时，它会在收到每个位时打印它们，我也会得到一个不同的数据字。每次都是全 1 的 20 位，而不是各种 1 和 0 的 24 位。我不明白为什么串行通信通道中的这个额外的调试输出会改变进入串行监视器的数据字？

这是我的设置和预设置代码：

// Using pins 2 and 3 on the Arduino, since 0 and 1 are used to talk to the USB port.
int ndrdy = 2;
int clck = 3;

// the setup routine runs once when you press reset:
void setup() {
    // initialize serial communication at 9600 bits per second:
    Serial.begin(9600);
    while (!Serial) {
        ; // wait for serial port to connect. Needed for native USB port only
    }
    // make the drdy's pin an input and clock an output:
    pinMode(ndrdy, INPUT);
}

以下是相关代码：

void loop() {
  // Hacky way of waiting for the signal that !DRDY is ready.
  while(digitalRead(ndrdy) == LOW) {
    // do nothing until pin pulls high.
  }
  while(digitalRead(ndrdy) == HIGH) {
    // keep doing nothing until pin goes low again.
  }
  // now data is ready, we can read

  long dataword = 0;

  for(int i = 0; i < 24; i++) {
    digitalWrite(clck, HIGH);
    delayMicroseconds(1);
    digitalWrite(clck, LOW);
    int new_bit = digitalRead(ndrdy);
    dataword <<= 1;       // shift everything one place to the left
    dataword |= new_bit;  // add the new bit to the newly empty place
  }

  // There's a total of 27 bits but we don't care about the last 3.
  // Write HIGH 3 times to flush it out.
  for (int i = 0; i < 3; i++) {
    digitalWrite(clck, HIGH);
    delayMicroseconds(1);
    digitalWrite(clck, LOW);
  }

  // Send out the data to the USB serial out:
  Serial.println(dataword, BIN);
}

这个在串口监视器中的输出是

13:44:45.685 -> 11111111111111111111
13:44:45.685 -> 11111111111111111111
13:44:45.718 -> 11111111111111111111
13:44:45.751 -> 11111111111111111111
13:44:45.751 -> 11111111111111111111
13:44:45.785 -> 11111111111111111111
13:44:45.818 -> 111111111111111111111
13:44:45.852 -> 11111111111111111111
13:44:45.852 -> 11111111111111111111
13:44:45.885 -> 11111111111111111111
13:44:45.918 -> 111111111111111111111
13:44:45.918 -> 11111111111111111111
13:44:45.951 -> 11111111111111111111

...等等。但是，当我在 for(int i = 0; i < 24; i++) 循环的右括号之前添加一个额外的 Serial.println(new_bit); 时，我在 Arduino IDE 的串行监视器中得到这样的输出（显示打开时间戳）：

14:41:19.992 -> 0
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 1
14:41:19.992 -> 0
14:41:19.992 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 0
14:41:20.025 -> 0
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.025 -> 1
14:41:20.058 -> 0
14:41:20.058 -> 1
14:41:20.058 -> 11111111011111001111101
14:41:20.091 -> 0
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 1
14:41:20.091 -> 0
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.125 -> 0
14:41:20.125 -> 0
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.125 -> 1
14:41:20.158 -> 1
14:41:20.158 -> 0
14:41:20.158 -> 1
14:41:20.158 -> 11111111011111001111101

如果我在Serial.println()-ing 该行上的new_bit 以外的任何内容，例如如果我执行Serial.println(dataword); 或者如果我引入一个小延迟而不是执行串行打印，则不会发生这种情况。在这些情况下，它仍然会输出 21 的输出。我不知道串行通信出了什么问题，因为从 ADC 读取似乎一切正常。如果我引入 5000us 或更多的延迟，那么dataword 的内容就会发生变化，这似乎成为延迟长度的函数。 IE。 dataword 的内容对于每个延迟长度都是恒定的（我尝试过 5000us、6000us、10000us 和 20000us）。如果延迟足够长，它会回到全 1。

Answer 1

通过查看数据表...

芯片启动时首先...默认输入Al引脚。您没有设置时钟引脚模式，因此您没有时钟。此外，ADC 最多可能需要 300 毫秒才能唤醒。这是您启动序列的一部分，当您退出 setup() 时，芯片应该准备就绪。您还可以在 setup() 中包含任何 ADC 寄存器的设置。参见数据表启动顺序@图 5 和图 6。

另外，如果您想尝试更低的时钟速度，请不要让clck 保持高电平超过 100us

来自数据表，2.5： “当SCLK由低变高并保持高电平超过100μs时，CS1237进入PowerDown模式，功耗小于0.1μA。当SCLK回到低电平时，芯片将恢复正常工作。”

void setup() 
{
    // initialize serial communication at 9600 bits per second:
    Serial.begin(9600);
    while (!Serial) {}
    
    // make the drdy's pin an input and clock an output:
    // remove pullup on ndrdy
    digitalWrite(ndrdy, LOW);
    pinMode(ndrdy, INPUT);

    digitalWrite(clck, LOW);
    pinMode(clck, OUTPUT);

    // wait for ADC to end its own boot sequence.
    while (digitalRead(ndrdy)) {}
    while (!digitalRead(ndrdy)) {}
}

数据表的图表“图 7”显示：

等到 /DRDY 为低，等待持续时间 t4（为 0），所以不等待是可以的，然后循环每个位：

• 设置时钟高
• 至少等待持续时间 t6 (455 ns)
• 读取输入位。
• 将时钟设置为低。
• 在下一个时钟之前，时钟必须保持低电平至少持续时间 t5 (455 ns)。

您可以在时钟低时读取数据位，但请注意数据库图。 8、时钟位一变低，第 27 位就失效。根据经验，这暗示您应该在时钟高时阅读。有些数据表很难阅读，有些甚至是错误的。这就是我对此的解释，但我可能错了，您可能还想在时钟高时尝试阅读。

你的输入程序就变成了：

// reads a 24 bit value from ADC, returns -1 if no data to read 
// note that this function does not wait, so your other processing 
// can still be responsive. 
long readADC() 
{
    // check if data is ready. 
    if (digitalRead(ndrdy))
        return -1;    

    long result = 0;

    // read 24 bits.
    for (int i = 0; i < 24; i++) 
    {
        // get ADC to output a bit.
        digitalWrite(clck, HIGH);
        delayMicroseconds(1);      

        // read it
        int new_bit = digitalRead(ndrdy);

        digitalWrite(clck, LOW);

        delayMicroseconds(1);      // this delay could be shorter, because of 
                                   // operations immediately taking some
                                   // time...  You may want to time it
                                   // using a scope, at least for the fun
                                   // of it.  On a slow 8-bit ATMega, it may not
                                   // be needed, there are move than 16 cycles
                                   // of processing below. plus 2 cycles for
                                   // jumping back to top of loop.
                                   // IS needed for sure at clock speeds above
                                   // 16 MHz.
        result <<= 1;
        result |= new_bit;
    }

    // emit 3 more clock cycles.
    for (int i = 0; i < 3; i++) 
    {
        digitalWrite(clck, HIGH);
        delayMicroseconds(1);      
        digitalWrite(clck, LOW);
        delayMicroseconds(1);
    }

    // note that the 27th clock cycle has set /DRDY high.
    // There is never any need to wait on /DRDY going high.

    return result;  // mask unwanted bits.
}


void loop()
{
    // ...

    long adcValue = readADC();

    if (adcValue >= 0)
    {
       // process ADC input
       Serial.print("ADC reading: ");
       Serial.print(adcValue);
       Serial.print(" (");
       Serial.print(adcValue, BIN);
       Serial.println(")");
    }

    // ...
}

一旦你顺利运行，你可以尝试通过创建自己的 455ns 延迟函数来加快阅读速度，不使用任何操作

#define NOOP() __asm__("nop\n\t")  // 1 operation cycle delay, for 8-bit ATMega, 
                                   // 1 op cycle == 1 clock cycle.
                       

实际延迟取决于您的时钟速度。通常，这些都是使用宏来实现的。

例如，在多行宏中。注意行尾的反斜杠。这些应该是该行的最后一个字符，并且宏中不应有任何空行

  // 500 ns delay @ 16MHz clock, on an 8-bit ATMega.
  #define NOOP() __asm__("nop\n\t")
  #define DELAY_500ns()   NOOP(); NOOP(); NOOP(); NOOP(); \ 
                          NOOP(); NOOP(); NOOP(); NOOP();