#include "blink.hpp" #include #include #include #include #include namespace { class Device : public blink::Platform { public: int next_gpio = 10; int next_timer = 100; int gpio = -1; int timer = -1; int physical = -1; int fault = 0; int immediate = 0; int reserved = 0; int writes = 0; int arms = 0; bool pending = false; bool flight = false; bool first = false; blink::Callback callback = nullptr; void *context = nullptr; std::vector> events; int request(int pin) override { int result = fault == 1 ? -5 : next_gpio++; events.push_back({1, pin, result}); if (result >= 0) gpio = result; return result; } int configure(int handle, int value) override { int result = fault == 2 ? -5 : 0; events.push_back({2, handle, value, result}); if (result == 0 && handle == gpio) physical = value; return result; } void write(int handle, int value) override { events.push_back({3, handle, value}); ++writes; if (handle == gpio && gpio >= 0) physical = value; } void release(int handle) override { events.push_back({4, handle}); if (handle == gpio) gpio = -1; } int create_timer(blink::Callback function, void *argument) override { int result = fault == 3 ? -5 : next_timer++; events.push_back({5, result}); if (result >= 0) { timer = result; callback = function; context = argument; first = true; pending = false; flight = false; } return result; } int arm(int handle, std::uint32_t period) override { bool initial = first; first = false; int result = initial && fault == 4 ? -5 : 0; ++arms; events.push_back({6, handle, period, result}); pending = true; if (initial && immediate) fire(); if (initial && reserved) hold(); return result; } void cancel(int handle) override { events.push_back({7, handle}); pending = false; } void drain(int handle) override { events.push_back({8, handle, flight ? 1 : 0}); complete(); } void destroy_timer(int handle) override { events.push_back({9, handle}); if (timer == handle) { timer = -1; pending = false; flight = false; callback = nullptr; context = nullptr; } } void fire() { if (timer < 0 || !pending || flight) return; pending = false; events.push_back({10, timer}); if (callback) callback(context); } void hold() { if (timer < 0 || !pending || flight) return; pending = false; flight = true; events.push_back({11, timer}); } void complete() { if (timer < 0 || !flight) return; flight = false; events.push_back({10, timer}); if (callback) callback(context); } }; void numbers(const std::vector &values) { std::cout << '['; bool separator = false; for (auto number : values) { if (separator) std::cout << ','; std::cout << number; separator = true; } std::cout << ']'; } bool decode(const std::string &input, std::string &output) { output.clear(); if (input == "-") return true; if (input.size() % 2) return false; auto digit = [](char value) { if (value >= '0' && value <= '9') return value - '0'; if (value >= 'a' && value <= 'f') return value - 'a' + 10; if (value >= 'A' && value <= 'F') return value - 'A' + 10; return -1; }; for (std::size_t at = 0; at < input.size(); at += 2) { int high = digit(input[at]); int low = digit(input[at + 1]); if (high < 0 || low < 0) return false; output.push_back(static_cast(high * 16 + low)); } return true; } void observe(int result, blink::Session &session, Device &device, const blink::Config *config, const std::string *raw) { auto s = session.snapshot(); std::cout << "{\"r\":" << result << ",\"s\":"; numbers({s.phase, s.pin, s.gpio, s.timer, s.logical, s.period, static_cast(s.pulses), static_cast(s.generation), static_cast(s.callbacks)}); std::cout << ",\"b\":"; numbers({device.gpio >= 0, device.timer >= 0, device.pending, device.flight, device.physical, device.writes, device.arms}); std::cout << ",\"log\":["; bool separator = false; for (const auto &event : device.events) { if (separator) std::cout << ','; numbers(event); separator = true; } std::cout << ']'; if (config != nullptr) { std::cout << ",\"c\":"; numbers({config->pin, config->period, config->active_low, config->initial}); std::cout << ",\"text\":" << std::quoted(blink::format_config(*config)); static const char digits[] = "0123456789abcdef"; std::cout << ",\"input\":\""; for (unsigned char byte : *raw) { std::cout << digits[byte >> 4] << digits[byte & 15]; } std::cout << '"'; } std::cout << "}\n"; } } int main() { Device devices[2]; blink::Session first(devices[0]); blink::Session second(devices[1]); blink::Session *sessions[2] = {&first, &second}; int selected = 0; std::string line; while (std::getline(std::cin, line)) { std::istringstream input(line); std::string op; if (!(input >> op)) continue; if (op == "U") { if (!(input >> selected) || selected < 0 || selected > 1) return 2; } Device &device = devices[selected]; blink::Session &session = *sessions[selected]; device.events.clear(); int result = 0; blink::Config config; const blink::Config *parsed = nullptr; std::string raw; if (op == "U" || op == "Q") { } else if (op == "I") { int seed = 0; if (!(input >> seed)) return 2; device.next_gpio = seed + 10; device.next_timer = seed + 100; } else if (op == "M") { if (!(input >> device.fault >> device.immediate >> device.reserved)) return 2; } else if (op == "O") { int commit = 0; if (!(input >> config.pin >> config.period >> config.active_low >> config.initial >> commit)) return 2; result = session.open(config, commit); } else if (op == "S") { result = session.stop(); } else if (op == "P") { std::uint32_t period = 0; if (!(input >> period)) return 2; result = session.change_period(period); } else if (op == "L") { int logical = 0; if (!(input >> logical)) return 2; result = session.set_level(logical); } else if (op == "V") { result = session.toggle(); } else if (op == "T") { unsigned count = 0; if (!(input >> count)) return 2; while (count--) device.fire(); } else if (op == "H") { device.hold(); } else if (op == "F") { device.complete(); } else if (op == "D") { if (!(input >> config.pin >> config.period >> config.active_low >> config.initial)) return 2; result = blink::validate(config); } else if (op == "C") { std::string hex; std::string text; if (!(input >> config.pin >> config.period >> config.active_low >> config.initial >> hex)) return 2; if (!decode(hex, text)) return 2; raw = text; result = blink::parse_config(raw, config); parsed = &config; } else { return 2; } observe(result, session, device, parsed, &raw); } return std::cin.bad() ? 2 : 0; }