https://github.com/anjadj/inter-process-communication-in-an-industrial-iot-gateway-device
gRPC & D-Bus
https://github.com/anjadj/inter-process-communication-in-an-industrial-iot-gateway-device
c cpp dbus driver grpc linux python
Last synced: 6 months ago
JSON representation
gRPC & D-Bus
- Host: GitHub
- URL: https://github.com/anjadj/inter-process-communication-in-an-industrial-iot-gateway-device
- Owner: AnjaDj
- Created: 2024-10-30T19:33:57.000Z (9 months ago)
- Default Branch: main
- Last Pushed: 2024-12-24T12:15:35.000Z (7 months ago)
- Last Synced: 2024-12-24T13:40:42.135Z (7 months ago)
- Topics: c, cpp, dbus, driver, grpc, linux, python
- Language: Python
- Homepage:
- Size: 16.7 MB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 19
-
Metadata Files:
- Readme: README.md
- Support: supporting libraries/ADC.service
Awesome Lists containing this project
README
# 🔸 gRPC
## Build and locally install gRPC and Protocol Buffers for C++ on Ubuntu x86_64 6.8.0-49-generic
Prerequisites
- cmake 3.16 or later (https://vitux.com/how-to-install-cmake-on-ubuntu/)
1. Configures a directory for locally installed packages and ensures the executables are easily accessible from the command line
```bash
~$ export LOCAL_INSTALL_DIR=$HOME/.local
~$ mkdir -p $LOCAL_INSTALL_DIR
~$ export PATH="$LOCAL_INSTALL_DIR/bin:$PATH"
2. Install the basic tools required to build gRPC
```bash
~$ sudo apt install -y build-essential autoconf libtool pkg-config
3. Clone the grpc repo and its submodules
```bash
~$ git clone --recurse-submodules -b v1.66.0 --depth 1 --shallow-submodules https://github.com/grpc/grpc
4. Build and locally install gRPC and Protocol Buffers
```bash
~$ cd grpc
~/grpc$ mkdir -p cmake/build
~/grpc$ pushd cmake/build
~grpc/cmake/build$ cmake -DgRPC_INSTALL=ON \
-DgRPC_BUILD_TESTS=OFF \
-DCMAKE_INSTALL_PREFIX=$LOCAL_INSTALL_DIR \
../..
~grpc/cmake/build$ make -j 4
~grpc/cmake/build$ make install
~grpc/cmake/build$ popd
5. Build the project
in `~/grpc/examples/protos/` save .proto file
in `~/grpc/examples/cpp/` create new directory `myproject` containing source .cc code and CMakeLists.txt
```bash
~/grpc$ cd examples/cpp/myproject
~/grpc/examples/cpp/myproject$ mkdir -p cmake/build
~/grpc/examples/cpp/myproject$ pushd cmake/build
~/grpc/examples/cpp/myproject/cmake/build$ cmake -DCMAKE_PREFIX_PATH=$LOCAL_INSTALL_DIR ../..
~/grpc/examples/cpp/myproject/cmake/build$ make -j 4
6. Run the project from the project `build` directory
```bash
~/grpc/examples/cpp/myproject/cmake/build$ ./app
## Build and locally install gRPC and Protocol Buffers for Python on Ubuntu x86_64 6.8.0-49-generic
Prerequisites
- Python 3.7 or higher
- pip version 9.0.1 or higher
1. Install gRPC
```bash
~$ python3 -m pip install grpcio
2. Install gRPC tools
```bash
~$ python3 -m pip install grpcio-tools
3. Build the project
create new directory `myproject` containing .proto file and source .py code
5. Run the project
from project directory `myproject` in terminal run `python3 app.py`
# 🔸 From Python script to Linux service using systemd
A daemon (or service) is a background process that is designed to run autonomously,with little or not user intervention. Services will start automatically every time the system starts, which eliminates the need to start it manually. Scripts that collect data, represent servers or similar are ideal candidates to be configured as services and not ordinary scripts.
1. Write Python script you want to make as service `/path/to/your_script.py`
2. Make your Python script executable
```bash
~$ chmod +x /path/to/your_script.py
4. Create systemd service file in directory `/etc/systemd/system/`. Systemd service files need to be in `/etc/systemd/system/` DIR!
```bash
~$ sudo nano /etc/systemd/system/your_script.service
5. Add following content to your .service file
```bash
[Unit]
Description=Python Script Service
After=network.target
[Service]
ExecStart=/usr/bin/python3 /path/to/your_script.py
Restart=always
User=your_user
WorkingDirectory=/path/to/
Environment="PATH=/usr/bin"
[Install]
WantedBy=multi-user.target
6. Reload systemd to recognise new service `your_script.service`
```bash
sudo systemctl daemon-reload
8. Enable new service at system startup
```bash
sudo systemctl enable your_script.service
10. Run service
```bash
sudo systemctl start your_script.service
11. Managing the service
- stop service
```bash
sudo systemctl stop your_script.service
- restart service
```bash
sudo systemctl stop your_script.service
- disable service at system startup
```bash
sudo systemctl disable your_script.service
# 🔸 Natively build a Linux kernel on RPi 3B
Complete quidance on : https://www.raspberrypi.com/documentation/computers/linux_kernel.html#install-directly-onto-the-sd-card.
This guide assumes that your Raspberry Pi runs the latest version of Raspberry Pi OS.
`sudo apt install git`
`git clone --depth=1 https://github.com/raspberrypi/linux`
1. Install the build dependencies
`sudo apt install bc bison flex libssl-dev make`
2. Build configuration
In this case, Im using RPi3B and for 32bit distribution run following commands
```bash
cd linux
KERNEL=kernel7
make bcm2709_defconfig
3. Build the 32-bit kernel (this step will take A LONG TIME -couple of hours)
`make -j6 zImage modules dtbs`
4. Install the kernel modules onto the boot media
`sudo make -j6 modules_install`
5. Create a backup of your current kernel and install the fresh kernel image
```bash
sudo cp /boot/firmware/$KERNEL.img /boot/firmware/$KERNEL-backup.img
sudo cp arch/arm/boot/zImage /boot/firmware/$KERNEL.img
6. For kernels version 6.5 and above
`sudo cp arch/arm/boot/dts/broadcom/*.dtb /boot/firmware/`
7. Copy over the overlays and README
```bash
sudo cp arch/arm/boot/dts/overlays/*.dtb* /boot/firmware/overlays/
sudo cp arch/arm/boot/dts/overlays/README /boot/firmware/overlays/
8. Finally, run the following command to reboot your Raspberry Pi and run your freshly-compiled kernel `sudo reboot`