Skip to content

Commit 3ea87ad

Browse files
jmz52thisiskeithbthinkyhead
authored
✨ SPI TFT / Touchscreen for STM32H7 (MarlinFirmware#25784)
Co-authored-by: thisiskeithb <13375512+thisiskeithb@users.noreply.github.com> Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
1 parent c483fe7 commit 3ea87ad

11 files changed

+387
-139
lines changed

‎Marlin/src/HAL/STM32/tft/tft_spi.cpp

+113-46
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,6 @@ void TFT_SPI::init() {
5252
SPIx.Init.NSS = SPI_NSS_SOFT;
5353
SPIx.Init.Mode = SPI_MODE_MASTER;
5454
SPIx.Init.Direction = (TFT_MISO_PIN == TFT_MOSI_PIN) ? SPI_DIRECTION_1LINE : SPI_DIRECTION_2LINES;
55-
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
5655
SPIx.Init.CLKPhase = SPI_PHASE_1EDGE;
5756
SPIx.Init.CLKPolarity = SPI_POLARITY_LOW;
5857
SPIx.Init.DataSize = SPI_DATASIZE_8BIT;
@@ -61,25 +60,43 @@ void TFT_SPI::init() {
6160
SPIx.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
6261
SPIx.Init.CRCPolynomial = 10;
6362

63+
#ifndef STM32H7xx
64+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; // 18 MBit/s for F103, 21 MBit/s for F407, 25 MBit/s for F411
65+
#else
66+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; // 20 MBit/s for H743
67+
SPIx.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
68+
SPIx.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
69+
SPIx.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
70+
SPIx.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
71+
SPIx.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
72+
SPIx.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
73+
SPIx.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
74+
SPIx.Init.IOSwap = SPI_IO_SWAP_DISABLE;
75+
#endif
76+
6477
pinmap_pinout(digitalPinToPinName(TFT_SCK_PIN), PinMap_SPI_SCLK);
6578
pinmap_pinout(digitalPinToPinName(TFT_MOSI_PIN), PinMap_SPI_MOSI);
6679
#if PIN_EXISTS(TFT_MISO) && TFT_MISO_PIN != TFT_MOSI_PIN
6780
pinmap_pinout(digitalPinToPinName(TFT_MISO_PIN), PinMap_SPI_MISO);
6881
#endif
69-
pin_PullConfig(get_GPIO_Port(STM_PORT(digitalPinToPinName(TFT_SCK_PIN))), STM_LL_GPIO_PIN(digitalPinToPinName(TFT_SCK_PIN)), GPIO_PULLDOWN);
7082

7183
#ifdef SPI1_BASE
7284
if (SPIx.Instance == SPI1) {
7385
__HAL_RCC_SPI1_CLK_ENABLE();
7486
#ifdef STM32F1xx
7587
__HAL_RCC_DMA1_CLK_ENABLE();
7688
DMAtx.Instance = DMA1_Channel3;
89+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; // SPI1 clock on F1 and F4 is two times faster than SPI2 and SPI3 clock
7790
#elif defined(STM32F4xx)
7891
__HAL_RCC_DMA2_CLK_ENABLE();
7992
DMAtx.Instance = DMA2_Stream3;
8093
DMAtx.Init.Channel = DMA_CHANNEL_3;
94+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; // SPI1 clock on F1 and F4 is two times faster than SPI2 and SPI3 clock
95+
#elif defined(STM32H7xx)
96+
__HAL_RCC_DMA1_CLK_ENABLE();
97+
DMAtx.Instance = DMA1_Stream4;
98+
DMAtx.Init.Request = DMA_REQUEST_SPI1_TX;
8199
#endif
82-
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
83100
}
84101
#endif
85102
#ifdef SPI2_BASE
@@ -92,6 +109,10 @@ void TFT_SPI::init() {
92109
__HAL_RCC_DMA1_CLK_ENABLE();
93110
DMAtx.Instance = DMA1_Stream4;
94111
DMAtx.Init.Channel = DMA_CHANNEL_0;
112+
#elif defined(STM32H7xx)
113+
__HAL_RCC_DMA1_CLK_ENABLE();
114+
DMAtx.Instance = DMA1_Stream4;
115+
DMAtx.Init.Request = DMA_REQUEST_SPI2_TX;
95116
#endif
96117
}
97118
#endif
@@ -105,25 +126,27 @@ void TFT_SPI::init() {
105126
__HAL_RCC_DMA1_CLK_ENABLE();
106127
DMAtx.Instance = DMA1_Stream5;
107128
DMAtx.Init.Channel = DMA_CHANNEL_0;
129+
#elif defined(STM32H7xx)
130+
__HAL_RCC_DMA1_CLK_ENABLE();
131+
DMAtx.Instance = DMA1_Stream4;
132+
DMAtx.Init.Request = DMA_REQUEST_SPI3_TX;
108133
#endif
109134
}
110135
#endif
111136

112-
HAL_SPI_Init(&SPIx);
113-
114137
DMAtx.Init.Direction = DMA_MEMORY_TO_PERIPH;
115138
DMAtx.Init.PeriphInc = DMA_PINC_DISABLE;
116139
DMAtx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
117140
DMAtx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
118141
DMAtx.Init.Mode = DMA_NORMAL;
119142
DMAtx.Init.Priority = DMA_PRIORITY_LOW;
120-
#ifdef STM32F4xx
143+
#if ANY(STM32F4xx, STM32H7xx)
121144
DMAtx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
122145
#endif
123146
}
124147

125148
void TFT_SPI::dataTransferBegin(uint16_t dataSize) {
126-
SPIx.Init.DataSize = dataSize == DATASIZE_8BIT ? SPI_DATASIZE_8BIT : SPI_DATASIZE_16BIT;
149+
SPIx.Init.DataSize = dataSize;
127150
HAL_SPI_Init(&SPIx);
128151
WRITE(TFT_CS_PIN, LOW);
129152
}
@@ -148,28 +171,43 @@ uint32_t TFT_SPI::getID() {
148171
uint32_t TFT_SPI::readID(const uint16_t inReg) {
149172
uint32_t data = 0;
150173
#if PIN_EXISTS(TFT_MISO)
151-
uint32_t BaudRatePrescaler = SPIx.Init.BaudRatePrescaler;
152-
uint32_t i;
174+
const uint32_t oldPrescaler = SPIx.Init.BaudRatePrescaler;
153175

154-
SPIx.Init.BaudRatePrescaler = SPIx.Instance == SPI1 ? SPI_BAUDRATEPRESCALER_8 : SPI_BAUDRATEPRESCALER_4;
176+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
155177
dataTransferBegin(DATASIZE_8BIT);
156178
writeReg(inReg);
157179

158180
if (SPIx.Init.Direction == SPI_DIRECTION_1LINE) SPI_1LINE_RX(&SPIx);
159-
__HAL_SPI_ENABLE(&SPIx);
160181

161-
for (i = 0; i < 4; i++) {
162-
#if TFT_MISO_PIN != TFT_MOSI_PIN
163-
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
164-
SPIx.Instance->DR = 0;
165-
#endif
166-
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_RXNE)) {}
167-
data = (data << 8) | SPIx.Instance->DR;
168-
}
182+
#ifdef STM32H7xx
183+
for (uint32_t i = 0; i < 4; i++) {
184+
MODIFY_REG(SPIx.Instance->CR2, SPI_CR2_TSIZE, 1);
185+
__HAL_SPI_ENABLE(&SPIx);
186+
SET_BIT(SPIx.Instance->CR1, SPI_CR1_CSTART);
187+
188+
#if TFT_MISO_PIN != TFT_MOSI_PIN
189+
SPIx.Instance->TXDR = 0;
190+
#endif
191+
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_EOT)) {}
192+
data = (data << 8) | SPIx.Instance->RXDR;
193+
__HAL_SPI_DISABLE(&SPIx);
194+
__HAL_SPI_CLEAR_EOTFLAG(&SPIx);
195+
__HAL_SPI_CLEAR_TXTFFLAG(&SPIx);
196+
}
197+
#else
198+
__HAL_SPI_ENABLE(&SPIx);
199+
for (uint32_t i = 0; i < 4; i++) {
200+
#if TFT_MISO_PIN != TFT_MOSI_PIN
201+
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
202+
SPIx.Instance->DR = 0;
203+
#endif
204+
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_RXNE)) {}
205+
data = (data << 8) | SPIx.Instance->DR;
206+
}
207+
#endif
169208

