BrainyPi Team, Author at Brainy Pi

BrainyPi Community Events: Building Together

BrainyPi Team — Sun, 09 Feb 2025 10:59:11 +0000

Over the past few years, the BrainyPi community has had the privilege of fostering innovation, creativity, and hands-on learning through a diverse range of engaging events. Consequently, these initiatives have provided individuals with the opportunity to explore cutting-edge technologies and expand their technical expertise. Through programs like the Makers Club and AI and IoT workshops, we have worked closely with passionate individuals, guiding them in their journey to experiment, collaborate, and bring their ideas to life. Therefore, seeing participants apply their skills in meaningful ways has been incredibly rewarding. Furthermore, we are grateful to be part of a community that values continuous learning, creative problem-solving, and collective growth.

Moreover, BrainyPi events are designed to provide valuable opportunities for learning and collaboration, catering to makers, developers, tech enthusiasts, and anyone curious about emerging technologies. Hence, regardless of experience level, participants gain practical knowledge that helps them innovate and build with confidence. As we reflect on our journey, it is exciting to explore the impact and achievements of this vibrant and growing community.

Makers Club: Turning Ideas into Reality

The Makers Club has played a pivotal role in strengthening the BrainyPi community by bringing together tech enthusiasts and innovators eager to transform ideas into real-world projects. As a result, these sessions have provided hands-on experience, encouraging participants to work with hardware, software, and electronics. Thus, individuals have been able to experiment, refine their concepts, and develop working prototypes while contributing to an inclusive build space for builders.

Highlights from the Makers Club:

Hands-on Electronics & Coding: Participants delved into embedded systems, microcontrollers, and sensor integrations, gaining essential technical skills.
DIY Tech Projects: By leveraging BrainyPi, members created innovative solutions such as smart home automation, robotics, and IoT-enabled devices.
Collaboration & Networking: These sessions fostered a thriving space where participants exchanged ideas, solved challenges together, and formed dynamic project teams.

AI & IoT Workshops: Learning by Doing

AI and IoT Workshops have offered a unique opportunity for individuals to gain hands-on experience with emerging technologies. As artificial intelligence continues to advance and the Internet of Things becomes more integrated into everyday life, we have actively worked to bridge the knowledge gap. By providing practical, real-world applications, these workshops have helped attendees develop essential skills, empowering them to apply their learning in meaningful ways.

What We Covered:

Introduction to AI & Machine Learning: Understanding fundamental AI concepts, neural networks, and real-world applications.
IoT for Beginners & Advanced Users: From setting up IoT sensors to deploying cloud-based automation.
BrainyPi-Powered AI Projects: Participants built AI models for object detection, speech recognition, and predictive analytics.
Live Demonstrations & Take-home Kits: Interactive learning experiences with real-world implementations.

The Impact: BrainyPi Community Growth

Gain hands-on experience with cutting-edge technology.

Build innovative projects with open-source hardware and software.

Connect with like-minded makers, engineers, and entrepreneurs.

Advance their careers with practical skills in AI, IoT, and embedded systems.

This is more than just a community—it is a genuine effort of many that builds an inclusive space for builders to innovate, experiment, and collaborate. The community-driven approach has helped participants turn ideas into tangible projects.

Let’s keep innovating together! Stay connected, keep building.

The post BrainyPi Community Events: Building Together appeared first on Brainy Pi.

Pedestrian Tracker on Brainy Pi

BrainyPi Team — Thu, 15 Jun 2023 07:03:48 +0000

In this blog post, we will delve into the Pedestrian Tracking Demo using OpenVINO on Brainy Pi. This impressive integration of AI and computer vision enables the detection of pedestrians in frames and the construction of their movement trajectories, frame-by-frame. This demonstration not only highlights the immense potential of OpenVINO in the development of computer vision products but also serves as a valuable resource for developers and entrepreneurs in this field. So, let’s roll up our sleeves and implement the Pedestrian Tracker on Brainy Pi with the power of OpenVINO!

Installing OpenVINO and Dependencies

To get started, we need to install OpenVINO and its dependencies on BrainyPi. Open a terminal and run the following command to install OpenVINO and the necessary OpenCV development files:

sudo apt install openvino-toolkit libopencv-dev

By installing OpenVINO, we gain access to a powerful set of tools and libraries for optimizing and deploying deep learning models on various hardware platforms.

Compiling the Demos

Once we install OpenVINO, we can proceed to compile the demos. These demos serve as an excellent starting point for understanding and exploring the capabilities of OpenVINO. Follow the steps below to compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:
```
source /opt/openvino/setupvars.sh
```
This step is crucial as it configures the necessary environment variables for working with OpenVINO.
Clone the Open Model Zoo repository, which contains the demos, using the following command:
```
git clone --recurse-submodules https://github.com/openvinotoolkit/open_model_zoo.git
cd open_model_zoo/demos/
```
The Open Model Zoo provides a collection of pre-trained models and demo applications that can be used with OpenVINO.
Build the demos by executing the build_demos.sh script:
```
./build_demos.sh
```
This step compiles the demo applications and makes them ready for execution.

Running the Pedestrian Tracker on Brainy Pi

With the demos compiled, we can now download the required models and run the Pedestrian Tracking Demo using OpenVINO. Follow these steps:

Download the models for the demo by running the following command:
```
omz_downloader --list ~/open_model_zoo/demos/pedestrian_tracker_demo/cpp/models.lst -o ~/models/ --precision FP16
```
The Open Model Zoo downloader allows us to easily fetch the models specified in the models.lst file.
Download the test video:
```
cd ~/
wget https://raw.githubusercontent.com/intel-iot-devkit/sample-videos/master/people-detection.mp4
```
This command downloads a sample video – an input for the Pedestrian Tracking Demo.

Once the models and the test video are downloaded, you can run the Pedestrian Tracking Demo using the following command:

