ESP32 S2 Dev SAOLA: SPI for two devices one is SD and EPaper

[Lakshminarauyana]

Hello guys ,

i am trying to use SPI for two devices  one is SD card and other is E-paper display.

when i try to implement two devices on two different bus i dont get the good result. but i tested the individual devices on the SPI bus its works when connected to (SPI bus : Sck-36,Miso-37,Mosi-35,SS-34)

But now i want to connect SD card on (SPI bus : Sck-36,Miso-37,Mosi-35,SS-34) and E-paper display(SPI bus : Sck-12,Miso-13,Mosi-11,SS-10)

from the below code sometime Sd card is detected and some time the E-paper display gives some rubbish images(not as intended).

So could anyone tell what is tat wrong i am doing in initializing the SPI Bus over Arduino.

As i want to use OTG in th applications as well.

Could anyone please provide me an insight to the problem i am facing.

 

Please find the code attached below

#include "RTClib.h"
#include "Wire.h"
#include "SHT31.h"
#include <GxEPD.h>
#include <GxGDEW075T7/GxGDEW075T7.h> // 7.5″ b/w 800×480
#include GxEPD_BitmapExamples

// FreeFonts from Adafruit_GFX
#include <Fonts/FreeMonoBold9pt7b.h>
#include <Fonts/FreeMonoBold12pt7b.h>
#include <Fonts/FreeMonoBold18pt7b.h>
#include <Fonts/FreeMonoBold24pt7b.h>

#include <GxIO/GxIO_SPI/GxIO_SPI.h>
#include <GxIO/GxIO.h>

#include "FS.h"
#include "SD.h"
#include "SPI.h"

#define LED_BUILTIN 3
#define SHT31_ADDRESS 0x44

#define SD_CS_PIN 34
#define SD_MOSI_PIN 35
#define SD_SCK_PIN 36
#define SD_MISO_PIN 37
/*SPI bus*/
SPIClass fspi = SPIClass(FSPI);

GxIO_Class io(fspi, /*CS=5*/10, /*DC=*/44, /*RST=*/43); // arbitrary selection of 17, 16
GxEPD_Class display(io, /*RST=*/43, /*BUSY=*/39); // arbitrary selection of (16), 4

RTC_DS1307 rtc;

char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday",
		"Thursday", "Friday", "Saturday" };

uint32_t start;
uint32_t stop;

SHT31 sht;
DateTime now;
void showBitmapExample() {
	const GFXfont *f = &FreeMonoBold9pt7b;
	display.fillScreen(GxEPD_WHITE);
	display.setTextColor(GxEPD_BLACK);
	display.setFont(f);
	display.setCursor(50, 50);
	display.println(now.year());
	display.println(sht.getTemperature());
	display.println("dfsafdjhgjfjsdfhDFKH");

// listDir(SD, "/", 0);
// createDir(SD, "/mydir");
// listDir(SD, "/", 0);
// removeDir(SD, "/mydir");
// listDir(SD, "/", 2);
// writeFile(SD, "/hello.txt", "Hello ");
// appendFile(SD, "/hello.txt", "World!\n");
// readFile(SD, "/hello.txt");
// deleteFile(SD, "/foo.txt");
// renameFile(SD, "/hello.txt", "/foo.txt");
// readFile(SD, "/foo.txt");
// testFileIO(SD, "/test.txt");
// display.setCursor(100, 100);
// display.println(SD.totalBytes() / (1024 * 1024));
// display.println(SD.usedBytes() / (1024 * 1024));
// delay(100);
#if defined(__AVR)
display.drawExampleBitmap(BitmapExample1, sizeof(BitmapExample1));
#else
	display.drawExampleBitmap(BitmapExample1, sizeof(BitmapExample1));
	delay(2000);
	display.drawExampleBitmap(BitmapExample2, sizeof(BitmapExample2));
	delay(5000);
	display.drawExampleBitmap(BitmapExample3, sizeof(BitmapExample1));
	delay(2000);
	display.drawExampleBitmap(BitmapExample4, sizeof(BitmapExample2));
	delay(5000);
	display.fillScreen(GxEPD_WHITE);
	display.drawExampleBitmap(BitmapExample1, 0, 0, GxEPD_WIDTH, GxEPD_HEIGHT,
			GxEPD_BLACK);
	display.update();
#endif
}

