ALPAKA/sta-core
1
0
Fork 0
mirror of https://git.intern.spaceteamaachen.de/ALPAKA/sta-core.git synced 2025-08-06 10:27:34 +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
Download Patch File Download Diff File Expand all files Collapse all files

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