170209
dataTransferEnd();
171-
172-
SPIx.Init.BaudRatePrescaler = BaudRatePrescaler;
210+
SPIx.Init.BaudRatePrescaler = oldPrescaler;
173211
#endif
174212

175213
return data >> 7;
@@ -182,6 +220,9 @@ bool TFT_SPI::isBusy() {
182220
#elif defined(STM32F4xx)
183221
#define __IS_DMA_ENABLED(__HANDLE__) ((__HANDLE__)->Instance->CR & DMA_SxCR_EN)
184222
#define __IS_DMA_CONFIGURED(__HANDLE__) ((__HANDLE__)->Instance->PAR != 0)
223+
#elif defined(STM32H7xx)
224+
#define __IS_DMA_ENABLED(__HANDLE__) (((DMA_Stream_TypeDef *)((__HANDLE__)->Instance))->CR & DMA_SxCR_EN)
225+
#define __IS_DMA_CONFIGURED(__HANDLE__) (((DMA_Stream_TypeDef *)((__HANDLE__)->Instance))->PAR != 0)
185226
#endif
186227

187228
if (!__IS_DMA_CONFIGURED(&DMAtx)) return false;
@@ -193,8 +234,13 @@ bool TFT_SPI::isBusy() {
193234
else {
194235
// Check if DMA transfer completed flag is set
195236
if (__HAL_DMA_GET_FLAG(&DMAtx, __HAL_DMA_GET_TC_FLAG_INDEX(&DMAtx)) == 0) return true;
196-
// Check if SPI transmit butter is empty and SPI is idle
197-
if ((!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) || (__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY))) return true;
237+
#ifdef STM32H7xx
238+
// Check if SPI data transfer is completed
239+
if (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_EOT)) return true;
240+
#else
241+
// Check if SPI is idle
242+
if (__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) return true;
243+
#endif
198244
}
199245