~/omz_demos_build/aarch64/Release/pedestrian_tracker_demo -i ~/people-detection.mp4 -m_det ~/models/intel/person-detection-retail-0013/FP16/person-detection-retail-0013.xml -m_reid ~/models/intel/person-reidentification-retail-0277/FP16/person-reidentification-retail-0277.xml -at ssd

This command executes the Pedestrian Tracking Demo, leveraging the person detection and person re-identification models to track pedestrians in the video.

By following these steps, you can quickly set up and run the Pedestrian Tracking Demo, gaining insights into the capabilities of OpenVINO and its potential for developing computer vision products.

Conclusion

The Pedestrian Tracking Demo using OpenVINO on Brainy Pi demonstrates the power of AI and computer vision in detecting and tracking pedestrians. By utilizing OpenVINO’s optimization and deployment capabilities, developers and entrepreneurs can build robust computer vision applications for various domains. We hope this blog post provides you with a useful overview and inspiration for incorporating OpenVINO into your computer vision projects.

References

OpenVINO Documentation: https://docs.openvino.ai/
Open Model Zoo Pedestrian Tracking Demo: https://docs.openvino.ai/2022.3/omz_demos_pedestrian_tracker_demo_cpp.html

The post Pedestrian Tracker on Brainy Pi appeared first on Brainy Pi.

Image Segmentation on Brainy Pi

BrainyPi Team — Thu, 15 Jun 2023 06:53:27 +0000

Today’s blog post will explore the robust capabilities of OpenVINO (Open Visual Inference and Neural Network Optimization) in image segmentation. We’ll showcase a demo that leverages OpenVINO on Brainy Pi, combining AI and computer vision to segment video frames. This blog targets developers and entrepreneurs interested in building computer vision products with OpenVINO. Let’s dive into implementing image segmentation on Brainy Pi!

Installing OpenVINO

Before we dive into the demo, we need to install OpenVINO and its dependencies on BrainyPi. Let’s start by opening a terminal and running the following command:

sudo apt install openvino-toolkit libopencv-dev

This command will install OpenVINO and the necessary OpenCV development files on your system, providing the foundation for our image segmentation demo.

Compiling the Demos

Once OpenVINO is successfully installed, we can proceed to compile the demos. These demos serve as an excellent starting point for understanding and exploring the capabilities of OpenVINO. Here are the steps to compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:
```
source /opt/openvino/setupvars.sh
```

Clone the Open Model Zoo repository, which contains the demos, by executing the following command:

git clone --recurse-submodules https://github.com/openvinotoolkit/open_model_zoo.git
cd open_model_zoo/demos/

Build the demos by running the build_demos.sh script:
```
./build_demos.sh
```

These steps will compile the demo applications. It will make them ready for execution and enabling us to dive into the exciting world of image segmentation with OpenVINO.

Running the Image Segmentation on Brainy Pi

With the demos successfully compiled, we can now proceed to download the required models and run the image segmentation demo using OpenVINO. Let’s follow the steps below:

Download the models required for the demo by running the following command:
```
omz_downloader --list ~/open_model_zoo/demos/segmentation_demo/cpp/models.lst -o ~/models/ --precision FP16
```
This command downloads the necessary models from the Open Model Zoo repository and saves them in the ~/models/ directory on your system.

Download a test video to feed into the demo. We will use the following command to download a sample video:

cd ~/
wget https://raw.githubusercontent.com/intel-iot-devkit/sample-videos/master/head-pose-face-detection-male.mp4

Once the models and the test video are downloaded, we can run the image segmentation demo using the following command:
```
~/omz_demos_build/aarch64/Release/segmentation_demo -i ~/head-pose-face-detection-male.mp4 -m ~/models/intel/semantic-segmentation-adas-0001/FP16/semantic-segmentation-adas-0001.xml
```
This command executes the image segmentation demo, processing the frames of the test video and producing segmented output based on the downloaded model.

By following these steps, you can witness the power of OpenVINO in action, as it intelligently segments the frames in the video and showcases the potential for building advanced computer vision applications.

Conclusion

In this blog post, we explored the Image Segmentation Demo using OpenVINO on BrainyPi. We covered the installation process, compilation of demos, and the steps to run the image segmentation demo with OpenVINO. By leveraging OpenVINO’s capabilities, developers and entrepreneurs can unlock the potential of AI and computer vision for their own projects and build advanced computer vision products.

If you’re interested in diving deeper into OpenVINO, be sure to check out the official OpenVINO documentation for more detailed information and resources.

Reference: OpenVINO Segmentation Demo Documentation

The post Image Segmentation on Brainy Pi appeared first on Brainy Pi.

Human Pose Detection on Brainy Pi

BrainyPi Team — Thu, 15 Jun 2023 06:33:59 +0000

Are you a developer or entrepreneur interested in harnessing the power of AI and computer vision to build innovative products? Well, look no further! In this blog post, we will not only walk you through the process of using OpenVINO on Brainy Pi to predict human poses using AI and computer vision, but also provide valuable insights and tips for your own computer vision projects. This demo not only showcases the remarkable capabilities of OpenVINO but also offers a solid starting point for your exciting journey into the world of computer vision. So, let’s dive right in and implement Human Pose Detection on Brainy Pi together!

Installing OpenVINO

Before we dive into the demo, let’s start by installing OpenVINO and its dependencies on BrainyPi. Follow these simple steps:

Open a terminal on your BrainyPi device and enter the following command to install OpenVINO and the necessary OpenCV development files:
```
sudo apt install openvino-toolkit libopencv-dev
```
This command will ensure that OpenVINO is installed and ready to use.

Compiling Demos

Now that OpenVINO is installed, we can proceed to compile the demos. These demos serve as valuable resources for understanding and exploring the capabilities of OpenVINO. Here’s how you can compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:
```
source /opt/openvino/setupvars.sh
```

