reorganized source, wip
Clyne Sullivan
3 years ago
parent
d24ed15843
commit
123cc4c756
@ -1,3 +1,3 @@
|
|||||||
source [find interface/stlink.cfg]
|
source [find interface/stlink.cfg]
|
||||||
source [find target/stm32h7x.cfg]
|
source [find target/stm32l4x.cfg]
|
||||||
|
|
||||||
|
|||||||
@ -0,0 +1,291 @@
|
|||||||
|
#include "communication.hpp"
|
||||||
|
|
||||||
|
#include "ch.h"
|
||||||
|
#include "hal.h"
|
||||||
|
|
||||||
|
#include "periph/adc.hpp"
|
||||||
|
#include "periph/dac.hpp"
|
||||||
|
#include "periph/usbserial.hpp"
|
||||||
|
#include "elfload.hpp"
|
||||||
|
#include "error.hpp"
|
||||||
|
#include "conversion.hpp"
|
||||||
|
#include "runstatus.hpp"
|
||||||
|
#include "samples.hpp"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <tuple>
|
||||||
|
|
||||||
|
__attribute__((section(".stacks")))
|
||||||
|
std::array<char, 4096> CommunicationManager::m_thread_stack = {};
|
||||||
|
|
||||||
|
void CommunicationManager::begin()
|
||||||
|
{
|
||||||
|
chThdCreateStatic(m_thread_stack.data(),
|
||||||
|
m_thread_stack.size(),
|
||||||
|
NORMALPRIO,
|
||||||
|
threadComm,
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void writeADCBuffer(unsigned char *);
|
||||||
|
static void setBufferSize(unsigned char *);
|
||||||
|
static void updateGenerator(unsigned char *);
|
||||||
|
static void loadAlgorithm(unsigned char *);
|
||||||
|
static void readStatus(unsigned char *);
|
||||||
|
static void startConversionMeasure(unsigned char *);
|
||||||
|
static void startConversion(unsigned char *);
|
||||||
|
static void stopConversion(unsigned char *);
|
||||||
|
static void startGenerator(unsigned char *);
|
||||||
|
static void readADCBuffer(unsigned char *);
|
||||||
|
static void readDACBuffer(unsigned char *);
|
||||||
|
static void unloadAlgorithm(unsigned char *);
|
||||||
|
static void readIdentifier(unsigned char *);
|
||||||
|
static void readExecTime(unsigned char *);
|
||||||
|
static void sampleRate(unsigned char *);
|
||||||
|
static void readConversionResults(unsigned char *);
|
||||||
|
static void readConversionInput(unsigned char *);
|
||||||
|
static void readMessage(unsigned char *);
|
||||||
|
static void stopGenerator(unsigned char *);
|
||||||
|
|
||||||
|
static const std::array<std::pair<char, void (*)(unsigned char *)>, 19> commandTable {{
|
||||||
|
{'A', writeADCBuffer},
|
||||||
|
{'B', setBufferSize},
|
||||||
|
{'D', updateGenerator},
|
||||||
|
{'E', loadAlgorithm},
|
||||||
|
{'I', readStatus},
|
||||||
|
{'M', startConversionMeasure},
|
||||||
|
{'R', startConversion},
|
||||||
|
{'S', stopConversion},
|
||||||
|
{'W', startGenerator},
|
||||||
|
{'a', readADCBuffer},
|
||||||
|
{'d', readDACBuffer},
|
||||||
|
{'e', unloadAlgorithm},
|
||||||
|
{'i', readIdentifier},
|
||||||
|
{'m', readExecTime},
|
||||||
|
{'r', sampleRate},
|
||||||
|
{'s', readConversionResults},
|
||||||
|
{'t', readConversionInput},
|
||||||
|
{'u', readMessage},
|
||||||
|
{'w', stopGenerator}
|
||||||
|
}};
|
||||||
|
|
||||||
|
void CommunicationManager::threadComm(void *)
|
||||||
|
{
|
||||||
|
while (1) {
|
||||||
|
if (USBSerial::isActive()) {
|
||||||
|
// Attempt to receive a command packet
|
||||||
|
if (unsigned char cmd[3]; USBSerial::read(&cmd[0], 1) > 0) {
|
||||||
|
// Packet received, first byte represents the desired command/action
|
||||||
|
auto func = std::find_if(commandTable.cbegin(), commandTable.cend(),
|
||||||
|
[&cmd](const auto& f) { return f.first == cmd[0]; });
|
||||||
|
if (func != commandTable.cend())
|
||||||
|
func->second(cmd);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
chThdSleepMicroseconds(100);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void writeADCBuffer(unsigned char *)
|
||||||
|
{
|
||||||
|
USBSerial::read(Samples::In.bytedata(), Samples::In.bytesize());
|
||||||
|
}
|
||||||
|
|
||||||
|
void setBufferSize(unsigned char *cmd)
|
||||||
|
{
|
||||||
|
if (EM.assert(run_status == RunStatus::Idle, Error::NotIdle) &&
|
||||||
|
EM.assert(USBSerial::read(&cmd[1], 2) == 2, Error::BadParamSize))
|
||||||
|
{
|
||||||
|
// count is multiplied by two since this command receives size of buffer
|
||||||
|
// for each algorithm application.
|
||||||
|
unsigned int count = (cmd[1] | (cmd[2] << 8)) * 2;
|
||||||
|
if (EM.assert(count <= MAX_SAMPLE_BUFFER_SIZE, Error::BadParam)) {
|
||||||
|
Samples::In.setSize(count);
|
||||||
|
Samples::Out.setSize(count);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void updateGenerator(unsigned char *cmd)
|
||||||
|
{
|
||||||
|
if (EM.assert(USBSerial::read(&cmd[1], 2) == 2, Error::BadParamSize)) {
|
||||||
|
unsigned int count = cmd[1] | (cmd[2] << 8);
|
||||||
|
if (EM.assert(count <= MAX_SAMPLE_BUFFER_SIZE, Error::BadParam)) {
|
||||||
|
if (run_status == RunStatus::Idle) {
|
||||||
|
Samples::Generator.setSize(count);
|
||||||
|
USBSerial::read(
|
||||||
|
reinterpret_cast<uint8_t *>(Samples::Generator.data()),
|
||||||
|
Samples::Generator.bytesize());
|
||||||
|
} else if (run_status == RunStatus::Running) {
|
||||||
|
int more;
|
||||||
|
do {
|
||||||
|
chThdSleepMicroseconds(10);
|
||||||
|
more = DAC::sigGenWantsMore();
|
||||||
|
} while (more == -1);
|
||||||
|
|
||||||
|
USBSerial::read(reinterpret_cast<uint8_t *>(
|
||||||
|
more == 0 ? Samples::Generator.data() : Samples::Generator.middata()),
|
||||||
|
Samples::Generator.bytesize() / 2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void loadAlgorithm(unsigned char *cmd)
|
||||||
|
{
|
||||||
|
if (EM.assert(run_status == RunStatus::Idle, Error::NotIdle) &&
|
||||||
|
EM.assert(USBSerial::read(&cmd[1], 2) == 2, Error::BadParamSize))
|
||||||
|
{
|
||||||
|
// Only load the binary if it can fit in the memory reserved for it.
|
||||||
|
unsigned int size = cmd[1] | (cmd[2] << 8);
|
||||||
|
if (EM.assert(size < MAX_ELF_FILE_SIZE, Error::BadUserCodeSize)) {
|
||||||
|
USBSerial::read(ELFManager::fileBuffer(), size);
|
||||||
|
auto entry = ELFManager::loadFromInternalBuffer();
|
||||||
|
EM.assert(entry != nullptr, Error::BadUserCodeLoad);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void readStatus(unsigned char *)
|
||||||
|
{
|
||||||
|
unsigned char buf[2] = {
|
||||||
|
static_cast<unsigned char>(run_status),
|
||||||
|
static_cast<unsigned char>(EM.pop())
|
||||||
|
};
|
||||||
|
|
||||||
|
USBSerial::write(buf, sizeof(buf));
|
||||||
|
}
|
||||||
|
|
||||||
|
void startConversionMeasure(unsigned char *)
|
||||||
|
{
|
||||||
|
if (EM.assert(run_status == RunStatus::Idle, Error::NotIdle)) {
|
||||||
|
run_status = RunStatus::Running;
|
||||||
|
ConversionManager::startMeasured();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void startConversion(unsigned char *)
|
||||||
|
{
|
||||||
|
if (EM.assert(run_status == RunStatus::Idle, Error::NotIdle)) {
|
||||||
|
run_status = RunStatus::Running;
|
||||||
|
ConversionManager::start();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void stopConversion(unsigned char *)
|
||||||
|
{
|
||||||
|
if (run_status == RunStatus::Running) {
|
||||||
|
ConversionManager::stop();
|
||||||
|
run_status = RunStatus::Idle;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void startGenerator(unsigned char *)
|
||||||
|
{
|
||||||
|
DAC::start(1, Samples::Generator.data(), Samples::Generator.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
void readADCBuffer(unsigned char *)
|
||||||
|
{
|
||||||
|
USBSerial::write(Samples::In.bytedata(), Samples::In.bytesize());
|
||||||
|
}
|
||||||
|
|
||||||
|
void readDACBuffer(unsigned char *)
|
||||||
|
{
|
||||||
|
|
||||||
|
USBSerial::write(Samples::Out.bytedata(), Samples::Out.bytesize());
|
||||||
|
}
|
||||||
|
|
||||||
|
void unloadAlgorithm(unsigned char *)
|
||||||
|
{
|
||||||
|
ELFManager::unload();
|
||||||
|
}
|
||||||
|
|
||||||
|
void readIdentifier(unsigned char *)
|
||||||
|
{
|
||||||
|
#if defined(TARGET_PLATFORM_H7)
|
||||||
|
USBSerial::write(reinterpret_cast<const uint8_t *>("stmdsph"), 7);
|
||||||
|
#else
|
||||||
|
USBSerial::write(reinterpret_cast<const uint8_t *>("stmdspl"), 7);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
void readExecTime(unsigned char *)
|
||||||
|
{
|
||||||
|
USBSerial::write(reinterpret_cast<uint8_t *>(&conversion_time_measurement.last),
|
||||||
|
sizeof(rtcnt_t));
|
||||||
|
}
|
||||||
|
|
||||||
|
void sampleRate(unsigned char *cmd)
|
||||||
|
{
|
||||||
|
if (EM.assert(USBSerial::read(&cmd[1], 1) == 1, Error::BadParamSize)) {
|
||||||
|
if (cmd[1] == 0xFF) {
|
||||||
|
unsigned char r = SClock::getRate();
|
||||||
|
USBSerial::write(&r, 1);
|
||||||
|
} else {
|
||||||
|
auto r = static_cast<SClock::Rate>(cmd[1]);
|
||||||
|
SClock::setRate(r);
|
||||||
|
ADC::setRate(r);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void readConversionResults(unsigned char *)
|
||||||
|
{
|
||||||
|
if (auto samps = Samples::Out.modified(); samps != nullptr) {
|
||||||
|
unsigned char buf[2] = {
|
||||||
|
static_cast<unsigned char>(Samples::Out.size() / 2 & 0xFF),
|
||||||
|
static_cast<unsigned char>(((Samples::Out.size() / 2) >> 8) & 0xFF)
|
||||||
|
};
|
||||||
|
USBSerial::write(buf, 2);
|
||||||
|
unsigned int total = Samples::Out.bytesize() / 2;
|
||||||
|
unsigned int offset = 0;
|
||||||
|
unsigned char unused;
|
||||||
|
while (total > 512) {
|
||||||
|
USBSerial::write(reinterpret_cast<uint8_t *>(samps) + offset, 512);
|
||||||
|
while (USBSerial::read(&unused, 1) == 0);
|
||||||
|
offset += 512;
|
||||||
|
total -= 512;
|
||||||
|
}
|
||||||
|
USBSerial::write(reinterpret_cast<uint8_t *>(samps) + offset, total);
|
||||||
|
while (USBSerial::read(&unused, 1) == 0);
|
||||||
|
} else {
|
||||||
|
USBSerial::write(reinterpret_cast<const uint8_t *>("\0\0"), 2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void readConversionInput(unsigned char *)
|
||||||
|
{
|
||||||
|
if (auto samps = Samples::In.modified(); samps != nullptr) {
|
||||||
|
unsigned char buf[2] = {
|
||||||
|
static_cast<unsigned char>(Samples::In.size() / 2 & 0xFF),
|
||||||
|
static_cast<unsigned char>(((Samples::In.size() / 2) >> 8) & 0xFF)
|
||||||
|
};
|
||||||
|
USBSerial::write(buf, 2);
|
||||||
|
unsigned int total = Samples::In.bytesize() / 2;
|
||||||
|
unsigned int offset = 0;
|
||||||
|
unsigned char unused;
|
||||||
|
while (total > 512) {
|
||||||
|
USBSerial::write(reinterpret_cast<uint8_t *>(samps) + offset, 512);
|
||||||
|
while (USBSerial::read(&unused, 1) == 0);
|
||||||
|
offset += 512;
|
||||||
|
total -= 512;
|
||||||
|
}
|
||||||
|
USBSerial::write(reinterpret_cast<uint8_t *>(samps) + offset, total);
|
||||||
|
while (USBSerial::read(&unused, 1) == 0);
|
||||||
|
} else {
|
||||||
|
USBSerial::write(reinterpret_cast<const uint8_t *>("\0\0"), 2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void readMessage(unsigned char *)
|
||||||
|
{
|
||||||
|
//USBSerial::write(reinterpret_cast<uint8_t *>(userMessageBuffer), userMessageSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
void stopGenerator(unsigned char *)
|
||||||
|
{
|
||||||
|
DAC::stop(1);
|
||||||
|
}
|
||||||
|
|
||||||
@ -0,0 +1,29 @@
|
|||||||
|
/**
|
||||||
|
* @file communication.hpp
|
||||||
|
* @brief Manages communication with the host computer.
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef STMDSP_COMMUNICATION_HPP
|
||||||
|
#define STMDSP_COMMUNICATION_HPP
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
|
||||||
|
class CommunicationManager
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static void begin();
|
||||||
|
|
||||||
|
private:
|
||||||
|
static void threadComm(void *);
|
||||||
|
|
||||||
|
static std::array<char, 4096> m_thread_stack;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // STMDSP_COMMUNICATION_HPP
|
||||||
|
|
||||||
@ -0,0 +1,206 @@
|
|||||||
|
#include "conversion.hpp"
|
||||||
|
|
||||||
|
#include "periph/adc.hpp"
|
||||||
|
#include "periph/dac.hpp"
|
||||||
|
#include "elfload.hpp"
|
||||||
|
#include "error.hpp"
|
||||||
|
#include "runstatus.hpp"
|
||||||
|
#include "samples.hpp"
|
||||||
|
|
||||||
|
constexpr msg_t MSG_CONVFIRST = 1;
|
||||||
|
constexpr msg_t MSG_CONVSECOND = 2;
|
||||||
|
constexpr msg_t MSG_CONVFIRST_MEASURE = 3;
|
||||||
|
constexpr msg_t MSG_CONVSECOND_MEASURE = 4;
|
||||||
|
|
||||||
|
constexpr auto MSG_FOR_FIRST = [](msg_t m) { return m & 1; };
|
||||||
|
constexpr auto MSG_FOR_MEASURE = [](msg_t m) { return m > 2; };
|
||||||
|
|
||||||
|
time_measurement_t conversion_time_measurement;
|
||||||
|
|
||||||
|
__attribute__((section(".convdata")))
|
||||||
|
thread_t *ConversionManager::m_thread_monitor = nullptr;
|
||||||
|
thread_t *ConversionManager::m_thread_runner = nullptr;
|
||||||
|
|
||||||
|
__attribute__((section(".stacks")))
|
||||||
|
std::array<char, 1024> ConversionManager::m_thread_monitor_stack = {};
|
||||||
|
__attribute__((section(".stacks")))
|
||||||
|
std::array<char, 128> ConversionManager::m_thread_runner_entry_stack = {};
|
||||||
|
__attribute__((section(".convdata")))
|
||||||
|
std::array<char, CONVERSION_THREAD_STACK_SIZE> ConversionManager::m_thread_runner_stack = {};
|
||||||
|
|
||||||
|
std::array<msg_t, 2> ConversionManager::m_mailbox_buffer;
|
||||||
|
mailbox_t ConversionManager::m_mailbox = _MAILBOX_DATA(m_mailbox, m_mailbox_buffer.data(), m_mailbox_buffer.size());
|
||||||
|
|
||||||
|
void ConversionManager::begin()
|
||||||
|
{
|
||||||
|
m_thread_monitor = chThdCreateStatic(m_thread_monitor_stack.data(),
|
||||||
|
m_thread_monitor_stack.size(),
|
||||||
|
NORMALPRIO + 1,
|
||||||
|
threadMonitor,
|
||||||
|
nullptr);
|
||||||
|
auto runner_stack_end = &m_thread_runner_stack[CONVERSION_THREAD_STACK_SIZE];
|
||||||
|
m_thread_runner = chThdCreateStatic(m_thread_runner_entry_stack.data(),
|
||||||
|
m_thread_runner_entry_stack.size(),
|
||||||
|
HIGHPRIO,
|
||||||
|
threadRunnerEntry,
|
||||||
|
runner_stack_end);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::start()
|
||||||
|
{
|
||||||
|
Samples::Out.clear();
|
||||||
|
ADC::start(Samples::In.data(), Samples::In.size(), adcReadHandler);
|
||||||
|
DAC::start(0, Samples::Out.data(), Samples::Out.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::startMeasured()
|
||||||
|
{
|
||||||
|
Samples::Out.clear();
|
||||||
|
ADC::start(Samples::In.data(), Samples::In.size(), adcReadHandlerMeasure);
|
||||||
|
DAC::start(0, Samples::Out.data(), Samples::Out.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::stop()
|
||||||
|
{
|
||||||
|
DAC::stop(0);
|
||||||
|
ADC::stop();
|
||||||
|
}
|
||||||
|
|
||||||
|
thread_t *ConversionManager::getMonitorHandle()
|
||||||
|
{
|
||||||
|
return m_thread_monitor;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::abort()
|
||||||
|
{
|
||||||
|
ELFManager::unload();
|
||||||
|
EM.add(Error::ConversionAborted);
|
||||||
|
run_status = RunStatus::Recovering;
|
||||||
|
|
||||||
|
// Confirm that the exception return thread is the algorithm...
|
||||||
|
uint32_t *psp;
|
||||||
|
asm("mrs %0, psp" : "=r" (psp));
|
||||||
|
|
||||||
|
bool isRunnerStack =
|
||||||
|
(uint32_t)psp >= reinterpret_cast<uint32_t>(m_thread_runner_stack.data()) &&
|
||||||
|
(uint32_t)psp <= reinterpret_cast<uint32_t>(m_thread_runner_stack.data() +
|
||||||
|
m_thread_runner_stack.size());
|
||||||
|
|
||||||
|
if (isRunnerStack)
|
||||||
|
{
|
||||||
|
// If it is, we can force the algorithm to exit by "resetting" its thread.
|
||||||
|
// We do this by rebuilding the thread's stacked exception return.
|
||||||
|
auto newpsp = reinterpret_cast<uint32_t *>(m_thread_runner_stack.data() +
|
||||||
|
m_thread_runner_stack.size() -
|
||||||
|
8 * sizeof(uint32_t));
|
||||||
|
// Set the LR register to the thread's entry point.
|
||||||
|
newpsp[5] = reinterpret_cast<uint32_t>(threadRunner);
|
||||||
|
// Overwrite the instruction we'll return to with "bx lr" (jump to address in LR).
|
||||||
|
newpsp[6] = psp[6];
|
||||||
|
*reinterpret_cast<uint16_t *>(newpsp[6]) = 0x4770; // "bx lr"
|
||||||
|
// Keep PSR contents (bit set forces Thumb mode, just in case).
|
||||||
|
newpsp[7] = psp[7] | (1 << 24);
|
||||||
|
// Set the new stack pointer.
|
||||||
|
asm("msr psp, %0" :: "r" (newpsp));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::threadMonitor(void *)
|
||||||
|
{
|
||||||
|
while (1) {
|
||||||
|
msg_t message;
|
||||||
|
msg_t fetch = chMBFetchTimeout(&m_mailbox, &message, TIME_INFINITE);
|
||||||
|
if (fetch == MSG_OK)
|
||||||
|
chMsgSend(m_thread_runner, message);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::threadRunnerEntry(void *stack)
|
||||||
|
{
|
||||||
|
ELFManager::unload();
|
||||||
|
port_unprivileged_jump(reinterpret_cast<uint32_t>(threadRunner),
|
||||||
|
reinterpret_cast<uint32_t>(stack));
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((section(".convcode")))
|
||||||
|
void ConversionManager::threadRunner(void *)
|
||||||
|
{
|
||||||
|
while (1) {
|
||||||
|
// Sleep until we receive a mailbox message.
|
||||||
|
msg_t message;
|
||||||
|
asm("svc 0; mov %0, r0" : "=r" (message));
|
||||||
|
|
||||||
|
if (message != 0) {
|
||||||
|
auto samples = MSG_FOR_FIRST(message) ? Samples::In.data()
|
||||||
|
: Samples::In.middata();
|
||||||
|
auto size = Samples::In.size() / 2;
|
||||||
|
|
||||||
|
auto entry = ELFManager::loadedElf();
|
||||||
|
if (entry) {
|
||||||
|
// Below, we remember the stack pointer just in case the
|
||||||
|
// loaded algorithm messes things up.
|
||||||
|
uint32_t sp;
|
||||||
|
|
||||||
|
if (!MSG_FOR_MEASURE(message)) {
|
||||||
|
asm("mov %0, sp" : "=r" (sp));
|
||||||
|
samples = entry(samples, size);
|
||||||
|
asm("mov sp, %0" :: "r" (sp));
|
||||||
|
} else {
|
||||||
|
// Start execution timer:
|
||||||
|
asm("mov %0, sp; eor r0, r0; svc 2" : "=r" (sp));
|
||||||
|
samples = entry(samples, size);
|
||||||
|
// Stop execution timer:
|
||||||
|
asm("mov r0, #1; svc 2; mov sp, %0" :: "r" (sp));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update the sample out buffer with the transformed samples.
|
||||||
|
if (samples != nullptr) {
|
||||||
|
if (MSG_FOR_FIRST(message))
|
||||||
|
Samples::Out.modify(samples, size);
|
||||||
|
else
|
||||||
|
Samples::Out.midmodify(samples, size);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::adcReadHandler(adcsample_t *buffer, size_t)
|
||||||
|
{
|
||||||
|
chSysLockFromISR();
|
||||||
|
|
||||||
|
// If previous request hasn't been handled, then we're going too slow.
|
||||||
|
// We'll need to abort.
|
||||||
|
if (chMBGetUsedCountI(&m_mailbox) > 1) {
|
||||||
|
chMBResetI(&m_mailbox);
|
||||||
|
chMBResumeX(&m_mailbox);
|
||||||
|
chSysUnlockFromISR();
|
||||||
|
abort();
|
||||||
|
} else {
|
||||||
|
// Mark the modified samples as 'fresh' or ready for manipulation.
|
||||||
|
if (buffer == Samples::In.data()) {
|
||||||
|
Samples::In.setModified();
|
||||||
|
chMBPostI(&m_mailbox, MSG_CONVFIRST);
|
||||||
|
} else {
|
||||||
|
Samples::In.setMidmodified();
|
||||||
|
chMBPostI(&m_mailbox, MSG_CONVSECOND);
|
||||||
|
}
|
||||||
|
chSysUnlockFromISR();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ConversionManager::adcReadHandlerMeasure(adcsample_t *buffer, size_t)
|
||||||
|
{
|
||||||
|
chSysLockFromISR();
|
||||||
|
if (buffer == Samples::In.data()) {
|
||||||
|
Samples::In.setModified();
|
||||||
|
chMBPostI(&m_mailbox, MSG_CONVFIRST_MEASURE);
|
||||||
|
} else {
|
||||||
|
Samples::In.setMidmodified();
|
||||||
|
chMBPostI(&m_mailbox, MSG_CONVSECOND_MEASURE);
|
||||||
|
}
|
||||||
|
chSysUnlockFromISR();
|
||||||
|
|
||||||
|
ADC::setOperation(adcReadHandler);
|
||||||
|
}
|
||||||
|
|
||||||
@ -0,0 +1,67 @@
|
|||||||
|
/**
|
||||||
|
* @file conversion.hpp
|
||||||
|
* @brief Manages algorithm application (converts input samples to output).
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef STMDSP_CONVERSION_HPP
|
||||||
|
#define STMDSP_CONVERSION_HPP
|
||||||
|
|
||||||
|
#include "ch.h"
|
||||||
|
#include "hal.h"
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
|
||||||
|
constexpr unsigned int CONVERSION_THREAD_STACK_SIZE =
|
||||||
|
#if defined(TARGET_PLATFORM_H7)
|
||||||
|
62 * 1024;
|
||||||
|
#else
|
||||||
|
15 * 1024;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
class ConversionManager
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static void begin();
|
||||||
|
|
||||||
|
// Begins sample conversion.
|
||||||
|
static void start();
|
||||||
|
// Begins conversion with execution time measured.
|
||||||
|
static void startMeasured();
|
||||||
|
// Stops conversion.
|
||||||
|
static void stop();
|
||||||
|
|
||||||
|
static thread_t *getMonitorHandle();
|
||||||
|
|
||||||
|
// Internal only: Aborts a running conversion.
|
||||||
|
static void abort();
|
||||||
|
|
||||||
|
private:
|
||||||
|
static void threadMonitor(void *);
|
||||||
|
static void threadRunnerEntry(void *stack);
|
||||||
|
|
||||||
|
static void threadRunner(void *);
|
||||||
|
static void adcReadHandler(adcsample_t *buffer, size_t);
|
||||||
|
static void adcReadHandlerMeasure(adcsample_t *buffer, size_t);
|
||||||
|
|
||||||
|
static thread_t *m_thread_monitor;
|
||||||
|
static thread_t *m_thread_runner;
|
||||||
|
|
||||||
|
static std::array<char, 1024> m_thread_monitor_stack;
|
||||||
|
static std::array<char, 128> m_thread_runner_entry_stack;
|
||||||
|
static std::array<char, CONVERSION_THREAD_STACK_SIZE> m_thread_runner_stack;
|
||||||
|
|
||||||
|
static std::array<msg_t, 2> m_mailbox_buffer;
|
||||||
|
static mailbox_t m_mailbox;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Stores the measured execution time.
|
||||||
|
extern time_measurement_t conversion_time_measurement;
|
||||||
|
|
||||||
|
#endif // STMDSP_CONVERSION_HPP
|
||||||
|
|
||||||
@ -1,26 +0,0 @@
|
|||||||
/**
|
|
||||||
* @file elf_load.hpp
|
|
||||||
* @brief Loads ELF binary data into memory for execution.
|
|
||||||
*
|
|
||||||
* Copyright (C) 2021 Clyne Sullivan
|
|
||||||
*
|
|
||||||
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
|
||||||
* the GNU General Public License along with this program.
|
|
||||||
* If not, see <https://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef ELF_LOAD_HPP_
|
|
||||||
#define ELF_LOAD_HPP_
|
|
||||||
|
|
||||||
#include <cstddef>
|
|
||||||
#include <cstdint>
|
|
||||||
|
|
||||||
namespace ELF
|
|
||||||
{
|
|
||||||
using Entry = uint16_t *(*)(uint16_t *, size_t);
|
|
||||||
|
|
||||||
Entry load(void *elf_data);
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // ELF_LOAD_HPP_
|
|
||||||
|
|
||||||
@ -0,0 +1,48 @@
|
|||||||
|
/**
|
||||||
|
* @file elfload.hpp
|
||||||
|
* @brief Loads ELF binary data into memory for execution.
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef ELF_LOAD_HPP_
|
||||||
|
#define ELF_LOAD_HPP_
|
||||||
|
|
||||||
|
#include "samplebuffer.hpp"
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
#include <cstddef>
|
||||||
|
|
||||||
|
constexpr unsigned int MAX_ELF_FILE_SIZE = 16 * 1024;
|
||||||
|
|
||||||
|
class ELFManager
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using EntryFunc = Sample *(*)(Sample *, size_t);
|
||||||
|
|
||||||
|
static EntryFunc loadFromInternalBuffer();
|
||||||
|
|
||||||
|
static EntryFunc loadedElf() {
|
||||||
|
return m_entry;
|
||||||
|
}
|
||||||
|
|
||||||
|
static unsigned char *fileBuffer() {
|
||||||
|
return m_file_buffer.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static void unload() {
|
||||||
|
m_entry = nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
static EntryFunc m_entry;
|
||||||
|
|
||||||
|
static std::array<unsigned char, MAX_ELF_FILE_SIZE> m_file_buffer;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // ELF_LOAD_HPP_
|
||||||
|
|
||||||
@ -0,0 +1,38 @@
|
|||||||
|
/**
|
||||||
|
* @file error.cpp
|
||||||
|
* @brief Tracks and reports non-critical errors.
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "error.hpp"
|
||||||
|
|
||||||
|
ErrorManager EM;
|
||||||
|
|
||||||
|
void ErrorManager::add(Error error)
|
||||||
|
{
|
||||||
|
if (m_index < m_queue.size())
|
||||||
|
m_queue[m_index++] = error;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ErrorManager::assert(bool condition, Error error)
|
||||||
|
{
|
||||||
|
if (!condition)
|
||||||
|
add(error);
|
||||||
|
return condition;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ErrorManager::hasError()
|
||||||
|
{
|
||||||
|
return m_index > 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
Error ErrorManager::pop()
|
||||||
|
{
|
||||||
|
return m_index == 0 ? Error::None : m_queue[--m_index];
|
||||||
|
}
|
||||||
|
|
||||||
@ -0,0 +1,138 @@
|
|||||||
|
#include "handlers.hpp"
|
||||||
|
|
||||||
|
#include "adc.hpp"
|
||||||
|
#include "conversion.hpp"
|
||||||
|
#include "cordic.hpp"
|
||||||
|
#include "runstatus.hpp"
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
void port_syscall(struct port_extctx *ctxp, uint32_t n)
|
||||||
|
{
|
||||||
|
switch (n) {
|
||||||
|
|
||||||
|
// Sleeps the current thread until a message is received.
|
||||||
|
// Used the algorithm runner to wait for new data.
|
||||||
|
case 0:
|
||||||
|
{
|
||||||
|
chSysLock();
|
||||||
|
chMsgWaitS();
|
||||||
|
auto monitor = ConversionManager::getMonitorHandle();
|
||||||
|
auto msg = chMsgGet(monitor);
|
||||||
|
chMsgReleaseS(monitor, MSG_OK);
|
||||||
|
chSysUnlock();
|
||||||
|
ctxp->r0 = msg;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Provides access to advanced math functions.
|
||||||
|
// A service call like this is required for some hardware targets that
|
||||||
|
// provide hardware-accelerated math computations (e.g. CORDIC).
|
||||||
|
case 1:
|
||||||
|
{
|
||||||
|
using mathcall = void (*)();
|
||||||
|
static mathcall funcs[3] = {
|
||||||
|
reinterpret_cast<mathcall>(cordic::sin),
|
||||||
|
reinterpret_cast<mathcall>(cordic::cos),
|
||||||
|
reinterpret_cast<mathcall>(cordic::tan),
|
||||||
|
};
|
||||||
|
#if defined(PLATFORM_H7)
|
||||||
|
asm("vmov.f64 d0, %0, %1" :: "r" (ctxp->r1), "r" (ctxp->r2));
|
||||||
|
if (ctxp->r0 < 3) {
|
||||||
|
funcs[ctxp->r0]();
|
||||||
|
asm("vmov.f64 %0, %1, d0" : "=r" (ctxp->r1), "=r" (ctxp->r2));
|
||||||
|
} else {
|
||||||
|
asm("eor r0, r0; vmov.f64 d0, r0, r0");
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
asm("vmov.f32 s0, %0" :: "r" (ctxp->r1));
|
||||||
|
if (ctxp->r0 < 3) {
|
||||||
|
funcs[ctxp->r0]();
|
||||||
|
asm("vmov.f32 %0, s0" : "=r" (ctxp->r1));
|
||||||
|
} else {
|
||||||
|
asm("eor r0, r0; vmov.f32 s0, r0");
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Starts or stops precise cycle time measurement.
|
||||||
|
// Used to measure algorithm execution time.
|
||||||
|
case 2:
|
||||||
|
if (ctxp->r0 == 0) {
|
||||||
|
chTMStartMeasurementX(&conversion_time_measurement);
|
||||||
|
} else {
|
||||||
|
chTMStopMeasurementX(&conversion_time_measurement);
|
||||||
|
// Subtract measurement overhead from the result.
|
||||||
|
// Running an empty algorithm ("bx lr") takes 196 cycles as of 2/4/21.
|
||||||
|
// Only measures algorithm code time (loading args/storing result takes 9 cycles).
|
||||||
|
constexpr rtcnt_t measurement_overhead = 196 - 1;
|
||||||
|
if (conversion_time_measurement.last > measurement_overhead)
|
||||||
|
conversion_time_measurement.last -= measurement_overhead;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Reads one of the analog inputs made available for algorithm run-time input.
|
||||||
|
case 3:
|
||||||
|
ctxp->r0 = ADC::readAlt(ctxp->r0);
|
||||||
|
break;
|
||||||
|
|
||||||
|
//case 4:
|
||||||
|
// {
|
||||||
|
// const char *str = reinterpret_cast<const char *>(ctxp->r0);
|
||||||
|
// auto src = str;
|
||||||
|
// auto dst = userMessageBuffer;
|
||||||
|
// while (*src)
|
||||||
|
// *dst++ = *src++;
|
||||||
|
// *dst = '\0';
|
||||||
|
// userMessageSize = src - str;
|
||||||
|
// }
|
||||||
|
// break;
|
||||||
|
default:
|
||||||
|
while (1);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
asm("svc 0");
|
||||||
|
while (1);
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
void MemManage_Handler()
|
||||||
|
{
|
||||||
|
// 1. Get the stack pointer.
|
||||||
|
uint32_t lr;
|
||||||
|
asm("mov %0, lr" : "=r" (lr));
|
||||||
|
|
||||||
|
// 2. Recover from the fault.
|
||||||
|
ConversionManager::abort();
|
||||||
|
|
||||||
|
// 3. Return.
|
||||||
|
asm("mov lr, %0; bx lr" :: "r" (lr));
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
void HardFault_Handler()
|
||||||
|
{
|
||||||
|
// Get the stack pointer.
|
||||||
|
//uint32_t *stack;
|
||||||
|
uint32_t lr;
|
||||||
|
asm("mov %0, lr" : "=r" (lr));
|
||||||
|
/*asm("\
|
||||||
|
tst lr, #4; \
|
||||||
|
ite eq; \
|
||||||
|
mrseq %0, msp; \
|
||||||
|
mrsne %0, psp; \
|
||||||
|
mov %1, lr; \
|
||||||
|
" : "=r" (stack), "=r" (lr));*/
|
||||||
|
|
||||||
|
// If coming from the algorithm, attempt to recover; otherwise, give up.
|
||||||
|
if (run_status != RunStatus::Running && (lr & 4) != 0)
|
||||||
|
MemManage_Handler();
|
||||||
|
|
||||||
|
while (1);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // extern "C"
|
||||||
|
|
||||||
@ -0,0 +1,31 @@
|
|||||||
|
/**
|
||||||
|
* @file handlers.hpp
|
||||||
|
* @brief Interrupt service routine handlers.
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef STMDSP_HANDLERS_HPP
|
||||||
|
#define STMDSP_HANDLERS_HPP
|
||||||
|
|
||||||
|
#include "ch.h"
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
void port_syscall(struct port_extctx *ctxp, uint32_t n);
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
void MemManage_Handler();
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
void HardFault_Handler();
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // STMDSP_HANDLERS_HPP
|
||||||
|
|
||||||
@ -0,0 +1,80 @@
|
|||||||
|
/**
|
||||||
|
* @file monitor.cpp
|
||||||
|
* @brief Manages the device monitoring thread (status LEDs, etc.).
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "monitor.hpp"
|
||||||
|
|
||||||
|
#include "error.hpp"
|
||||||
|
#include "runstatus.hpp"
|
||||||
|
|
||||||
|
#include "ch.h"
|
||||||
|
#include "hal.h"
|
||||||
|
|
||||||
|
void Monitor::begin()
|
||||||
|
{
|
||||||
|
chThdCreateStatic(m_thread_stack.data(),
|
||||||
|
m_thread_stack.size(),
|
||||||
|
LOWPRIO,
|
||||||
|
threadMonitor,
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Monitor::threadMonitor(void *)
|
||||||
|
{
|
||||||
|
palSetLineMode(LINE_BUTTON, PAL_MODE_INPUT_PULLUP);
|
||||||
|
auto readButton = [] {
|
||||||
|
#ifdef TARGET_PLATFORM_L4
|
||||||
|
return !palReadLine(LINE_BUTTON);
|
||||||
|
#else
|
||||||
|
return palReadLine(LINE_BUTTON);
|
||||||
|
#endif
|
||||||
|
};
|
||||||
|
|
||||||
|
palClearLine(LINE_LED_RED);
|
||||||
|
palClearLine(LINE_LED_YELLOW);
|
||||||
|
|
||||||
|
while (1) {
|
||||||
|
bool isidle = run_status == RunStatus::Idle;
|
||||||
|
auto led = isidle ? LINE_LED_GREEN : LINE_LED_YELLOW;
|
||||||
|
auto delay = isidle ? 500 : 250;
|
||||||
|
|
||||||
|
palSetLine(led);
|
||||||
|
chThdSleepMilliseconds(delay);
|
||||||
|
palClearLine(led);
|
||||||
|
chThdSleepMilliseconds(delay);
|
||||||
|
|
||||||
|
if (run_status == RunStatus::Idle && readButton()) {
|
||||||
|
palSetLine(LINE_LED_RED);
|
||||||
|
palSetLine(LINE_LED_YELLOW);
|
||||||
|
chSysLock();
|
||||||
|
while (readButton())
|
||||||
|
asm("nop");
|
||||||
|
while (!readButton())
|
||||||
|
asm("nop");
|
||||||
|
chSysUnlock();
|
||||||
|
palClearLine(LINE_LED_RED);
|
||||||
|
palClearLine(LINE_LED_YELLOW);
|
||||||
|
chThdSleepMilliseconds(500);
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool erroron = false;
|
||||||
|
if (auto err = EM.hasError(); err ^ erroron) {
|
||||||
|
erroron = err;
|
||||||
|
if (err)
|
||||||
|
palSetLine(LINE_LED_RED);
|
||||||
|
else
|
||||||
|
palClearLine(LINE_LED_RED);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((section(".stacks")))
|
||||||
|
std::array<char, 256> Monitor::m_thread_stack = {};
|
||||||
|
|
||||||
@ -0,0 +1,29 @@
|
|||||||
|
/**
|
||||||
|
* @file monitor.hpp
|
||||||
|
* @brief Manages the device monitoring thread (status LEDs, etc.).
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef STMDSP_MONITOR_HPP
|
||||||
|
#define STMDSP_MONITOR_HPP
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
|
||||||
|
class Monitor
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static void begin();
|
||||||
|
|
||||||
|
private:
|
||||||
|
static void threadMonitor(void *);
|
||||||
|
|
||||||
|
static std::array<char, 256> m_thread_stack;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // STMDSP_MONITOR_HPP
|
||||||
|
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
// Run status
|
||||||
|
//
|
||||||
|
enum class RunStatus : char
|
||||||
|
{
|
||||||
|
Idle = '1',
|
||||||
|
Running,
|
||||||
|
Recovering
|
||||||
|
};
|
||||||
|
|
||||||
|
extern RunStatus run_status;
|
||||||
|
|
||||||
@ -0,0 +1,35 @@
|
|||||||
|
/**
|
||||||
|
* @file samples.cpp
|
||||||
|
* @brief Provides sample buffers for inputs and outputs.
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "samples.hpp"
|
||||||
|
|
||||||
|
#include "ch.h"
|
||||||
|
#include "hal.h"
|
||||||
|
|
||||||
|
#include <cstdint>
|
||||||
|
|
||||||
|
static_assert(sizeof(adcsample_t) == sizeof(uint16_t));
|
||||||
|
static_assert(sizeof(dacsample_t) == sizeof(uint16_t));
|
||||||
|
|
||||||
|
#if defined(TARGET_PLATFORM_H7)
|
||||||
|
__attribute__((section(".convdata")))
|
||||||
|
SampleBuffer Samples::In (reinterpret_cast<Sample *>(0x38000000)); // 16k
|
||||||
|
__attribute__((section(".convdata")))
|
||||||
|
SampleBuffer Samples::Out (reinterpret_cast<Sample *>(0x30004000)); // 16k
|
||||||
|
SampleBuffer Samples::SigGen (reinterpret_cast<Sample *>(0x30000000)); // 16k
|
||||||
|
#else
|
||||||
|
__attribute__((section(".convdata")))
|
||||||
|
SampleBuffer Samples::In (reinterpret_cast<Sample *>(0x20008000)); // 16k
|
||||||
|
__attribute__((section(".convdata")))
|
||||||
|
SampleBuffer Samples::Out (reinterpret_cast<Sample *>(0x2000C000)); // 16k
|
||||||
|
SampleBuffer Samples::Generator (reinterpret_cast<Sample *>(0x20010000)); // 16k
|
||||||
|
#endif
|
||||||
|
|
||||||
@ -0,0 +1,26 @@
|
|||||||
|
/**
|
||||||
|
* @file samples.hpp
|
||||||
|
* @brief Provides sample buffers for inputs and outputs.
|
||||||
|
*
|
||||||
|
* Copyright (C) 2021 Clyne Sullivan
|
||||||
|
*
|
||||||
|
* Distributed under the GNU GPL v3 or later. You should have received a copy of
|
||||||
|
* the GNU General Public License along with this program.
|
||||||
|
* If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef STMDSP_SAMPLES_HPP
|
||||||
|
#define STMDSP_SAMPLES_HPP
|
||||||
|
|
||||||
|
#include "samplebuffer.hpp"
|
||||||
|
|
||||||
|
class Samples
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static SampleBuffer In;
|
||||||
|
static SampleBuffer Out;
|
||||||
|
static SampleBuffer Generator;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // STMDSP_SAMPLES_HPP
|
||||||
|
|
||||||
Loading…
Reference in New Issue