尝试在2个Arduinos之间通过SPI发送浮点值

我目前正试图通过SPI跨两个Arduinos发送浮点值。目前，我正在发送一个静态值2.25，然后通过

Serial.println（）

命令读取。然后我想从线性位移传感器传递一个浮点值。我的最终目标是能够让主设备询问信息，从设备收集适当的数据并打包，然后主设备接收所述数据并处理它需要的信息

目前，我收到一个错误“调用重载的'println（字节[7]）是不明确的”，我不知道为什么会收到这个错误。我目前是一名机械工程专业的学生，正在通过C/C++进行速成课程。我对自己正在做的事情并不完全肯定。我知道浮点数是4字节，我正在尝试创建一个7字节的缓冲区来存储浮点数和“\n”字符，还有剩余的空间。我现在的代码如下

大师：

#include <SPI.h>
void setup() {
  pinMode(SS,OUTPUT);
  digitalWrite(SS,HIGH);
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV4);
}

void loop() {
  digitalWrite(SS,LOW);
  float a = 2.25;
  SPI.transfer(a);
  SPI.transfer('\n');
  digitalWrite(SS,HIGH);
}

#include <SPI.h>

float a = 3.14;
float b = 2.25;
uint8_t storage [12];
float buff[2] = {a, b};
void setup()
{
  digitalWrite(SS, HIGH);
  SPI.begin();
  Serial.begin(9600);
  SPI.setClockDivider(SPI_CLOCK_DIV8);
}

void loop()
{

  digitalWrite(SS, LOW);
  memcpy(storage, &buff, 8);
  Serial.print("storage[0] = "); Serial.println(storage[0]); // the 
  following serial prints were to check i was getting the right decimal 
  numbers for the floats.
  Serial.print("storage[1] = "); Serial.println(storage[1]);
  Serial.print("storage[2] = "); Serial.println(storage[2]);
  Serial.print("storage[3] = "); Serial.println(storage[3]);
  Serial.print("storage[4] = "); Serial.println(storage[4]);
  Serial.print("storage[5] = "); Serial.println(storage[5]);
  Serial.print("storage[6] = "); Serial.println(storage[6]);
  Serial.print("storage[7] = "); Serial.println(storage[7]);
  SPI.transfer(storage, sizeof storage ); //SPI library allows a user to 
  transfer a whole array of bytes and you need to include the size of the 
  array.
  digitalWrite(SS, HIGH);
  delay(1000);
}

#包括
无效设置（）{
pinMode（SS，输出）；
数字写入（SS，高）；
SPI.begin（）；
SPI.设置时钟分配器（SPI时钟分配器4）；
}
void循环（）{
数字写入（SS，低电平）；
浮点数a=2.25；
SPI.转让（a）；
SPI.transfer（'\n'）；
数字写入（SS，高）；
}

我的从属代码如下：

#include <SPI.h>

byte buf[7];
volatile byte pos = 0;
volatile boolean process_it = false;

void setup() {
  Serial.begin(9600);
  pinMode(MISO,OUTPUT);
  digitalWrite(MISO,LOW);
  SPCR |= _BV(SPE); // SPI Enable, sets this Arduino to Slave
  SPCR |= _BV(SPIE); // SPI interrupt enabled
}

ISR(SPI_STC_vect) {
  // Interrupt Service Routine(SPI_(SPI Transfer Complete)_vector)
  byte c = SPDR;
  // SPDR = SPI Data Register, so you are saving the byte of information in that register to byte c
  if (pos < sizeof buf) {
    buf[pos++] = c;
    if (c == '\n') {
      process_it = true;
    }
  }
}

void loop() {
  if (process_it = true) {
    Serial.println(buf);
    pos = 0;
    process_it = false;
  }
}

#包括
字节buf[7]；
易失字节pos=0；
易失性布尔过程_it=false；
无效设置（）{
Serial.begin（9600）；
pinMode（MISO，输出）；
数字写入（味噌，低）；
SPCR |=_BV（SPE）；//SPI启用，将此Arduino设置为从属
SPCR |=_BV（SPIE）；//SPI中断已启用
}
情报、监视和侦察（SPI-STC-vect）{
//中断服务程序（SPI_（SPI传输完成）_向量）
字节c=SPDR；
//SPDR=SPI数据寄存器，因此您正在将该寄存器中的信息字节保存到字节c
如果（位置

直接的问题是Serial.print不知道如何处理字节数组。将其声明为char数组或在print语句中强制转换：

char buf[7];

或

不管怎样，它都不会像你想要的那样以浮标的形式出现

实现这一切的一种更简单的方法是使用memcpy或union在float和bytes之间来回移动。在主机端：

uint8_t buf[4];
memcpy(buf, &a, 4);

然后使用SPI发送4个字节。在外围端将其反转

---

请注意，将“\n”作为终止字节发送是一个坏主意，因为它可能会导致奇怪的行为，因为浮点中的一个字节很容易是0x0a，相当于“\n”的十六进制形式。

我知道了我需要做什么，我想发布我完成的代码。我还添加了一种传输多个浮点值的功能

大师：

#include <SPI.h>
void setup() {
  pinMode(SS,OUTPUT);
  digitalWrite(SS,HIGH);
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV4);
}

void loop() {
  digitalWrite(SS,LOW);
  float a = 2.25;
  SPI.transfer(a);
  SPI.transfer('\n');
  digitalWrite(SS,HIGH);
}

#include <SPI.h>

