Teensy 3.1 - SPI - Master Tx - Slave Rx

Status
Not open for further replies.

Fluffy

Member
Hey guys,

So I've been stuck on this issue for quite a while. I've been trying to figure out how this library works:
HTML:
https://github.com/btmcmahan/Teensy-3.0-SPI-Master---Slave

I found a few issues with the header and found a solution here:
HTML:
https://github.com/soerup/Teensy-3.0-SPI-Master---Slave/commit/18efd0fbef6a444e74da32d6bd09aa28adf8a97e

I ran the following code on my master:
Code:
#include <t3spi.h>

//Initialize T3SPI class as SPI_MASTER
T3SPI SPI_MASTER;

//The number of integers per data packet
#define dataLength 256

//Initialize the arrays for outgoing data
//volatile uint8_t  data[dataLength] = {}; 
volatile uint16_t data[dataLength] = {}; 


void setup(){
  
  Serial.begin(115200);
  
  //Begin SPI in MASTER (SCK pin, MOSI pin, MISO pin, CS pin, Active State)
  SPI_MASTER.begin_MASTER(SCK, MOSI, MISO, CS1, CS_ActiveLOW);
  
  //Set the CTAR (CTARn, Frame Size, SPI Mode, Shift Mode, Clock Divider) 
  //SPI_MASTER.setCTAR(CTAR1,8,SPI_MODE0,LSB_FIRST,SPI_CLOCK_DIV4);
  SPI_MASTER.setCTAR(CTAR0,16,SPI_MODE0,LSB_FIRST,SPI_CLOCK_DIV2);
  
  //Populate data array 
  for (int i=0; i<dataLength; i++){
    data[i]=i;}

  //Wait for Slave
  delay(5000);
}

void loop(){
  
  //Capture the time before sending data
  SPI_MASTER.timeStamp1 = micros();

  //Send n number of data packets
  for (int i=0; i<1; i++) {
  
    //Send data (data array, data array length, CTARn, CS pin)
    //SPI_MASTER.tx8(data, dataLength,CTAR1,CS1);}  
    SPI_MASTER.tx16(data, dataLength,CTAR0,CS1);}
    
  //Capture the time when transfer is done
  SPI_MASTER.timeStamp2 = micros();
  
  //Print data sent & data received
  for (int i=0; i<dataLength; i++){
    Serial.print("data[");
    Serial.print(i);
    Serial.print("]: ");
    Serial.println(data[i]);
    Serial.flush();}

    //Print statistics for the previous transfer
    SPI_MASTER.printStatistics(dataLength);
  
  //Reset the packet count 
  SPI_MASTER.packetCT=0;
  
  delay(2000);
}

Ran this in the slave:
Code:
#include <t3spi.h>
 
//Initialize T3SPI class as SPI_SLAVE
T3SPI SPI_SLAVE;
 
//The number of integers per data packet
//MUST be the same as defined on the MASTER device
#define dataLength  256
 
//Initialize the arrays for incoming data
//volatile uint8_t data[dataLength] = {};
volatile uint16_t data[dataLength] = {};
 
 
void setup(){
 
  Serial.begin(115200);
 
  //Begin SPI in SLAVE (SCK pin, MOSI pin, MISO pin, CS pin)
  SPI_SLAVE.begin_SLAVE(SCK, MOSI, MISO, CS0);
 
  //Set the CTAR0_SLAVE0 (Frame Size, SPI Mode)
  //SPI_SLAVE.setCTAR_SLAVE(8, SPI_MODE0);
  SPI_SLAVE.setCTAR_SLAVE(16, SPI_MODE0);
 
  //Enable the SPI0 Interrupt
  NVIC_ENABLE_IRQ(IRQ_SPI0);
 
}
 
void loop(){
 
  //Capture the time before receiving data
  if (SPI_SLAVE.dataPointer==0 && SPI_SLAVE.packetCT==0){
    SPI_SLAVE.timeStamp1=micros();}  
 
  //Capture the time when transfer is done
  if (SPI_SLAVE.packetCT==1){
    SPI_SLAVE.timeStamp2=micros();
 
    //Print data received & data sent
    for (int i=0; i<dataLength; i++){
      Serial.print("data[");
      Serial.print(i);
      Serial.print("]: ");
      Serial.println(data[i]);
      Serial.flush();}
 
      //Print statistics for the previous transfer
      SPI_SLAVE.printStatistics(dataLength);
   
    //Reset the packet count  
    SPI_SLAVE.packetCT=0;}
}
 
