STM32SPIDevice.cpp

/*
 * STM32SPIDevice.cpp
 *
 *  Created on: Sep 15, 2026
 *      Author: johng
 */
 
#include "STM32SPIDevice.hpp"
#include <cstring>
 
STM32SPIDevice::STM32SPIDevice(SPI_HandleTypeDef *hspi, GPIO_TypeDef *csPort, uint16_t csPin, uint32_t timeoutMs)
    : _hspi(hspi), _csPort(csPort), _csPin(csPin), _timeoutMs(timeoutMs) {
}
 
void STM32SPIDevice::begin() {
    HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_SET);
}
 
void STM32SPIDevice::beginTransaction() {
    HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_RESET);
}
 
void STM32SPIDevice::endTransaction() {
    HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_SET);
}
 
uint8_t STM32SPIDevice::transfer(uint8_t send) {
    uint8_t received = 0xFF;
    HAL_SPI_TransmitReceive(_hspi, &send, &received, 1, _timeoutMs);
    return received;
}
 
void STM32SPIDevice::transfer(uint8_t *buffer, size_t len) {
    // Same buffer for TX and RX: safe here because HAL's blocking
    // implementation processes one byte at a time, fully transmitting
    // buffer[i] before overwriting it with the received byte -- by the time
    // index i is written, its transmitted value has already gone out.
    HAL_SPI_TransmitReceive(_hspi, buffer, buffer, len, _timeoutMs);
}
 
bool STM32SPIDevice::read(uint8_t *buffer, size_t len, uint8_t sendValue) {
    memset(buffer, sendValue, len);
 
    beginTransaction();
    HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(_hspi, buffer, buffer, len, _timeoutMs);
    endTransaction();
 
    return status == HAL_OK;
}
 
bool STM32SPIDevice::write(const uint8_t *buffer, size_t len, const uint8_t *prefixBuffer, size_t prefixLen) {
    beginTransaction();
 
    HAL_StatusTypeDef status = HAL_OK;
    if (prefixLen > 0) {
        status = HAL_SPI_Transmit(_hspi, const_cast<uint8_t *>(prefixBuffer), prefixLen, _timeoutMs);
    }
    if (status == HAL_OK && len > 0) {
        status = HAL_SPI_Transmit(_hspi, const_cast<uint8_t *>(buffer), len, _timeoutMs);
    }
 
    endTransaction();
    return status == HAL_OK;
}
 
bool STM32SPIDevice::writeThenRead(const uint8_t *writeBuffer, size_t writeLen, uint8_t *readBuffer, size_t readLen, uint8_t sendValue) {
    if (writeLen + readLen > kMaxCombinedBytes) {
        return false;
    }
 
    uint8_t txBuffer[kMaxCombinedBytes];
    uint8_t rxBuffer[kMaxCombinedBytes];
 
    memcpy(txBuffer, writeBuffer, writeLen);
    memset(txBuffer + writeLen, sendValue, readLen);
 
    beginTransaction();
    HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(_hspi, txBuffer, rxBuffer, writeLen + readLen, _timeoutMs);
    endTransaction();
 
    if (status != HAL_OK) {
        return false;
    }
 
    memcpy(readBuffer, rxBuffer + writeLen, readLen);
    return true;
}