void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {
	Serial.printf("Listing directory: %s\n", dirname);

	File root = fs.open(dirname);
	if (!root) {
		Serial.println("Failed to open directory");
		return;
	}
	if (!root.isDirectory()) {
		Serial.println("Not a directory");
		return;
	}

	File file = root.openNextFile();
	while (file) {
		if (file.isDirectory()) {
			Serial.print(" DIR : ");
			Serial.println(file.name());
// if(levels){
// listDir(fs, file.path(), levels -1);
// }
		} else {
			Serial.print(" FILE: ");
			Serial.print(file.name());
			Serial.print(" SIZE: ");
			Serial.println(file.size());
		}
		file = root.openNextFile();
	}
}

void createDir(fs::FS &fs, const char *path) {
	Serial.printf("Creating Dir: %s\n", path);
	if (fs.mkdir(path)) {
		Serial.println("Dir created");
	} else {
		Serial.println("mkdir failed");
	}
}

void removeDir(fs::FS &fs, const char *path) {
	Serial.printf("Removing Dir: %s\n", path);
	if (fs.rmdir(path)) {
		Serial.println("Dir removed");
	} else {
		Serial.println("rmdir failed");
	}
}

void readFile(fs::FS &fs, const char *path) {
	Serial.printf("Reading file: %s\n", path);

	File file = fs.open(path);
	if (!file) {
		Serial.println("Failed to open file for reading");
		return;
	}

	Serial.print("Read from file: ");
	while (file.available()) {
		Serial.write(file.read());
	}
	file.close();
}

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

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

void appendFile(fs::FS &fs, const char *path, const char *message) {
	Serial.printf("Appending to file: %s\n", path);

	File file = fs.open(path, FILE_APPEND);
	if (!file) {
		Serial.println("Failed to open file for appending");
		return;
	}
	if (file.print(message)) {
		Serial.println("Message appended");
	} else {
		Serial.println("Append failed");
	}
	file.close();
}

void renameFile(fs::FS &fs, const char *path1, const char *path2) {
	Serial.printf("Renaming file %s to %s\n", path1, path2);
	if (fs.rename(path1, path2)) {
		Serial.println("File renamed");
	} else {
		Serial.println("Rename failed");
	}
}

void deleteFile(fs::FS &fs, const char *path) {
	Serial.printf("Deleting file: %s\n", path);
	if (fs.remove(path)) {
		Serial.println("File deleted");
	} else {
		Serial.println("Delete failed");
	}
}

void testFileIO(fs::FS &fs, const char *path) {
	File file = fs.open(path);
	static uint8_t buf[512];
	size_t len = 0;
	uint32_t start = millis();
	uint32_t end = start;
	if (file) {
		len = file.size();
		size_t flen = len;
		start = millis();
		while (len) {
			size_t toRead = len;
			if (toRead > 512) {
				toRead = 512;
			}
			file.read(buf, toRead);
			len -= toRead;
		}
		end = millis()
		– start;
		Serial.printf("%u bytes read for %u ms\n", flen, end);
		file.close();
	} else {
		Serial.println("Failed to open file for reading");
	}

	file = fs.open(path, FILE_WRITE);
	if (!file) {
		Serial.println("Failed to open file for writing");
		return;
	}

	size_t i;
	start = millis();
	for (i = 0; i < 2048; i++) {
		file.write(buf, 512);
	}
	end = millis()
	– start;
	Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
	file.close();
}
void setup() {
//fspi.begin(12,13,11,10);
// initialize built in LED pin as an output.
	pinMode(LED_BUILTIN, OUTPUT);
// initialize USB serial converter so we have a port created
	Serial.begin(115200);
	if (!rtc.begin()) {
		Serial.println("Couldn't find RTC");
		Serial.flush();
//abort();
	}
	if (!rtc.isrunning()) {
		Serial.println("RTC is NOT running, let's set the time!");
// When time needs to be set on a new device, or after a power loss, the
// following line sets the RTC to the date & time this sketch was compiled
		rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
		rtc.adjust(DateTime(2022, 1, 04, 10, 15, 0));
	}
	Wire.begin();
	sht.begin(SHT31_ADDRESS);
	Wire.setClock(100000);

	uint16_t stat = sht.readStatus();
	Serial.print(stat, HEX);
	Serial.println();

	if (!SD.begin()) {
		Serial.println("Card Mount Failed");
		return;
	}

	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);