//Interrupt Service Routine to handle incoming data
void spi0_isr(void){
 
  //Function to handle data
  //SPI_SLAVE.rx8 (data, dataLength);
  SPI_SLAVE.rx16(data, dataLength);
}

Got this in the serial monitor:
data[0]: 36555
data[1]: 36555
data[2]: 36555
data[3]: 36555
...
data[255]: 36555

SPIO_MCR: 00000000000000000000000000000000
SPIO_CTAR_SLAVE: 01111000000000000000000000000000
SPI0_SR: 01000010000000000000000000000000
SPI0_RSER: 00000000000000100000000000000000
Frame Size: 16
Data Length: 256
Packets: 1
Bytes Sent: 512
Time Elapsed: 291
uSecs/Byte: 0.57
Mbps: 1.76

I expected the same data to be received in the slave, and instead, I received 36555. What am I doing wrong?
 
If you using Teensy as slave, the maximal speed is 12 MHz that is you have to use CLOCK_DIV4 for 48MHz F_BUS (96 MHz F_CPU)

can you verify the values of CLK,MOSI,MISO and CS1 (master) and CS0 (slave) and confirm that you have physical connection between those pins.
did you intentionally chose different CS pins for master and slave?

I cannot comment on functionality of library as I did not use it, but only checked the code for this reply.
 
Clock speed is set at SPI_CLOCK_DIV2 = 24 MHz
SCK is 0x0D
MOSI is 0x0B
MISO is 0x0C
CS0 is 0x01
CS1 is 0x02

These values are defined originally in the header file.


Physical connections are:
Master Slave
7 (MOSI)<---------> 7 (MOSI)
8 (MISO)<---------> 8 (MISO)
14 (SCK)<---------> 14 (SCK)
10 (SS) <---------> 10 (SS)
 
According to t3spi.cpp you should have
Code:
SCK: 0D -> pin 13
MOSI: 0B -> pin 11
MISO: 0C -> pin 12
CS0: 01 -> pin 10
CS1: 02 -> pin 9
you may have to change physical connections

as you use master ss (pin10) you should also specify CS0 in master or change connection

also use SPI_CLOCK_DIV4
to please the teensy in slave modus
(12 MHz is max spi speed in slave modus)
 
Thanks for the speedy reply!

Are there are simple examples that use the teensy SPI.h? I looked at the ones here: https://www.pjrc.com/teensy/td_libs_SPI.html
The one with the pot doesn't fit my description since I want to send data from one teensy to another teensy. If you could direct me to one of those simple examples of an SPI between two teensy, I'd be very grateful :)
 
Thanks for the speedy reply!

Are there are simple examples that use the teensy SPI.h? I looked at the ones here: https://www.pjrc.com/teensy/td_libs_SPI.html
The one with the pot doesn't fit my description since I want to send data from one teensy to another teensy. If you could direct me to one of those simple examples of an SPI between two teensy, I'd be very grateful :)

I do not have an example that uses spi.h but I posted previously a simple program that I used to communicate between two teensy
https://forum.pjrc.com/threads/27651-SPI-DMA-slave-problem?p=63408&viewfull=1#post63408
with a correction in a later post
 
I might be wrong, but I think pin 11 and 12 should be crossed.

Code:
      Master    <---------> Slave
MOSI: 11 (DOUT) <---------> 12 (DIN)
MISO: 12 (DIN)  <---------> 11 (DOUT)
SCK:  13 (SCK)  <---------> 13 (SCK)
SS:   10 (CS0)  <---------> 10 (CS0)

or with the alt pins
Code:
      Master    <---------> Slave
MOSI:  7 (DOUT) <--------->  8 (DIN)
MISO:  8 (DIN)  <--------->  7 (DOUT)
SCK:  14 (SCK)  <---------> 14 (SCK)
SS:   10 (CS0)  <---------> 10 (CS0)
 
I might be wrong, but I think pin 11 and 12 should be crossed.