Clone the Open Model Zoo repository, which contains the demos, using the following command:

git clone --recurse-submodules https://github.com/openvinotoolkit/open_model_zoo.git
cd open_model_zoo/demos/

Build the demos by executing the build_demos.sh script:
```
./build_demos.sh
```
This will compile the demo applications and make them ready for execution.

Running the Demos

With the demos compiled, we can now download the required models and run the human pose detection demo. Follow these steps:

Download the models needed for the demo by running the following command:
```
omz_downloader --list ~/open_model_zoo/demos/human_pose_estimation_demo/cpp/models.lst -o ~/models/ --precision FP16
```
This command will download the necessary models for the demo and save them in the ~/models/ directory.
Download the test video that will be used for the demo:
```
cd ~/
wget https://raw.githubusercontent.com/intel-iot-devkit/sample-videos/master/face-demographics-walking.mp4
```
This command will download a sample video called face-demographics-walking.mp4.

Once the models and the test video are downloaded, you can run the demo using the following command:

~/omz_demos_build/aarch64/Release/human_pose_estimation_demo -i ~/face-demographics-walking.mp4 -m ~/models/intel/human-pose-estimation-0001/FP16/human-pose-estimation-0001.xml -at openpose

This command will execute the human pose estimation demo using OpenVINO on the test video.

Conclusion

Congratulations! You have successfully installed OpenVINO, compiled the demos, and run the human pose detection demo on BrainyPi. This demo showcases the power of AI and computer vision in predicting human poses, providing a solid foundation for developers and entrepreneurs to build their own computer vision products.

To delve deeper into the human pose detection demo and explore additional features and options, refer to the OpenVINO documentation.

Get creative and leverage the potential of OpenVINO to unlock a world of possibilities in computer vision applications. Happy coding!

Note: The content of this blog is based on OpenVINO 2023.0 documentation and may be subject to updates in future releases.

The post Human Pose Detection on Brainy Pi appeared first on Brainy Pi.

Social Distance Monitoring with Brainy Pi

BrainyPi Team — Thu, 15 Jun 2023 03:41:58 +0000

In today’s world, where social distancing has become an essential practice, leveraging computer vision and artificial intelligence (AI) can play a vital role in monitoring and ensuring safe distancing measures. In this blog, we will showcase a Social Distancing Monitoring Demo using OpenVINO and Brainy Pi, a powerful combination for developers and entrepreneurs looking to build computer vision products. We will guide you through the installation process, compiling the demos, and running the demo application, allowing you to determine the distance between individuals in a video/camera-feed. Lets implement Social Distance Monitoring Product !

Installing OpenVINO

To begin, we need to install OpenVINO and its dependencies on BrainyPi. Open a terminal and run the following command:

sudo apt install openvino-toolkit libopencv-dev

This command will install OpenVINO and the necessary OpenCV development files on your system.

Compiling Demos

Once OpenVINO is installed, we can proceed to compile the demos. These demos provide a great starting point for understanding and exploring the capabilities of OpenVINO. Follow the steps below:

Set up the OpenVINO environment by sourcing the setupvars.sh script:
```
source /opt/openvino/setupvars.sh
```

Clone the Open Model Zoo repository, which contains the demos, using the following command:

git clone --recurse-submodules https://github.com/openvinotoolkit/open_model_zoo.git
cd open_model_zoo/demos/

Build the demos by executing the build_demos.sh script:
```
./build_demos.sh
```

This will compile the demo applications and make them ready for execution.

Running the Demo for Social Distance Monitoring

With the demos compiled, we can now download the required models and run them using OpenVINO. Follow these steps:

Download the models needed for the demo by running the following command:

omz_downloader --list ~/open_model_zoo/demos/social_distance_demo/cpp/models.lst -o ~/models/ --precision FP16

Download the test video:

cd ~/
wget https://raw.githubusercontent.com/intel-iot-devkit/sample-videos/master/face-demographics-walking.mp4

Once the models and the test video are downloaded, you can run the object detection demo using the following command:

~/omz_demos_build/aarch64/Release/social_distance_demo -i ~/face-demographics-walking.mp4 -m_det ~/models/intel/person-detection-retail-0013/FP16/person-detection-retail-0013.xml -m_reid ~/models/intel/person-reidentification-retail-0277/FP16/person-reidentification-retail-0277.xml

Reference:

https://docs.openvino.ai/2022.3/omz_demos_social_distance_demo_cpp.html

Conclusion:

In this blog, we have demonstrated how to build a Social Distancing Monitoring product using OpenVINO and BrainyPi. First and foremost, by combining AI and computer vision, you can determine the distance between individuals in a video, providing valuable insights for ensuring safe social distancing. Furthermore, developers and entrepreneurs looking to incorporate this technology into their computer vision products now have a starting point to explore and enhance the capabilities of OpenVINO. Additionally, by following the steps outlined in this blog, you can get started on your journey to building innovative solutions for a safer future.

Remember, social distancing plays a crucial role in our collective well-being because it helps maintain safe distances and prevents the spread of contagious diseases. Additionally, technology can be a powerful ally in achieving these goals, so it is important to leverage its capabilities effectively.

The post Social Distance Monitoring with Brainy Pi appeared first on Brainy Pi.

Cross Road Camera Demo On Brainy Pi

BrainyPi Team — Thu, 15 Jun 2023 03:36:58 +0000

In this blog post, we will explore the AI pipeline for person detection, recognition, and reidentification using OpenVINO on BrainyPi. OpenVINO, short for Open Visual Inference and Neural Network Optimization, is a powerful toolkit by Intel that enables developers to deploy deep learning models efficiently on various hardware platforms. Let’s implement Cross Road Camera Demo on Brainy Pi !

