ESP32 HSPI and VSPI Conflict

flyingrock · April 2, 2025, 9:08am

Good Morning,

I am new to ESP32S3 I am currently trying to get my board which has an integrated LCD to use both HSPI and VSPI.

The issue I am having is that when I am using one or the other I am able to get no issues. But when I try to use both HSPI and VSPI simultaneously I am having issues with the LCD display (The display shows up with static...).

My question is what could be causing this issue?

The code is as follows

#include "Display_ST7789.h"
#include "LVGL_Driver.h"
//#include "RGB_lamp.h"
#include "ui.h"
#include <SPI.h>


// =============================================
// Hardware Configuration
// =============================================
#define ADF_SCLK   14  // HSPI SCK (MUST be 14)
#define ADF_MOSI   13  // HSPI MOSI (MUST be 13)
#define ADF_MISO   12  // HSPI MISO (optional)
#define ADF_CS     15  // HSPI CS (recommended)
#define ADF_LE     3   // Latch Enable
#define ADF_CE     1   // Chip Enable
#define ADF_LD     5   // Lock Detect

SPIClass adf_spi(HSPI);  // Dedicated HSPI instance

// =============================================
// ADF4351 Register Values
// =============================================
const uint32_t ADF4351_Registers[6] = {
  0x00400000,  // Register 0
  0x8008011,   // Register 1
  0x004E42,    // Register 2
  0x0004B3,    // Register 3
  0x0DC80FC,   // Register 4
  0x0580005    // Register 5
};


void setup() {
  Serial.begin(115200);
  while (!Serial);

  // Initialize LCD (uses VSPI)
  LCD_Init();
  delay(100);
  Set_Backlight(90);
  
  
  // PROPER ADF4351 INITIALIZATION
  Serial.println("Initializing ADF4351 HSPI");
  
  // Initialize control pins
  pinMode(ADF_LE, OUTPUT);
  pinMode(ADF_CE, OUTPUT);
  digitalWrite(ADF_LE, HIGH);
  digitalWrite(ADF_CE, LOW);  // Enable chip

  // Initialize HSPI with CORRECT pins
  Serial.println("HSPI Pins:");
  Serial.printf("SCK: %d, MOSI: %d, CS: %d\n", ADF_SCLK, ADF_MOSI, ADF_CS);
  
  adf_spi.begin(ADF_SCLK, ADF_MISO, ADF_MOSI, ADF_CS);
  pinMode(ADF_CS, OUTPUT);
  digitalWrite(ADF_CS, HIGH);  // Start with CS high

  // Test SPI communication
  Serial.println("Testing SPI...");
  uint8_t test_byte = 0;
  adf_spi.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  digitalWrite(ADF_CS, LOW);
  test_byte = adf_spi.transfer(0x55);  // Test pattern
  digitalWrite(ADF_CS, HIGH);
  adf_spi.endTransaction();
  Serial.printf("SPI test returned: 0x%02X\n", test_byte);

  writeAllRegisters(); // Program ADF4351
  Serial.println("System Initialized");
}

// =============================================
//  Register Writing Functions
// =============================================
void writeRegister(uint32_t value) {
  Serial.printf("Writing: 0x%08X\n", value);
  
  uint8_t bytes[4] = {
    (uint8_t)(value >> 24),
    (uint8_t)(value >> 16),
    (uint8_t)(value >> 8),
    (uint8_t)(value & 0xFF)
  };

  // Use adf_spi instance (not global SPI)
  adf_spi.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  digitalWrite(ADF_CS, LOW);
  
  for (int i = 0; i < 4; i++) {
    adf_spi.transfer(bytes[i]);
    Serial.printf("  Byte %d: 0x%02X\n", i, bytes[i]);
    delayMicroseconds(5);  // Small delay between bytes
  }
  
  digitalWrite(ADF_CS, HIGH);
  adf_spi.endTransaction();

  // Latch data
  digitalWrite(ADF_LE, LOW);
  delayMicroseconds(1);
  digitalWrite(ADF_LE, HIGH);
  Serial.println("  Latched");
}

void writeAllRegisters() {
  Serial.println("\nProgramming ADF4351:");
  for (int i = 5; i >= 0; i--) {
    writeRegister(ADF4351_Registers[i]);
    delay(10);
  }
  Serial.println("Programming Complete");
}

Display_ST7789.cpp

#include "Display_ST7789.h"

SPIClass LCDspi(FSPI);
#define SPI_WRITE(_dat)         LCDspi.transfer(_dat)
#define SPI_WRITE_Word(_dat)    LCDspi.transfer16(_dat)
void SPI_Init()
{
  LCDspi.begin(EXAMPLE_PIN_NUM_SCLK,EXAMPLE_PIN_NUM_MISO,EXAMPLE_PIN_NUM_MOSI); 
}