200246
abort();
@@ -205,22 +251,40 @@ void TFT_SPI::abort() {
205251
HAL_DMA_Abort(&DMAtx); // Abort DMA transfer if any
206252
HAL_DMA_DeInit(&DMAtx);
207253

208-
CLEAR_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);
254+
#ifdef STM32H7xx
255+
CLEAR_BIT(SPIx.Instance->CFG1, SPI_CFG1_TXDMAEN);
256+
__HAL_SPI_CLEAR_EOTFLAG(&SPIx);
257+
__HAL_SPI_CLEAR_TXTFFLAG(&SPIx);
258+
#else
259+
CLEAR_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);
260+
#endif
209261

210-
dataTransferEnd(); // Stop SPI and deselect CS
262+
dataTransferEnd(); // Stop SPI and deselect CS
211263
}
212264

213265
void TFT_SPI::transmit(uint16_t data) {
214266
#if TFT_MISO_PIN == TFT_MOSI_PIN
215267
SPI_1LINE_TX(&SPIx);
216268
#endif
217269

218-
__HAL_SPI_ENABLE(&SPIx);
270+
#ifdef STM32H7xx
271+
MODIFY_REG(SPIx.Instance->CR2, SPI_CR2_TSIZE, 1);
272+
__HAL_SPI_ENABLE(&SPIx);
273+
SET_BIT(SPIx.Instance->CR1, SPI_CR1_CSTART);
274+
275+
SPIx.Instance->TXDR = data;
219276

220-
SPIx.Instance->DR = data;
277+
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_SR_EOT)) {}
221278

222-
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_TXE)) {}
223-
while ( __HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) {}
279+
__HAL_SPI_CLEAR_EOTFLAG(&SPIx);
280+
__HAL_SPI_CLEAR_TXTFFLAG(&SPIx);
281+
#else
282+
__HAL_SPI_ENABLE(&SPIx);
283+
SPIx.Instance->DR = data;
284+
while (__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) {}
285+
#endif
286+
287+
__HAL_SPI_DISABLE(&SPIx);
224288