The ability to detect, recognize, and reidentify persons is a crucial component in many computer vision applications, such as surveillance systems, crowd analysis, and personalized marketing. By leveraging OpenVINO’s optimization techniques and the Brainy Pi platform, we can build a robust and efficient solution for person-related tasks.

Installing OpenVINO

To get started, we need to install OpenVINO and its dependencies on BrainyPi. Open a terminal and execute the following command:

sudo apt install openvino-toolkit libopencv-dev

This command will install OpenVINO and the necessary OpenCV development files on your BrainyPi system.

Compiling Demos

Once OpenVINO is installed, we can proceed to compile the demos by Open Model Zoo. These demos serve as excellent starting points for understanding and exploring the capabilities of OpenVINO. Follow the steps below to compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:
```
source /opt/openvino/setupvars.sh
```

Clone the Open Model Zoo repository, which contains the demos, by executing the following command:

git clone --recurse-submodules https://github.com/openvinotoolkit/open_model_zoo.git
cd open_model_zoo/demos/

Now, build the demos by running the build_demos.sh script:
```
./build_demos.sh
```

This process will compile the demo applications and make them ready for execution on BrainyPi.

Running Cross Road Camera Demo

With the demos compiled, we can now download the required models and run them using OpenVINO. Follow these steps to run the demos:

Download the models required for the demo by executing the following command:

omz_downloader --list ~/open_model_zoo/demos/crossroad_camera_demo/cpp/models.lst -o ~/models/ --precision FP16

Download the test video that we will use for demonstration purposes:

cd ~/
wget https://raw.githubusercontent.com/intel-iot-devkit/sample-videos/master/people-detection.mp4

Once the models and the test video are downloaded, you can run the object detection demo using the following command:

~/omz_demos_build/aarch64/Release/crossroad_camera_demo -i ~/people-detection.mp4 -m ~/models/intel/person-vehicle-bike-detection-crossroad-0078/FP16/person-vehicle-bike-detection-crossroad-0078.xml -m_pa ~/models/intel/person-attributes-recognition-crossroad-0230/FP16/person-attributes-recognition-crossroad-0230.xml -m_reid ~/models/intel/person-reidentification-retail-0287/FP16/person-reidentification-retail-0287.xml

In the above command, we specify the input video, as well as the paths to the downloaded models for person detection, person attributes recognition, and person reidentification. Feel free to adjust these paths based on your specific setup.

Reference

https://docs.openvino.ai/2022.3/omz_demos_crossroad_camera_demo_cpp.html

Conclusion

In this blog post, we have walked through the process of setting up OpenVINO on BrainyPi and using it to build an AI pipeline for person detection, recognition,

and reidentification. By leveraging the power of OpenVINO and the BrainyPi platform, developers and entrepreneurs can integrate these capabilities into their own computer vision products.

The ability to accurately detect and recognize persons opens up numerous possibilities for applications in various domains, including security, retail analytics, and customer experience enhancement. With the step-by-step instructions provided in this blog, you now have a solid foundation to start implementing your own AI-powered computer vision solutions using OpenVINO and BrainyPi.

The post Cross Road Camera Demo On Brainy Pi appeared first on Brainy Pi.

Cacti on Brainy Pi

BrainyPi Team — Tue, 13 Jun 2023 17:52:08 +0000

Cacti is a powerful open-source software application designed for network monitoring and graphing because it utilizes Simple Network Management Protocol (SNMP) to collect data from network devices and presents it in visual graphs and charts. With its web-based interface, system administrators can easily create and customize graphs, monitor specific metrics, and set threshold-based alerts. Furthermore, Cacti stores collected data in a database, enabling historical analysis and trend tracking. In addition to these features, it offers user management and access control features, making it an ideal tool for network administrators. So, let’s delve into exploring Cacti on Brainy Pi and discover its full potential!

Hardware Requirements

Before getting started with Cacti installation, ensure that your Brainy Pi meets the following hardware requirements:

Brainy Pi board
Ethernet connection to the network/Internet

Install Required Packages

To set up Cacti on your Brainy Pi, you need to install the following packages:

Apache Web Server:

sudo apt-get install apache2

Start the Apache service:

sudo systemctl start apache2

PHP:

sudo apt install php7.4-fpm php7.4-mbstring php7.4-mysql php7.4-curl php7.4-gd php7.4-zip php7.4-xml -y

MySQL:

sudo apt install php7.4-fpm php7.4-mbstring php7.4-mysql php7.4-curl php7.4-gd php7.4-zip php7.4-xml -y
sudo apt install mariadb-server

Set a password for the MySQL root user:

sudo mysql_secure_installation

Installing Cacti on Brainy Pi

To install Cacti, run the following command:

sudo apt install cacti

During the installation, you will be prompted to configure Cacti.

Set a password as prompted.
Choose Apache2 as the web server.

Cacti will automatically configure itself based on the selected options.

Security Settings for Cacti

To access Cacti through a web browser, you need to configure the security settings. Edit the Cacti configuration file:

sudo nano /etc/apache2/sites-enabled/cacti.conf

Add the following lines to the file:

Alias /cacti /usr/share/cacti/site 
 
    
      # httpd 2.4 
      Require all granted

Restart the Apache service:

sudo systemctl restart apache2

Adding a Device (Server) to Cacti

To monitor a server using Cacti, you need to add it as a device in the Cacti interface. Follow these steps:

Log in to the Cacti web interface using your credentials.
Go to “Create” in the menu.
Fill in the required information, such as IP address, SNMP community string, and device type.
Click on create.

Cacti will now start collecting data from the added server and display it in graphs and charts.

Conclusion

By following the steps outlined in this blog, you can successfully implement Cacti on your Brainy Pi device and start monitoring your network servers. Cacti provides a user-friendly interface, powerful graphing capabilities, and customizable alerting options, making it an invaluable tool for system administrators.

Remember to regularly check the Cacti interface to monitor your servers’ performance and proactively address any issues. Happy monitoring!

