#include <SPI.h>

#define CS 10

void setup() {
  char buffer[] = "Uryyb, FCV! ";

  Serial.begin(115200);
  pinMode(CS, OUTPUT);

  // Transacción SPI: envía el contenido del búfer y lo sobrescribe con los datos recibidos.
  digitalWrite(CS, LOW);
  SPI.begin();
  SPI.transfer(buffer, strlen(buffer));
  SPI.end();
  digitalWrite(CS, HIGH);

  Serial.println("Datos recibidos desde el SPI:");
  Serial.println(buffer);
}

void loop() {
}


spi-chip-example.ino

diagram.json

// Ejemplo de chip SPI personalizado de Wokwi
//
// Este chip implementa un cifrado de sustitución de letras ROT13 simple.
// Recibe una cadena a través de SPI y devuelve la misma cadena con
// cada carácter alfabético reemplazado con su sustitución ROT13.
//
//
// SPDX-License-Identifier: MIT
// Copyright (C) 2023 Ulises Ale / wokwi.com

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct {
  pin_t    cs_pin;
  uint32_t spi;
  uint8_t  spi_buffer[1];
} chip_state_t;

static void chip_pin_change(void *user_data, pin_t pin, uint32_t value);
static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count);

void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));
  
  chip->cs_pin = pin_init("CS", INPUT_PULLUP);

  const pin_watch_config_t watch_config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };
  pin_watch(chip->cs_pin, &watch_config);

  const spi_config_t spi_config = {
    .sck = pin_init("SCK", INPUT),
    .miso = pin_init("MISO", INPUT),
    .mosi = pin_init("MOSI", INPUT),
    .done = chip_spi_done,
    .user_data = chip,
  };
  chip->spi = spi_init(&spi_config);
  
  printf("SPI Chip inicializado!\n");

}

uint8_t rot13(uint8_t value) {
  const uint8_t ROT = 13;
  if(value >= 'A' && value <='Z') {
    return (value + ROT) <= 'Z' ? value + ROT : value - ROT;
  }
  if(value >= 'a' && value <= 'z') {
    return (value + ROT) <= 'z' ? value + ROT : value - ROT;
  }
  return value;
}

void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;
  // Handle CS pin logic
  if (pin == chip->cs_pin) {
    if (value == LOW) {
      printf("SPI chip seleccionado\n");
      chip->spi_buffer[0] = ' '; // Algunos datos ficticios para el primer carácter
      spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    } else {
      printf("SPI chip no seleccionado\n");
      spi_stop(chip->spi);
    }
  }
}

void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
  chip_state_t *chip = (chip_state_t*)user_data;
  if (!count) {    
  // Esto significa que llegamos aquí desde spi_stop y no se recibieron datos
    return;
  }

  // Aplicar la transformación ROT13 y almacenar el resultado en el búfer.
  // El resultado se volverá a leer durante la próxima transferencia SPI.
  buffer[0] = rot13(buffer[0]);

  if (pin_read(chip->cs_pin) == LOW) {
    // Continuar con el siguiente personaje
    spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
  }
}