//
// listDir(SD, "/", 0);
// createDir(SD, "/mydir");
// listDir(SD, "/", 0);
// removeDir(SD, "/mydir");
// listDir(SD, "/", 2);
// writeFile(SD, "/hello.txt", "Hello ");
// appendFile(SD, "/hello.txt", "World!\n");
// readFile(SD, "/hello.txt");
// deleteFile(SD, "/foo.txt");
// renameFile(SD, "/hello.txt", "/foo.txt");
// readFile(SD, "/foo.txt");
// testFileIO(SD, "/test.txt");
// Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
// Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
	delay(1000);
	display.init(0); // enable diagnostic output on Serial
}

// the loop function runs over and over again forever
void loop() {

	Serial.println("Hello world");
	digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
	delay(1000); // wait for a second
	digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
	delay(1000);

	DateTime now = rtc.now();

	Serial.print(now.year(), DEC);
	Serial.print('/');
	Serial.print(now.month(), DEC);
	Serial.print('/');
	Serial.print(now.day(), DEC);
	Serial.print(" (");
	Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
	Serial.print(") ");
	Serial.print(now.hour(), DEC);
	Serial.print(':');
	Serial.print(now.minute(), DEC);
	Serial.print(':');
	Serial.print(now.second(), DEC);
	Serial.println();

	Serial.print(" since midnight 1/1/1970 = ");
	Serial.print(now.unixtime());
	Serial.print("s = ");
	Serial.print(now.unixtime() / 86400L);
	Serial.println("d");

// calculate a date which is 7 days, 12 hours, 30 minutes, and 6 seconds into the future
	DateTime future(now + TimeSpan(7, 12, 30, 6));

	Serial.print(" now + 7d + 12h + 30m + 6s: ");
	Serial.print(future.year(), DEC);
	Serial.print('/');
	Serial.print(future.month(), DEC);
	Serial.print('/');
	Serial.print(future.day(), DEC);
	Serial.print(' ');
	Serial.print(future.hour(), DEC);
	Serial.print(':');
	Serial.print(future.minute(), DEC);
	Serial.print(':');
	Serial.print(future.second(), DEC);
	Serial.println();

	Serial.println();
	delay(3000); // wait for a second
	start = micros();
	sht.read(); // default = true/fast slow = false
	stop = micros();

	Serial.print("\t");
	Serial.print(stop – start);
	Serial.print("\t");
	Serial.print(sht.getTemperature(), 1);
	Serial.print("\t");
	Serial.println(sht.getHumidity(), 1);
	delay(100);
	display.drawExampleBitmap(BitmapExample1, sizeof(BitmapExample1));
	delay(2000);
	showBitmapExample();
	delay(2000);
}

// the setup function runs once when you press reset or power the board
#include "RTClib.h"
#include "Wire.h"
#include "SHT31.h"
#include <GxEPD.h>
#include <GxGDEW075T7/GxGDEW075T7.h> // 7.5″ b/w 800×480
#include GxEPD_BitmapExamples

// FreeFonts from Adafruit_GFX
#include <Fonts/FreeMonoBold9pt7b.h>
#include <Fonts/FreeMonoBold12pt7b.h>
#include <Fonts/FreeMonoBold18pt7b.h>
#include <Fonts/FreeMonoBold24pt7b.h>

#include <GxIO/GxIO_SPI/GxIO_SPI.h>
#include <GxIO/GxIO.h>

#include "FS.h"
#include "SD.h"
#include "SPI.h"

#define LED_BUILTIN 3
#define SHT31_ADDRESS 0x44