float a = 3.14;
float b = 2.25;
uint8_t storage [12];
float buff[2] = {a, b};
void setup()
{
  digitalWrite(SS, HIGH);
  SPI.begin();
  Serial.begin(9600);
  SPI.setClockDivider(SPI_CLOCK_DIV8);
}

void loop()
{

  digitalWrite(SS, LOW);
  memcpy(storage, &buff, 8);
  Serial.print("storage[0] = "); Serial.println(storage[0]); // the 
  following serial prints were to check i was getting the right decimal 
  numbers for the floats.
  Serial.print("storage[1] = "); Serial.println(storage[1]);
  Serial.print("storage[2] = "); Serial.println(storage[2]);
  Serial.print("storage[3] = "); Serial.println(storage[3]);
  Serial.print("storage[4] = "); Serial.println(storage[4]);
  Serial.print("storage[5] = "); Serial.println(storage[5]);
  Serial.print("storage[6] = "); Serial.println(storage[6]);
  Serial.print("storage[7] = "); Serial.println(storage[7]);
  SPI.transfer(storage, sizeof storage ); //SPI library allows a user to 
  transfer a whole array of bytes and you need to include the size of the 
  array.
  digitalWrite(SS, HIGH);
  delay(1000);
}

#包括
浮点数a=3.14；
浮动b=2.25；
uint8_t存储[12]；
浮动buff[2]={a，b}；
无效设置（）
{
数字写入（SS，高）；
SPI.begin（）；
Serial.begin（9600）；
SPI.设置时钟分配器（SPI时钟分配器8）；
}
void循环（）
{
数字写入（SS，低电平）；
memcpy（存储和buff，8）；
Serial.print（“存储[0]=”）；Serial.println（存储[0]）；//
下面的序列图是为了检查我的小数点是否正确
浮点数。
Serial.print（“存储[1]=”）；Serial.println（存储[1]）；
Serial.print（“存储[2]=”）；Serial.println（存储[2]）；
Serial.print（“存储[3]=”）；Serial.println（存储[3]）；
Serial.print（“存储[4]=”）；Serial.println（存储[4]）；
Serial.print（“存储[5]=”）；Serial.println（存储[5]）；
Serial.print（“存储[6]=”）；Serial.println（存储[6]）；
Serial.print（“存储[7]=”）；Serial.println（存储[7]）；
传输（存储，存储大小）；//SPI库允许用户
传输整个字节数组，需要包含
数组。
数字写入（SS，高）；
延迟（1000）；
}

对于我的从属代码：

#include <SPI.h>

byte storage [8];
volatile byte pos;
volatile boolean process;
float buff[2];

void setup()
{
  pinMode(MISO,OUTPUT);
  SPCR |= _BV(SPE);
  SPCR |= _BV(SPIE);
  pos = 0;
  process = false;
  Serial.begin(9600);

}

ISR(SPI_STC_vect)
{
  byte gathered = SPDR;
  if( pos < sizeof storage)
    {
      storage[pos++] = gathered;
    }
    else 
    process = true;
}

void loop()
{
  if( process )
  {
    Serial.print("storage[0] = "); Serial.println(storage[0]);
    Serial.print("storage[1] = "); Serial.println(storage[1]);
    Serial.print("storage[2] = "); Serial.println(storage[2]);
    Serial.print("storage[3] = "); Serial.println(storage[3]);
    Serial.print("storage[4] = "); Serial.println(storage[4]);
    Serial.print("storage[5] = "); Serial.println(storage[5]);
    Serial.print("storage[6] = "); Serial.println(storage[6]);
    Serial.print("storage[7] = "); Serial.println(storage[7]);
    memcpy(buff,&storage,8);
    Serial.print("This is buff[0]");Serial.println(buff[0]);
    Serial.print("This is buff[1]");Serial.println(buff[1]);
    storage[pos] = 0;
    pos = 0;
    process = false;


  }
}

#包括
字节存储[8]；
易失字节位置；
易变布尔过程；
浮动增益[2]；
无效设置（）
{
pinMode（MISO，输出）；
SPCR |=_BV（SPE）；
SPCR |=_BV（SPIE）；
pos=0；
过程=假；
Serial.begin（9600）；
}
情报、监视和侦察（SPI-STC-vect）
{
字节=SPDR；
如果（位置<存储大小）
{
存储[pos++]=已收集；
}
其他的
过程=真；
}
void循环（）
{
if（流程）
{
Serial.print（“存储[0]=”）；Serial.println（存储[0]）；
Serial.print（“存储[1]=”）；Serial.println（存储[1]）；
Serial.print（“存储[2]=”）；Serial.println（存储[2]）；
Serial.print（“存储[3]=”）；Serial.println（存储[3]）；
Serial.print（“存储[4]=”）；Serial.println（存储[4]）；
Serial.print（“存储[5]=”）；Serial.println（存储[5]）；
Serial.print（“存储[6]=”）；Serial.println（存储[6]）；
Serial.print（“存储[7]=”）；Serial.println（存储[7]）；
memcpy（buff和storage，8）；
Serial.print（“这是buff[0]”）；Serial.println（buff[0]）；
Serial.print（“这是buff[1]”）；Serial.println（buff[1]）；
存储位置=0；
pos=0；
过程=假；
}
}

将浮点值粘贴在缓冲区中，并通过SPI发送字节。在接收端，将字节读入一个字符数组，并以浮点形式读取。我不知道如何实现你告诉我的内容。我查阅了命令和它们的含义，但我本身并不知道它应该是什么样子或工作原理。我可以扩展您告诉我的内容，以便稍后传输浮点数组吗？我很抱歉评论这么晚，因为学校让我很忙。