avr-something/utils.h at master · M3Henry/avr-something · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#pragma once
#include <inttypes.h>

template <typename T = uint8_t>
constexpr T volatile& memory(const uintptr_t addr)
{
	return *reinterpret_cast<T*>(addr);
}

inline constexpr uint8_t bit(const uint8_t shift)
{
//	static_assert(8 > shift, "must be in range (0, 7)");
	return uint8_t(1) << shift;
}

inline constexpr uint8_t bits()
{
	return 0;
}

template <typename...Ts>
inline constexpr uint8_t bits(const uint8_t shift, Ts... others)
{
//	static_assert(8 > shift, "must be in range (0, 7)");
	return bit(shift) | bits(others...);
}

inline constexpr uint16_t wbit(const uint8_t shift)
{
//	static_assert(8 > shift, "must be in range (0, 7)");
	return uint8_t(1) << shift;
}

inline constexpr uint8_t mix(const uint8_t a, const uint8_t b, const uint8_t mask)
{
	return (a & ~mask) | (b & mask);
}

template <typename T>
struct flashPtr
{
	static_assert(sizeof(T) == 1, "flashPtr operates on single bytes");

	constexpr flashPtr(T const* const p)
	:	ptr(p)
	{}
	template <uint16_t S>
	constexpr flashPtr(const T(& a)[S])
	:	ptr(static_cast<T const*>(a))
	{}

	T load() const
	{
		T result;
		asm volatile
		(
			"lpm %0, Z"

			: "=r" (result)
			: "z" (ptr)
		);
		return result;
	}
	T load_post_inc()
	{
		T result;
		asm volatile
		(
			"lpm %0, Z+"

			: "=r" (result), "=z" (ptr)
			: "1" (ptr)
		);
		return result;
	}
	constexpr flashPtr& operator ++()
	{
		++ptr;
		return *this;
	}
	constexpr flashPtr& operator --()
	{
		--ptr;
		return *this;
	}
	constexpr flashPtr operator +(const uint16_t delta) const
	{
		return flashPtr(ptr + delta);
	}
	constexpr flashPtr operator -(const uint16_t delta) const
	{
		return flashPtr(ptr - delta);
	}
	constexpr bool operator !=(const flashPtr& that) const
	{
		return ptr != that.ptr;
	}

	static_assert(sizeof(uint16_t) == sizeof(T const *), "Flash ptr should be a word");

private:
	T const* ptr;
};