void LCD_WriteCommand(uint8_t Cmd)  
{ 
  LCDspi.beginTransaction(SPISettings(SPIFreq, MSBFIRST, SPI_MODE0));
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, LOW);  
  digitalWrite(EXAMPLE_PIN_NUM_LCD_DC, LOW); 
  SPI_WRITE(Cmd);
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, HIGH);  
  LCDspi.endTransaction();
}
void LCD_WriteData(uint8_t Data) 
{ 
  LCDspi.beginTransaction(SPISettings(SPIFreq, MSBFIRST, SPI_MODE0));
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, LOW);  
  digitalWrite(EXAMPLE_PIN_NUM_LCD_DC, HIGH);  
  SPI_WRITE(Data);  
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, HIGH);  
  LCDspi.endTransaction();
}    
void LCD_WriteData_Word(uint16_t Data)
{
  LCDspi.beginTransaction(SPISettings(SPIFreq, MSBFIRST, SPI_MODE0));
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, LOW);  
  digitalWrite(EXAMPLE_PIN_NUM_LCD_DC, HIGH); 
  SPI_WRITE_Word(Data);
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, HIGH);  
  LCDspi.endTransaction();
}   
void LCD_WriteData_nbyte(uint8_t* SetData,uint8_t* ReadData,uint32_t Size) 
{ 
  LCDspi.beginTransaction(SPISettings(SPIFreq, MSBFIRST, SPI_MODE0));
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, LOW);  
  digitalWrite(EXAMPLE_PIN_NUM_LCD_DC, HIGH);  
  LCDspi.transferBytes(SetData, ReadData, Size);
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, HIGH);  
  LCDspi.endTransaction();
} 

void LCD_Reset(void)
{
  digitalWrite(EXAMPLE_PIN_NUM_LCD_CS, LOW);       
  delay(50);
  digitalWrite(EXAMPLE_PIN_NUM_LCD_RST, LOW); 
  delay(50);
  digitalWrite(EXAMPLE_PIN_NUM_LCD_RST, HIGH); 
  delay(50);
}
void LCD_Init(void)
{
  pinMode(EXAMPLE_PIN_NUM_LCD_CS, OUTPUT);
  pinMode(EXAMPLE_PIN_NUM_LCD_DC, OUTPUT);
  pinMode(EXAMPLE_PIN_NUM_LCD_RST, OUTPUT); 
  Backlight_Init();
  SPI_Init();

  LCD_Reset();
  //************* Start Initial Sequence **********// 
  LCD_WriteCommand(0x11);
  delay(120);
  LCD_WriteCommand(0x36);
  if (HORIZONTAL)
      LCD_WriteData(0x00);
  else
      LCD_WriteData(0x70);

  LCD_WriteCommand(0x3A);
  LCD_WriteData(0x05);

  LCD_WriteCommand(0xB0);
  LCD_WriteData(0x00);
  LCD_WriteData(0xE8);
  
  LCD_WriteCommand(0xB2);
  LCD_WriteData(0x0C);
  LCD_WriteData(0x0C);
  LCD_WriteData(0x00);
  LCD_WriteData(0x33);
  LCD_WriteData(0x33);

  LCD_WriteCommand(0xB7);
  LCD_WriteData(0x35);

  LCD_WriteCommand(0xBB);
  LCD_WriteData(0x35);

  LCD_WriteCommand(0xC0);
  LCD_WriteData(0x2C);

  LCD_WriteCommand(0xC2);
  LCD_WriteData(0x01);

  LCD_WriteCommand(0xC3);
  LCD_WriteData(0x13);

  LCD_WriteCommand(0xC4);
  LCD_WriteData(0x20);

  LCD_WriteCommand(0xC6);
  LCD_WriteData(0x0F);

  LCD_WriteCommand(0xD0);
  LCD_WriteData(0xA4);
  LCD_WriteData(0xA1);

  LCD_WriteCommand(0xD6);
  LCD_WriteData(0xA1);

  LCD_WriteCommand(0xE0);
  LCD_WriteData(0xF0);
  LCD_WriteData(0x00);
  LCD_WriteData(0x04);
  LCD_WriteData(0x04);
  LCD_WriteData(0x04);
  LCD_WriteData(0x05);
  LCD_WriteData(0x29);
  LCD_WriteData(0x33);
  LCD_WriteData(0x3E);
  LCD_WriteData(0x38);
  LCD_WriteData(0x12);
  LCD_WriteData(0x12);
  LCD_WriteData(0x28);
  LCD_WriteData(0x30);

  LCD_WriteCommand(0xE1);
  LCD_WriteData(0xF0);
  LCD_WriteData(0x07);
  LCD_WriteData(0x0A);
  LCD_WriteData(0x0D);
  LCD_WriteData(0x0B);
  LCD_WriteData(0x07);
  LCD_WriteData(0x28);
  LCD_WriteData(0x33);
  LCD_WriteData(0x3E);
  LCD_WriteData(0x36);
  LCD_WriteData(0x14);
  LCD_WriteData(0x14);
  LCD_WriteData(0x29);
  LCD_WriteData(0x32);

  LCD_WriteCommand(0x21);

  LCD_WriteCommand(0x11);
  delay(120);
  LCD_WriteCommand(0x29); 
}
/******************************************************************************
function: Set the cursor position
parameter :
    Xstart:   Start uint16_t x coordinate
    Ystart:   Start uint16_t y coordinate
    Xend  :   End uint16_t coordinates
    Yend  :   End uint16_t coordinatesen
******************************************************************************/
void LCD_SetCursor(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t  Yend)
{ 
  if (HORIZONTAL) {
    // set the X coordinates
    LCD_WriteCommand(0x2A);
    LCD_WriteData(Xstart >> 8);
    LCD_WriteData(Xstart + Offset_X);
    LCD_WriteData(Xend >> 8);
    LCD_WriteData(Xend + Offset_X);
    
    // set the Y coordinates
    LCD_WriteCommand(0x2B);
    LCD_WriteData(Ystart >> 8);
    LCD_WriteData(Ystart + Offset_Y);
    LCD_WriteData(Yend >> 8);
    LCD_WriteData(Yend + Offset_Y);
  }
  else {
    // set the X coordinates
    LCD_WriteCommand(0x2A);
    LCD_WriteData(Ystart >> 8);
    LCD_WriteData(Ystart + Offset_Y);
    LCD_WriteData(Yend >> 8);
    LCD_WriteData(Yend + Offset_Y);
    // set the Y coordinates
    LCD_WriteCommand(0x2B);
    LCD_WriteData(Xstart >> 8);
    LCD_WriteData(Xstart + Offset_X);
    LCD_WriteData(Xend >> 8);
    LCD_WriteData(Xend + Offset_X);
  }
  LCD_WriteCommand(0x2C);
}
/******************************************************************************
function: Refresh the image in an area
parameter :
    Xstart:   Start uint16_t x coordinate
    Ystart:   Start uint16_t y coordinate
    Xend  :   End uint16_t coordinates
    Yend  :   End uint16_t coordinates
    color :   Set the color
******************************************************************************/
void LCD_addWindow(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t Yend,uint16_t* color)
{             
  uint16_t Show_Width = Xend - Xstart + 1;
  uint16_t Show_Height = Yend - Ystart + 1;
  uint32_t numBytes = Show_Width * Show_Height * sizeof(uint16_t);
  uint8_t Read_D[numBytes];
  LCD_SetCursor(Xstart, Ystart, Xend, Yend);
  LCD_WriteData_nbyte((uint8_t*)color, Read_D, numBytes);        
}
// backlight
void Backlight_Init(void)
{
  ledcAttach(EXAMPLE_PIN_NUM_BK_LIGHT, Frequency, Resolution);    
  ledcWrite(EXAMPLE_PIN_NUM_BK_LIGHT, 100);                      
}

