@Ulagat

I built Veya — smart glasses that detect eye diseases using AI and a Raspberry Pi 4. The system captures close-up eye images through an Arducam Hawkeye camera, processes them locally with a trained neural network, and identifies conditions like cataract, conjunctivitis, and pterygium in 2-3 seconds. Results are transmitted via WiFi to a companion mobile app that displays the diagnosis, confidence score, and health recommendations. The project includes three main components: (1) the ML pipeline with a MobileNetV2 model optimized for edge deployment, (2) a Flask API running on the Pi for communication, and (3) the Veya mobile app for viewing scan history and results. I also built a web interface (veya-web repo: github.com/ulacoder/veya-web) for educational cuctions. Total hardware cost is under $280,through an Arducam Hawkeye camera, processes them locally with a trained neural network, and identifies conditions like cataract, conjunctivitis, and pterygium in 2-3 seconds. Results are transmitted via WiFi to a companion mobile app that displays the diagnosis, confidence score, and hoject includes three main components: (1) the MLgithub.com/ulacoder/veya-web) for educational content and device setup instructions. Total hardware cost is under $280, making professional-grade eye screening accessible to communities without ophthalmologists.

The biggest challenge was optimizing the CNN to run on the Raspberry Pi 4 without killing accuracy or battery life. MobileNetV2 is designed for mobile, but gettingquired converting to TensorFlow Lite, applyingint8 quantization, and stripping the model down to ~4MB. Balancing three disease classes plus "healthy" was tricky — medicadatasets are heavily imbalanced, so I had to aud use weighted loss functions. On the hardwareside, camera positioning is critical — the Arducam Hawkeye needs to be mounted at exactly the right distance and angle to capture enough retinal detail for accurate detection. I'm also about to start the hardware assembly phase now that all the software is ready — connecting the camera, Pi, and power bank into a wearable form factor that's actually comfortable is the next major hurdle.

I'm proud that this works end-to-end and is genuinely affordable. Commercial eye screening devices cost $10,000+, but Veya does it for under $280 in parts. The model hitsl datasets, which means it can actually catchdiseases early enough to matter. I'm also proud of the UX — the Veya app has a clean onboarding flow that explains eye health
in simple terms, step-by-step connection instruwith actionable recommendations. It's not just a tech demo — it's designed for real people in rural clinics, schools, or disaster relief situations where bringing a $10k machine isn't an option. The fact that all processing happens locally (no cloud, no privacy concerns) makes it usable even in areas with zero internet.

To test Veya, you'll need:

Hardware:
- Raspberry Pi 4 (4GB RAM recommended)
- Arducam Hawkeye camera module
- 10,000mAh power bank
- 32GB microSD card
- USB-C cable

Software repos:
- ML pipeline: github.com/ulacoder/veya-ml
- Web interface: github.com/ulacoder/veya-web
- Mobile app: (coming soon — still in development)

Testing steps:

1. Clone the ML repo:
git clone https://github.com/ulacoder/veya-ml
cd veya-ml
pip install -r ml/requirements.txt
2. Run inference on test images:
python ml/inference.py --image sample_eye.jpg --model veya_model_lite.tflite
2. The model outputs: disease class (Healthy / Cataract / Conjunctivitis / Pterygium) + confidence score.
3. For full hardware testing (once I finish assembly):
- Flash Raspberry Pi OS to the SD card
- Install the Flask API: python api/server.py
- Connect your phone to the Pi's WiFi hotspot
- Open the Veya ap

I made Veya — a web app that connects to smart glasses (Raspberry Pi + camera) to detect eye diseases in real-time. Users enter their glasses' IP address, scan their eye, and get AI diagnosis in 3 seconds. It detects cataracts, conjunctivitis, and pterygium with 85%+ accuracy. All processing happens locally on the Raspberry Pi (no cloud), so medical data stays private. Built with Next.js, TypeScript, and TensorFlow Lite. The UI has dark/light themes, bilingual support (EN/RU), and tracks scan history.

---
What was challenging?

1. Real-time detection pipeline — Getting eye i Lite model → diagnosis in under 3 secondsrequired careful API design. Built demo mode first to test UI flows before dealing with hardware integration.

2. WiFi connection architecture — Users need to connect the web app to glasses over local network. Added IP validation, timeout handling, and clear error messages for when Pi is offline or unreachable.

3. Privacy constraints — Medical data can't leave the device. Had to design everything for local processing on Raspberry Pi instead of cloud APIs. This means the model runs on a $35 computer, not a server farm.