#define SD_CS_PIN 34
#define SD_MOSI_PIN 35
#define SD_SCK_PIN 36
#define SD_MISO_PIN 37
/*SPI bus*/
SPIClass fspi = SPIClass(FSPI);

GxIO_Class io(fspi, /*CS=5*/10, /*DC=*/44, /*RST=*/43); // arbitrary selection of 17, 16
GxEPD_Class display(io, /*RST=*/43, /*BUSY=*/39); // arbitrary selection of (16), 4

RTC_DS1307 rtc;

char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday",
		"Thursday", "Friday", "Saturday" };

uint32_t start;
uint32_t stop;

SHT31 sht;
DateTime now;
void showBitmapExample() {
	const GFXfont *f = &FreeMonoBold9pt7b;
	display.fillScreen(GxEPD_WHITE);
	display.setTextColor(GxEPD_BLACK);
	display.setFont(f);
	display.setCursor(50, 50);
	display.println(now.year());
	display.println(sht.getTemperature());
	display.println("dfsafdjhgjfjsdfhDFKH");

// listDir(SD, "/", 0);
// createDir(SD, "/mydir");
// listDir(SD, "/", 0);
// removeDir(SD, "/mydir");
// listDir(SD, "/", 2);
// writeFile(SD, "/hello.txt", "Hello ");
// appendFile(SD, "/hello.txt", "World!\n");
// readFile(SD, "/hello.txt");
// deleteFile(SD, "/foo.txt");
// renameFile(SD, "/hello.txt", "/foo.txt");
// readFile(SD, "/foo.txt");
// testFileIO(SD, "/test.txt");
// display.setCursor(100, 100);
// display.println(SD.totalBytes() / (1024 * 1024));
// display.println(SD.usedBytes() / (1024 * 1024));
// delay(100);
#if defined(__AVR)
display.drawExampleBitmap(BitmapExample1, sizeof(BitmapExample1));
#else
	display.drawExampleBitmap(BitmapExample1, sizeof(BitmapExample1));
	delay(2000);
	display.drawExampleBitmap(BitmapExample2, sizeof(BitmapExample2));
	delay(5000);
	display.drawExampleBitmap(BitmapExample3, sizeof(BitmapExample1));
	delay(2000);
	display.drawExampleBitmap(BitmapExample4, sizeof(BitmapExample2));
	delay(5000);
	display.fillScreen(GxEPD_WHITE);
	display.drawExampleBitmap(BitmapExample1, 0, 0, GxEPD_WIDTH, GxEPD_HEIGHT,
			GxEPD_BLACK);
	display.update();
#endif
}

void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {
	Serial.printf("Listing directory: %s\n", dirname);

	File root = fs.open(dirname);
	if (!root) {
		Serial.println("Failed to open directory");
		return;
	}
	if (!root.isDirectory()) {
		Serial.println("Not a directory");
		return;
	}

	File file = root.openNextFile();
	while (file) {
		if (file.isDirectory()) {
			Serial.print(" DIR : ");
			Serial.println(file.name());
// if(levels){
// listDir(fs, file.path(), levels -1);
// }
		} else {
			Serial.print(" FILE: ");
			Serial.print(file.name());
			Serial.print(" SIZE: ");
			Serial.println(file.size());
		}
		file = root.openNextFile();
	}
}

void createDir(fs::FS &fs, const char *path) {
	Serial.printf("Creating Dir: %s\n", path);
	if (fs.mkdir(path)) {
		Serial.println("Dir created");
	} else {
		Serial.println("mkdir failed");
	}
}

void removeDir(fs::FS &fs, const char *path) {
	Serial.printf("Removing Dir: %s\n", path);
	if (fs.rmdir(path)) {
		Serial.println("Dir removed");
	} else {
		Serial.println("rmdir failed");
	}
}

void readFile(fs::FS &fs, const char *path) {
	Serial.printf("Reading file: %s\n", path);

	File file = fs.open(path);
	if (!file) {
		Serial.println("Failed to open file for reading");
		return;
	}

	Serial.print("Read from file: ");
	while (file.available()) {
		Serial.write(file.read());
	}
	file.close();
}

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

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