void Set_Backlight(uint8_t Light)                        //
{

  if(Light > 100 || Light < 0)
    printf("Set Backlight parameters in the range of 0 to 100 \r\n");
  else{
    uint32_t Backlight = Light*10;
    ledcWrite(EXAMPLE_PIN_NUM_BK_LIGHT, Backlight);
  }
}

Display_ST7789.h

#pragma once
#include <Arduino.h>
#include <SPI.h>
#define LCD_WIDTH   172 //LCD width
#define LCD_HEIGHT  320 //LCD height

#define SPIFreq                        10000000
#define EXAMPLE_PIN_NUM_MISO           -1
#define EXAMPLE_PIN_NUM_MOSI           45
#define EXAMPLE_PIN_NUM_SCLK           40
#define EXAMPLE_PIN_NUM_LCD_CS         42
#define EXAMPLE_PIN_NUM_LCD_DC         41
#define EXAMPLE_PIN_NUM_LCD_RST        39
#define EXAMPLE_PIN_NUM_BK_LIGHT       48
#define Frequency       1000                    // PWM frequencyconst 
#define Resolution      10                      

#define VERTICAL   0
#define HORIZONTAL 1

#define Offset_X 34
#define Offset_Y 0


void LCD_SetCursor(uint16_t x1, uint16_t y1, uint16_t x2,uint16_t y2);

void LCD_Init(void);
void LCD_SetCursor(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t  Yend);
void LCD_addWindow(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t Yend,uint16_t* color);

void Backlight_Init(void);
void Set_Backlight(uint8_t Light);

Any help regarding this would be greatly appreciated

system · September 29, 2025, 9:08am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
ESP32S3 FSPI & HSPI Help Programming	3	561	September 26, 2025
Two SPIs parallel on ESP32-S3 3rd Party Boards	2	373	October 6, 2025
Using VSPI and HSPI simultaneously 3rd Party Boards	20	1406	January 16, 2025
Issues with simultaneously using HSPI and VSPI on CrowPanel ESP32 Display 2.4 Networking, Protocols, and Devices	3	504	November 29, 2024
ESP32 Initialize HSPI as default SPI? 3rd Party Boards	12	12335	February 1, 2024

ESP32 HSPI and VSPI Conflict

Related topics