Safety Gate AI: AI-Powered PPE Access Control Prototype

Introduction

For my Project One, I made Safety Gate AI. It is a prototype gate system that checks if a person is wearing the required personal protective equipment before giving access.

The system uses a camera and a YOLO object detection model. It checks for:

1. safety helmet
2. safety vest
3. safety glasses
4. safety shoes

If all required PPE is detected, the system gives access. If something is missing, access stays denied. The prototype also uses a Raspberry Pi 5, a Freenove project kit, a servo gate, an RGB LED, a buzzer, RFID, and a Gradio dashboard.

This project is made as a safety prototype. The goal is not to replace a real safety officer, but to show how AI can support safety checks at an entrance.

For this project I used:

1. Raspberry Pi 5
2. Freenove project kit
3. Camera
4. Servo motor
5. RGB LED
6. Buzzer
7. RFID module
8. Jumper wires
9. Breadboard or project board
10. Laptop or monitor for testing
11. Safety helmet
12. Safety vest
13. Safety glasses
14. Safety shoes
15. Trained YOLO model file: best.pt
16. Python
17. OpenCV
18. Ultralytics YOLO
19. Gradio

First I collected my own image dataset. I took photos of different people, different backgrounds, and different PPE combinations.

The model was trained to detect these classes:

1. no_helmet
2. no_shoes
3. no_vest
4. person
5. safety_glasses
6. safety_helmet
7. safety_shoes
8. safety_vest

The required classes for opening the gate are:

1. safety_helmet
2. safety_vest
3. safety_glasses
4. safety_shoes

At first, the model had problems detecting safety glasses because they are small in a full-body image. To improve this, I collected around 130 extra photos with safety glasses and retrained the model. After that, the safety glasses detection became better.

Before connecting all hardware, I tested the model with a simple live camera script.

The script opened the camera, detected PPE, and showed the result on the screen. I tested it with:

1. full PPE
2. missing helmet
3. missing vest
4. missing glasses
5. missing safety shoes
6. different people
7. different backgrounds

The model worked well after retraining. I also added a rule that all PPE must be detected several times in a row before access is approved. This makes the system more stable and prevents one lucky wrong detection from opening the gate.

After the model worked on my laptop, I moved the project to the Raspberry Pi 5.

I installed the needed Python packages:

I placed the trained model file inside my project folder:

Then I tested if the Raspberry Pi could load the model and detect PPE from the camera.

I used Gradio as the user interface. This makes the prototype easier to use because I do not need to run everything only from the terminal.

The Gradio dashboard has pages/tabs for:

1. running the PPE check
2. showing camera result
3. showing access approved or denied
4. showing missing PPE
5. showing logs
6. explaining how the system works

The user starts the check from the Gradio dashboard. There is no physical start button in my current prototype.

The dashboard shows a clear result:

or:

The servo motor is used as a small gate.

When access is denied, the servo stays closed.

When access is approved, the servo moves to the open position.

Example behavior:

This makes the prototype easy to understand during a demo. The servo is not a real industrial gate, but it simulates the same idea.

The RGB LED gives quick visual feedback.

I used these colors:

1. Red = access denied
2. Green = access approved
3. Blue or white = system ready / waiting

This helps the user understand the system without reading the screen all the time.

Example:

The buzzer gives sound feedback.

I used it like this:

1. short beep = access approved
2. warning beep = access denied

This is useful because in a real gate system, users may not always look at the screen. Sound feedback makes the result more noticeable.

The RFID module is used to simulate user identification.

The idea is:

1. User scans an RFID card.
2. The system knows someone wants access.
3. The PPE check is started from the Gradio dashboard.
4. The system checks the camera image.
5. The gate opens only if all PPE is detected.

In the current prototype, RFID is part of the access system, but the main safety decision still comes from the AI PPE detection.

The most important part of the project is the access logic.

The system does not approve access just because one frame looks correct. Instead, the required PPE must be detected multiple times in a row.

The rule is:

If one required item is missing, the counter resets.

This makes the system more reliable.

Example:

After access is approved, it stays approved until the system is reset.

I tested the prototype with different situations.

Some test cases:

TestExpected result

Person with all PPE

Access approved

Missing helmet

Access denied

Missing vest

Access denied

Missing safety glasses

Access denied

Missing safety shoes

Access denied

Different person

Should still work

Different background

Should still work

Helmet in hand

Should not count as correct PPE

Glasses not worn

Should not approve

Bad lighting

May be harder, access should stay denied if uncertain

The most difficult class was safety glasses because they are small. I improved this by collecting more photos with safety glasses.

The electronics are placed in a kiosk-style prototype. The kiosk holds the camera and makes the project look more like a real access control system.

The camera must be placed so it can see the full body, including the safety shoes. This is important because the model needs to check all PPE items.

The enclosure also helps with cable management and presentation.

The final prototype can:

1. detect a person
2. detect required PPE
3. show the result in Gradio
4. deny access if PPE is missing
5. approve access if all PPE is detected
6. open a servo gate
7. show RGB LED feedback
8. make buzzer feedback
9. use RFID as part of the access flow

The project works well with different people and different backgrounds. The AI model is not perfect, but the safety logic is strict. If something is uncertain or missing, the gate does not open.

This is important for a safety project.

The biggest problem was detecting safety glasses. They are small, and in a full-body image they are harder to detect than a vest or helmet.

I solved this by:

1. collecting more photos
2. adding more full-PPE images with glasses
3. retraining the YOLO model
4. testing with different people and backgrounds

Another problem was making the system user-friendly. A terminal demo works for testing, but it is not clear for normal users. That is why I used Gradio. It makes the system easier to use and explain.

Safety Gate AI is a working prototype for AI-based PPE access control.

The project combines computer vision, Raspberry Pi hardware, Gradio, RFID, and physical feedback using a servo, LED, and buzzer.

I learned that the AI model is only one part of the project. A good prototype also needs clear user feedback, stable logic, testing, and a physical setup that people can understand.

The most important lesson was that safety systems must be strict. If the model is unsure, the system should deny access instead of allowing someone without the correct PPE.