Code:
      Master    <---------> Slave
MOSI: 11 (DOUT) <---------> 12 (DIN)
MISO: 12 (DIN)  <---------> 11 (DOUT)
SCK:  13 (SCK)  <---------> 13 (SCK)
SS:   10 (CS0)  <---------> 10 (CS0)

or with the alt pins
Code:
      Master    <---------> Slave
MOSI:  7 (DOUT) <--------->  8 (DIN)
MISO:  8 (DIN)  <--------->  7 (DOUT)
SCK:  14 (SCK)  <---------> 14 (SCK)
SS:   10 (CS0)  <---------> 10 (CS0)

I guess, you are wrong
MISO Master In Slave Out
MOSI Master Out Slave In

so the direct connection is correct
 
Nope, HWGuy is correct. MOSI and MISO don't appear anywhere in the chip reference, it only refers to SIN and SOUT, and I'm using pin 12 for slave input (although not "proper" SPI) in my current project.
 
Indeed HWGuy is correct. They're not labeled MISO and MOSI for exactly this reason. It would have been nice if Freescale would swap their directions in slave mode, like pretty much every other microcontroller does, but that's simply not the way Freescale made the chip.

Also, while this is probably overly obvious, I'd recommend testing first at a slow speed like 1 MBit/sec. Then try increasing the speed once it's known to be working.
 
Nope, HWGuy is correct. MOSI and MISO don't appear anywhere in the chip reference, it only refers to SIN and SOUT, and I'm using pin 12 for slave input (although not "proper" SPI) in my current project.

I just checked a pcb of mine, where three T3.1 xchange data with SPI and INDEED the data lines are crossed.
I must have seen too many SPI devices recently (sram, uSD) that are proper save devices.
Sorry.
 
