436 lines
14 KiB
C++
436 lines
14 KiB
C++
//
|
|
// Created by Kurosu Chan on 2024/1/18.
|
|
//
|
|
|
|
#include <cstdint>
|
|
#include <driver/spi_master.h>
|
|
#include <esp_log.h>
|
|
#include "esp_err.h"
|
|
#include "hal_error.hpp"
|
|
#include "hal_gpio.hpp"
|
|
#include "hal_spi.hpp"
|
|
#include "utils/app_utils.hpp"
|
|
#include "utils/app_instant.hpp"
|
|
// https://docs.espressif.com/projects/esp-idf/en/v5.3.2/esp32h2/api-reference/peripherals/spi_master.html
|
|
// https://github.com/espressif/esp-idf/blob/v5.3.2/examples/peripherals/spi_master/lcd/main/spi_master_example_main.c
|
|
namespace app::driver::hal::spi {
|
|
static constexpr uint8_t CMD_BIT_SIZE = 8;
|
|
static constexpr uint8_t OFFSET_BIT_SIZE = 8;
|
|
static constexpr uint8_t REG_ADDR_BIT_SIZE = 16;
|
|
|
|
static constexpr auto MAX_BUFFER_SIZE = 256;
|
|
|
|
namespace details {
|
|
static bool is_initialized = false;
|
|
static spi_device_handle_t spi_device;
|
|
|
|
static uint8_t _data_buffer[MAX_BUFFER_SIZE];
|
|
/**
|
|
* @brief only used in read/write buffer io
|
|
*/
|
|
static std::span<uint8_t> data_buffer = std::span{_data_buffer};
|
|
}
|
|
|
|
/**
|
|
* a traditional way to complete an synchronous SPI transaction
|
|
*
|
|
* @sa https://github.com/nopnop2002/esp-idf-sx126x/blob/bd26fd20b118c6d57d35b0554d8de80378d614a8/components/ra01s/ra01s.c#L123-L161
|
|
* @sa https://github.com/IanBurwell/DynamicLRS/blob/c26f7f8dcca0c1b70af0aa6aee3aba3a1652aba6/components/DLRS_LoRadio/radiolib_esp32s3_hal.hpp#L193-L201
|
|
*
|
|
*/
|
|
|
|
static constexpr auto verify_statuses = [](std::span<const uint8_t> statuses) {
|
|
uint8_t i = 0;
|
|
for (const auto st : statuses) {
|
|
if (const auto err = status_to_err(st); err != error::OK) {
|
|
ESP_LOGE(TAG, "failed to verify status 0x%02x at byte %u", st, i);
|
|
return err;
|
|
}
|
|
i += 1;
|
|
}
|
|
return error::OK;
|
|
};
|
|
|
|
void init(spi_config_t config) {
|
|
if (details::is_initialized) {
|
|
return;
|
|
}
|
|
|
|
// Configure SPI bus
|
|
spi_bus_config_t bus_config = {
|
|
.mosi_io_num = MOSI_PIN,
|
|
.miso_io_num = MISO_PIN,
|
|
.sclk_io_num = SCLK_PIN,
|
|
.quadwp_io_num = -1,
|
|
.quadhd_io_num = -1,
|
|
.data4_io_num = -1,
|
|
.data5_io_num = -1,
|
|
.data6_io_num = -1,
|
|
.data7_io_num = -1,
|
|
.max_transfer_sz = 0,
|
|
.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_GPIO_PINS,
|
|
.intr_flags = 0,
|
|
};
|
|
|
|
// Configure SPI device
|
|
// https://github.com/nopnop2002/esp-idf-sx126x/blob/main/components/ra01s/ra01s.c
|
|
//
|
|
// SPI_DEVICE_HALFDUPLEX flag will turn the device into half-duplex
|
|
// See also the phase
|
|
// https://docs.espressif.com/projects/esp-idf/en/v5.3.2/esp32/api-reference/peripherals/spi_master.html#spi-transactions
|
|
spi_device_interface_config_t dev_config = {
|
|
.command_bits = 0,
|
|
.address_bits = 0,
|
|
.dummy_bits = 0,
|
|
.mode = 0,
|
|
.duty_cycle_pos = 128,
|
|
.clock_speed_hz = config.clock_speed_hz,
|
|
.spics_io_num = CS_PIN,
|
|
.flags = SPI_DEVICE_NO_DUMMY,
|
|
.queue_size = 1,
|
|
};
|
|
|
|
ESP_ERROR_CHECK(spi_bus_initialize(config.host_id, &bus_config, SPI_DMA_CH_AUTO));
|
|
ESP_ERROR_CHECK(spi_bus_add_device(config.host_id, &dev_config, &details::spi_device));
|
|
|
|
|
|
gpio_config_t io_conf = {
|
|
.pin_bit_mask = (1ULL << BUSY_PIN),
|
|
.mode = GPIO_MODE_INPUT,
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&io_conf));
|
|
details::is_initialized = true;
|
|
}
|
|
|
|
// https://docs.espressif.com/projects/esp-idf/en/release-v5.3/esp32/api-reference/peripherals/spi_master.html
|
|
// https://github.com/espressif/arduino-esp32/blob/5ba4c21a990f46b61ae8c7913b81e15064b2a8ef/cores/esp32/esp32-hal-spi.c#L836-L843
|
|
// https://github.com/espressif/esp-idf/issues/5223
|
|
|
|
/*!
|
|
\brief wait for busy pin to go down
|
|
\return true if the pin goes down, return false if timeout
|
|
\note The LLCC68 uses the pin BUSY to indicate the status of the chip and
|
|
its ability (or not) to receive another command while internal processing
|
|
occurs. Prior to executing one of the generic functions, it is thus
|
|
necessary to check the status of BUSY to make sure the chip is in a state
|
|
where it can process another function.
|
|
*/
|
|
inline bool wait_for_not_busy(const size_t timeout_ms) {
|
|
if constexpr (BUSY_PIN == GPIO_NUM_NC) {
|
|
app::utils::delay_ms(timeout_ms);
|
|
return true;
|
|
} else {
|
|
const auto io_inst = app::utils::Instant<>{};
|
|
while (hal::gpio::digital_read(BUSY_PIN) == hal::gpio::HIGH) {
|
|
if (io_inst.elapsed_ms() > timeout_ms) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// The communication with the LLCC68 is organized around generic functions which
|
|
// allow the user to control the device behavior. Each function is based on an
|
|
// Operational Command (refer throughout this document as “Opcode”), which is
|
|
// then followed by a set of parameters. The LLCC68 use the BUSY pin to indicate
|
|
// the status of the chip. In the following chapters, it is assumed that host
|
|
// micro-controller has an SPI and access to it via spi.write(data). Data is an
|
|
// 8-bit word. The SPI chip select is defined by NSS, active low.
|
|
|
|
|
|
// Through the SPI interface, the host can issue commands to the chip or access
|
|
// the data memory space to directly retrieve or write data. In normal
|
|
// operation, a reduced number of direct data write operations is required
|
|
// except when accessing the data buffer. The user interacts with the circuit
|
|
// through an API (instruction set).
|
|
|
|
/*! READ */
|
|
|
|
constexpr auto STACK_BUFFER_SIZE = 32;
|
|
constexpr auto PADDING = 0xFE;
|
|
|
|
Result<Unit, error_t>
|
|
read_stream(uint8_t cmd, std::span<uint8_t> data, const size_t timeout_ms) {
|
|
std::array<uint8_t, STACK_BUFFER_SIZE> _rx_buf;
|
|
std::array<uint8_t, STACK_BUFFER_SIZE> _tx_buf;
|
|
|
|
if (data.empty() or data.size() > STACK_BUFFER_SIZE - 1) {
|
|
return ue_t{error::INVALID_SIZE};
|
|
}
|
|
|
|
if (not wait_for_not_busy(timeout_ms)) {
|
|
return ue_t{error::TIMEOUT};
|
|
}
|
|
|
|
auto rx_buffer = std::span{_rx_buf}.subspan(0, data.size() + 1);
|
|
auto tx_buffer = std::span{_tx_buf}.subspan(0, rx_buffer.size());
|
|
std::ranges::fill(tx_buffer, PADDING);
|
|
|
|
spi_transaction_ext_t transaction{};
|
|
// during the Command and Address phases, the members spi_transaction_t::cmd
|
|
// and spi_transaction_t::addr are sent to the bus, nothing is read at this
|
|
// time.
|
|
transaction = spi_transaction_ext_t{
|
|
.base = {
|
|
.flags = SPI_TRANS_VARIABLE_CMD,
|
|
.cmd = cmd,
|
|
// total data length, in bits
|
|
.length = static_cast<size_t>(rx_buffer.size() * 8),
|
|
// total data length received, should be not greater than length in
|
|
// full-duplex mode (0 defaults this to the value of length).
|
|
.rxlength = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.tx_buffer = tx_buffer.data(),
|
|
.rx_buffer = rx_buffer.data(),
|
|
},
|
|
.command_bits = CMD_BIT_SIZE,
|
|
.address_bits = 0,
|
|
.dummy_bits = 0,
|
|
};
|
|
esp_err_t err = spi_device_transmit(details::spi_device, &transaction.base);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "spi transmit: %s (%d)", esp_err_to_name(err), err);
|
|
return ue_t{error::FAILED};
|
|
}
|
|
|
|
auto status = rx_buffer[0];
|
|
if (const auto err = status_to_err(status); err != error::OK) {
|
|
return ue_t{err};
|
|
}
|
|
|
|
std::copy(rx_buffer.begin() + 1, rx_buffer.end(), data.begin());
|
|
return {};
|
|
}
|
|
|
|
|
|
/*! WRITE */
|
|
|
|
Result<Unit, error_t>
|
|
write_stream(uint8_t cmd, std::span<const uint8_t> data, const size_t timeout_ms) {
|
|
std::array<uint8_t, STACK_BUFFER_SIZE> _rx_buf;
|
|
|
|
if (data.size() > STACK_BUFFER_SIZE - 1) {
|
|
return ue_t{error::INVALID_SIZE};
|
|
}
|
|
|
|
if (not wait_for_not_busy(timeout_ms)) {
|
|
return ue_t{error::TIMEOUT};
|
|
}
|
|
|
|
const auto rx_buffer = std::span{_rx_buf}.subspan(0, data.size());
|
|
spi_transaction_ext_t transaction{};
|
|
transaction = spi_transaction_ext_t{
|
|
.base = {
|
|
.flags = SPI_TRANS_VARIABLE_CMD,
|
|
.cmd = cmd,
|
|
.length = static_cast<size_t>(data.size() * 8),
|
|
.rxlength = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.tx_buffer = data.data(),
|
|
.rx_buffer = rx_buffer.data(),
|
|
},
|
|
.command_bits = CMD_BIT_SIZE,
|
|
.address_bits = 0,
|
|
.dummy_bits = 0,
|
|
};
|
|
esp_err_t err = spi_device_transmit(details::spi_device, &transaction.base);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "spi transmit: %s (%d)", esp_err_to_name(err), err);
|
|
return ue_t{error::FAILED};
|
|
}
|
|
|
|
if (const auto err = verify_statuses(rx_buffer); err != error::OK) {
|
|
return ue_t{err};
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
|
|
/*! READ REGISTER */
|
|
|
|
Result<Unit, error_t>
|
|
read_register(uint16_t reg, std::span<uint8_t> data, const size_t timeout_ms) {
|
|
std::array<uint8_t, STACK_BUFFER_SIZE> _rx_buf;
|
|
std::array<uint8_t, STACK_BUFFER_SIZE> _tx_buf;
|
|
|
|
if (data.size() > STACK_BUFFER_SIZE - 1) {
|
|
return ue_t{error::INVALID_SIZE};
|
|
}
|
|
|
|
if (not wait_for_not_busy(timeout_ms)) {
|
|
return ue_t{error::TIMEOUT};
|
|
}
|
|
|
|
// Note that the host has to send an NOP after sending the 2
|
|
// bytes of address to start receiving data bytes on the next NOP sent.
|
|
//
|
|
// NOTE: I'm not sure if ESP32 would send 0x00 (NOP) after MOSI phase
|
|
// if the tx_buffer is nullptr.
|
|
spi_transaction_ext_t transaction;
|
|
|
|
auto rx_buffer = std::span{_rx_buf}.subspan(0, data.size() + 1);
|
|
auto tx_buffer = std::span{_tx_buf}.subspan(0, rx_buffer.size());
|
|
std::ranges::fill(tx_buffer, PADDING);
|
|
|
|
transaction = spi_transaction_ext_t{
|
|
.base = {
|
|
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
|
|
.cmd = SPI_READ_COMMAND,
|
|
.addr = reg,
|
|
.length = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.rxlength = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.tx_buffer = tx_buffer.data(),
|
|
.rx_buffer = rx_buffer.data(),
|
|
},
|
|
.command_bits = static_cast<uint8_t>(CMD_BIT_SIZE),
|
|
.address_bits = static_cast<uint8_t>(REG_ADDR_BIT_SIZE),
|
|
.dummy_bits = 0,
|
|
};
|
|
esp_err_t err = spi_device_transmit(details::spi_device, &transaction.base);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "spi transmit: %s (%d)", esp_err_to_name(err), err);
|
|
return ue_t{error::FAILED};
|
|
}
|
|
|
|
auto status = rx_buffer[0];
|
|
if (const auto err = status_to_err(status); err != error::OK) {
|
|
return ue_t{err};
|
|
}
|
|
std::copy(rx_buffer.begin() + 1, rx_buffer.end(), data.begin());
|
|
return {};
|
|
}
|
|
|
|
/*! WRITE REGISTER */
|
|
|
|
Result<Unit, error_t>
|
|
write_register(uint16_t offset, std::span<const uint8_t> data, const size_t timeout_ms) {
|
|
std::array<uint8_t, STACK_BUFFER_SIZE> _rx_buf;
|
|
if (data.size() > STACK_BUFFER_SIZE - 1) {
|
|
return ue_t{error::INVALID_SIZE};
|
|
}
|
|
|
|
if (not wait_for_not_busy(timeout_ms)) {
|
|
return ue_t{error::TIMEOUT};
|
|
}
|
|
|
|
auto rx_buffer = std::span{_rx_buf}.subspan(0, data.size());
|
|
|
|
spi_transaction_ext_t transaction;
|
|
transaction = spi_transaction_ext_t{
|
|
.base = {
|
|
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
|
|
.cmd = SPI_WRITE_COMMAND,
|
|
.addr = offset,
|
|
.length = static_cast<size_t>(data.size() * 8),
|
|
.rxlength = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.tx_buffer = data.data(),
|
|
.rx_buffer = rx_buffer.data(),
|
|
},
|
|
.command_bits = static_cast<uint8_t>(CMD_BIT_SIZE),
|
|
.address_bits = static_cast<uint8_t>(REG_ADDR_BIT_SIZE),
|
|
.dummy_bits = 0,
|
|
};
|
|
|
|
esp_err_t err = spi_device_transmit(details::spi_device, &transaction.base);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "spi transmit: %s (%d)", esp_err_to_name(err), err);
|
|
return ue_t{error::FAILED};
|
|
}
|
|
|
|
if (const auto err = verify_statuses(rx_buffer); err != error::OK) {
|
|
return ue_t{err};
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
|
|
/*! READ BUFFER */
|
|
Result<std::span<const uint8_t>, error_t>
|
|
read_buffer(uint8_t offset, uint8_t size, const size_t timeout_ms) {
|
|
const auto size_required = static_cast<size_t>(size) + 1;
|
|
if (size_required > details::data_buffer.size()) {
|
|
return ue_t{error::INVALID_SIZE};
|
|
}
|
|
|
|
auto rx_buffer = details::data_buffer.subspan(0, size_required);
|
|
auto _tx_buffer = std::make_unique<uint8_t[]>(rx_buffer.size());
|
|
auto tx_buffer = std::span{_tx_buffer.get(), rx_buffer.size()};
|
|
std::ranges::fill(tx_buffer, PADDING);
|
|
|
|
spi_transaction_ext_t transaction;
|
|
transaction = spi_transaction_ext_t{
|
|
.base = {
|
|
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
|
|
.cmd = SPI_READ_BUFFER_CMD,
|
|
.addr = offset,
|
|
.length = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.rxlength = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.tx_buffer = tx_buffer.data(),
|
|
.rx_buffer = rx_buffer.data(),
|
|
},
|
|
.command_bits = static_cast<uint8_t>(CMD_BIT_SIZE),
|
|
.address_bits = static_cast<uint8_t>(OFFSET_BIT_SIZE),
|
|
.dummy_bits = 0,
|
|
};
|
|
esp_err_t err = spi_device_transmit(details::spi_device, &transaction.base);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "spi transmit: %s (%d)", esp_err_to_name(err), err);
|
|
return ue_t{error::FAILED};
|
|
}
|
|
|
|
const auto status = rx_buffer[0];
|
|
if (const auto err = status_to_err(status); err != error::OK) {
|
|
return ue_t{err};
|
|
}
|
|
|
|
return std::span{rx_buffer.begin() + 1, rx_buffer.end()};
|
|
};
|
|
|
|
/*! WRITE BUFFER */
|
|
|
|
Result<Unit, error_t>
|
|
write_buffer(uint8_t offset, std::span<const uint8_t> data_from_host, const size_t timeout_ms) {
|
|
if (data_from_host.size() > details::data_buffer.size()) {
|
|
return ue_t{error::INVALID_SIZE};
|
|
}
|
|
|
|
if (not wait_for_not_busy(timeout_ms)) {
|
|
return ue_t{error::TIMEOUT};
|
|
}
|
|
|
|
auto rx_buffer = details::data_buffer.subspan(0, data_from_host.size());
|
|
|
|
spi_transaction_ext_t transaction;
|
|
transaction = spi_transaction_ext_t{
|
|
.base = {
|
|
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
|
|
.cmd = SPI_WRITE_BUFFER_CMD,
|
|
.addr = offset,
|
|
.length = static_cast<size_t>(data_from_host.size() * 8),
|
|
.rxlength = static_cast<size_t>(rx_buffer.size() * 8),
|
|
.tx_buffer = data_from_host.data(),
|
|
.rx_buffer = rx_buffer.data(),
|
|
},
|
|
.command_bits = static_cast<uint8_t>(CMD_BIT_SIZE),
|
|
.address_bits = static_cast<uint8_t>(OFFSET_BIT_SIZE),
|
|
.dummy_bits = 0,
|
|
};
|
|
|
|
esp_err_t err = spi_device_transmit(details::spi_device, &transaction.base);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "spi transmit: %s (%d)", esp_err_to_name(err), err);
|
|
return ue_t{error::FAILED};
|
|
}
|
|
|
|
if (const auto err = verify_statuses(rx_buffer); err != error::OK) {
|
|
return ue_t{err};
|
|
}
|
|
|
|
return {};
|
|
}
|
|
}
|