我想有效地将带有寄存器的结构映射到内存。 实际上我有这样的工作代码:
具有外设寄存器的结构:
struct Periph {
volatile uint32_t REG1;
volatile uint32_t REG2;
};
在设备中这个外设两次位于内存中的两个不同地址,所以定义这些地址:
static constexpr size_t PERIPH1_BASE = 0x40000000;
static constexpr size_t PERIPH2_BASE = 0x40001000;
然后我有一个驱动程序可以使用这些寄存器中的任何一个:
template<size_t Base> struct Driver {
inline Periph &r() {
return *reinterpret_cast<Periph *>(base);
}
void setFoo(uint32_t x) {
r().REG1 = x;
}
uint32_t getBar() {
return r().REG2;
}
};
使用这个驱动很简单,只需要将某个外设的地址设置到模板中即可:
Driver<PERIPH1_BASE> drv;
uint32_t x = drv.getBar();
drv.setFoo(x);
...
如果编译器在优化后合并所有内联函数,那么此方法可以非常有效地使用寄存器并且没有任何开销。
但这不是很安全,因为我可以设置Driver
来自不同外设的任何地址。
我的改进想法是将对结构的引用作为模板参数,但没有成功。
首先我定义了对寄存器的引用:
static Periph &PERIPH1 = *reinterpret_cast<Periph *>(PERIPH1_BASE);
static Periph &PERIPH2 = *reinterpret_cast<Periph *>(PERIPH2_BASE);
这是有效的,我可以像这样直接访问这些寄存器:
PERIPH2.REG1 = 123;
但我不知道如何将这些引用传递给模板参数,我的尝试如下:
template<Periph &r> struct Driver {
void setFoo(uint32_t x) {
r.REG1 = x;
}
uint32_t getBar() {
return r.REG2;
}
};
Driver<PERIPH2> drv;
drv.setFoo(x);
由此我得到以下错误:
`error: the value of 'PERIPH2' is not usable in a constant expression`
如果我将 PERIPH2 定义为 constexpr,则会出现另一个错误:
`error: reinterpret_cast from integer to pointer`
... 那么如何将对对象的引用作为模板参数呢? 或使它变得更好的想法或建议。
这里还存在许多其他解决方案(例如将引用放入 Driver 构造函数...),但这会减慢对寄存器的访问速度。
感谢您的帮助。
最佳答案
But I have no idea how to pass these references to template argument
因为它们是不同的东西。据我了解,这可能对您有所帮助:将您的外围设备结构用作具有封装基地址的单例。
template<std::size_t Base>
struct periph {
static constexpr periph volatile& instance() {
return *reinterpret_cast<periph volatile*>(Base);
}
template<std::size_t N>
static constexpr std::uint32_t volatile& reg() {
return periph::instance().reg_[N];
}
// prohibit instance constructing
periph() = delete;
periph(periph const&) = delete;
periph(periph&&) = delete;
private:
uint32_t reg_[2];
};
您可以通过 instance()
访问寄存器或 reg<>()
方法。例如:
periph<0x00001000>::reg<0>() = 0;
现在,让你的 Driver
的模板参数采用类型而不是值:
template<typename Periph>
struct driver {
using periph_type = Periph;
// for example
void foo() {
periph_type::reg<0>() = 1234;
}
};
看,Periph::instance()
是你想传递的引用。如您所见,driver::foo()
使用 Periph
-定义的静态方法 Periph::reg<>()
访问外围实例而不是显式地址。看起来更安全。
您也可以放弃默认模板实现并实现特化:
using periph1 = periph<0x40000000>;
using periph2 = periph<0x40001000>;
template<typename Periph>
struct driver;
template<>
struct driver<periph1> {
// specialization for periph1 only
};
template<>
struct driver<periph2> {
// specialization for periph2 only
};
或者
template<std::size_t Base>
struct driver< periph<Base> > {
// use periph<Base> here
};
对于另一个(与periph
不同)外围设备,您应该实现另一个 类型(例如i2c<>
)。可能,与 periph<>
相同的方式实现(封装地址作为模板参数)。但是,如果您处理多个相同类型的外围设备(例如,多个 CAN 总线),您应该/可能使用具有不同类型的相同类型 Base
更新:
另外,您可能想看看这个实现:
template<std::size_t Base>
struct periph {
private:
struct context {
std::uint32_t reg[2];
};
static constexpr context volatile& ctx() {
return *reinterpret_cast<context volatile*>(Base);
}
public:
static volatile std::uint32_t & REG1;
static volatile std::uint32_t & REG2;
};
template<std::size_t Base>
volatile std::uint32_t & periph<Base>::REG1 = ctx().reg[0];
template<std::size_t Base>
volatile std::uint32_t & periph<Base>::REG2 = ctx().reg[1];
在这种情况下,地址 ( Base
) 仍然被封装到 struct periph
中但寄存器可能作为静态成员访问:
periph<0> p;
p.REG1 = 1;
periph<0>::REG1 = 0;
关于c++ - 传递指向结构的引用作为模板参数,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/32790106/