ALPAKA/sta-core
1
0
Fork 0
mirror of https://git.intern.spaceteamaachen.de/ALPAKA/sta-core.git synced 2025-06-10 16:55:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added some buxfixes to spi code

Browse Source
This commit is contained in:
Dario 2023-05-16 21:15:53 +01:00
parent 0bc924bba2
commit 38bdbbe526
12 changed files with 186 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/sta/config.hpp Normal file
View File

@ -0,0 +1,11 @@
#ifndef STA_CONFIG
#define STA_CONFIG
// Use the raspberry pi for this project.
#include <sta/raspi/mcu/common.hpp>
// #define DEBUG
#define STA_PRINTF_USE_STDLIB
#define STA_DEBUG_PRINTF
#endif

16
include/sta/printable.hpp
View File

@ -70,14 +70,6 @@ namespace sta
*/
void print(uint32_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num Integer
* @param base Integer base
*/
void print(size_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print c-string.
*
@ -143,14 +135,6 @@ namespace sta
*/
void println(uint32_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num Integer
* @param base Integer base
*/
void println(size_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print c-string followed by a new-line.
*

44
include/sta/raspi/delay.hpp Normal file
View File

@ -0,0 +1,44 @@
/**
* @file
* @brief Delay functions.
*
* Configuration:
* * STA_RASPI_DELAY_US_TIM: 1 MHz TIM instance used by sta::delayUs
*
* NOTE: TIM time base must be started before use of sta::delayUs by calling sta::initHAL.
* When using startup system task this is handled automatically.
*/
#ifndef STA_CORE_RASPI_DELAY_HPP
#define STA_CORE_RASPI_DELAY_HPP
// Only enable module on RASPI platform
#include <sta/config.hpp>
#if defined(STA_PLATFORM_RASPI) || defined(DOXYGEN)
#include <cstdint>
namespace sta
{
/**
* @brief Millisecond delay.
*
* @param ms Milliseconds
*/
void delayMs(uint32_t ms);
/**
* @brief Microsecond delay.
*
* @param us Microseconds
*/
void delayUs(uint32_t us);
} // namespace sta
#endif // STA_PLATFORM_RASPI
#endif // STA_CORE_RASPI_DELAY_HPP

6
include/sta/raspi/gpio_pin.hpp
View File

@ -37,12 +37,6 @@ namespace sta
uint8_t pin_;
GpioMode mode_;
};
class DummyGpioPin : public RaspiGpioPin {
DummyGpioPin();
void setState(GpioPinState state) override;
};
} // namespace sta
#endif // STA_RASPI_GPIO_ENABLED

8
include/sta/raspi/spi.hpp
View File

@ -36,9 +36,15 @@ namespace sta
int spifd_;
bool open_;
const bool persistent_open_;
SPISettings settings_;
uint8_t mode_;
uint8_t dataSize_;
uint8_t bitOrder_;
uint32_t clkSpeed_;
void update_setting(int setting, int value);
int get_setting(int setting, void * rslt_ptr);
void get_setting(int setting, void * rslt_ptr);
void update_settings();
};

3
include/sta/spi/spi.hpp
View File

@ -81,8 +81,7 @@ namespace sta
*
* @return %SPI settings
*/
const SPISettings & settings() const;
const SPISettings & settings();
/**
* @brief Acquire usage rights to use the interface.

38
src/printable.cpp
View File

@ -2,6 +2,8 @@
#include <cinttypes>
#include <cstring>
#include <sta/assert.hpp>
#include <sta/lang.hpp>
namespace sta
{
@ -22,17 +24,17 @@ namespace sta
print(buffer);
}
void print(uint8_t num, IntegerBase base /* = IntegerBase::DEC */)
void print(uint8_t num, IntegerBase base)
{
printBase(num, base, "%" PRIu8, sizeof(num));
}
void print(uint16_t num, IntegerBase base /* = IntegerBase::DEC */)
void print(uint16_t num, IntegerBase base)
{
printBase(num, base, "%" PRIu16, sizeof(num));
}
void print(uint32_t num, IntegerBase base /* = IntegerBase::DEC */)
void print(uint32_t num, IntegerBase base)
{
printBase(num, base, "%" PRIu32, sizeof(num));
}
@ -42,6 +44,10 @@ namespace sta
print(str, strlen(str));
}
void print(const char * str, size_t length) {
print(str, length);
}
void println()
{
print("\r\n", 2);
@ -65,19 +71,19 @@ namespace sta
println();
}
void println(uint8_t num, IntegerBase base /* = IntegerBase::DEC */)
void println(uint8_t num, IntegerBase base)
{
print(num, base);
println();
}
void println(uint16_t num, IntegerBase base /* = IntegerBase::DEC */)
void println(uint16_t num, IntegerBase base)
{
print(num, base);
println();
}
void println(uint32_t num, IntegerBase base /* = IntegerBase::DEC */)
void println(uint32_t num, IntegerBase base)
{
print(num, base);
println();
@ -96,12 +102,26 @@ namespace sta
void printBase(uintmax_t value, IntegerBase base, const char * fmt, size_t size)
{
switch (base)
{
case IntegerBase::DEC:
printDec(value, fmt);
break;
case IntegerBase::HEX:
printHex(value, size);
break;
case IntegerBase::BIN:
printBin(value, size);
break;
default:
STA_ASSERT_MSG(false, "Case for IntegerBase enum not handled");
STA_UNREACHABLE();
}
}
void printDec(uintmax_t value, const char * fmt)
{
printf(fmt, value);
}
void printBin(uintmax_t value, size_t digits)
@ -111,7 +131,7 @@ namespace sta
void printHex(uintmax_t value, size_t digits)
{
printf("%x", value);
}
} // namespace sta

