Add binary, hex, and EEPROM files for TestSketch with bootloader

- Added TestSketch.ino.with_bootloader.bin containing the compiled binary with bootloader.
- Added TestSketch.ino.with_bootloader.hex containing the hex representation of the compiled sketch.
- Added ArduinoUno.bin for EEPROM data storage.

backup

Author: Kinin-Code-Offical

CoreSim/src/RobotTwin.CoreSim/IPC/FirmwareClient.cs

@@ -7,7 +7,7 @@ internal static class FirmwareProtocol
     {
         internal const uint ProtocolMagic = 0x57465452; // "RTFW"
         internal const ushort ProtocolMajor = 1;
-        internal const ushort ProtocolMinor = 1;
+        internal const ushort ProtocolMinor = 3;
         internal const int HeaderSize = 20;
         internal const uint MaxPayloadBytes = 8 * 1024 * 1024;
 

CoreSim/src/RobotTwin.CoreSim/IPC/FirmwareProtocol.cs

@@ -0,0 +1,7 @@
+<Project>
+  <PropertyGroup>
+    <BaseOutputPath>$(MSBuildThisFileDirectory)builds\$(MSBuildProjectName)\</BaseOutputPath>
+    <BaseIntermediateOutputPath>$(MSBuildThisFileDirectory)builds\$(MSBuildProjectName)\obj\</BaseIntermediateOutputPath>
+    <DefaultItemExcludes>$(DefaultItemExcludes);**\bin\**;**\obj\**</DefaultItemExcludes>
+  </PropertyGroup>
+</Project>

Directory.Build.props

@@ -16,15 +16,15 @@ set(SOURCES
     "${REPO_ROOT}/FirmwareEngine/Rpi/RpiBackend.cpp"
     "${REPO_ROOT}/FirmwareEngine/Rpi/RpiShm.cpp"
     "${REPO_ROOT}/FirmwareEngine/Rpi/QemuProcess.cpp"
-    "${REPO_ROOT}/FirmwareEngine/U1/U1.cpp"
+    # "${REPO_ROOT}/FirmwareEngine/U1/U1.cpp" # Removed for Real Sim
     "${REPO_ROOT}/NativeEngine/src/MCU/ATmega328P_ISA.c"
 )
 
 add_executable(RoboTwinFirmwareHost ${SOURCES})
 target_include_directories(RoboTwinFirmwareHost PRIVATE
     "${REPO_ROOT}/FirmwareEngine"
     "${REPO_ROOT}/FirmwareEngine/include"
-    "${REPO_ROOT}/FirmwareEngine/U1"
+    # "${REPO_ROOT}/FirmwareEngine/U1" # Removed for Real Sim
     "${REPO_ROOT}/FirmwareEngine/Rpi"
     "${REPO_ROOT}/NativeEngine/include"
 )
@@ -48,3 +48,13 @@ target_include_directories(RoboTwinFirmwareHostLockstepSanity PRIVATE
 set_target_properties(RoboTwinFirmwareHostLockstepSanity PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY "${OUT_DIR}"
 )
+
+add_executable(SketchRunner
+    "${REPO_ROOT}/FirmwareEngine/tests/SketchRunner.cpp"
+)
+target_include_directories(SketchRunner PRIVATE
+    "${REPO_ROOT}/FirmwareEngine"
+)
+set_target_properties(SketchRunner PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY "${OUT_DIR}"
+)

FirmwareEngine/CMakeLists.txt

@@ -4,11 +4,67 @@
 #include <cstring>
 #include <cstdlib>
 #include <thread>
+#include <sddl.h>
+
+#pragma comment(lib, "Advapi32.lib")
 
 namespace firmware
 {
     namespace
     {
+        void WriteBits(std::uint8_t *dst, std::size_t dstBits, std::size_t offset, std::size_t width, std::uint64_t value)
+        {
+            if (!dst || width == 0)
+                return;
+            if (offset + width > dstBits)
+                return;
+            for (std::size_t bit = 0; bit < width; ++bit)
+            {
+                std::size_t target = offset + bit;
+                std::size_t byteIndex = target / 8;
+                std::size_t bitIndex = target % 8;
+                if ((value >> bit) & 0x1u)
+                {
+                    dst[byteIndex] = static_cast<std::uint8_t>(dst[byteIndex] | (1u << bitIndex));
+                }
+            }
+        }
+
+        void WriteDebugBits(std::uint8_t *dst, std::size_t dstBytes, const OutputDebugState &debug)
+        {
+            if (!dst || dstBytes < kDebugBitBytes)
+                return;
+            std::memset(dst, 0, dstBytes);
+            const std::size_t dstBits = dstBytes * 8;
+            WriteBits(dst, dstBits, kDbgBitPc, 16, debug.pc);
+            WriteBits(dst, dstBits, kDbgBitSp, 16, debug.sp);
+            WriteBits(dst, dstBits, kDbgBitSreg, 8, debug.sreg);
+            WriteBits(dst, dstBits, kDbgBitFlashBytes, 32, debug.flashBytes);
+            WriteBits(dst, dstBits, kDbgBitSramBytes, 32, debug.sramBytes);
+            WriteBits(dst, dstBits, kDbgBitEepromBytes, 32, debug.eepromBytes);
+            WriteBits(dst, dstBits, kDbgBitIoBytes, 32, debug.ioBytes);
+            WriteBits(dst, dstBits, kDbgBitCpuHz, 32, debug.cpuHz);
+            WriteBits(dst, dstBits, kDbgBitStackHighWater, 16, debug.stackHighWater);
+            WriteBits(dst, dstBits, kDbgBitHeapTop, 16, debug.heapTopAddress);
+            WriteBits(dst, dstBits, kDbgBitStackMin, 16, debug.stackMinAddress);
+            WriteBits(dst, dstBits, kDbgBitDataSegmentEnd, 16, debug.dataSegmentEnd);
+            WriteBits(dst, dstBits, kDbgBitStackOverflows, 32, static_cast<std::uint32_t>(debug.stackOverflows));
+            WriteBits(dst, dstBits, kDbgBitInvalidMem, 32, static_cast<std::uint32_t>(debug.invalidMemoryAccesses));
+            WriteBits(dst, dstBits, kDbgBitInterruptCount, 32, static_cast<std::uint32_t>(debug.interruptCount));
+            WriteBits(dst, dstBits, kDbgBitInterruptLatencyMax, 32, static_cast<std::uint32_t>(debug.interruptLatencyMax));
+            WriteBits(dst, dstBits, kDbgBitTimingViolations, 32, static_cast<std::uint32_t>(debug.timingViolations));
+            WriteBits(dst, dstBits, kDbgBitCriticalSectionCycles, 32, static_cast<std::uint32_t>(debug.criticalSectionCycles));
+            WriteBits(dst, dstBits, kDbgBitSleepCycles, 32, static_cast<std::uint32_t>(debug.sleepCycles));
+            WriteBits(dst, dstBits, kDbgBitFlashAccessCycles, 32, static_cast<std::uint32_t>(debug.flashAccessCycles));
+            WriteBits(dst, dstBits, kDbgBitUartOverflows, 32, static_cast<std::uint32_t>(debug.uartOverflows));
+            WriteBits(dst, dstBits, kDbgBitTimerOverflows, 32, static_cast<std::uint32_t>(debug.timerOverflows));
+            WriteBits(dst, dstBits, kDbgBitBrownOutResets, 32, static_cast<std::uint32_t>(debug.brownOutResets));
+            WriteBits(dst, dstBits, kDbgBitGpioStateChanges, 32, static_cast<std::uint32_t>(debug.gpioStateChanges));
+            WriteBits(dst, dstBits, kDbgBitPwmCycles, 32, static_cast<std::uint32_t>(debug.pwmCycles));
+            WriteBits(dst, dstBits, kDbgBitI2cTransactions, 32, static_cast<std::uint32_t>(debug.i2cTransactions));
+            WriteBits(dst, dstBits, kDbgBitSpiTransactions, 32, static_cast<std::uint32_t>(debug.spiTransactions));
+        }
+
         bool LockstepTraceEnabled()
         {
             static const bool enabled = []()
@@ -138,13 +194,19 @@ namespace firmware
         payload.pin_count = static_cast<std::uint32_t>(kPinCount);
         payload.board_id_size = static_cast<std::uint32_t>(kBoardIdSize);
         payload.analog_count = static_cast<std::uint32_t>(kAnalogCount);
+        payload.flash_bytes = 0;
+        payload.sram_bytes = 0;
+        payload.eeprom_bytes = 0;
+        payload.io_bytes = 0;
+        payload.cpu_hz = 0;
         WritePacket(MessageType::HelloAck, reinterpret_cast<const std::uint8_t *>(&payload), sizeof(payload));
     }
 
     bool PipeManager::SendOutputState(const std::string &boardId, std::uint64_t stepSequence, std::uint64_t tickCount, const std::uint8_t *pins, std::size_t count,
                                       std::uint64_t cycles, std::uint64_t adcSamples,
                                       const std::uint64_t *uartTxBytes, const std::uint64_t *uartRxBytes,
-                                      std::uint64_t spiTransfers, std::uint64_t twiTransfers, std::uint64_t wdtResets)
+                                      std::uint64_t spiTransfers, std::uint64_t twiTransfers, std::uint64_t wdtResets,
+                                      const OutputDebugState &debug)
     {
         if (!pins || count < kPinCount)
             return false;
@@ -167,6 +229,36 @@ namespace firmware
         payload.twi_transfers = twiTransfers;
         payload.wdt_resets = wdtResets;
         payload.timestamp_micros = NowMicros();
+        payload.flash_bytes = debug.flashBytes;
+        payload.sram_bytes = debug.sramBytes;
+        payload.eeprom_bytes = debug.eepromBytes;
+        payload.io_bytes = debug.ioBytes;
+        payload.cpu_hz = debug.cpuHz;
+        payload.pc = debug.pc;
+        payload.sp = debug.sp;
+        payload.sreg = debug.sreg;
+        payload.stack_high_water = debug.stackHighWater;
+        payload.heap_top_address = debug.heapTopAddress;
+        payload.stack_min_address = debug.stackMinAddress;
+        payload.data_segment_end = debug.dataSegmentEnd;
+        payload.stack_overflows = debug.stackOverflows;
+        payload.invalid_memory_accesses = debug.invalidMemoryAccesses;
+        payload.interrupt_count = debug.interruptCount;
+        payload.interrupt_latency_max = debug.interruptLatencyMax;
+        payload.timing_violations = debug.timingViolations;
+        payload.critical_section_cycles = debug.criticalSectionCycles;
+        payload.sleep_cycles = debug.sleepCycles;
+        payload.flash_access_cycles = debug.flashAccessCycles;
+        payload.uart_overflows = debug.uartOverflows;
+        payload.timer_overflows = debug.timerOverflows;
+        payload.brown_out_resets = debug.brownOutResets;
+        payload.gpio_state_changes = debug.gpioStateChanges;
+        payload.pwm_cycles = debug.pwmCycles;
+        payload.i2c_transactions = debug.i2cTransactions;
+        payload.spi_transactions = debug.spiTransactions;
+        payload.debug_bit_count = kDebugBitCount;
+        payload.reserved1 = 0;
+        WriteDebugBits(payload.debug_bits, sizeof(payload.debug_bits), debug);
 
         if (LockstepTraceEnabled())
         {
@@ -304,6 +396,30 @@ namespace firmware
                 Enqueue(cmd);
                 continue;
             }
+
+            if (type == MessageType::MemoryPatch)
+            {
+                if (payload.size() < sizeof(MemoryPatchHeader))
+                {
+                    SendError("system", 2, "Invalid patch payload");
+                    continue;
+                }
+                const auto *header = reinterpret_cast<const MemoryPatchHeader *>(payload.data());
+                std::size_t expected = sizeof(MemoryPatchHeader) + header->length;
+                if (payload.size() < expected)
+                {
+                    SendError("system", 2, "Patch payload truncated");
+                    continue;
+                }
+                PipeCommand cmd;
+                cmd.type = PipeCommand::Type::Patch;
+                cmd.boardId = ReadFixedString(header->board_id, kBoardIdSize);
+                cmd.memoryType = static_cast<MemoryType>(header->memory_type);
+                cmd.address = header->address;
+                cmd.data.assign(payload.begin() + sizeof(MemoryPatchHeader), payload.begin() + expected);
+                Enqueue(cmd);
+                continue;
+            }
         }
     }
 
@@ -317,6 +433,15 @@ namespace firmware
             _pipeHandle = INVALID_HANDLE_VALUE;
         }
 
+        SECURITY_ATTRIBUTES attrs{};
+        attrs.nLength = sizeof(attrs);
+        attrs.bInheritHandle = FALSE;
+        PSECURITY_DESCRIPTOR security = nullptr;
+        if (ConvertStringSecurityDescriptorToSecurityDescriptorW(L"D:(A;;GA;;;WD)", SDDL_REVISION_1, &security, nullptr))
+        {
+            attrs.lpSecurityDescriptor = security;
+        }
+
         _pipeHandle = CreateNamedPipeW(
             _pipeName.c_str(),
             PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
@@ -325,7 +450,12 @@ namespace firmware
             65536,
             65536,
             0,
-            nullptr);
+            security ? &attrs : nullptr);
+
+        if (security)
+        {
+            LocalFree(security);
+        }
 
         if (_pipeHandle == INVALID_HANDLE_VALUE)
         {

FirmwareEngine/PipeManager.cpp

@@ -17,7 +17,8 @@ namespace firmware
         enum class Type
         {
             Load,
-            Step
+            Step,
+            Patch
         };
 
         Type type = Type::Load;
@@ -30,6 +31,39 @@ namespace firmware
         std::uint8_t pins[kPinCount]{};
         std::uint16_t analog[kAnalogCount]{};
         std::size_t analogCount = 0;
+        MemoryType memoryType = MemoryType::Flash;
+        std::uint32_t address = 0;
+    };
+
+    struct OutputDebugState
+    {
+        std::uint32_t flashBytes = 0;
+        std::uint32_t sramBytes = 0;
+        std::uint32_t eepromBytes = 0;
+        std::uint32_t ioBytes = 0;
+        std::uint32_t cpuHz = 0;
+        std::uint16_t pc = 0;
+        std::uint16_t sp = 0;
+        std::uint8_t sreg = 0;
+        std::uint16_t stackHighWater = 0;
+        std::uint16_t heapTopAddress = 0;
+        std::uint16_t stackMinAddress = 0;
+        std::uint16_t dataSegmentEnd = 0;
+        std::uint64_t stackOverflows = 0;
+        std::uint64_t invalidMemoryAccesses = 0;
+        std::uint64_t interruptCount = 0;
+        std::uint64_t interruptLatencyMax = 0;
+        std::uint64_t timingViolations = 0;
+        std::uint64_t criticalSectionCycles = 0;
+        std::uint64_t sleepCycles = 0;
+        std::uint64_t flashAccessCycles = 0;
+        std::uint64_t uartOverflows = 0;
+        std::uint64_t timerOverflows = 0;
+        std::uint64_t brownOutResets = 0;
+        std::uint64_t gpioStateChanges = 0;
+        std::uint64_t pwmCycles = 0;
+        std::uint64_t i2cTransactions = 0;
+        std::uint64_t spiTransactions = 0;
     };
 
     class PipeManager
@@ -49,7 +83,8 @@ namespace firmware
         bool SendOutputState(const std::string &boardId, std::uint64_t stepSequence, std::uint64_t tickCount, const std::uint8_t *pins, std::size_t count,
                              std::uint64_t cycles, std::uint64_t adcSamples,
                              const std::uint64_t *uartTxBytes, const std::uint64_t *uartRxBytes,
-                             std::uint64_t spiTransfers, std::uint64_t twiTransfers, std::uint64_t wdtResets);
+                             std::uint64_t spiTransfers, std::uint64_t twiTransfers, std::uint64_t wdtResets,
+                             const OutputDebugState &debug);
         void SendSerial(const std::string &boardId, const std::uint8_t *data, std::size_t size);
         void SendStatus(const std::string &boardId, std::uint64_t tickCount);
         void SendLog(const std::string &boardId, LogLevel level, const std::string &text);