Bus SPI on PLC Raspberry from Industrial Shields

1. Introduction
   
2. Requirements
3. The SPI Protocol
4. Advantages and Disadvantages
5. Typical SPI connections
6. Hardware
7. Software
   
8. "Echo" example
   

Option 1) If it is a connection where few slaves have to be connected, the parallel connection scheme should be used:

An additional SS (Slave Select) line is required for each slave device connected, to select the device with which communication has to be made.

Option 2) This previous connection has the disadvantage of requiring a line for each slave device. In the case of having many slave devices, this may not be practical, so it is possible to adopt a cascade connection, where each slave transmits data to the next one:

On the other hand, in this configuration the information must reach all the slaves so that the communication is terminated, that is why, in general, the bus response speed is lower than in the first configuration.

Every Industrial Shields programmable logic controller has the SO, SI and SCK pins. Check the User Manual of your industrial PLC version to see where these pins are located. Also, check the Pinout chapter of the User Manual to see how many pins can be used as SS (Slave Select). Here you have the Raspberry 58+ PLC controller example, picking up the GPIO8 pin as SS:

To use the SPI port on Raspberry we can use the Python library Adafruit-Blinka, which contains high-level elements and low-level drivers to interact with the SPI interface.

Basic SPI functions:

spi = board.SPI()       # Creates an SPI object to interact with the bus
spi.try_lock()          # Tries to get control of the SPI bus    
spi.write(write_buff)   # Sends the data through the bus
spi.readinto(read_buff) # If anything was received, it will put it in the read buffer
                        # if not, it will zero it.
# Both write_buff and read_buff must be of "byte" types.

If you want to change settings like clock speed, phase or polarity:

spi.configure(100000, 0, 0) # speed, phase and polarity
                            # By default, clock normally low-rising edge

However, being that each device has an specific data frame,  we normally shouldn't use these functions directly, and our use of the SPI bus is carried out indirectly through the library of the component used. Luckily, there are a lot of wrapper libraries for SPI chips that are compatible with the Adafruit-Blinka library. You can found them searching for your specific module.

An "echo" is essentially a program that takes in some input, processes it in some way, and then outputs that same input. It's commonly used as a basic test program to make sure that communication is working correctly between two devices.

In this example, the Raspberry PLC will be the master and the M-Duino will be the slave:

Raspberry Python script:

import board
import digitalio
spi = board.SPI()  # uses SPI0 default pins
cs = digitalio.DigitalInOut(board.CE0) # select chip, GPIO8 by default

try:
    spi.unlock() # first unlock if SPI is being used by other programs
except ValueError:
    print("SPI not locked, proceeding to lock")
while not spi.try_lock():
    pass
spi.configure(100000) # change sclk frequency

try:
    write_buff = bytearray(b'0')
    while True:
        cs.value = False # select the chip
        read_buff = bytearray(1)
        spi.write(write_buff)
        spi.readinto(read_buff)
        if (read_buff != write_buff):
            print("Expected {}, but received {}" \
                  .format(write_buff, read_buff))
        else:
            print("Sent correctly")
        cs.value = True # de-select the chip
        time.sleep(1)

except KeyboardInterrupt:  # unlock the spi bus when ctrl-c'ing out of the loop
    print("Unlocking SPI bus and exiting...")
    spi.unlock()

M-Duino program:

#include  <SPI.h>

volatile boolean received;
volatile byte receivedData;
ISR (SPI_STC_vect) {     // Interrupt routine function
  receivedData = SPDR;   // Get the received data from SPDR register
  received = true;       // Sets received as True 
}

void setup() {
  Serial.begin(115200);
  pinMode(MISO,OUTPUT);   //Sets MISO as OUTPUT
  SPCR |= _BV(SPE);       //Turn on SPI in Slave Mode
  received = false;
  SPCR |= _BV(SPIE);
}

void loop() { 
  if(received) {                        
    SPDR = receivedData;    // send back the received data
    received = false;
    Serial.println((char) receivedData);
  }
}

If we run these two programs, connecting both PLCs as we seen before in option 1, we will see that the Raspberry PLC is always receiving the character '0'.