How to work with the 3 SPI buses in parallel?

[yanshay]

I'm developing with Rust on the ESP32-2432S028R.

What I noticed is that the TFT, Touch and SDCard all use SPI, but on separate busses (so different Mosi/Miso/Sck).
I got each one separately working and two together, but how can I use all three together when the ESP32 supports only two HW SPI? I believe that's doable, as I've seen a project that seem to be doing it, but couldn't track all the libraries and how it is done exactly.
I need the TFT and touch working and from time to time to access the SD-Card.

Since Rust is all about safety it puts all kinds of constraints on simultaneously using the HW, but I'm trying to figure out how it's done in C++ and then search for a way to adapt it to Rust.

[DoctorU]

I'm also trying to do this, so I'll update you once I succeed!

Can you just create separate SPIClass instances?

I currently have TFT_eSPI (which creates in SPIClass instance called spi) and Touch, using my custom SPIClass tsSpi = SPIClass(VSPI);

[DoctorU]

So, I think there's two possible routes.

1. Software SPI. https://github.com/niteris/ArduinoSoftSpi
2. use the two available SPI interfaces sparingly. In the case of running TFT, SD and Touch together, I'm leaning towards SPI2 for the program-synchronous tasks (TFT, SD) and SPI3 for the asynchronous ones (i.e., an unexpected touch event from a user). I'm not sure if this will even work, though... 😬

[DoctorU]

Esp32 did suggest that it's OK to use regular GPIO pins for SPI, with a timing penalty.

https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/peripherals/spi_master.html#gpio-matrix-and-io-mux

[DoctorU]

I've tried it this morning, and it just works!

// note:TFT_eSPI creates spi(HSPI) 
SPIClass sdSpi = SPIClass(VSPI); // SD uses default VSPI pins
SPIClass touchSpi = SPIClass(); // esp32 seems to support software SPI. COOL! 

Then specify the correct PICO/POCI/CS/CLK pins in the begin statements (see PINS.md and OTHER examples).

[DoctorU]

I've tried it: it just works!

// note:TFT_eSPI creates instance spi = SPIClass(HSPI)
SPIClass sdSpi = SPIClass(VSPI); // SD uses default VSPI pins
SPIClass touchSpi = SPIClass(); // esp32 seems to support software SPI. COOL! 

Then specify the correct PICO/POCI/CS/CLK pins in the begin statements (see PINS.md and OTHER examples).

[dOpesen]

Hi DoctorU,

i am trying to get it to work, but i am really lost to know what to do exactly.

i also want to run tft, touch and sd at the same time, but it crashes if i want to write on sd, so i think it has to do with spi.

i have now this:

// Touchscreen pins
#define XPT2046_IRQ 36 // T_IRQ
#define XPT2046_MOSI 32 // T_DIN
#define XPT2046_MISO 39 // T_OUT
#define XPT2046_CLK 25 // T_CLK
#define XPT2046_CS 33 // T_CS

SPIClass touchscreenSPI = SPIClass();
TFT_eSPI tft = TFT_eSPI(HSPI);
SPIClass sdSpi = SPIClass(VSPI); // using the standard VSPI pins

Now you are writing that i have to specify the correct PICO/POCI/CS/CLK in the begi, statements, but i am lost here.

which pins i need to specify to get it to work?

Thanks.

[Wires2005]

Hi dOpesen,

I've been struggling with this for a while too. Could only have touch or sd working but not both.
Finally found a way around it this evening.
Note: I'm barely more than a beginner so this may not be very elegant and may be bad practice...but it seems to be working.

Instead of using XPT2046_Touchscreen.h, use the XPT2046_Bitbang_Slim library by Claus Naveke. This operates a softwware SPI bus for the touchscreen so that VSPI is free for the SD card. From what I've been able to find out the issue is that the touch controller and sd card are on different GPIO. Ideally you want them on the same GPIO but with different chip select lines so they could share the same bus. I read a post elsewhere detailing a mod where the tf slot pins were lifted and wired to the touch controller GPIO pins. I guess that would work but I didn't feel like trying that unless there was no other option. This mod would however free up some GPIO if your project needed it, so that's interesting.

I've picked out the below lines out of my project because I've got a bunch of lvgl and I2C stuff in there that's irrelevant, I think this is all you need.

#include <TFT_eSPI.h>
#include <SD.h>
#include <SPI.h>
#include <XPT2046_Bitbang.h>

#define XPT2046_IRQ 36
#define XPT2046_MOSI 32
#define XPT2046_MISO 39
#define XPT2046_CLK 25
#define XPT2046_CS 33

SPIClass sdSpi = SPIClass(VSPI);
XPT2046_Bitbang ts = XPT2046_Bitbang(XPT2046_MOSI, XPT2046_MISO, XPT2046_CLK, XPT2046_CS);
TFT_eSPI tft = TFT_eSPI();