With these modifications, your blog will provide a more detailed and comprehensive guide for system admins to set up and use Cacti on Brainy Pi.

The post Cacti on Brainy Pi appeared first on Brainy Pi.

Zabbix on Brainy Pi

BrainyPi Team — Tue, 13 Jun 2023 17:29:43 +0000

Zabbix is an open-source network monitoring and management software that helps organizations monitor the performance and availability of their IT infrastructure. It offers a wide range of monitoring capabilities for servers, networks, applications, and logs. Zabbix collects data from various sources, analyzes it, and provides insights through customizable dashboards, performance graphs, and reports. It also includes an alerting and notification system to promptly notify administrators of any issues. Overall, Zabbix is a flexible and powerful tool for proactive monitoring and management of IT resources. Let’s explore Zabbix on Brainy Pi.

Pre-Requisites

Update you system packages
```
sudo apt update
```
NGNIX web server should be installed and make sure it has been setup to use php.

Installing NGNIX

install NGNIX

sudo apt install nginx

Start its service

sudo systemctl start nginx

Configuring NGNIX for PHP

Installing dependencies

sudo apt install php7.4-fpm php7.4-mbstring php7.4-mysql php7.4-curl php7.4-gd php7.4-curl php7.4-zip php7.4-xml -y

Making changes to the default NGNIX file

sudo nano /etc/nginx/sites-enabled/default

Find the line:

index index.html index.htm;

And replace it with:

index index.php index.html index.htm;

Then, find:

#location ~ \.php$ {
        #       include snippets/fastcgi-php.conf;
        #
        #       # With php5-cgi alone:
        #       fastcgi_pass 127.0.0.1:9000;
        #       # With php5-fpm:
        #       fastcgi_pass unix:/var/run/php5-fpm.sock;
        #}

and replace with:

location ~ \.php$ {
               include snippets/fastcgi-php.conf;
               fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
        }

Save and exit the file.

Reload the NGNIX sevrvice

sudo systemctl reload nginx

Setting up the php

sudo nano /home/u647482157/domains/brainypi.com/public_html/index.php

to this file add the following line of code

(); ?>

save and exit.

Now you can go to your web sever and enter

http://'s IP ADDRESS>

You would be greeted with NGNIX home page.

Device should have MySQL installed on it.

Installing MYSQL

Install the MYSQL server software

sudo apt install mariadb-server

setting a password for the root user

sudo mysql_secure_installation

Just follow the prompts to set a password for the root user and to secure your MySQL installation.

Now you can make changes to your MYSQL server using

sudo mysql -u root -p

To exit MYSQL you can either use quit or ctrl + d.

Installing Zabbix on Brainy Pi

Adding `Zabbix server` repository to our device using `wget`.

wget https://repo.zabbix.com/zabbix/6.2/raspbian/pool/main/z/zabbix-release/zabbix-release_6.2-2%2Bdebian11_all.deb

Once the packages are downloaded, we can use the dpkg tool to install it.
```
sudo dpkg -i zabbix-release_6.2-2+debian11_all.deb
```
Update your packages so that the system gets aware of zabbix packages
```
sudo apt update
```

Install the Zabbix server, its frontend interface, and its agent software.

sudo apt install zabbix-server-mysql zabbix-frontend-php zabbix-nginx-conf zabbix-sql-scripts zabbix-agent

Setting up the Zabbix server on Brainy Pi

Configure the SQL Database for Zabbix

We need to start by loading up the MySQL command-line tool.
```
sudo mysql -uroot -p
```

Creating a database called zabbix

CREATE DATABASE zabbix CHARACTER SET utf8 collate utf8_bin;

Create a user called “zabbix” that will be used to access the new database.
```
CREATE USER zabbix@localhost IDENTIFIED BY 'PASSWORDHERE';
```
Finally, with both the user and database created, we need to grant some privileges.
```
GRANT ALL PRIVILEGES on zabbix.* to zabbix@localhost;
```
Exit the database
```
quit;
```
Import the tables and initial Zabbix data.
```
zcat /usr/share/zabbix-sql-scripts/mysql/server.sql.gz | mysql --default-character-set=utf8mb4 -uzabbix -p zabbix
```
Before proceeding, you will need to enter the password you set for the “zabbix” user earlier in this guide. Please note this process can take some time as it needs to insert a lot of data into the SQL database.

Modifying the Zabbix Server Configuration

We now need to modify the configuration file for the Zabbix server to set the password for the database.

Without this, Zabbix won’t know how to connect itself to our Pi’s MySQL software.

Modifying the Zabbix server configuration
```
sudo nano /etc/zabbix/zabbix_server.conf
```
Using ctrl + w fine the line that says
```
#DBPassowrd=
```
Uncomment this line and add your zabbix password here. It should look like:
```
DBPassword=PASSWORD
```
Save and exit

Reconfiguring NGINX for the Zabbix Frontend

Modify the default NGINX configuration to point at the Zabbix config file.
```
sudo nano /etc/nginx/nginx.conf
```
Find the following line using ctrl + w
```
include /etc/nginx/sites-enabled/*;
```
and add the following line below it
```
include /etc/zabbix/nginx.conf;
```
save and exit
Modify the Zabbix configuration file
```
sudo nano /etc/zabbix/nginx.conf
```
Within this file, find the following line and uncomment it.
This line should be somewhere near the top of the file.
```
#        listen          8080;
```
save and exit

Remove the default NGINX configuration.

sudo rm /etc/nginx/sites-enabled/default

Restart all of our services so that the configuration changes take effect.
```
sudo systemctl restart zabbix-server zabbix-agent nginx php7.4-fpm
```

Now that we have set up NGINX, MySQL, and the Zabbix server, we can finally load its web interface.

You can use any web browser to access your Pi’s Zabbix server. You will only need to know your Pi’s local IP address.

