🚙CAN Interface Sample App

Here is an example of a Qt application that uses the CAN interface from TorizonOS to receive CAN messages and display them on the screen.

Prerequisites

• Ensure you have a CAN interface set up and connected to your ATDM.

• Ensure that the necessary CAN utilities and libraries are installed on your ATDM.

Example Code

This example uses the Python python-can library to interact with the CAN interface. You'll need to install this library in your Docker container.

Dockerfile

First, update your Dockerfile to include the python-can library:

Dockerfile FROM torizon/qt5-wayland:latest

# Install necessary packages
RUN apt-get update && apt-get install -y \
    python3-pip \
    can-utils \
    && apt-get clean && apt-get autoremove && rm -rf /var/lib/apt/lists/*

# Install python-can library
RUN pip3 install python-can

# Copy application files
COPY . /app
WORKDIR /app

CMD ["python3", "main.py"]

main.py

Here's an example of the Qt application that receives CAN messages and displays them on the screen:

python import sys
from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget
import can
import threading

class CANReceiver(QWidget):
    def __init__(self):
        super().__init__()

        self.initUI()
        self.initCAN()

    def initUI(self):
        self.setWindowTitle('CAN Message Receiver')
        self.layout = QVBoxLayout()
        self.label = QLabel('Waiting for CAN messages...')
        self.layout.addWidget(self.label)
        self.setLayout(self.layout)
        self.resize(400, 200)

    def initCAN(self):
        # Initialize CAN interface
        self.bus = can.interface.Bus(channel='can0', bustype='socketcan')

        # Start a thread to read CAN messages
        self.can_thread = threading.Thread(target=self.read_can_messages)
        self.can_thread.start()

    def read_can_messages(self):
        while True:
            message = self.bus.recv()
            if message:
                self.display_message(message)

    def display_message(self, message):
        msg = f'ID: {message.arbitration_id}, Data: {message.data}'
        self.label.setText(msg)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    receiver = CANReceiver()
    receiver.show()
    sys.exit(app.exec_())

Running the Application

1. Build the Docker Container

   Build your Docker container with the following command:

   docker build -t my-qt-can-app .

2. Deploy the Application to ATDM

   Deploy the Docker container to your ATDM:

   docker run -d --rm --name my-qt-can-app-container --network host --privileged my-qt-can-app

Summary

This example demonstrates how to create a simple Qt application that uses the CAN interface on TorizonOS to receive and display CAN messages. The application initializes the CAN interface, starts a separate thread to read CAN messages, and updates the UI to display the received messages. This provides a foundation for developing more complex CAN-based applications on your ATDM.

For more information on working with CAN in Python, you can refer to the python-can documentation.