Code:
data[0]: 62   returnData[0]: 0
data[1]: 63   returnData[1]: 1
data[2]: 32769   returnData[2]: 2
data[3]: 3   returnData[3]: 3
data[4]: 4   returnData[4]: 4
data[5]: 6   returnData[5]: 5
data[6]: 7   returnData[6]: 6
data[7]: 8   returnData[7]: 7
data[8]: 9   returnData[8]: 8
data[9]: 12   returnData[9]: 9
data[10]: 13   returnData[10]: 10
data[11]: 32775   returnData[11]: 11
data[12]: 15   returnData[12]: 12
data[13]: 16   returnData[13]: 13
data[14]: 17   returnData[14]: 14
data[15]: 19   returnData[15]: 15
data[16]: 23   returnData[16]: 16
data[17]: 24   returnData[17]: 17
data[18]: 25   returnData[18]: 18
data[19]: 27   returnData[19]: 19
data[20]: 28   returnData[20]: 20
data[21]: 30   returnData[21]: 21
data[22]: 31   returnData[22]: 22
data[23]: 32   returnData[23]: 23
data[24]: 33   returnData[24]: 24
data[25]: 34   returnData[25]: 25
data[26]: 35   returnData[26]: 26
data[27]: 36   returnData[27]: 27
data[28]: 37   returnData[28]: 28
data[29]: 38   returnData[29]: 29
data[30]: 39   returnData[30]: 30
data[31]: 47   returnData[31]: 31
data[32]: 63   returnData[32]: 32
data[33]: 64   returnData[33]: 33
data[34]: 65   returnData[34]: 34
data[35]: 32801   returnData[35]: 35
data[36]: 67   returnData[36]: 36
data[37]: 70   returnData[37]: 37
data[38]: 71   returnData[38]: 38
data[39]: 72   returnData[39]: 39
data[40]: 73   returnData[40]: 40
data[41]: 76   returnData[41]: 41
data[42]: 77   returnData[42]: 42
data[43]: 79   returnData[43]: 43
data[44]: 80   returnData[44]: 44
data[45]: 81   returnData[45]: 45
data[46]: 82   returnData[46]: 46
data[47]: 83   returnData[47]: 47
data[48]: 87   returnData[48]: 48
data[49]: 88   returnData[49]: 49
data[50]: 89   returnData[50]: 50
data[51]: 91   returnData[51]: 51
data[52]: 92   returnData[52]: 52
data[53]: 94   returnData[53]: 53
data[54]: 95   returnData[54]: 54
data[55]: 120   returnData[55]: 55
data[56]: 121   returnData[56]: 56
data[57]: 124   returnData[57]: 57
data[58]: 125   returnData[58]: 58
data[59]: 127   returnData[59]: 59
data[60]: 128   returnData[60]: 60
data[61]: 129   returnData[61]: 61
data[62]: 130   returnData[62]: 62
data[63]: 131   returnData[63]: 63
data[64]: 135   returnData[64]: 64
data[65]: 136   returnData[65]: 65
data[66]: 137   returnData[66]: 66
data[67]: 139   returnData[67]: 67
data[68]: 140   returnData[68]: 68
data[69]: 142   returnData[69]: 69
data[70]: 143   returnData[70]: 70
data[71]: 144   returnData[71]: 71
data[72]: 145   returnData[72]: 72
data[73]: 146   returnData[73]: 73
data[74]: 147   returnData[74]: 74
data[75]: 148   returnData[75]: 75
data[76]: 149   returnData[76]: 76
data[77]: 150   returnData[77]: 77
data[78]: 151   returnData[78]: 78
data[79]: 159   returnData[79]: 79
data[80]: 160   returnData[80]: 80
data[81]: 161   returnData[81]: 81
data[82]: 162   returnData[82]: 82
data[83]: 163   returnData[83]: 83
data[84]: 164   returnData[84]: 84
data[85]: 166   returnData[85]: 85
data[86]: 167   returnData[86]: 86
data[87]: 168   returnData[87]: 87
data[88]: 169   returnData[88]: 88
data[89]: 172   returnData[89]: 89
data[90]: 173   returnData[90]: 90
data[91]: 175   returnData[91]: 91
data[92]: 188   returnData[92]: 92
data[93]: 190   returnData[93]: 93
data[94]: 191   returnData[94]: 94
data[95]: 224   returnData[95]: 95
data[96]: 225   returnData[96]: 96
data[97]: 240   returnData[97]: 97
data[98]: 241   returnData[98]: 98
data[99]: 243   returnData[99]: 99
data[100]: 244   returnData[100]: 100
data[101]: 246   returnData[101]: 101
data[102]: 247   returnData[102]: 102
data[103]: 248   returnData[103]: 103
data[104]: 249   returnData[104]: 104
data[105]: 252   returnData[105]: 105
data[106]: 253   returnData[106]: 106
data[107]: 255   returnData[107]: 107
data[108]: 0   returnData[108]: 108
data[109]: 1   returnData[109]: 109
data[110]: 2   returnData[110]: 110
data[111]: 3   returnData[111]: 111
data[112]: 32771   returnData[112]: 112
data[113]: 7   returnData[113]: 113
data[114]: 8   returnData[114]: 114
data[115]: 9   returnData[115]: 115
data[116]: 11   returnData[116]: 116
data[117]: 14   returnData[117]: 117
data[118]: 15   returnData[118]: 118
data[119]: 24   returnData[119]: 119
data[120]: 25   returnData[120]: 120
data[121]: 28   returnData[121]: 121
data[122]: 29   returnData[122]: 122
data[123]: 32783   returnData[123]: 123
data[124]: 31   returnData[124]: 124
data[125]: 62   returnData[125]: 125
data[126]: 63   returnData[126]: 126
data[127]: 127   returnData[127]: 127
data[128]: 128   returnData[128]: 128
data[129]: 192   returnData[129]: 129
data[130]: 193   returnData[130]: 130
data[131]: 195   returnData[131]: 131
data[132]: 196   returnData[132]: 132
data[133]: 198   returnData[133]: 133
data[134]: 199   returnData[134]: 134
data[135]: 200   returnData[135]: 135
data[136]: 201   returnData[136]: 136
data[137]: 204   returnData[137]: 137
data[138]: 205   returnData[138]: 138
data[139]: 207   returnData[139]: 139
data[140]: 208   returnData[140]: 140
data[141]: 209   returnData[141]: 141
data[142]: 210   returnData[142]: 142
data[143]: 211   returnData[143]: 143
data[144]: 215   returnData[144]: 144
data[145]: 216   returnData[145]: 145
data[146]: 217   returnData[146]: 146
data[147]: 219   returnData[147]: 147
data[148]: 220   returnData[148]: 148
data[149]: 222   returnData[149]: 149
data[150]: 223   returnData[150]: 150
data[151]: 224   returnData[151]: 151
data[152]: 225   returnData[152]: 152
data[153]: 226   returnData[153]: 153
data[154]: 227   returnData[154]: 154
data[155]: 228   returnData[155]: 155
data[156]: 229   returnData[156]: 156
data[157]: 230   returnData[157]: 157
data[158]: 231   returnData[158]: 158
data[159]: 239   returnData[159]: 159
data[160]: 255   returnData[160]: 160
data[161]: 0   returnData[161]: 161
data[162]: 1   returnData[162]: 162
data[163]: 32769   returnData[163]: 163
data[164]: 3   returnData[164]: 164
data[165]: 4   returnData[165]: 165
data[166]: 6   returnData[166]: 166
data[167]: 7   returnData[167]: 167
data[168]: 8   returnData[168]: 168
data[169]: 9   returnData[169]: 169
data[170]: 12   returnData[170]: 170
data[171]: 13   returnData[171]: 171
data[172]: 32775   returnData[172]: 172
data[173]: 15   returnData[173]: 173
data[174]: 16   returnData[174]: 174
data[175]: 17   returnData[175]: 175
data[176]: 19   returnData[176]: 176
data[177]: 32779   returnData[177]: 177
data[178]: 23   returnData[178]: 178
data[179]: 24   returnData[179]: 179
data[180]: 25   returnData[180]: 180
data[181]: 32781   returnData[181]: 181
data[182]: 27   returnData[182]: 182
data[183]: 28   returnData[183]: 183
data[184]: 30   returnData[184]: 184
data[185]: 31   returnData[185]: 185
data[186]: 56   returnData[186]: 186
data[187]: 57   returnData[187]: 187
data[188]: 60   returnData[188]: 188
data[189]: 61   returnData[189]: 189
data[190]: 32799   returnData[190]: 190
data[191]: 63   returnData[191]: 191
data[192]: 64   returnData[192]: 192
data[193]: 65   returnData[193]: 193
data[194]: 32801   returnData[194]: 194
data[195]: 67   returnData[195]: 195
data[196]: 32803   returnData[196]: 196
data[197]: 71   returnData[197]: 197
data[198]: 96   returnData[198]: 198
data[199]: 97   returnData[199]: 199
data[200]: 32817   returnData[200]: 200
data[201]: 99   returnData[201]: 201
data[202]: 32819   returnData[202]: 202
data[203]: 103   returnData[203]: 203
data[204]: 108   returnData[204]: 204
data[205]: 109   returnData[205]: 205
data[206]: 32823   returnData[206]: 206
data[207]: 111   returnData[207]: 207
data[208]: 112   returnData[208]: 208
data[209]: 113   returnData[209]: 209
data[210]: 32825   returnData[210]: 210
data[211]: 115   returnData[211]: 211
data[212]: 120   returnData[212]: 212
data[213]: 121   returnData[213]: 213
data[214]: 32829   returnData[214]: 214
data[215]: 123   returnData[215]: 215
data[216]: 124   returnData[216]: 216
data[217]: 126   returnData[217]: 217
data[218]: 127   returnData[218]: 218
data[219]: 224   returnData[219]: 219
data[220]: 225   returnData[220]: 220
data[221]: 226   returnData[221]: 221
data[222]: 227   returnData[222]: 222
data[223]: 228   returnData[223]: 223
data[224]: 230   returnData[224]: 224
data[225]: 231   returnData[225]: 225
data[226]: 32887   returnData[226]: 226
data[227]: 239   returnData[227]: 227
data[228]: 240   returnData[228]: 228
data[229]: 241   returnData[229]: 229
data[230]: 243   returnData[230]: 230
data[231]: 244   returnData[231]: 231
data[232]: 246   returnData[232]: 232
data[233]: 247   returnData[233]: 233
data[234]: 248   returnData[234]: 234
data[235]: 249   returnData[235]: 235
data[236]: 252   returnData[236]: 236
data[237]: 253   returnData[237]: 237
data[238]: 255   returnData[238]: 238
data[239]: 0   returnData[239]: 239
data[240]: 1   returnData[240]: 240
data[241]: 2   returnData[241]: 241
data[242]: 3   returnData[242]: 242
data[243]: 7   returnData[243]: 243
data[244]: 8   returnData[244]: 244
data[245]: 9   returnData[245]: 245
data[246]: 11   returnData[246]: 246
data[247]: 12   returnData[247]: 247
data[248]: 14   returnData[248]: 248
data[249]: 15   returnData[249]: 249
data[250]: 24   returnData[250]: 250
data[251]: 25   returnData[251]: 251
data[252]: 28   returnData[252]: 252
data[253]: 29   returnData[253]: 253
data[254]: 31   returnData[254]: 254
data[255]: 60   returnData[255]: 255


                 33222222222211111111110000000000
                 10987654321098765432109876543210
                 --------------------------------