hostname -I

With your Pi’s IP address, go to the following address in your web browser.

http://[IPADDRESS]

Conclusion

You should have successfully installed the Zabbix monitoring software on your Brainy Pi.

You can use Zabbix to monitor various things, including your Brainy Pi’s CPU load and network utilization.

The post Zabbix on Brainy Pi appeared first on Brainy Pi.

Nagios on Brainy Pi

BrainyPi Team — Tue, 13 Jun 2023 17:12:26 +0000

Nagios is an open-source monitoring system that helps organizations and IT professionals monitor the health and performance of their IT infrastructure. It provides a comprehensive solution for monitoring systems, networks, applications, and services. Let’s explore Nagios on Brainy Pi.

Nagios allows you to monitor various aspects of your infrastructure, such as servers, switches, routers, databases, and more. It uses a plugin-based architecture, where different plugins are responsible for monitoring specific resources or services. These plugins collect data and report it back to Nagios for processing and analysis.

Equipment Required

Brainy Pi
Power Supply
Keyboard and mouse
Monitor and HDMI cable
Ethernet Cable or Wi-Fi

Preparing device for Nagios

Before we start, let us ensure that our operating system is entirely up to date.

To update everything, we need to type in the following two commands into the terminal.

sudo apt update
sudo apt upgrade

Once your BrainyPi has finished updating, we can now install the packages that we will be using to run Nagios.

Run the following command to install all the packages we require.

sudo apt install -y autoconf build-essential wget unzip apache2 apache2-utils libapache2-mod-php php libgd-dev snmp libnet-snmp-perl gettext libssl-dev wget bc gawk dc libmcrypt-dev
sudo a2enmod php7.4

This command installs several packages that we need. These packages include the compiler we need to compile the Nagios software. We also install the Apache web server, which is used for Nagios’s web interface.

Downloading and Compiling Nagios

To start, we are going to first change into the /tmp directory.

This directory is where we will download, extract, and compile the Nagios source code.

cd /tmp

We can now download the Nagios source code to our BrainyPi by running the following command.

wget -O nagios.tar.gz https://github.com/NagiosEnterprises/nagioscore/archive/nagios-4.4.6.tar.gz

This command will use wget to download the Nagios source code to our /tmp directory.

Once the archive has finished download, we can extract it by running the following command.

tar xzf nagios.tar.gz

Now change into the Nagios directory and configure the software for compilation.

cd /tmp/nagioscore-nagios-4.4.6/
./configure --with-httpd-conf=/etc/apache2/sites-enabled

Let us now compile Nagios by running the following command.

make all

This process can take some time as it needs to compile all the Nagios code. Running this can take approximately 5 minutes.

Setting Up Nagios on Brainy Pi

Let us make use of the make command to create the user and group Nagios needs to run.

We will also add the www-data user to the nagios group that is created by our make command.

sudo make install-groups-users
sudo usermod -a -G nagios www-data

Next, install the compiled binaries to our operating system by utilizing the command below.

sudo make install

We can also use the make command to install the Nagios service and set it up to start at boot.

Run the following command to install the Nagios core daemon.

sudo make install-daemoninit

Now we can run the following command to set up the external command directory.

sudo make install-commandmode

Our next step is to copy the sample configuration file again by using the make command.

sudo make install-config

These configuration files are needed for Nagios to operate. Without the config files, the software will not load.

Our second last step is to install the Apache configuration files.

This command will install the required configuration files to the directory we specified when we configured the makefile.

We will also use two a2enmod commands to make sure that the required Apache modules are enabled.

sudo make install-webconf
sudo a2enmod rewrite
sudo a2enmod cgi

In our final step, we will be creating an Apache user that you will use to access the Nagios interface on your BrainyPi.

The following command will create a user called nagiosadmin. You will be asked to specify a password for this user.

sudo htpasswd -c /usr/local/nagios/etc/htpasswd.users nagiosadmin

The user must be called nagiosadmin to satisfy the default configuration of Nagios.

Starting Nagios on Brainy Pi

Our first step is to restart the Apache web server by running the following command.

sudo systemctl restart apache2

Restarting Apache will allow our new configuration files to be loaded in.

Next, enable the Nagios service and start it up by running the following two commands.

sudo systemctl enable nagios
sudo systemctl start nagios

By enabling the service, we will be allowing Nagios to start up at boot on your BrainyPi.

You can verify that Nagios has started on your BrainyPi by running the following command.

sudo systemctl status nagios

If everything is working as intended, you should see the following text be outputted to the terminal.

Active: active (running)

This text tells us that the service is active and is currently running.

Installing the Nagios Plugins

First change into our /tmp directory.

cd /tmp

Now that we are in the /tmp directory, we can download the Nagios plugins by running the command below.

wget -O nagios-plugins.tar.gz https://github.com/nagios-plugins/nagios-plugins/releases/download/release-2.3.3/nagios-plugins-2.3.3.tar.gz

Now extract the plugin source code to our current directory by using the following command.

tar zxf nagios-plugins.tar.gz

Our next step is to change into our newly created directory and configure the plugins for compilation.

cd /tmp/nagios-plugins-2.3.3
./configure

Once the configuration process has completed, we can compile the Nagios plugins by running the following command.

make

This process can also take some time to execute.

Finish up this process by installing the Nagios plugins by running the following command.

sudo make install

To make sure Nagios loads in the new plugins, restart the software by running the command below.

sudo systemctl restart nagios

Connecting to the Nagios Web Interface

To access the Nagios web interface, you will need to know the BrainyPi’s IP address.

You can retrieve your Brainy Pi’s local IP address by running the following command.

hostname -I

You need the host’s ip for the next step.

To connect to the Nagios web interface, you will need to go to your Pi’s IP address followed by /nagios.

http://[IPADDRESS]/nagios

When you try to connect, you will be asked to enter a username and password.

