Signals in CAPL Scripting

CAPL (CAN Application Programming Language) is a high-level programming language used in automotive systems, particularly for simulating and testing CAN (Controller Area Network) networks. In CAPL, signals are used to represent data that can be transmitted or received over a CAN bus. These signals are typically associated with CAN messages and their individual data fields.

CAPL allows interaction with signals, making it easier to simulate, test, and analyze CAN communication in real-time.

Key Concepts of Signals in CAPL

Signal Declaration: In CAPL, signals can be declared as variables that correspond to specific CAN signals in a message. These signals represent data that can either be sent or received.

Signal Types: Signals in CAPL can be associated with messages and come in various types:

Single-value signals: A signal that holds one value at a time, such as an integer, float, or boolean.

Array signals: A signal that represents multiple values, such as an array of integers.

Bus signals: Signals that are transmitted over the CAN bus.

Signal Manipulation: Signals can be manipulated (read or written) using CAPL functions. These signals can be part of a CAN message and can represent parameters like speed, temperature, or pressure.

Signal Updating: Signals can be updated when certain events or conditions are met. For example, a signal could be updated when a specific message is received on the CAN bus or when a timer expires.

Types of Signals in CAPL

Global Signals: These are predefined signals available globally in the script, typically tied to the CAN bus messages. For example, if a signal is part of a CAN message, it can be referenced globally.

Local Signals: These are signals defined within a function or procedure in CAPL and are not globally accessible outside that scope.

Syntax for Working with Signals in CAPL

Declaration: To declare a signal, use the following syntax:
capl

signal <type> <signal_name>;

Here, <type> is the data type of the signal, and <signal_name> is the name of the signal.

Accessing Signals in CAN Messages: Signals are often part of a CAN message. They can be accessed and manipulated directly in CAPL using the message's name followed by the signal name. Example: capl message CAN_Message

{
signal speed : uint16;  // speed signal in the CAN message
signal temperature : int8; // temperature signal in the CAN message
}
Accessing these signals in CAPL:
capl

CAN_Message.speed = 100;  // Assign value 100 to the speed signal
CAN_Message.temperature = 25;  // Assign value 25 to the temperature signal

Sending Signals: When you want to send a signal, you would assign a value to the signal, and then send the corresponding CAN message. Example: capl message CAN_Message

{
signal speed : uint16;
signal temperature : int8;
}
// Function to send a CAN message
on timer sendMessage
{
CAN_Message.speed = 120;  // Set speed value
CAN_Message.temperature = 30;  // Set temperature value
output(CAN_Message);  // Send the CAN message with the signals
}

Receiving Signals: Signals are often received through CAN messages. In CAPL, you can use on message handlers to react to received signals. Example: capl message CAN_Message

{
signal speed : uint16;
signal temperature : int8;
}
// Handler to receive and print the speed and temperature signals
on message CAN_Message
{
output("Speed: %d, Temperature: %d", CAN_Message.speed, CAN_Message.temperature);
}
Signal Conversion: CAPL allows you to convert signals between different data types. For instance, you might convert an integer signal into a float.
Example:
capl

uint16 rawValue = CAN_Message.speed;
float speedValue = (float) rawValue / 10.0;  // Convert to a floating-point value
Working with Signal Attributes: Signals in CAPL can have attributes such as min/max values, scaling factors, and unit conversion. These attributes can be used to define how the signal is interpreted.
Example:
capl

signal temperature : int8 {
min: -40;
max: 125;
scalingFactor: 0.5;
unit: "Celsius";
}

Here, the temperature signal is bounded between -40 and 125, scaled by a factor of 0.5, and measured in Celsius.

Example 1: Sending and Receiving a Signal

// Declare the CAN message with signals
message VehicleData
{
signal speed : uint16;
signal fuelLevel : uint8;
}
// Sending signal in a message
on timer sendSignal
{
VehicleData.speed = 80;  // Set speed to 80
VehicleData.fuelLevel = 50;  // Set fuel level to 50%
output(VehicleData);  // Send the message with speed and fuel level signals
}
// Receiving signal from a message
on message VehicleData
{
output("Received speed: %d km/h, Fuel level: %d%%", VehicleData.speed, VehicleData.fuelLevel);
}

Example 2: Signal Conversion and Processing

message SensorData
{
signal temperature : int16;  // Temperature signal (in deci-Celsius)
signal pressure : uint16;    // Pressure signal (in Pascals)
}
// Handler for processing the received signal
on message SensorData
{
// Convert temperature from deci-Celsius to Celsius
float realTemperature = (float) SensorData.temperature / 10.0;
// Check if the temperature is too high
if (realTemperature > 75.0)
{
output("Warning: High temperature detected! %0.1f°C", realTemperature);
}
// Print the pressure
output("Pressure: %d Pa", SensorData.pressure);
}

Summary

In CAPL, signals are integral for CAN communication, allowing you to simulate and manipulate various data values transmitted over the bus. By associating signals with CAN messages, you can send and receive data and perform operations such as signal conversion, updating values, and handling events based on the signal data.

Signals provide an abstraction layer over the raw CAN data, making it easier to work with parameters like speed, temperature, pressure, etc., in a structured way. CAPL's functions for reading, writing, and processing signals facilitate advanced testing and simulation scenarios.