void appendFile(fs::FS &fs, const char *path, const char *message) {
	Serial.printf("Appending to file: %s\n", path);

	File file = fs.open(path, FILE_APPEND);
	if (!file) {
		Serial.println("Failed to open file for appending");
		return;
	}
	if (file.print(message)) {
		Serial.println("Message appended");
	} else {
		Serial.println("Append failed");
	}
	file.close();
}

void renameFile(fs::FS &fs, const char *path1, const char *path2) {
	Serial.printf("Renaming file %s to %s\n", path1, path2);
	if (fs.rename(path1, path2)) {
		Serial.println("File renamed");
	} else {
		Serial.println("Rename failed");
	}
}

void deleteFile(fs::FS &fs, const char *path) {
	Serial.printf("Deleting file: %s\n", path);
	if (fs.remove(path)) {
		Serial.println("File deleted");
	} else {
		Serial.println("Delete failed");
	}
}

void testFileIO(fs::FS &fs, const char *path) {
	File file = fs.open(path);
	static uint8_t buf[512];
	size_t len = 0;
	uint32_t start = millis();
	uint32_t end = start;
	if (file) {
		len = file.size();
		size_t flen = len;
		start = millis();
		while (len) {
			size_t toRead = len;
			if (toRead > 512) {
				toRead = 512;
			}
			file.read(buf, toRead);
			len -= toRead;
		}
		end = millis()
		– start;
		Serial.printf("%u bytes read for %u ms\n", flen, end);
		file.close();
	} else {
		Serial.println("Failed to open file for reading");
	}

	file = fs.open(path, FILE_WRITE);
	if (!file) {
		Serial.println("Failed to open file for writing");
		return;
	}

	size_t i;
	start = millis();
	for (i = 0; i < 2048; i++) {
		file.write(buf, 512);
	}
	end = millis()
	– start;
	Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
	file.close();
}
void setup() {
//fspi.begin(12,13,11,10);
// initialize built in LED pin as an output.
	pinMode(LED_BUILTIN, OUTPUT);
// initialize USB serial converter so we have a port created
	Serial.begin(115200);
	if (!rtc.begin()) {
		Serial.println("Couldn't find RTC");
		Serial.flush();
//abort();
	}
	if (!rtc.isrunning()) {
		Serial.println("RTC is NOT running, let's set the time!");
// When time needs to be set on a new device, or after a power loss, the
// following line sets the RTC to the date & time this sketch was compiled
		rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
		rtc.adjust(DateTime(2022, 1, 04, 10, 15, 0));
	}
	Wire.begin();
	sht.begin(SHT31_ADDRESS);
	Wire.setClock(100000);

	uint16_t stat = sht.readStatus();
	Serial.print(stat, HEX);
	Serial.println();

	if (!SD.begin()) {
		Serial.println("Card Mount Failed");
		return;
	}

	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);
//
// listDir(SD, "/", 0);
// createDir(SD, "/mydir");
// listDir(SD, "/", 0);
// removeDir(SD, "/mydir");
// listDir(SD, "/", 2);
// writeFile(SD, "/hello.txt", "Hello ");
// appendFile(SD, "/hello.txt", "World!\n");
// readFile(SD, "/hello.txt");
// deleteFile(SD, "/foo.txt");
// renameFile(SD, "/hello.txt", "/foo.txt");
// readFile(SD, "/foo.txt");
// testFileIO(SD, "/test.txt");
// Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
// Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
	delay(1000);
	display.init(0); // enable diagnostic output on Serial
}