SPIO_MCR:        00000000000000000000000000000000
SPIO_CTAR_SLAVE: 01111000000000000000000000000000
SPI0_SR:         01000000000000000100000100000000
SPI0_RSER:       00000000000000100000000000000000
I couldn't get the Master Tx - Slave Rx to work so I tried to work on the Master RX TX and Slave RX TX example.
So this is what I'm getting from my Slave. Return data seems fine, but data sent from master is quite unpredictable.

This is the Code I'm using for the Master:
Code:
#include <t3spi.h>

//Initialize T3SPI class as SPI_MASTER
T3SPI SPI_MASTER;

//The number of integers per data packet
#define dataLength 256

//Initialize the arrays for outgoing data
//volatile uint8_t  data[dataLength] = {}; 
volatile uint16_t data[dataLength] = {}; 


//Initialize the arrays for incoming data
//volatile uint8_t returnData[dataLength] = {}; 
volatile uint16_t returnData[dataLength] = {};


void setup(){
  
  Serial.begin(115200);
  
  //Begin SPI in MASTER (SCK pin, MOSI pin, MISO pin, CS pin, Active State)
  SPI_MASTER.begin_MASTER(SCK, MOSI, MISO, CS1, CS_ActiveLOW);
  
  //Set the CTAR (CTARn, Frame Size, SPI Mode, Shift Mode, Clock Divider) 
  //SPI_MASTER.setCTAR(CTAR0,8,SPI_MODE0,LSB_FIRST,SPI_CLOCK_DIV2);
  SPI_MASTER.setCTAR(CTAR_0,16,SPI_MODE0,LSB_FIRST,SPI_CLOCK_DIV4);
  
  //Populate data array 
  for (int i=0; i<dataLength; i++){
    data[i]=i;}

  //Wait for Slave
  delay(5000);
}

