PythonRunExample.py

# Profinity Script - Python Run Template
#
# This script will execute the code in the run method each time it is called, either as
# part of a scheduled event of just run manually.
#
# For further information on the capabilites of Profinity Scripting, see the example scripts.
#

def RunMe():
    print('This is a Python message!')
    print(Profinity.Message)

    # ============================================================================
    # EXAMPLE CODE - These examples show how to use major Profinity features
    # ============================================================================
    # The code below demonstrates various capabilities but is commented out so it
    # doesn't affect the script's current functionality. Uncomment and modify as needed.
    # ============================================================================

    # ----------------------------------------------------------------------------
    # EXAMPLE 1: Read CAN Packet (Latest received packet for a specific CAN ID)
    # ----------------------------------------------------------------------------
    # Get the latest valid CAN packet received for a specific CAN ID
    # Replace 0x100 with your actual CAN ID (can be hex like 0x100 or decimal like 256)
    # can_id = 0x100
    # received_packet = Profinity.CANBus.LatestValidPacketReceivedByID(can_id)
    # if received_packet is not None:
    #     # Read major CAN packet properties
    #     print(f'CAN ID: {received_packet.CanId} (Hex: {received_packet.CanIdAsHex})')
    #     print(f'Data length: {received_packet.DataLength} bytes')
    #     print(f'Extended frame: {received_packet.Extended}')
    #     print(f'CAN FD: {received_packet.CanFD}')
    #     print(f'Remote frame (RTR): {received_packet.Rtr}')
    #     print(f'Heartbeat: {received_packet.Heartbeat}')
    #     print(f'Settings packet: {received_packet.Settings}')
    #     print(f'Data encoding: {received_packet.DataEncoding}')
    #     print(f'Age: {received_packet.MillisecondsSinceCreated} ms')
    #
    #     # Read packet data in various formats
    #     # Access raw byte array
    #     raw_data = received_packet.Data
    #     if raw_data is not None and len(raw_data) > 0:
    #         print(f'Raw data (bytes): {" ".join(f"{b:02X}" for b in raw_data)}')
    #
    #     # Access data as 32-bit signed integers (most common)
    #     if received_packet.Int32Pos0 is not None:
    #         print(f'Int32 at position 0: {received_packet.Int32Pos0}')
    #     if received_packet.Int32Pos1 is not None:
    #         print(f'Int32 at position 1: {received_packet.Int32Pos1}')
    #
    #     # Access data as floats (for floating-point values)
    #     if received_packet.FloatPos0 is not None:
    #         print(f'Float at position 0: {received_packet.FloatPos0}')
    #
    #     # Access individual bytes
    #     if received_packet.BytePos0 is not None:
    #         print(f'Byte at position 0: {received_packet.BytePos0} (0x{received_packet.BytePos0:02X})')
    #     if received_packet.BytePos1 is not None:
    #         print(f'Byte at position 1: {received_packet.BytePos1} (0x{received_packet.BytePos1:02X})')
    #
    #     # Access as 16-bit signed integers
    #     if received_packet.Short16Pos0 is not None:
    #         print(f'Int16 at position 0: {received_packet.Short16Pos0}')
    #
    #     # Access as unsigned integers
    #     if received_packet.UInt32Pos0 is not None:
    #         print(f'UInt32 at position 0: {received_packet.UInt32Pos0}')
    # else:
    #     print(f'No valid CAN packet found for ID {hex(can_id)}')
    #
    # # Alternative: Wait for a CAN packet with timeout (blocks until packet arrives or timeout)
    # # packet = Profinity.CANBus.Receive(can_id, timeout=1000)  # 1 second timeout
    #

    # ----------------------------------------------------------------------------
    # EXAMPLE 2: Write and Read CAN Packets (Complete read/write example)
    # ----------------------------------------------------------------------------
    # This example demonstrates both reading existing packets and creating/sending new ones
    #
    # # Part A: Read an existing CAN packet
    # from Profinity.Comms.CANBus import CanPacket
    #
    # read_can_id = 0x100
    # existing_packet = Profinity.CANBus.LatestValidPacketReceivedByID(read_can_id)
    # if existing_packet is not None:
    #     print(f'Read packet - ID: {existing_packet.CanIdAsHex}, Data: {" ".join(f"{b:02X}" for b in existing_packet.Data)}')
    #     # Read and display packet properties
    #     print(f'  Extended: {existing_packet.Extended}, Length: {existing_packet.DataLength}')
    #     if existing_packet.Int32Pos0 is not None:
    #         print(f'  Int32[0]: {existing_packet.Int32Pos0}')
    #
    # # Part B: Create and send a new CAN packet
    # # Method 1: Create with CAN ID only, then set data using typed properties
    # packet_to_send = CanPacket(0x200)
    # packet_to_send.Int32Pos0 = 100  # Set first 4 bytes as signed 32-bit integer
    # packet_to_send.Int32Pos1 = 200  # Set next 4 bytes as signed 32-bit integer
    # Profinity.CANBus.SendMessage(packet_to_send)
    # print(f'Sent packet ID {packet_to_send.CanIdAsHex} with Int32 values: {packet_to_send.Int32Pos0}, {packet_to_send.Int32Pos1}')
    #
    # # Method 2: Create packet with float values
    # float_packet = CanPacket(0x300)
    # float_packet.FloatPos0 = 3.14159  # Set first 4 bytes as float
    # float_packet.FloatPos1 = 2.71828  # Set next 4 bytes as float
    # Profinity.CANBus.SendMessage(float_packet)
    #
    # # Method 3: Create packet with individual bytes
    # byte_packet = CanPacket(0x400)
    # byte_packet.BytePos0 = 0x01
    # byte_packet.BytePos1 = 0x02
    # byte_packet.BytePos2 = 0x03
    # byte_packet.BytePos3 = 0x04
    # byte_packet.BytePos4 = 0x05
    # byte_packet.BytePos5 = 0x06
    # byte_packet.BytePos6 = 0x07
    # byte_packet.BytePos7 = 0x08
    # Profinity.CANBus.SendMessage(byte_packet)
    #
    # # Method 4: Create with byte array (full control)
    # can_data = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11]
    # detailed_packet = CanPacket(0x500, False, False, False, 8, CanPacket.Encoding.LittleEndian, can_data)
    # sent = Profinity.CANBus.SendMessage(detailed_packet)
    # if sent:
    #     print(f'CAN packet {detailed_packet.CanIdAsHex} sent successfully')
    #     print(f'  Raw data: {" ".join(f"{b:02X}" for b in detailed_packet.Data)}')
    #     print(f'  Data length: {detailed_packet.DataLength} bytes')
    #
    # # Method 5: Create extended frame (29-bit CAN ID)
    # extended_packet = CanPacket(
    #     0x1FFFFFFF,  # Extended ID (29 bits)
    #     True,        # extendedFrameFormat
    #     False,       # remoteFrame
    #     False,       # errorFrame
    #     8,           # dataLength
    #     CanPacket.Encoding.LittleEndian,
    #     [0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88]
    # )
    # Profinity.CANBus.SendMessage(extended_packet)
    # print(f'Extended frame {extended_packet.CanIdAsHex} sent (Extended: {extended_packet.Extended})')
    #

    # ----------------------------------------------------------------------------
    # EXAMPLE 3: Read DBC Message and Signal
    # ----------------------------------------------------------------------------
    # Access DBC signals through component name, message name, and signal name
    # Replace these with your actual component, message, and signal names
    # component_name = "YourComponentName"  # e.g., "BatteryPack"
    # message_name = "YourMessageName"      # e.g., "STW_ANGLHP_STAT"
    # signal_name = "YourSignalName"        # e.g., "StW_AnglHP"
    #
    # try:
    #     # Get the DBC signal and read its value
    #     signal = Profinity.DBC.GetDbcSignal(component_name, message_name, signal_name)
    #     signal_value = signal.Value
    #     print(f'DBC Signal {component_name}.{message_name}.{signal_name} = {signal_value}')
    #
    #     # You can also access signal properties like:
    #     # - signal.Minimum
    #     # - signal.Maximum
    #     # - signal.Unit
    #     # - signal.Comment
    # except Exception as ex:
    #     print(f'Error reading DBC signal: {ex.Message}')
    #     # Common errors: Component not found, Message not found, Signal not found
    #

    # ----------------------------------------------------------------------------
    # EXAMPLE 4: Store State (Local to this script instance)
    # ----------------------------------------------------------------------------
    # Store values that persist between script runs within this script instance
    # Useful for maintaining counters, flags, or temporary data
    #
    # # Store different data types
    # Profinity.State.Set("counter", 42)
    # Profinity.State.Set("lastMessage", "Script executed successfully")
    # from datetime import datetime
    # Profinity.State.Set("lastRunTime", datetime.now().isoformat())
    #
    # # Retrieve stored values (returns None if key doesn't exist)
    # counter_obj = Profinity.State.Get("counter")
    # if counter_obj is not None:
    #     counter = int(counter_obj)
    #     counter += 1  # Increment counter
    #     Profinity.State.Set("counter", counter)
    #     print(f'Run count: {counter}')
    #
    # last_msg = Profinity.State.Get("lastMessage")
    # if last_msg is not None:
    #     print(f'Last message: {last_msg}')
    #

    # ----------------------------------------------------------------------------
    # EXAMPLE 5: Share State (Global across all scripts)
    # ----------------------------------------------------------------------------
    # Store values that can be accessed by all scripts in the profile
    # Useful for inter-script communication and shared data
    #
    # # Set global values
    # Profinity.GlobalState.Set("sharedCounter", 100)
    # Profinity.GlobalState.Set("systemStatus", "Running")
    # from datetime import datetime
    # Profinity.GlobalState.Set("lastUpdateTime", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    #
    # # Read global values set by other scripts
    # shared_counter = Profinity.GlobalState.Get("sharedCounter")
    # if shared_counter is not None:
    #     count = int(shared_counter)
    #     print(f'Shared counter value: {count}')
    #
    # status = Profinity.GlobalState.Get("systemStatus")
    # if status is not None:
    #     print(f'System status from other script: {status}')
    #
    # # Increment shared counter (example of coordination between scripts)
    # if shared_counter is not None:
    #     current_count = int(shared_counter)
    #     Profinity.GlobalState.Set("sharedCounter", current_count + 1)
    #

    # ----------------------------------------------------------------------------
    # EXAMPLE 6: Check for Script Cancellation (Important for long-running operations)
    # ----------------------------------------------------------------------------
    # Always check Profinity.ScriptCancelled in loops to allow graceful cancellation
    # This allows the script to be stopped gracefully when needed
    #
    # iteration_count = 0
    # while iteration_count < 100 and not Profinity.ScriptCancelled:
    #     # Do some work here
    #     print(f'Iteration {iteration_count}')
    #
    #     # Check cancellation periodically in long operations
    #     if Profinity.ScriptCancelled:
    #         print('Script was cancelled, exiting loop')
    #         break
    #
    #     iteration_count += 1
    #     import time
    #     time.sleep(0.1)  # Small delay to avoid tight loop
    #
    # # Check cancellation before long operations
    # if not Profinity.ScriptCancelled:
    #     # Perform time-consuming operation
    #     pass
    # else:
    #     print('Script was cancelled, skipping operation')
    #     return False  # Indicate script was cancelled
    #


RunMe()