225289
#if TFT_MISO_PIN != TFT_MOSI_PIN
226290
__HAL_SPI_CLEAR_OVRFLAG(&SPIx); // Clear overrun flag in 2 Lines communication mode because received data is not read
@@ -237,35 +301,38 @@ void TFT_SPI::transmitDMA(uint32_t memoryIncrease, uint16_t *data, uint16_t coun
237301

238302
dataTransferBegin();
239303

240-
HAL_DMA_Start(&DMAtx, (uint32_t)data, (uint32_t)&(SPIx.Instance->DR), count);
241-
__HAL_SPI_ENABLE(&SPIx);
304+
#ifdef STM32H7xx
305+
HAL_DMA_Start(&DMAtx, (uint32_t)data, (uint32_t)&(SPIx.Instance->TXDR), count);
242306

243-
SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN); // Enable Tx DMA Request
307+
CLEAR_BIT(SPIx.Instance->CFG1, SPI_CFG1_TXDMAEN);
308+
MODIFY_REG(SPIx.Instance->CR2, SPI_CR2_TSIZE, count);
309+
SET_BIT(SPIx.Instance->CFG1, SPI_CFG1_TXDMAEN); // Enable Tx DMA Request
310+
__HAL_SPI_ENABLE(&SPIx);
311+
SET_BIT(SPIx.Instance->CR1, SPI_CR1_CSTART);
312+
#else
313+
HAL_DMA_Start(&DMAtx, (uint32_t)data, (uint32_t)&(SPIx.Instance->DR), count);
314+
315+
__HAL_SPI_ENABLE(&SPIx);
316+
SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN); // Enable Tx DMA Request
317+
#endif
244318

245319
TERN_(TFT_SHARED_IO, while (isBusy()));
246320
}
247321

248322
void TFT_SPI::transmit(uint32_t memoryIncrease, uint16_t *data, uint16_t count) {
249-
DMAtx.Init.MemInc = memoryIncrease;
250-
HAL_DMA_Init(&DMAtx);
251-
252-
if (TFT_MISO_PIN == TFT_MOSI_PIN)
253-
SPI_1LINE_TX(&SPIx);
254-
255-
dataTransferBegin();
256-
257-
HAL_DMA_Start(&DMAtx, (uint32_t)data, (uint32_t)&(SPIx.Instance->DR), count);
258-
__HAL_SPI_ENABLE(&SPIx);
259-
260-
SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN); // Enable Tx DMA Request
323+
transmitDMA(memoryIncrease, data, count);
261324

262325
HAL_DMA_PollForTransfer(&DMAtx, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);
263-
while ( __HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) {}
326+
#ifdef STM32H7xx
327+
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_SR_EOT)) {}
328+
#else
329+
while (__HAL_SPI_GET_FLAG(&SPIx, SPI_FLAG_BSY)) {}
330+
#endif
264331
abort();
265332
}
266333