---
What are you proud of?

Cost vs medical devices: Built with $50 hardwar5,000 professional eye screening equipment. 300xcheaper.

Privacy-first architecture: All AI happens on device. No cloud, no data leaks, works offline. Critical for medical applications.

Real-world impact: Designed for rural Kazakhstamited. If someone in a village can screen forcataracts without traveling 200km to a city clinic, that matters.

Speed: Built the full MVP in 6 hours — 550 lineUX, deployed and working.

---
What should people know so they can test your p

Live demo (simulated AI): https://veya-web-zeta.vercel.app

How to test:
1. Click through all screens: Home → Connect → Scan → Analysis
2. Try demo mode (no hardware needed) — it simulates AI results
3. Toggle dark/light theme (top-right corner)
4. Switch between English/Russian
5. View scan history after multiple scans

With real hardware (Raspberry Pi + camera):
1. Get your Pi's IP address
2. Enter it in the Connect screen
3. Position camera to capture eye
4. Click Scan
5. Get real AI diagnosis

What to look for:
- Glassmorphism UI design
- Smooth animations and transitions
- Confidence scores for each disease
- Scan history tracking
- Error handling (try entering invalid IP like "999.999.999.999")

KozbenSal — eye-tracking system that lets people draw and control computers using only their eyes and blinks. Built for people with motor disabilities who can't use keyboards or mice.

The system uses a modified PS3 Eye camera with custom lens + IR LEDs for binary imaging, paired with hybrid computer vision (CV + MediaPipe) to track eye movements in real-time. You blink to place points, and the system draws lines between them. No hands needed.

Tech stack: Python + OpenCV + MediaPipe for hybrid pupil detection, custom IR illumination setup, Eye Aspect Ratio-based blink detection, 9-point calibration system.

---
What was challenging?

1. PS3 Eye camera modification for binary imaging — Had to physically replace the lens to get clear binary (black/white) images of the pupil. This required precise alignment and multiple attempts to get the focal length right without distortion.

2. IR LED circuit issues — Used infrared LEDs to illuminate the eye for better pupil contrast in binary mode. The LEDs kept shutting off due to power supply instability and overheating. Had to debug the circuit, add proper current limiting resistors, and ensure consistent illumination without flickering.

3. Head movement = lost tracking — The system requires the user's head to stay fixed in position. Any movement breaks calibration. Had to add clear instructions and eventually realized this needs a physical head stabilizer/chin rest for real-world use.

4. Hybrid pupil detection — MediaPipe alone wasn't accurate enough. Built a fallback system: extract eye region → Gaussian blur → threshold for binary imaging → find darkest contour (pupil) → combine with MediaPipe iris. Took days to tune thresholds that work across different lighting conditions.

---
What are you proud of?

Hardware hacking works: Successfully modified consumer hardware (PS3 Eye) with custom optics and IR illumination to create a specialized eye-tracker. Proof that you don't need $15,000 commercial solutions.

Open source: Full code, BOM, and hardware mod instructions on GitHub so others can replicate and improve it.

---
What should people know to test your project?

IMPORTANT: Head must be fixed during use
The system loses calibration if you move your head. You need to stay still or use a chin rest/head stabilizer.

Hardware Requirements:
- Modified PS3 Eye camera (lens replaced for binary imaging)
- IR LEDs for eye illumination
- Python 3.8+
- Head stabilizer or chin rest (recommended)

Setup:
git clone https://github.com/ulacoder/KozbenSal.git
cd KozbenSal
pip install -r requirements.txt
python test_cameras.py # find your camera index
# edit eye_tracker.py line 19 if needed
python main.py

How to test:
1. Fix your head position — use chin rest or stay very still
2. Ensure IR LEDs are on and illuminating your eyes
3. Look at the 9 calibration points — wait for auto-calibration
4. Press TAB → drawing mode
5. Blink once → green point appears
6. Move only your eyes (not head) to another spot
7. Blink again → line draws between points

Tips for best results:
- IR illumination must be consistent (check LED power)
- Sit 40-60cm from camera, head fixed
- Good ambient lighting helps (not just IR)
- If cursor jumps, press R to recalibrate
- Watch top-right preview — should see purple rings on detected pupils

Known limitations:
- Head movement breaks tracking (needs physical stabilizer)
- IR LEDs can overheat if run too long (monitor temperature)
- Binary imaging works best in controlled lighting
- Blink sensitivity varies per person