12 typedef uint16_t address_t;
13 typedef uint8_t byte_t;
14 typedef uint8_t command_t;
15 typedef uint8_t sleep_t;
16 typedef uint8_t color_t;
17 typedef uint8_t led_t;
19 // TODO: strong typedefs http://www.boost.org/doc/libs/1_61_0/libs/serialization/doc/strong_typedef.html ?
21 const address_t MEMORY_SIZE = 1024;
24 * Skip to the given address.
25 * parameter: address_t
27 const command_t CMD_GOTO = 0x70;
30 * Compare values on two addresses and go to one of given three addresses.
31 * parameter: address_t a
32 * parameter: address_t b
33 * parameter: address_t GOTO target when a == b
34 * parameter: address_t GOTO target when a > b
35 * parameter: address_t GOTO target when a < b
37 const command_t CMD_GOTO_COMPARE = 0x80;
40 * Wait given time in ms.
43 const command_t CMD_SLEEP = 0xFF;
47 * parameter: led_t LED number
48 * parameter: color_t red
49 * parameter: color_t green
50 * parameter: color_t blue
52 const command_t CMD_COLOR = 0xAA;
57 const command_t CMD_END = 0xED;
60 * Increase value at given address
61 * parameter: address_t
63 const command_t CMD_INCREMENT = 0x11;
66 * Decrease value at given address
67 * parameter: address_t
69 const command_t CMD_DECREMENT = 0x12;
72 * Placeholder for unsupported command.
75 const command_t CMD_INVALID = 0x1;
77 // TODO: more commands, better numbers
80 * Reads data on given position in memory and increments the index (position).
82 template<typename T> T read(byte_t * memory, address_t &index) {
83 // TODO: for addresses: map higher memory to static hardcoded areas or peripherals
84 // TODO: sizeof (byte_t) != 1 ?
85 T * value = reinterpret_cast<T*> (memory + index);
86 index += sizeof (*value) / sizeof (byte_t);
91 * Writes data to given position in memory and increments the index (position).
93 template<typename T> void write(byte_t * memory, address_t &index, const T value) {
94 // TODO: sizeof (byte_t) != 1 ?
95 // T * m = (T*) (memory + index);
96 T * m = reinterpret_cast<T*> (memory + index);
98 index += sizeof (value) / sizeof (byte_t);
101 int main(int argc, char* argv[]) {
103 setlocale(LC_ALL, "");
105 byte_t * memory = (byte_t*) malloc(MEMORY_SIZE);
107 // Sample program / data:
108 // TODO: load bytes from file, stdin, serial port, network…
111 write<command_t>(memory, a, CMD_SLEEP);
112 write<sleep_t>(memory, a, 255);
113 write<command_t>(memory, a, CMD_SLEEP);
114 write<sleep_t>(memory, a, 10);
115 write<command_t>(memory, a, CMD_SLEEP);
116 write<sleep_t>(memory, a, 255);
117 write<command_t>(memory, a, CMD_GOTO);
118 write<address_t>(memory, a, a + sizeof (address_t) + 2 * sizeof (command_t));
119 write<command_t>(memory, a, CMD_INVALID);
120 write<command_t>(memory, a, CMD_INVALID);
121 write<command_t>(memory, a, CMD_SLEEP);
122 write<sleep_t>(memory, a, 255);
123 write<command_t>(memory, a, CMD_COLOR);
124 write<led_t>(memory, a, 23);
125 write<color_t>(memory, a, 0);
126 write<color_t>(memory, a, 200);
127 write<color_t>(memory, a, 255);
128 write<command_t>(memory, a, CMD_INCREMENT);
129 write<address_t>(memory, a, 0);
130 write<command_t>(memory, a, CMD_DECREMENT);
131 write<address_t>(memory, a, 0);
132 write<command_t>(memory, a, CMD_GOTO_COMPARE);
133 write<address_t>(memory, a, 0);
134 write<address_t>(memory, a, 0 + sizeof (command_t) + sizeof (sleep_t));
135 write<address_t>(memory, a, a - 3 * sizeof (address_t) - 2 * sizeof (command_t));
136 write<address_t>(memory, a, 0);
137 write<address_t>(memory, a, a + sizeof (address_t));
138 write<command_t>(memory, a, CMD_END);
141 for (address_t i = 0; i < MEMORY_SIZE;) {
142 wprintf(L"command %*d = ", 4, i);
143 command_t command = read<command_t>(memory, i);
144 wprintf(L"%02X ", command);
149 i = read<address_t>(memory, i);
150 wprintf(L"GOTO %*d\n", 5, i);
155 sleep_t delay = read<sleep_t>(memory, i);
156 wprintf(L"SLEEP %*d ms\n", 4, delay);
157 this_thread::sleep_for(chrono::milliseconds(delay));
162 led_t led = read<led_t>(memory, i);
163 color_t r = read<color_t>(memory, i);
164 color_t g = read<color_t>(memory, i);
165 color_t b = read<color_t>(memory, i);
166 wprintf(L"COLOR %02X %02X %02X → %d\n", r, g, b, led);
172 address_t address = read<address_t>(memory, i);
173 address_t address_r = address;
174 address_t address_w = address_r;
175 byte_t value = read<byte_t>(memory, address_r);
176 value = command == CMD_INCREMENT ? value + 1 : value - 1;
177 write<byte_t>(memory, address_w, value);
178 wprintf(L"%sCREMENT %*d → %02X\n", (command == CMD_INCREMENT ? "IN" : "DE"), 5, address, value);
181 case CMD_GOTO_COMPARE:
183 address_t aa = read<address_t>(memory, i);
184 address_t ab = read<address_t>(memory, i);
185 address_t eq = read<address_t>(memory, i);
186 address_t gt = read<address_t>(memory, i);
187 address_t lt = read<address_t>(memory, i);
189 byte_t a = read<byte_t>(memory, aa);
190 byte_t b = read<byte_t>(memory, ab);
193 else if (a > b) i = gt;
196 wprintf(L"GOTO COMPARE a = %02X, b = %02X, eq = %d, gt = %d, lt = %d → %d\n", a, b, eq, gt, lt, i);
207 wprintf(L"invalid command\n");
215 wprintf(L"all done\n");