The username should be nagiosadmin(specified above in the tutorial), and the password should be what you entered.

Upon a successful connection, you should be greeted by the Nagios core homepage, all running from your Brainy Pi.

Conclusion

Throughout this blog, we have explored the step-by-step process of setting up Nagios, from installing the necessary dependencies to configuring the monitoring system.

By following these instructions, administrators can gain real-time visibility into the health and performance of their systems, networks, and services. With its plugin-based architecture, customizable notifications, and extensive community support, Nagios remains a popular choice for monitoring needs.

The post Nagios on Brainy Pi appeared first on Brainy Pi.

ChatGPT API on Brainy Pi

BrainyPi Team — Fri, 09 Jun 2023 17:53:48 +0000

If you’re a developer looking to integrate an intelligent assistant into your project, you may want to consider using the ChatGPT API on Brainy Pi from OpenAI. With ChatGPT, you can build chatbots, virtual assistants, and other conversational interfaces that can understand natural language and provide intelligent responses.

In this blog post, we’ll walk you through the process of using the ChatGPT API on Brainy Pi, a popular platform for building IoT projects. By the end of this post, you should be able to build your own intelligent assistant using ChatGPT and BrainyPi.

Getting Started

Before you can start using ChatGPT API on Brainy Pi, you’ll need to sign up for an OpenAI API key.

Go to the link
Login into the ChatGPT website.
Go to “API Keys”, Click on “Create new secret key”.
Copy the newly generated secret key. This key will be used to communicate with the API.
Check if you can use the ChatGPT API.
1. Invalid
2. Valid
If you have an invalid account they you have to pay to enable this feature.

Installing dependencies

Once you have your API key, you can install the OpenAI Python library using pip:

sudo apt update && sudo apt upgrade
sudo apt install -y python3 python3-pip 
pip3 install openai

Creating a Chatbot

You’ll need to import the OpenAI library and set your API key:
```
import openai

openai.api_key = 'API_KEY'
```
You can replace API_KEY with your actual API key.

Now that you have everything set up, you can start building your chatbot. Here’s an example code snippet that you can use as a starting point:

messages = [ {"role": "system", "content": "You are an intelligent assistant." } ]
while True:
    message = input("You: ")
    messages.append(
        {"role": "user", "content": message},
    )
    chat = openai.ChatCompletion.create(
        model="davinci", messages=messages
    )
    reply = chat.choices[0].text
    print("Assistant: ", reply)
    messages.append({"role": "system", "content": reply})

In this code snippet, we start by initializing a list of messages that includes a welcome message from the system. We then enter a loop that prompts the user for input and appends each message to the `messages` list.

Next, we call the openai.ChatCompletion.create() method to generate a response from the ChatGPT model. We pass in the messages list as input and specify the model to use (in this case, davinci, which is one of the most powerful ChatGPT models available).
Finally, we print the response and append it to the messages list so that it can be used as input for the next iteration of the loop.

Final code for ChatGPT on Brainy Pi

import openai

openai.api_key = 'API_KEY'

messages = [ {"role": "system", "content": "You are an intelligent assistant." } ]
while True:
    message = input("You: ")
    messages.append(
        {"role": "user", "content": message},
    )
    chat = openai.ChatCompletion.create(
        model="gpt-3.5-turbo", messages=messages
    )
    reply = chat.choices[0].message
    print("Assistant: ", reply.content)
    messages.append(reply)

Customizing Your Chatbot

Of course, this is just a basic example, and you’ll likely want to customize your chatbot to better fit your needs. Here are a few tips for customizing your chatbot:

Modify the messages list to include additional context for the ChatGPT model. For example, you could include information about the user’s name, location, or preferences.
Use a different ChatGPT model to achieve different levels of performance and accuracy. OpenAI offers several models with varying levels of computational complexity and performance.
Use the openai.Completion.create() method to specify additional parameters for the ChatGPT model, such as the maximum length of the response or the presence of specific keywords.
Implement error handling to ensure that your chatbot can handle unexpected inputs or errors from the API.

Conclusion

In this blog post, we’ve shown you how to use the ChatGPT API on Brainy Pi to build an intelligent assistant. With ChatGPT, you can create chatbots, virtual assistants, and other conversational interfaces that can understand natural language and provide intelligent responses. By following the steps outlined in this post, you should now have the knowledge and tools you need to start building your own chatbot using the ChatGPT API on Brainy Pi.

Of course, this is just the beginning. There’s a lot more you can do with ChatGPT, from building more sophisticated chatbots to integrating it with other platforms and services. To learn more about the ChatGPT API and its capabilities, check out the OpenAI website and documentation.

Happy building!

The post ChatGPT API on Brainy Pi appeared first on Brainy Pi.

BrainyPi Team, Author at Brainy Pi

BrainyPi Community Events: Building Together

Makers Club: Turning Ideas into Reality

Highlights from the Makers Club:

Hands-on Electronics & Coding: Participants delved into embedded systems, microcontrollers, and sensor integrations, gaining essential technical skills.

DIY Tech Projects: By leveraging BrainyPi, members created innovative solutions such as smart home automation, robotics, and IoT-enabled devices.

Collaboration & Networking: These sessions fostered a thriving space where participants exchanged ideas, solved challenges together, and formed dynamic project teams.

AI & IoT Workshops: Learning by Doing

What We Covered:

Introduction to AI & Machine Learning: Understanding fundamental AI concepts, neural networks, and real-world applications.

IoT for Beginners & Advanced Users: From setting up IoT sensors to deploying cloud-based automation.

BrainyPi-Powered AI Projects: Participants built AI models for object detection, speech recognition, and predictive analytics.

Live Demonstrations & Take-home Kits: Interactive learning experiences with real-world implementations.

The Impact: BrainyPi Community Growth

Gain hands-on experience with cutting-edge technology.

