How to best use SPI (master/slave)?

Question

This is a follow/new insight regarding my previous question Messages for SPI protocol.

One idea from that question is to use the SS line to know a new message is being sent from the master to the slave. The master will be the STM32 and the slave the Arduino, see below:

  Slave   <---  Master
 Arduino  (SPI) STM32
   |            ^ ^ ^
   V            | | |
RS485/DMX512   3x UART/MIDI

The Master receives MIDI signals from various sources, processes them, transmits (changed) MIDI messages back and sends SPI messages to the Arduino which sends the DMX signals.

So far so good, I am currently implementing the Arduino code (including a Windows test application).

The reason I use an Arduino for RS485/DMX is mainly because I couldn't get it to work on an STM32, but also to relieve the STM32 processing power.

However, I need more SRAM on the Arduino, so I will use a SPI SRAM chip (32K256). The problem is, that I'm not sure if I can let the Arduino be the slave.

SPI RAM 32K256
    |(SPI)
    V
   Slave   <---  Master
  Arduino  (SPI) STM32
    |            ^ ^ ^
    V            | | |
RS485/DMX512     3x UART/MIDI

Some things I considered:

• Making the Arduino the Master, and poll to the STM32 (resulting in my useless poll events likely).
• Keeping the STM32 master and when a send fails to retry.
• Using I2C but I think SPI is easier to implement.

Afaik the communication needs to be completely synchronous, but I'm not sure if there is some 'relaxation' due to buffers inside the SPI peripherals.

Some more background information about the entire project:

• The STM32 read inputs from various MIDI inputs (synthesizers mainly)
• At a later stage I might also add other inputs (non MIDI).
• The STM32 processes these messages and sends out MIDI messages and commands for the Arduino slave.
• The Arduino slave processes the messages which can be something like (make all front DMX lights fade in and out between red and blue, make lights X and Y green, switch on stroboscope with speed 50, etc). These messages all have the same length (18 bytes).
• For each DMX light (17 so far, but can increase in future), I have a class (instance) that keeps information (max 64 bytes) per light, this will not fit in an Arduino, so I use external SRAM.
• As often as possible (but at least every few ms), the Arduino processes a light, by reading its data from the SRAM, and changing the fade colors, and also processes new commands from the master if there are any. And finally saving back the changed data to SRAM.

Any insights would be helpful.

Answer 1

Making the Arduino the Master, and poll to the STM32 (resulting in my useless poll events likely)

Perhaps you can have an extra "interrupt" line from the STM32 to the Arduino to signal when data is available. It could directly trigger an interrupt on the Arduino.

^{simulate this circuit – Schematic created using CircuitLab}

If you have fixed size data packets, the STM32 SPI+DMA peripherals can handle SPI slave traffic autonomously, without any CPU intervention after the interrupt line is triggered (OK, the signal must be reset eventually, a DMA transfer complete interrupt, or a one-shot timer can do that).