Renode - documentation¶

Introduction

• Installing Renode
• Using Renode
  • Running and quitting Renode
  • Monitor (Renode CLI)
  • Basic interactive workflow
  • .resc scripts
  • Configuring the user interface
• Running your first demo
• Supported boards
• Supported peripherals
• Troubleshooting
• Testing with Renode
  • Renode’s testing capabilities
  • Running the robot test script
  • Creating the test file
  • Advanced usage
• Developing Renode
  • Debugging with GDB
  • VS Code configurations

Basic usage

• Working with machines
  • Creating machines
  • Switching between machines
  • Loading platforms
  • Accessing and manipulating peripherals
  • Loading binaries
  • Clearing the emulation
• Describing platforms
  • Defining peripherals
  • Connecting peripherals
  • Including files
• Monitor and script syntax
  • Using built-in commands
  • Accessing emulation objects
  • Accessing attributes of an object
  • Supported data types
  • Monitor variable types
  • File paths
  • Renode Script syntax
• Basic execution control
  • Starting and pausing the execution
  • Executing instruction-by-instruction
  • Blocking and non-blocking stepping
  • Inspecting the current location
• Using the logger
  • Logging level
  • Logging to file
  • Logging access to peripherals
  • Hushing excessive unhandled access logs
• State saving and loading
  • State saving in tests
  • Loading gzip compressed save files
• Renode Sensor Data Format (RESD)
  • What is the Renode Sensor Data format?
  • RESD Data Blocks
• Sensors and virtual environment
  • Controlling individual sensors
  • Controlling sensors globally
• Metrics analyzer
  • Profiling
  • Visualizing
• Running Renode in different modes
  • Telnet mode
  • Headless mode
  • Console mode
  • UART interactions in the Monitor
• Using Python in Renode
  • Direct Python execution in the Monitor
  • Python peripherals in a platform description
  • Python hooks in Renode
  • Python enabled classes
  • RISC-V extensions
• Configuring a RISC-V CPU
  • Picking specific ISA variants
  • Customizing the CPU
  • Adding a custom RISC-V instruction
  • Adding a custom RISC-V Control and Status Register

Debugging

• Debugging with GDB
  • Connecting to GDB
  • Starting emulation
  • Complex scenarios
• Debugging software with Visual Studio Code
  • Launch configuration
  • Defining tasks
  • Renode simulation script
  • debug.conf

Execution tracing

• Execution tracing in Renode
  • Logging executed function names
  • Logging peripheral accesses
  • Execution tracing
  • Usage of gathered data
  • Specialized uses of execution tracing
• Execution metrics, profiling and opcode counting
  • Execution metrics
  • Guest application profiling
  • Opcode counting
• Generating a coverage report
  • Prerequisites
  • Building a binary for coverage gathering
  • Gathering coverage for a sample program
  • Report formats
  • Coverview integration
  • Gathering Zephyr’s coverage
  • Legacy report mode
• Guest CPU Cache Modelling

Networking

• Setting up a wired network
  • Creating a switch
  • Connecting interfaces
  • Disconnecting interfaces
  • Starting the interface
  • Controlling the traffic
• Setting up a wireless network
  • Creating a wireless medium
  • Connecting interfaces
  • Disconnecting interfaces
  • Positioning the nodes
  • Controlling the traffic
• Connecting to the host network
  • Regarding time flow
  • Opening a TAP interface
  • Using TAP interface on Windows
  • Connecting TAP interface switch
  • Starting the interface
  • Transferring files from host
• Inspecting the traffic with Wireshark
  • Logging the whole traffic
  • Observing a specific interface
• Machine to machine connections
  • Symmetrical connections
  • Asymmetrical connections
  • Modeling the timing of the events

Host integration

• UART integration
  • UART pty terminal
  • Socket terminal
  • Redirecting to a file
• CAN integration
  • Host requirements
  • Creating a SocketCAN bridge
• Arduino IDE/CLI integration
  • Installing TensorFlow examples
  • Configuring Renode
  • Loading from Arduino IDE
  • Loading from Arduino CLI
  • Starting the simulation
• Sharing files between host and simulated platform
  • Sharing files using VirtIO block device
  • Directory sharing
  • Sharing files using TFTP

Advanced topics

• Co-simulating with an HDL simulator
  • Adding co-simulated blocks
  • DPI-based integration method
  • Custom, direct integration method (Verilator-only)
  • Connecting to verilated models
• Building Renode from source
  • Prerequisites
  • Downloading the source code
  • Building Renode
  • Creating packages
• Platform description format
  • Indentation
  • Comments
  • Basic structure
  • Values
  • Registration info
  • Attributes
  • Inline objects
  • Depending on other files
  • Entry override order
• Time framework
  • Time and performance units
  • Time sources and sinks
  • Synchronization
  • Time domain
  • Configuration and monitoring
  • CPU pausing vs. halting
• Peripheral modeling guide
  • How does access to the system bus work?
  • What if there is no peripheral mapped at given offset?
  • What happens when the peripheral does not implement the given access width?
  • Writing a peripheral model in C#
  • Register modeling guidelines
  • Bus peripheral size
  • Testing guidelines
  • Example peripherals
• Loading assembly to memory
  • Prerequisites
  • Compiling assembly code to an executable
  • Debugging tlib

Tutorials

• Microsemi Mi-V example
  • Installation
  • Starting Renode
  • Scripts
  • Loading our setup
  • Simple commands
  • Debugging and inspection
  • SoftConsole integration
• Testing Zephyr PTP support
  • Prerequisites
  • The test suite
• Renode, Fomu and EtherBone bridge example
  • System architecture
  • Prerequisites
  • Verifying the device
  • Loading the bitstream (optional)
  • Running the demo
• USB/IP support
  • USB/IP protocol
  • Creating a USB/IP server
  • Exporting devices
  • Attaching exported device to host
  • Real life scenario: Foboot
• Co-simulating your verilated model
  • Creating a verilated peripheral
  • Building a verilated peripheral
  • Running a verilated peripheral
  • Using Renode Verilator sample peripherals
  • Performance of the simulation
  • Verilator Trace
  • Core-v-mcu “Hello World” example with verilated UART
• Bluetooth Low Energy simulation in Renode
  • Running a precompiled demo
  • Building your own Zephyr samples
  • Looking into the script
  • Packet interception hooks with BLE
• BLE HCI integration with Renode
  • Integration with Android Emulator
  • Bluetooth Mesh networking