void loop(){
  
  //Capture the time before sending data
  SPI_MASTER.timeStamp1 = micros();

  //Send n number of data packets
  for (int i=0; i<1; i++) {
  
    //Send data (data array, data array length, CTARn, CS pin)
    //SPI_MASTER.txrx8(data, returnData, dataLength,CTAR0,CS1);}  
    SPI_MASTER.txrx16(data, returnData, dataLength,CTAR_0,CS1);}
    
  //Capture the time when transfer is done
  SPI_MASTER.timeStamp2 = micros();
  
  //Print data sent & data received
  for (int i=0; i<dataLength; i++){
    Serial.print("data[");
    Serial.print(i);
    Serial.print("]: ");
    Serial.print(data[i]);
    Serial.print("   returnData[");
    Serial.print(i);
    Serial.print("]: ");
    Serial.println(returnData[i]);
    Serial.flush();}

    //Print statistics for the previous transfer
    SPI_MASTER.printStatistics(dataLength);
  
  //Reset the packet count 
  SPI_MASTER.packetCT=0;
  
  delay(2000);
}
This is for the Slave:
Code:
#include <t3spi.h>

//Initialize T3SPI class as SPI_SLAVE
T3SPI SPI_SLAVE;

//The number of integers per data packet
//MUST be the same as defined on the MASTER device
#define dataLength  256

//Initialize the arrays for incoming data
//volatile uint8_t data[dataLength] = {};
volatile uint16_t data[dataLength] = {};