23
src/raspi/delay.cpp Normal file
View File

@ -0,0 +1,23 @@
#include <sta/raspi/delay.hpp>
#ifdef STA_PLATFORM_RASPI
#include <sta/raspi/hal.hpp>
#include <sta/assert.hpp>
#include <sta/lang.hpp>
namespace sta
{
void delayMs(uint32_t ms)
{
delay(ms);
}
void delayUs(uint32_t us)
{
delayMicroseconds(us);
}
} // namespace sta
#endif // STA_PLATFORM_RASPI

13
src/raspi/gpio_pin.cpp
View File

@ -16,15 +16,12 @@ namespace sta
digitalWrite(pin_, state == GpioPinState::GPIO_LOW ? LOW : HIGH);
}
DummyGpioPin::DummyGpioPin() : RaspiGpioPin { -1 , GpioMode::GPIO_INPUT }
{
class DummyGpioPin : public RaspiGpioPin {
public:
DummyGpioPin() : RaspiGpioPin { 0, GpioMode::GPIO_INPUT } {}
}
void DummyGpioPin::setState(GpioPinState state)
{
// Don't do anything.
}
void setState(GpioPinState state) override {}
};
static DummyGpioPin dummyGpio;

85
src/raspi/spi.cpp
View File

@ -10,12 +10,14 @@
#include <cstdlib>
#include <string.h>
#include <cstdio>
// Imports needed for SPI handling on Linux.
#include <linux/spi/spidev.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#define STA_DEBUG_IOCTL_WRITE(result) STA_ASSERT_MSG(result >= 0, "ioctl writing failed!")
#define STA_DEBUG_IOCTL_READ(result) STA_ASSERT_MSG(result >= 0, "ioctl reading failed!")
@ -28,8 +30,8 @@
namespace sta
{
RaspiSPI::RaspiSPI(SPINode node, const SPISettings & settings, Mutex * mutex, bool persistent_open = true)
: SPI(settings, mutex), open_{ false }, persistent_open_{ persistent_open }
RaspiSPI::RaspiSPI(SPINode node, const SPISettings & settings, Mutex * mutex, bool persistent_open)
: SPI(settings, mutex), open_{ false }, persistent_open_{ persistent_open }, settings_{ settings }
{
// Check validity of parameters.
STA_DEBUG_NULLPTR(mutex);
@ -60,6 +62,8 @@ namespace sta
STA_DEBUG_FD_OPEN();
struct spi_ioc_transfer spi_message[1];
// According to the documentation, spi_message should be zero intialized.
memset(spi_message, 0, sizeof(spi_message));
spi_message[0].tx_buf = (unsigned long)&value;
spi_message[0].len = 1;
@ -74,6 +78,8 @@ namespace sta
STA_DEBUG_FD_OPEN();
struct spi_ioc_transfer spi_message[1];
// According to the documentation, spi_message should be zero intialized.
memset(spi_message, 0, sizeof(spi_message));
spi_message[0].tx_buf = (unsigned long)&value;
spi_message[0].len = 1;
@ -90,10 +96,18 @@ namespace sta
STA_ASSERT_MSG(size != 0, "Buffer size cannot be 0!");
struct spi_ioc_transfer spi_message[1];
// According to the documentation, spi_message should be zero intialized.
memset(spi_message, 0, sizeof(spi_message));
spi_message[0].tx_buf = (unsigned long)buffer;
spi_message[0].len = size;
printf("Sending ");
for (int i = 0; i < size; i++) {
printf("%x, ", buffer[i]);
}
printf("\n");
int result = ioctl(spifd_, SPI_IOC_MESSAGE(1), spi_message);
STA_DEBUG_IOCTL_SEND(result);
@ -107,6 +121,8 @@ namespace sta
STA_ASSERT_MSG(size != 0, "Buffer size cannot be 0!");
struct spi_ioc_transfer spi_message[1];
// According to the documentation, spi_message should be zero intialized.
memset(spi_message, 0, sizeof(spi_message));
spi_message[0].rx_buf = (unsigned long)rxBuffer;
@ -115,6 +131,10 @@ namespace sta
int result = ioctl(spifd_, SPI_IOC_MESSAGE(1), spi_message);
if (result == -1) {
printf("Sending failed with error '%s'! \n", strerror(errno));
}
STA_DEBUG_IOCTL_SEND(result);
}
@ -125,6 +145,8 @@ namespace sta
STA_ASSERT_MSG(size != 0, "Buffer size cannot be 0!");
struct spi_ioc_transfer spi_message[1];
// According to the documentation, spi_message should be zero intialized.
memset(spi_message, 0, sizeof(spi_message));
spi_message[0].rx_buf = (unsigned long)buffer;
@ -132,6 +154,12 @@ namespace sta
int result = ioctl(spifd_, SPI_IOC_MESSAGE(1), spi_message);
printf("Receiving ");
for (int i = 0; i < size; i++) {
printf("%x, ", buffer[i]);
}
printf("\n");
STA_DEBUG_IOCTL_SEND(result);
}
@ -157,70 +185,75 @@ namespace sta
void RaspiSPI::update_setting(int setting, int value)
{
STA_DEBUG_FD_OPEN();
int result = ioctl(spifd_, setting, value);
STA_DEBUG_IOCTL_WRITE(result);
}
int RaspiSPI::get_setting(int setting, void * rslt_ptr)
void RaspiSPI::get_setting(int setting, void * rslt_ptr)
{
STA_DEBUG_FD_OPEN();
int result = ioctl(spifd_, setting, rslt_ptr);
STA_DEBUG_IOCTL_READ(result);
STA_DEBUG_IOCTL_READ(result);
}
void RaspiSPI::update_settings()
{
SPISettings settings = this->settings();
int mode;
STA_DEBUG_FD_OPEN();
switch (settings.mode)
switch (settings_.mode)
{
case SPIMode::MODE_0:
mode = SPI_MODE_0;
mode_ = SPI_MODE_0;
break;
case SPIMode::MODE_1:
mode = SPI_MODE_1;
mode_ = SPI_MODE_1;
break;
case SPIMode::MODE_2:
mode = SPI_MODE_2;
mode_ = SPI_MODE_2;
break;
case SPIMode::MODE_3:
mode = SPI_MODE_3;
mode_ = SPI_MODE_3;
break;
default:
STA_ASSERT_MSG(false, "Case for SPIMode enum not handled");
STA_UNREACHABLE();
}
dataSize_ = settings_.dataSize == SPIDataSize::SIZE_8 ? 0 : 16;
bitOrder_ = settings_.bitOrder == SPIBitOrder::MSB ? 0 : 1;
clkSpeed_ = settings_.clkSpeed;
// Set the spi mode.
update_setting(SPI_IOC_WR_MODE, mode);
int result = ioctl(spifd_, SPI_IOC_WR_MODE, &mode_);
STA_DEBUG_IOCTL_WRITE(result);
// Set the word size. According to the documentation "the value zero signifies eight bits".
update_setting(SPI_IOC_WR_BITS_PER_WORD, settings.dataSize == SPIDataSize::SIZE_8 ? 0 : 16);
result = ioctl(spifd_, SPI_IOC_WR_BITS_PER_WORD, &dataSize_);
STA_DEBUG_IOCTL_WRITE(result);
// Set the bit order. According to the documentation zero means MSB first, everything else means LSB first.
update_setting(SPI_IOC_WR_LSB_FIRST, settings.bitOrder == SPIBitOrder::MSB ? 0 : 1);
result = ioctl(spifd_, SPI_IOC_WR_LSB_FIRST, &bitOrder_);
STA_DEBUG_IOCTL_WRITE(result);
// Set the maximum clock speed.
update_setting(SPI_IOC_WR_MAX_SPEED_HZ, settings.clkSpeed);
result = ioctl(spifd_, SPI_IOC_WR_MAX_SPEED_HZ, &clkSpeed_);
STA_DEBUG_IOCTL_WRITE(result);
#if defined(DEBUG)
uint8_t r_mode = 0;
get_setting(SPI_IOC_RD_MODE, &r_mode);
STA_ASSERT_MSG(r_mode == mode, "The mode wasn't set correctly!");
STA_ASSERT_MSG(r_mode == mode_, "The mode wasn't set correctly!");
uint8_t r_dataSize = 0;
get_setting(SPI_IOC_WR_BITS_PER_WORD, &r_dataSize);
STA_ASSERT_MSG(r_dataSize == (settings.dataSize == SPIDataSize::SIZE_8 ? 0 : 16), "The data size wasn't set correctly!");
STA_ASSERT_MSG(r_dataSize == (settings_.dataSize == SPIDataSize::SIZE_8 ? 8 : 16), "The data size wasn't set correctly!");
uint8_t r_bitOrder = 0;
get_setting(SPI_IOC_RD_LSB_FIRST, &r_bitOrder);
STA_ASSERT_MSG(r_bitOrder == (settings.bitOrder == SPIBitOrder::MSB ? 0 : 1), "The data size wasn't set correctly!");
STA_ASSERT_MSG(r_bitOrder == (settings_.bitOrder == SPIBitOrder::MSB ? 0 : 1), "The data size wasn't set correctly!");
uint32_t r_clk_Speed;
get_setting(SPI_IOC_RD_MAX_SPEED_HZ, &r_clk_Speed);
STA_ASSERT_MSG(r_clk_Speed == settings.clkSpeed, "The clock speed wasn't set correctly!");
STA_ASSERT_MSG(r_clk_Speed == settings_.clkSpeed, "The clock speed wasn't set correctly!");
#endif // STA_DEBUG
}
@ -235,16 +268,18 @@ namespace sta
return;
spifd_ = open(spidev_, O_RDWR);
STA_ASSERT(spifd_ >= 0);
open_ = true;
STA_ASSERT(spifd_ >= 0);
update_settings();
}
void RaspiSPI::release()
{
if (!persistent_open_) {
STA_ASSERT_MSG(open_, "'release' was called despite the device being closed! This has to be a bug!");
if (!persistent_open_ && open_) {
close(spifd_);
}

3
src/spi/spi.cpp
View File

@ -1,5 +1,6 @@
#include <sta/spi/spi.hpp>
#include <cstdio>
namespace sta
{
@ -7,7 +8,7 @@ namespace sta
: settings_{settings}, mutex_{mutex}
{}
const SPISettings & SPI::settings() const
const SPISettings & SPI::settings()
{
return settings_;
}

4
src/stm32/i2c.cpp
View File

@ -1,5 +1,7 @@
#include <sta/stm32/i2c.hpp>
#if false
namespace sta {
STM32I2cDevice::STM32I2cDevice(I2C_HandleTypeDef* i2cHandle, uint16_t address, Mutex* mutex, bool master, bool blocking)
: I2cDevice(address, mutex, master, blocking) {
@ -51,3 +53,5 @@ namespace sta {
return res == HAL_OK;
}
}
#endif // false