Bus SPI en el PLC Raspberry de Industrial Shields

1. Introducción
   
2. Requisitos
3. El protocolo SPI
4. Ventajas y desventajas
5. Conexiones SPI típicas
6. Hardware
7. Software
   
8. Ejemplo "Echo"
   

Opción 1) Si es una conexión en la que hay que conectar pocos esclavos, se debe usar el esquema de conexión en paralelo:

Se necesita una línea SS (Slave Select) adicional por cada dispositivo esclavo conectado, para seleccionar el dispositivo con el que se debe comunicar.

Opción 2) La conexión anterior tiene el inconveniente de requerir una línea por cada dispositivo esclavo. Si hay muchos esclavos, puede no ser práctica, por lo que se puede adoptar una conexión en cascada, en la que cada esclavo transmite los datos al siguiente:

Por otro lado, en esta configuración la información debe llegar a todos los esclavos para que la comunicación termine, por eso, en general, la velocidad de respuesta del bus es menor que en la primera configuración.

Todos los controladores lógicos programables de Industrial Shields tienen los pines SO, SI y SCK. Consulta el manual de usuario de tu versión de PLC industrial para ver dónde están estos pines. Consulta también el capítulo Pinout del manual de usuario para ver cuántos pines se pueden usar como SS (Slave Select). Aquí tienes el ejemplo del controlador Raspberry 58+ PLC, escogiendo el pin GPIO8 como SS:

Para usar el puerto SPI en la Raspberry podemos usar la biblioteca de Python Adafruit-Blinka, que contiene elementos de alto nivel y controladores de bajo nivel para interactuar con la interfaz SPI.

Funciones SPI básicas:

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.

Si quieres cambiar ajustes como la velocidad de reloj, la fase o la polaridad:

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

Sin embargo, como cada dispositivo tiene una trama de datos específica,  normalmente no deberíamos usar estas funciones directamente, y el uso del bus SPI se hace de forma indirecta a través de la biblioteca del componente utilizado. Por suerte, existen muchas bibliotecas envoltorio (wrapper) para chips SPI compatibles con la biblioteca Adafruit-Blinka. Puedes encontrarlas buscando tu módulo concreto.

Un "echo" es básicamente un programa que recibe una entrada, la procesa de algún modo y devuelve esa misma entrada. Se usa habitualmente como programa de prueba básico para comprobar que la comunicación entre dos dispositivos funciona correctamente.

En este ejemplo, el Raspberry PLC será el maestro y el M-Duino será el esclavo:

Script de Python para la Raspberry:

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()

Programa para el M-Duino:

#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);
  }
}

Si ejecutamos estos dos programas, conectando ambos PLC como hemos visto en la opción 1, veremos que el Raspberry PLC siempre recibe el carácter '0'.