267334
#if ENABLED(USE_SPI_DMA_TC)
268-
void TFT_SPI::TransmitDMA_IT(uint32_t memoryIncrease, uint16_t *data, uint16_t count) {
335+
void TFT_SPI::transmitDMA_IT(uint32_t memoryIncrease, uint16_t *data, uint16_t count) {
269336

270337
DMAtx.Init.MemInc = memoryIncrease;
271338
HAL_DMA_Init(&DMAtx);

‎Marlin/src/HAL/STM32/tft/tft_spi.h

+6-3
Original file line numberDiff line numberDiff line change
@@ -25,8 +25,10 @@
2525
#include "stm32f1xx_hal.h"
2626
#elif defined(STM32F4xx)
2727
#include "stm32f4xx_hal.h"
28+
#elif defined(STM32H7xx)
29+
#include "stm32h7xx_hal.h"
2830
#else
29-
#error SPI TFT is currently only supported on STM32F1 and STM32F4 hardware.
31+
#error SPI TFT is currently only supported on STM32F1, STM32F4 and STM32H7 hardware.
3032
#endif
3133

3234
#ifndef LCD_READ_ID
@@ -38,6 +40,7 @@
3840

3941
#define DATASIZE_8BIT SPI_DATASIZE_8BIT
4042
#define DATASIZE_16BIT SPI_DATASIZE_16BIT
43+
#define DATASIZE_32BIT SPI_DATASIZE_32BIT
4144
#define TFT_IO_DRIVER TFT_SPI
4245
#define DMA_MAX_SIZE 0xFFFF
4346

@@ -51,7 +54,7 @@ class TFT_SPI {
5154
static void transmit(uint32_t memoryIncrease, uint16_t *data, uint16_t count);
5255
static void transmitDMA(uint32_t memoryIncrease, uint16_t *data, uint16_t count);
5356
#if ENABLED(USE_SPI_DMA_TC)
54-
static void TransmitDMA_IT(uint32_t memoryIncrease, uint16_t *data, uint16_t count);
57+
static void transmitDMA_IT(uint32_t memoryIncrease, uint16_t *data, uint16_t count);
5558
#endif
5659

5760
public:
@@ -71,7 +74,7 @@ class TFT_SPI {
7174
static void writeMultiple_DMA(uint16_t color, uint16_t count) { static uint16_t data; data = color; transmitDMA(DMA_MINC_DISABLE, &data, count); }
7275

7376
#if ENABLED(USE_SPI_DMA_TC)
74-
static void writeSequenceIT(uint16_t *data, uint16_t count) { TransmitDMA_IT(DMA_MINC_ENABLE, data, count); }
77+
static void writeSequenceIT(uint16_t *data, uint16_t count) { transmitDMA_IT(DMA_MINC_ENABLE, data, count); }
7578
inline static void DMA_IRQHandler() { HAL_DMA_IRQHandler(&TFT_SPI::DMAtx); }
7679
#endif
7780

‎Marlin/src/HAL/STM32/tft/xpt2046.cpp

+37-7
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,6 @@ void XPT2046::init() {
5656
SPIx.Init.NSS = SPI_NSS_SOFT;
5757
SPIx.Init.Mode = SPI_MODE_MASTER;
5858
SPIx.Init.Direction = SPI_DIRECTION_2LINES;
59-
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
6059
SPIx.Init.CLKPhase = SPI_PHASE_2EDGE;
6160
SPIx.Init.CLKPolarity = SPI_POLARITY_HIGH;
6261
SPIx.Init.DataSize = SPI_DATASIZE_8BIT;
@@ -65,6 +64,20 @@ void XPT2046::init() {
6564
SPIx.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
6665
SPIx.Init.CRCPolynomial = 10;
6766

67+
#ifndef STM32H7xx
68+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; // 4.5 MBit/s for F103 and 5.25 MBit/s for F407
69+
#else
70+
SPIx.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; // 5 MBit/s for H743
71+
SPIx.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
72+
SPIx.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
73+
SPIx.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
74+
SPIx.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
75+
SPIx.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
76+
SPIx.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
77+
SPIx.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
78+
SPIx.Init.IOSwap = SPI_IO_SWAP_DISABLE;
79+
#endif
80+
6881
pinmap_pinout(digitalPinToPinName(TOUCH_SCK_PIN), PinMap_SPI_SCLK);
6982
pinmap_pinout(digitalPinToPinName(TOUCH_MOSI_PIN), PinMap_SPI_MOSI);
7083
pinmap_pinout(digitalPinToPinName(TOUCH_MISO_PIN), PinMap_SPI_MISO);
@@ -141,13 +154,30 @@ uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
141154
}
142155

143156
uint16_t XPT2046::hardwareIO(uint16_t data) {
144-
__HAL_SPI_ENABLE(&SPIx);
145-
while ((SPIx.Instance->SR & SPI_FLAG_TXE) != SPI_FLAG_TXE) {}
146-
SPIx.Instance->DR = data;
147-
while ((SPIx.Instance->SR & SPI_FLAG_RXNE) != SPI_FLAG_RXNE) {}
148-
__HAL_SPI_DISABLE(&SPIx);
157+
#ifdef STM32H7xx
158+
MODIFY_REG(SPIx.Instance->CR2, SPI_CR2_TSIZE, 1);
159+
__HAL_SPI_ENABLE(&SPIx);
160+
SET_BIT(SPIx.Instance->CR1, SPI_CR1_CSTART);
161+
162+
SPIx.Instance->TXDR = data;
149163

150-
return SPIx.Instance->DR;
164+
while (!__HAL_SPI_GET_FLAG(&SPIx, SPI_SR_EOT)) {}
165+
data = SPIx.Instance->RXDR;
166+
167+
__HAL_SPI_DISABLE(&SPIx);
168+
__HAL_SPI_CLEAR_EOTFLAG(&SPIx);
169+
__HAL_SPI_CLEAR_TXTFFLAG(&SPIx);
170+
171+
return data;
172+
#else
173+
__HAL_SPI_ENABLE(&SPIx);
174+
while ((SPIx.Instance->SR & SPI_FLAG_TXE) != SPI_FLAG_TXE) {}
175+
SPIx.Instance->DR = data;
176+
while ((SPIx.Instance->SR & SPI_FLAG_RXNE) != SPI_FLAG_RXNE) {}
177+
__HAL_SPI_DISABLE(&SPIx);
178+
179+
return SPIx.Instance->DR;
180+
#endif
151181
}
152182

153183
uint16_t XPT2046::softwareIO(uint16_t data) {

0 commit comments

Comments
 (0)