void setup() {
  ts.begin();
  tft.begin();
  if (!SD.begin()) {
    Serial.println("SD not ready");
  }
  // Print some data to serial as confirmation the card is addressable.
  uint8_t cardType = SD.cardType();
  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }
  Serial.print("SD Card Type: ");
  if (cardType == CARD_MMC) {
    Serial.println("MMC");
  } else if (cardType == CARD_SD) {
    Serial.println("SDSC");
  } else if (cardType == CARD_SDHC) {
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);
}

My touch coordinates are passed to lvgl in the below function, but bear in mind there's no touch calibration and I might have to add that once I've used it for a while to see how it responds....so YMMV.

/*Read the touchpad*/
void my_touchpad_read(lv_indev_drv_t *indev_drv, lv_indev_data_t *data) {
  TouchPoint touch = ts.getTouch();
  if (touch.zRaw >= 500) {   // Was registering phantum touches with a z value around 200.
    //Map this to the pixel position
    data->point.x = map(touch.xRaw, touchScreenMinimumX, touchScreenMaximumX, 1, screenWidth);  /* Touchscreen X calibration */
    data->point.y = map(touch.yRaw, touchScreenMinimumY, touchScreenMaximumY, 1, screenHeight); /* Touchscreen Y calibration */
    data->state = LV_INDEV_STATE_PR;

    Serial.print("Touch x ");
    Serial.print(data->point.x);
    Serial.print(" y ");
    Serial.print(data->point.y);
    Serial.print(" z ");
    Serial.println(touch.zRaw);
  } else {
    data->state = LV_INDEV_STATE_REL;
  }
}

[dOpesen]

Hi Wires2005,

thanks for your input and your little "workaround".

Also on my side it is now working, i just make a little change and it is running with XPT2046_Touchscreen.h.

#include <TFT_eSPI.h>
#include <XPT2046_Touchscreen.h>
#include <FS.h>
#include <SD.h>
#include <SPI.h>

// Touchscreen pins
#define XPT2046_IRQ 36 // T_IRQ
#define XPT2046_MOSI 32 // T_DIN
#define XPT2046_MISO 39 // T_OUT
#define XPT2046_CLK 25 // T_CLK
#define XPT2046_CS 33 // T_CS

SPIClass touchscreenSPI = SPIClass();
TFT_eSPI tft = TFT_eSPI();                          // i just erase the "HSPI" in the ()
SPIClass sdSpi = SPIClass(VSPI);
XPT2046_Touchscreen touchscreen(XPT2046_CS, XPT2046_IRQ);

// SD Card Write Function

void writeFile(fs::FS &fs, char * path, char * message) {
  Serial.printf("Writing file: %s\n", path);

  File tempsettxt = fs.open(path, FILE_WRITE);
  if (!tempsettxt) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (tempsettxt.print(message)) {
    Serial.println("File written");
  } else {
    tempsettxt.println("Write failed");
  }
  tempsettxt.close();
} 

void setup() {

  tft.setRotation(1); 
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  touchscreenSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  touchscreen.begin(touchscreenSPI);
  touchscreen.setRotation(1);
  tft.fillScreen(TFT_BLACK);

  // SD Card begin/check

   if (!SD.begin(SS, sdSpi, 80000000)) {   // here is important to match sdSpi with "SPIClass sdSpi = SPIClass(VSPI);"
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();

  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }

And for SD card reading i'am using:

File filerlftoff = SD.open("/rlftoff.txt", "r");   

  String fCVrlftoff = "";          // declare String variable             

  while ( filerlftoff.available() ) {           
    fCVrlftoff += (char)filerlftoff.read();        // read Data on SD in String
  }
  rlftoff = fCVrlftoff.toFloat();                   // convert Stringdata to float (if needed)
  filerlftoff.close();

void loop() { ... }

Perhaps it helps too,

Greetings

[TheNitek]

One of your SPI devices is not going to work properly. The ESP32 only support 2 SPI bus (on the CYD they all use different ones), so if you need to use 3 buses, you have use a software implementation for one of them (for performance reasons touch makes the most sense)

[dOpesen]

Hi TheNitek,

yes, you are right, my solution is not good, it runs without any issues till now, but it is not the best way to go with it.

I am a beginner and i have tried to read and to understand how to use software implemenation for one of these SPI busses, but i failed in the first tries.

Perhaps you can give me a helping hand and/or recommend me a good documentation for better understandings what i have to do?

Would be great.

[HamidRezaKarimiS]

Hi,
I do something to solve this issue.
I hope it be useful.
https://github.com/HamidRezaKarimiS/CYD-ESP32-2432S028R--001

[clach04]

The link above doesn't match the text, copy/ paste https://github.com/HamidRezaKarimiS/CYD-ESP32-2432S028R--001