Build innovative projects with open-source hardware and software.

Connect with like-minded makers, engineers, and entrepreneurs.

Advance their careers with practical skills in AI, IoT, and embedded systems.

This is more than just a community—it is a genuine effort of many that builds an inclusive space for builders to innovate, experiment, and collaborate. The community-driven approach has helped participants turn ideas into tangible projects.

Let’s keep innovating together! Stay connected, keep building.

Pedestrian Tracker on Brainy Pi

Installing OpenVINO and Dependencies

To get started, we need to install OpenVINO and its dependencies on BrainyPi. Open a terminal and run the following command to install OpenVINO and the necessary OpenCV development files:

By installing OpenVINO, we gain access to a powerful set of tools and libraries for optimizing and deploying deep learning models on various hardware platforms.

Compiling the Demos

Once we install OpenVINO, we can proceed to compile the demos. These demos serve as an excellent starting point for understanding and exploring the capabilities of OpenVINO. Follow the steps below to compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:

This step is crucial as it configures the necessary environment variables for working with OpenVINO.

Clone the Open Model Zoo repository, which contains the demos, using the following command:

The Open Model Zoo provides a collection of pre-trained models and demo applications that can be used with OpenVINO.

Build the demos by executing the build_demos.sh script:

This step compiles the demo applications and makes them ready for execution.

Running the Pedestrian Tracker on Brainy Pi

With the demos compiled, we can now download the required models and run the Pedestrian Tracking Demo using OpenVINO. Follow these steps:

Download the models for the demo by running the following command:

The Open Model Zoo downloader allows us to easily fetch the models specified in the models.lst file.

Download the test video:

This command downloads a sample video – an input for the Pedestrian Tracking Demo.

Once the models and the test video are downloaded, you can run the Pedestrian Tracking Demo using the following command:

This command executes the Pedestrian Tracking Demo, leveraging the person detection and person re-identification models to track pedestrians in the video.

By following these steps, you can quickly set up and run the Pedestrian Tracking Demo, gaining insights into the capabilities of OpenVINO and its potential for developing computer vision products.

Conclusion

References

OpenVINO Documentation: https://docs.openvino.ai/

Open Model Zoo Pedestrian Tracking Demo: https://docs.openvino.ai/2022.3/omz_demos_pedestrian_tracker_demo_cpp.html

Image Segmentation on Brainy Pi

Installing OpenVINO

Before we dive into the demo, we need to install OpenVINO and its dependencies on BrainyPi. Let’s start by opening a terminal and running the following command:

This command will install OpenVINO and the necessary OpenCV development files on your system, providing the foundation for our image segmentation demo.

Compiling the Demos

Once OpenVINO is successfully installed, we can proceed to compile the demos. These demos serve as an excellent starting point for understanding and exploring the capabilities of OpenVINO. Here are the steps to compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:

Clone the Open Model Zoo repository, which contains the demos, by executing the following command:

Build the demos by running the build_demos.sh script:

These steps will compile the demo applications. It will make them ready for execution and enabling us to dive into the exciting world of image segmentation with OpenVINO.

Running the Image Segmentation on Brainy Pi

With the demos successfully compiled, we can now proceed to download the required models and run the image segmentation demo using OpenVINO. Let’s follow the steps below:

Download the models required for the demo by running the following command:

This command downloads the necessary models from the Open Model Zoo repository and saves them in the ~/models/ directory on your system.

Download a test video to feed into the demo. We will use the following command to download a sample video:

Once the models and the test video are downloaded, we can run the image segmentation demo using the following command:

This command executes the image segmentation demo, processing the frames of the test video and producing segmented output based on the downloaded model.

By following these steps, you can witness the power of OpenVINO in action, as it intelligently segments the frames in the video and showcases the potential for building advanced computer vision applications.

Conclusion

If you’re interested in diving deeper into OpenVINO, be sure to check out the official OpenVINO documentation for more detailed information and resources.

Reference: OpenVINO Segmentation Demo Documentation

Human Pose Detection on Brainy Pi

Installing OpenVINO

Before we dive into the demo, let’s start by installing OpenVINO and its dependencies on BrainyPi. Follow these simple steps:

Open a terminal on your BrainyPi device and enter the following command to install OpenVINO and the necessary OpenCV development files:

This command will ensure that OpenVINO is installed and ready to use.

Compiling Demos

Now that OpenVINO is installed, we can proceed to compile the demos. These demos serve as valuable resources for understanding and exploring the capabilities of OpenVINO. Here’s how you can compile the demos:

Set up the OpenVINO environment by sourcing the setupvars.sh script:

Clone the Open Model Zoo repository, which contains the demos, using the following command:

Build the demos by executing the build_demos.sh script:

This will compile the demo applications and make them ready for execution.

Running the Demos

With the demos compiled, we can now download the required models and run the human pose detection demo. Follow these steps:

Download the models needed for the demo by running the following command:

Set up the OpenVINO environment by sourcing the `setupvars.sh` script:

Build the demos by executing the `build_demos.sh` script:

The Open Model Zoo downloader allows us to easily fetch the models specified in the `models.lst` file.

Set up the OpenVINO environment by sourcing the `setupvars.sh` script:

Build the demos by running the `build_demos.sh` script:

This command downloads the necessary models from the Open Model Zoo repository and saves them in the `~/models/` directory on your system.

Set up the OpenVINO environment by sourcing the `setupvars.sh` script:

Build the demos by executing the `build_demos.sh` script:

This command will download the necessary models for the demo and save them in the `~/models/` directory.

This command will download a sample video called `face-demographics-walking.mp4`.

Set up the OpenVINO environment by sourcing the `setupvars.sh` script:

Build the demos by executing the `build_demos.sh` script:

Set up the OpenVINO environment by sourcing the `setupvars.sh` script:

Now, build the demos by running the `build_demos.sh` script: