Arduino.ru

код слейва я выше привёл

 

 

мастер:

      digitalWrite(SS, LOW);
      SPI.transfer(0x01);
      delay(10);

      int sendToSlaveOne[] = {2,6,0,1};  // mode, val1, val2, val3

      for (unsigned int i=0; i < sizeof(sendToSlaveOne); i++)
      {
          int ints = sendToSlaveOne[i];
          SPI.transfer(ints);
      }

      int back = SPI.transfer(0xAF);
      
      SPI.endTransaction();

      delay(10);

      String message = String("Back Data = ");
      message += String(back);
      Serial.println(message);

      digitalWrite(SS, HIGH);

 

со строкой 

int back = SPI.transfer(0xAF);

я чего только не пробовал - нужен, в принципе,  массив int, но корректно работает только byte.

 

 

  

 

спасибо, код понятен, но опять я не нашёл ответа.  Вы слейву посылаете строку, получаете байт.  Это понятно.  С этим нет вопросов.  Меня интересует механика именно получения от слейва массива.  Как это происходит?  Должен ли я на стороне слейва разбирать массив (например - int[]) на байты и пересылать их по одному по нескольким единичным запросам от мастера, чтобы потом на стороне мастера опять эти байты собрать в интеджеры, а те, соответственно, - в массив?

Побайтно.

 

Ситуация, когда у мастера есть для отправки, например, пять байт, а ожидает он от слейва - двести, тут не рассматривается?  Нет, правда, спасибо, я понял Ваш код, я думал - есть варианты, когда по одному запросу приходит некоторый объём данных (желательно не-фиксированной длины).

вот, не могу найти где глючит. :-(  

 

проблемы: почему-то первый байт приходит вместо 0 - 116 и откуда-то берётся запрос на 9й пересылаемый байт.  Мастер посылает только 8 запросов SPI.transfer(0x16), но слейв откуда-то берёт 9й. :-( 

 

Мастер:

 

#include <Arduino.h>
#include "SPI.h"

// --------------- пара кнопок -----------------
const byte buttonUp = 11;
byte buttonStateUp = 0;
byte buttonStateFlagUp = 0;

const byte buttonDown = 12;
byte buttonStateDown = 0;
byte buttonStateFlagDown = 0;
//----------------------------------------------


const byte intDataArrSize = 4;            // длина int-массива
int recivedFromSlave[intDataArrSize];     // массив данных от сенсоров слейва
int sendToSlaveOne[] = {2009,6,0,-2321};  // данные для отсылки слейву


void setup (void)
{
  Serial.begin(115200);

  pinMode(buttonUp,INPUT);
  pinMode(buttonDown,INPUT);

  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV8);
  digitalWrite(SS,HIGH);

  recivedFromSlave[0] = 19;
  recivedFromSlave[1] = 622;
  recivedFromSlave[2] = -10;
  recivedFromSlave[3] = 32000;

  // смотрим, что в int-массиве от слейва при инициализации
  String message = String("init data (INT) = ");
  for (byte i=0; i<intDataArrSize; i++)
  {
    if (i>0) message += String(", ");
    message += String(recivedFromSlave[i]);
  }
  Serial.println(message);
}


void examButtons()            // опрашиваем кнопки
{
    byte buttons[] = {buttonUp, buttonDown};
    byte *states[] = {&buttonStateUp, &buttonStateDown};
    byte *flags[] = {&buttonStateFlagUp, &buttonStateFlagDown};

    byte buttonState = 0;

    for (byte i=0; i<sizeof(buttons); i++)
    {
      buttonState = digitalRead(buttons[i]);
      if(buttonState == HIGH)
      {
        *states[i] = 1;
      } else {
        *states[i] = 0;
        *flags[i] = 0;
      }
    }
}

void sendData() {

      digitalWrite(SS, LOW);
      SPI.transfer(0x01);     // инициируем отсылку
      delay(10);

      for (unsigned int i=0; i < sizeof(sendToSlaveOne); i++)
      {
          int ints = sendToSlaveOne[i];
          SPI.transfer(ints);
      }

      byte recivedArr[sizeof(recivedFromSlave)];            // byte-массив для данных от слейва
      for (byte ii=0; ii<sizeof(recivedFromSlave); ii++)
      {
        recivedArr[ii] = SPI.transfer(0x16);    // маркер запроса байта данных от слейва

        // проверяем, что пришло
        String message = String("recivedArr[" + String(ii) + "] = ");
        message += String(recivedArr[ii]);
        Serial.println(message);

        delay(5);
      }

      SPI.transfer(0xAF);             // маркер конца пакета данных

      SPI.endTransaction();
      digitalWrite(SS, HIGH);

      byte ii=0;
      for (byte i=0; i<intDataArrSize; i++)
      {
        recivedFromSlave[i] = recivedArr[ii+1] | (recivedArr[ii]<<8);
        ii = ii+2;
      }

      // смотрим, что в int-массиве от слейва
      String message = String("back data (INT) = ");
      for (byte i=0; i<intDataArrSize; i++)
      {
        if (i>0) message += String(", ");
        message += String(recivedFromSlave[i]);
      }
      Serial.println(message);
}



void loop(void)
{
  examButtons();

  if (buttonStateUp==1)
  {
    if (buttonStateFlagUp == 0)
    {
      buttonStateFlagUp = 1;
      sendData();
    }
  }
}

Слейв:

#include <Arduino.h>
#include "SPI.h"


const byte intDataArrSize = 4;                    // длина int-массива
int dataFromSensors[] = {0,0,0,0};                // рабочий массив
byte sendDataToMaster[sizeof(dataFromSensors)];   // массив для передачи
byte sCur = 0;                                    // курсор передачи
byte bCur = 0;                                    // курсор буфера

volatile bool newDataFlag = false;              // флаг готовности новых данных от мастера

#define BUFFER_SIZE 50
char buffer[BUFFER_SIZE];         // буфер для данных от мастера



void makeDataToMaster()                        // конвертируем рабочий int-массив в byte-массив для передачи
{
  byte ii=0;
  for (byte i=0; i<intDataArrSize;i++)
  {
    sendDataToMaster[ii] = highByte(dataFromSensors[i]);
    ii++;
    sendDataToMaster[ii] = lowByte(dataFromSensors[i]);
    ii++;
  }
}


void setup()
{
  Serial.begin(115200);
  pinMode(MISO,OUTPUT);                   //Sets MISO as OUTPUT (Have to Send data to Master IN
  SPCR |= _BV(SPE);                       //Turn on SPI in Slave Mode
  SPI.attachInterrupt();                  //Interuupt ON is set for SPI commnucation

  // имитация сбора данных от сенсоров
  dataFromSensors[0] = 48;
  dataFromSensors[1] = -2001;
  dataFromSensors[2] = 99;
  dataFromSensors[3] = 21;
}




ISR (SPI_STC_vect)
{
  byte byteFromMaster = SPDR;

  if (bCur < sizeof(buffer)) {
          buffer[bCur++] = byteFromMaster;
          if (byteFromMaster == 0xAF)         // конец пакета
          {
              newDataFlag = true;          // данные от мастера обновлены
              sCur = 0;
          }

          if (byteFromMaster == 0x16)     // запрос мастера на отправку массива
          {
                if (sCur == 0)            // начало отправки массива мастеру
                {
                  makeDataToMaster();     // готовим массив для отправки мастеру
                }

                SPDR = sendDataToMaster[sCur];
                // проверяем, что послали
                String message = String("sent: ") + String(sendDataToMaster[sCur]) + String(" (sendDataToMaster[") + String(sCur) + String("])");
                Serial.println(message);

                sCur++;
          }
      }
}


void loop()
{
  if(newDataFlag)             // обрабатываем полученное от мастера
  {
    newDataFlag = false;      // ждём новый пакет от мастера
  }
}

вот итог:

байты	уходят от слейва	приходят к мастеру
0	0	116
1	48	48
2	248	248
3	47	47
4	0	0
5	99	99
6	0	0
7	21	21
8	8