// the loop function runs over and over again forever
void loop() {

	Serial.println("Hello world");
	digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
	delay(1000); // wait for a second
	digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
	delay(1000);

	DateTime now = rtc.now();

	Serial.print(now.year(), DEC);
	Serial.print('/');
	Serial.print(now.month(), DEC);
	Serial.print('/');
	Serial.print(now.day(), DEC);
	Serial.print(" (");
	Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
	Serial.print(") ");
	Serial.print(now.hour(), DEC);
	Serial.print(':');
	Serial.print(now.minute(), DEC);
	Serial.print(':');
	Serial.print(now.second(), DEC);
	Serial.println();

	Serial.print(" since midnight 1/1/1970 = ");
	Serial.print(now.unixtime());
	Serial.print("s = ");
	Serial.print(now.unixtime() / 86400L);
	Serial.println("d");

// calculate a date which is 7 days, 12 hours, 30 minutes, and 6 seconds into the future
	DateTime future(now + TimeSpan(7, 12, 30, 6));

	Serial.print(" now + 7d + 12h + 30m + 6s: ");
	Serial.print(future.year(), DEC);
	Serial.print('/');
	Serial.print(future.month(), DEC);
	Serial.print('/');
	Serial.print(future.day(), DEC);
	Serial.print(' ');
	Serial.print(future.hour(), DEC);
	Serial.print(':');
	Serial.print(future.minute(), DEC);
	Serial.print(':');
	Serial.print(future.second(), DEC);
	Serial.println();

	Serial.println();
	delay(3000); // wait for a second
	start = micros();
	sht.read(); // default = true/fast slow = false
	stop = micros();

	Serial.print("\t");
	Serial.print(stop – start);
	Serial.print("\t");
	Serial.print(sht.getTemperature(), 1);
	Serial.print("\t");
	Serial.println(sht.getHumidity(), 1);
	delay(100);
	display.drawExampleBitmap(BitmapExample1, sizeof(BitmapExample1));
	delay(2000);
	showBitmapExample();
	delay(2000);
}

[Renzo Mischianti]

Hi Lakshminarauyana,
I think It’s more complex the problem, from here It seems that the spi pins can be changed only via begin.

But when you declare GxIO

GxIO_Class io(fspi, /*CS=5*/10, /*DC=*/44, /*RST=*/43); // arbitrary selection of 17, 16

evenif you declare CS pin, inside It start spi with begin() standard parameter.

void GxIO_SPI::init()
{
  if (_cs >= 0)
  {
    digitalWrite(_cs, HIGH);
    pinMode(_cs, OUTPUT);
  }
  if (_dc >= 0)
  {
    digitalWrite(_dc, HIGH);
    pinMode(_dc, OUTPUT);
  }
  if (_rst >= 0)
  {
    digitalWrite(_rst, HIGH);
    pinMode(_rst, OUTPUT);
  }
  if (_bl >= 0)
  {
    digitalWrite(_bl, HIGH);
    pinMode(_bl, OUTPUT);
  }
  reset();
  _spi.begin();
}

but this command start SPI with standard pins

void SPIClass::begin(int8_t sck, int8_t miso, int8_t mosi, int8_t ss)
{
    if(_spi) {
        return;
    }

    if(!_div) {
        _div = spiFrequencyToClockDiv(_freq);
    }

    _spi = spiStartBus(_spi_num, _div, SPI_MODE0, SPI_MSBFIRST);
    if(!_spi) {
        return;
    }

    if(sck == -1 && miso == -1 && mosi == -1 && ss == -1) {
#if CONFIG_IDF_TARGET_ESP32S2
        _sck = (_spi_num == FSPI) ? SCK : -1;
        _miso = (_spi_num == FSPI) ? MISO : -1;
        _mosi = (_spi_num == FSPI) ? MOSI : -1;
        _ss = (_spi_num == FSPI) ? SS : -1;
#elif CONFIG_IDF_TARGET_ESP32C3
        _sck = SCK;
        _miso = MISO;
        _mosi = MOSI;
        _ss = SS;
#else
        _sck = (_spi_num == VSPI) ? SCK : 14;
        _miso = (_spi_num == VSPI) ? MISO : 12;
        _mosi = (_spi_num == VSPI) ? MOSI : 13;
        _ss = (_spi_num == VSPI) ? SS : 15;
#endif
    } else {
        _sck = sck;
        _miso = miso;
        _mosi = mosi;
        _ss = ss;
    }

    spiAttachSCK(_spi, _sck);
    spiAttachMISO(_spi, _miso);
    spiAttachMOSI(_spi, _mosi);

}

I don’t know if can solve but try to change void GxIO_SPI::init() by pass the sck, miso, mosi, ss parameter.

Bye Renzo

[Author]

Posts