Service Management

Red Pitaya uses systemd for managing background services. This guide covers how to control system services, which is useful for optimizing performance, troubleshooting, and customizing system behavior.

Overview

Red Pitaya runs several background services that provide various functionalities. Understanding how to manage these services allows you to:

• Optimize system performance for specific tasks

• Troubleshoot service-related issues

• Customize which services run at startup

• Free up system resources when needed

Red Pitaya Services

The main Red Pitaya system services include:

Service Name	Description
redpitaya_nginx	Customized Nginx web server for Red Pitaya web interface and applications
redpitaya_e3_controller	Service that detects whether an external board is connected to the E3 slot (only active on Gen 2 PRO boards)
redpitaya_startup	Service for running Red Pitaya startup scripts

Note

To see all installed Red Pitaya services (including inactive ones), use:

systemctl list-units "redpitaya*" --no-pager --all

For additional system services and details, see the Build Red Pitaya OS documentation.

Important

Web Interface (Nginx) and SCPI Server Exclusivity

The redpitaya_nginx web interface and the SCPI server (/opt/redpitaya/bin/monitor) cannot run simultaneously. They both access the same hardware resources, which causes conflicts.

• Before starting SCPI: Stop the Nginx service with systemctl stop redpitaya_nginx

• Before starting web interface: Stop any running SCPI server instances

For more details, see the SCPI Server documentation.

Basic Service Commands

All service management commands require SSH access to Red Pitaya. See SSH Access for connection instructions.

Start a Service

Start a service immediately:

systemctl start <service_name>

Example:

systemctl start redpitaya_nginx

The service starts immediately but will not automatically start on next boot unless enabled.

Stop a Service

Stop a running service immediately:

systemctl stop <service_name>

Example:

systemctl stop redpitaya_nginx

The service stops immediately but may restart on next boot if it’s enabled.

Enable Service on Boot

Configure a service to start automatically at boot:

systemctl enable <service_name>

Example:

systemctl enable redpitaya_scpi

Note

This command only configures startup behavior. To also start the service immediately:

systemctl enable redpitaya_nginx
systemctl start redpitaya_nginx

Disable Service on Boot

Prevent a service from starting automatically at boot:

systemctl disable <service_name>

Example:

systemctl disable redpitaya_nginx

Note

This command only affects startup behavior. To also stop the currently running service:

systemctl disable redpitaya_nginx
systemctl stop redpitaya_nginx

Check Service Status

View the current status of a service:

systemctl status <service_name>

Example output for a running service:

● redpitaya_nginx.service - Red Pitaya Nginx Web Server
     Loaded: loaded (/etc/systemd/system/redpitaya_nginx.service; enabled)
     Active: active (running) since Wed 2026-02-05 10:23:15 UTC; 2h ago
   Main PID: 1234 (nginx)
      Tasks: 5
     Memory: 12.3M
     CGroup: /system.slice/redpitaya_nginx.service

Example output for a stopped service:

● redpitaya_nginx.service - Red Pitaya Nginx Web Server
     Loaded: loaded (/etc/systemd/system/redpitaya_nginx.service; disabled)
     Active: inactive (dead)

Press q to exit the status view.

Restart a Service

Restart a service (stop and start):

systemctl restart <service_name>

This is useful after configuration changes or to clear service state issues.

List All Services

View all Red Pitaya services and their status:

systemctl list-units "redpitaya*" --no-pager

Example output:

UNIT                            LOAD   ACTIVE   SUB     DESCRIPTION
redpitaya_e3_controller.service loaded inactive dead    Service for an application that detects...
redpitaya_nginx.service         loaded active   running Customized Nginx web server for Red Pitaya...
redpitaya_startup.service       loaded inactive dead    Service for startup script Red Pitaya

Common Use Cases

Disable Web Interface for Performance

When running performance-critical applications (like high-speed streaming), disable the web interface to free up resources:

systemctl stop redpitaya_nginx
systemctl disable redpitaya_nginx

To restore:

systemctl enable redpitaya_nginx
systemctl start redpitaya_nginx

Use cases: * High-speed data streaming (See streaming optimization) * CPU-intensive signal processing * Minimizing network bandwidth usage

Running SCPI Server Manually

If you need SCPI command access, the SCPI server can be started manually in the terminal.

Warning

The SCPI server and Nginx web interface cannot run at the same time. They access the same hardware resources and will cause conflicts.

For temporary SCPI usage, stop the web interface (it will restart on next boot):

systemctl stop redpitaya_nginx
/opt/redpitaya/bin/monitor &

The & runs the command in the background, allowing continued terminal use.

Note

If you want SCPI to start automatically at boot instead of the web interface, see Starting SCPI server at boot time in the SCPI documentation.

Use cases: * Remote instrument control via SCPI commands * Automated testing and measurement * Integration with test equipment

For complete SCPI setup, command reference, and examples, see the SCPI Server documentation.

Running Custom Commands at Boot

The startup script (/opt/redpitaya/sbin/startup.sh) can be used to run custom commands at every boot. This is useful for tasks that need to execute after the system starts, but should not be managed as systemd services.

Note

Use `enable`/`disable` for permanent service configuration

To permanently prevent a service from starting at boot, simply run systemctl disable <service_name> once. This configuration persists across reboots without needing the startup script.

The startup script is for running commands that need to execute at boot, not for managing service enable/disable state.

Example use case: Automatically start SCPI server at boot

1. Edit the startup script:

   nano /opt/redpitaya/sbin/startup.sh
   

2. Add commands at the end of the file:

   # Start SCPI server automatically
   /opt/redpitaya/bin/monitor &
   

3. Save and exit (Ctrl+X, Y, Enter)

The commands will run automatically at every boot.

Troubleshooting

Service Won’t Start

If a service fails to start:

1. Check the service status for error messages:

   systemctl status <service_name>
   

2. View detailed logs:

   journalctl -u <service_name> -n 50
   

3. Check if another instance is already running:

   ps aux | grep <service_name>
   

Service Keeps Restarting

If a service automatically restarts after being stopped, it may be configured for automatic restart:

1. Check the service configuration:

   systemctl cat <service_name>
   

2. Look for Restart= settings in the service file

3. Disable the service to prevent automatic restarts:

   systemctl disable <service_name>
   systemctl stop <service_name>
   

Changes Don’t Persist After Reboot

If service state doesn’t persist:

1. Ensure you used enable/disable commands, not just start/stop

2. Verify the change took effect:

   systemctl is-enabled <service_name>
   

Related Topics

• SSH Access - Required for service management

• Build Red Pitaya OS - Complete service list and systemd details

• Streaming Performance Optimization - Streaming-specific service optimization

• Network Configuration - Network service configuration

Additional Resources

• systemd documentation - Official systemd/systemctl reference

• Known Software Issues - Common service-related problems

• Red Pitaya Forum - Community support for service issues