//Initialize the arrays for outgoing data
//volatile uint8_t returnData[dataLength] = {};
volatile uint16_t returnData[dataLength] = {};


void setup(){
  
  Serial.begin(115200);
  
  //Begin SPI in SLAVE (SCK pin, MOSI pin, MISO pin, CS pin)
  SPI_SLAVE.begin_SLAVE(SCK, MOSI, MISO, CS0);
  
  //Set the CTAR0_SLAVE0 (Frame Size, SPI Mode)
  //SPI_SLAVE.setCTAR_SLAVE(8, SPI_MODE0);
  SPI_SLAVE.setCTAR_SLAVE(16, SPI_MODE0);
  
  //Enable the SPI0 Interrupt
  NVIC_ENABLE_IRQ(IRQ_SPI0);
  
  //Poputlate the array of outgoing data
  for (int i=0; i<dataLength; i++){
    returnData[i]=i;}
}

void loop(){

  //Capture the time before receiving data
  if (SPI_SLAVE.dataPointer==0 && SPI_SLAVE.packetCT==0){
    SPI_SLAVE.timeStamp1=micros();}  
 
  //Capture the time when transfer is done
  if (SPI_SLAVE.packetCT==1){
    SPI_SLAVE.timeStamp2=micros();

    //Print data received & data sent
    for (int i=0; i<dataLength; i++){
      Serial.print("data[");
      Serial.print(i);
      Serial.print("]: ");
      Serial.print(data[i]);
      Serial.print("   returnData[");
      Serial.print(i);
      Serial.print("]: ");
      Serial.println(returnData[i]);
      Serial.flush();}
  
      //Print statistics for the previous transfer
      SPI_SLAVE.printStatistics(dataLength); 
   
    //Reset the packet count   
    SPI_SLAVE.packetCT=0;}
}

//Interrupt Service Routine to handle incoming data
void spi0_isr(void){
  
  //Function to handle data
  //SPI_SLAVE.rxtx8 (data, returnData, dataLength);
  SPI_SLAVE.rxtx16(data, returnData, dataLength);
}
 
I realize this thread has been dead for quite a while, but I find myself also having to connect two Teensies via SPI. I'm using the same library, and same example code, and get connection, but (using the clock divider SPI_CLOCK_DIV4) the Slave updates post only about every 20-25 seconds--and the received data is really screwed up. Has this ever been resolved? Is there an alternative library to SPI master<->slave two Teensies? The first code segment is the serial output from the Master, followed by the serial output from the connected Slave:

Code:
data-M[250]: 250
data-M[251]: 251
data-M[252]: 252
data-M[253]: 253
data-M[254]: 254
data-M[255]: 255


                 33222222222211111111110000000000
                 10987654321098765432109876543210
                 --------------------------------
SPIO_MCR:        10000000000000010000000000000000
SPIO_CTAR0:      11111000000000000001000000000001
SPI0_SR:         01000010000000100000000001000000
SPI0_RSER:       00000000000000000000000000000000

Frame Size:      16
Data Length:     256
Packets:         1
Bytes Sent:      512
Time Elapsed:    462
uSecs/Byte:      0.90
Mbps:            1.11

Code:
data-S[250]: 3
data-S[251]: 63
data-S[252]: 7
data-S[253]: 127
data-S[254]: 15
data-S[255]: 255


                 33222222222211111111110000000000
                 10987654321098765432109876543210
                 --------------------------------
SPIO_MCR:        00000000000000000000000000000000
SPIO_CTAR_SLAVE: 01111000000000000000000000000000
SPI0_SR:         01000010000000000000000000000011
SPI0_RSER:       00000000000000100000000000000000

Frame Size:      16
Data Length:     256
Packets:         1
Bytes Sent:      512
Time Elapsed:    804739337
uSecs/Byte:      1571756.50
Mbps:            0.00
 
theres a SPI master/slave library that takes advantage of the slave’s peripheral ports and supports 2-way communication callbacks, I actually had it tested once with one master and 2 slaves and it was running both fine

2x slave, 1 master, 24mhz transfers — https://www.youtube.com/watch?v=xD9TTK5cL6g

you can search the forum for SPI_MSTransfer, teensy 3.2/3.5/3.6 supported
 
Status
Not open for further replies.
Back
Top