एएम रेडियो ब्रेक-इन प्रणाली

एक 12-चैनल एएम रेडियो प्रसारण प्रणाली जो मानवरहित सुरंगों में आपातकालीन अलर्ट प्रसारित करने के लिए रेड पिटाया एफपीजीए का उपयोग करती है।

सुरंग में एएम रेडियो क्यों? निर्माण और रखरखाव के दौरान, मानक एएम रेडियो वाले वाहन उन सुरंगों से गुजरते हैं जहां मोबाइल कवरेज नहीं है। एएम सिग्नल लीकी फीडर केबलों के माध्यम से सुरंग संरचनाओं के साथ प्रसारित होते हैं, और रिसीवर सस्ते, मजबूत और पहले से ही हर वाहन में मौजूद होते हैं। यह प्रणाली पूर्व-रिकॉर्ड किए गए आपातकालीन अलर्ट को कई आवृत्तियों पर प्रसारित करती है ताकि बैंड के किसी भी स्टेशन पर ट्यून किया गया कोई भी एएम रेडियो संदेश प्राप्त कर सके। एक हार्डवेयर वॉचडॉग यह सुनिश्चित करता है कि यदि नियंत्रण प्रणाली विफल हो जाती है तो आरएफ आउटपुट बंद हो जाता है - क्योंकि मानवरहित सुरंग में ट्रांसमीटर को स्वचालित रूप से पुनः प्रारंभ करना एक स्वीकार्य विफलता मोड नहीं है।

विशेषताएँ

विशेषता	स्थिति
12 एक साथ वाहक आवृत्तियाँ	✅
रनटाइम आवृत्ति कॉन्फ़िगरेशन (कोई हार्डवेयर परिवर्तन नहीं)	✅
पूर्व-रिकॉर्डेड ऑडियो के साथ एएम मॉड्यूलेशन	✅
डायनेमिक पावर स्केलिंग	✅
एमवीसी आर्किटेक्चर (रस्ट + जावास्क्रिप्ट)	✅
इवेंट बस के माध्यम से इवेंट-संचालित प्रकाशन/सदस्यता	✅
स्टेटलेस यूआई — डिवाइस सत्य का स्रोत है	✅
नेटवर्क पोलिंग और ऑटो-रीकनेक्ट	✅
फेल-सेफ हार्डवेयर वॉचडॉग (5 सेकंड टाइमआउट)	✅
औपचारिक सत्यापन (14 गुण, 6 कवर, सभी सिद्ध)	✅

आर्किटेक्चर

सिस्टम आर्किटेक्चर

सॉफ्टवेयर परत

फ्रेमवर्क: रस्ट (टौरी) बैकएंड + जावास्क्रिप्ट फ्रंटएंड
आर्किटेक्चर: इवेंट-संचालित प्रकाशन/सदस्यता के साथ एमवीसी
मॉडल (model.rs): नेटवर्कमैनेजर टीसीपी/एससीपीआई, डिवाइस स्थिति, 500ms पोलिंग, एक्सपोनेंशियल बैकऑफ के साथ ऑटो-रीकनेक्ट को संभालता है
व्यू (view.js, index.html): स्टेटलेस — केवल पुष्टि की गई डिवाइस स्थिति को प्रस्तुत करता है। कभी भी हार्डवेयर स्थिति नहीं मानता।
नियंत्रक (controller.js): उपयोगकर्ता इनपुट संभालता है, बस में ईवेंट प्रकाशित करता है
ईवेंट बस (event_bus.rs, event_bus.js): घटक सीधे एक-दूसरे को कॉल करने के बजाय एक केंद्रीय बस के माध्यम से संचार करते हैं। रस्ट टौरी ब्रिज के माध्यम से जेएस फ्रंटएंड को ईवेंट भेजता है।
स्टेट मशीन (state_machine.rs): आइडल → आर्मिंग → आर्म्ड → स्टार्टिंग → ब्रॉडकास्टिंग → स्टॉपिंग। मध्यवर्ती अवस्थाएँ अमान्य संक्रमणों को रोकती हैं।
सत्य का स्रोत: डिवाइस, सॉफ्टवेयर नहीं। हार्डवेयर द्वारा पुष्टि करने के बाद ही यूआई अपडेट होता है।

हार्डवेयर परत

एनसीओ: 12 संख्यात्मक रूप से नियंत्रित ऑसिलेटर वाहक आवृत्तियाँ (505–1605 kHz) उत्पन्न करते हैं
एएम मॉड्यूलेटर: ऑडियो स्रोत को प्रत्येक वाहक के साथ जोड़ता है
डायनेमिक स्केलिंग: सक्षम चैनलों की संख्या के आधार पर आउटपुट पावर समायोजित होती है
ऑडियो बफर: बीआरएएम पूर्व-रिकॉर्डेड आपातकालीन संदेशों को संग्रहीत करता है (~5 kHz प्लेबैक दर पर 16,384 नमूना बफर)। रनटाइम लोडिंग के लिए एक्सी ऑडियो लोडर उपलब्ध है।
वॉचडॉग टाइमर (wd.v): हार्डवेयर फेल-सेफ — यदि जीयूआई हार्टबीट 5 सेकंड के लिए रुक जाती है, तो आरएफ आउटपुट बंद और लैच हो जाता है। केवल मैनुअल ऑपरेटर रीसेट आउटपुट को पुनर्स्थापित करता है।
एससीपीआई सर्वर (am_scpi_server.py): रेड पिटाया पर चलता है, टेक्स्ट कमांड पार्स करता है, आवृत्तियों को फेज इंक्रीमेंट में परिवर्तित करता है, /dev/mem के माध्यम से एफपीजीए रजिस्टरों में लिखता है।

सिग्नल जनरेशन प्रवाह```

GUI click → invoke("set_frequency") → model.rs sends "FREQ:CH1 700000" over TCP → am_scpi_server.py converts to phase_inc = (700000 × 2³²) / 125MHz → writes to FPGA register via /dev/mem → NCO generates carrier → AM modulates → RF output

---

## औपचारिक सत्यापन

वॉचडॉग टाइमर को बाउंडेड मॉडल चेकिंग और के-इंडक्शन (SymbiYosys + Z3 SMT सॉल्वर) का उपयोग करके गणितीय रूप से सही सिद्ध किया गया है। सिमुलेशन-आधारित परीक्षण के विपरीत, जो व्यक्तिगत परिदृश्यों की जाँच करता है, औपचारिक सत्यापन **हर संभव इनपुट, हर संभव स्थिति, हर समय** में शुद्धता साबित करता है।

### 14 सुरक्षा गुण (सभी उत्तीर्ण)

| श्रेणी | # | गुण | गारंटी |
|----------|---|----------|-----------|
| **बुनियादी** | 1 | रीसेट सब कुछ साफ़ करता है | `!rstn` → counter=0, triggered=0, warning=0 |
| | 2 | हार्टबीट ट्रिगर को रोकता है | हार्टबीट काउंटर को रीसेट करता है, ट्रिगर और चेतावनी को साफ़ करता है |
| | 6 | डिसेबल सब कुछ रोकता है | `!enable` → सभी आउटपुट साफ़ हो गए |
| | 7 | काउंटर सीमाबद्ध | काउंटर कभी भी TIMEOUT_CYCLES से अधिक नहीं होता |
| | 8 | फ़ोर्स रीसेट काम करता है | `force_reset` सभी स्थिति को साफ़ करता है |
| | 9 | सीमा से पहले चेतावनी कम | counter < WARNING_CYCLES → warning=0 |
| **सुरक्षा** | 3 | **कोई जल्दी ट्रिगर नहीं** | **triggered केवल तभी जब counter ≥ TIMEOUT_CYCLES** |
| | 4 | टाइमआउट पर ट्रिगर की गारंटी | लाइवनेस: टाइमआउट हमेशा ट्रिगर को सक्रिय करता है |
| | 5 | ट्रिगर से पहले चेतावनी | triggered=1 → warning=1 |
| | 5b | कॉन्ट्रापोज़िटिव | !warning → !triggered |
| | 10 | क्षेत्र में चेतावनी अधिक | counter > WARNING_CYCLES → warning=1 |
| | 11 | काउंटर सही ढंग से बढ़ता है | गिनती के दौरान प्रति क्लॉक चक्र में ठीक +1 |
| **आउटपुट** | 12 | time_remaining शून्य पर | counter=0 → time_remaining = TIMEOUT_SEC |
| | 13 | ट्रिगर पर time_remaining | triggered → time_remaining = 0 |
| | 14 | time_remaining मोनोटोनिक | गिनती के दौरान प्रत्येक चक्र में घटता है |

### 6 कवर परिदृश्य (सभी तक पहुंचे)

| # | परिदृश्य | कदम | विवरण |
|---|----------|-------|-------------|
| 1 | ट्रिगर सक्रिय होता है | 23 | काउंटर टाइमआउट तक पहुँचता है |
| 2 | बिना ट्रिगर के चेतावनी | 21 | चेतावनी क्षेत्र में, अभी तक टाइमआउट नहीं हुआ |
| 3 | सटीक टाइमआउट सीमा | 22 | काउंटर = TIMEOUT_CYCLES बिल्कुल |
| 4 | अंतिम क्षण का हार्टबीट | 19 | काउंटर = T-1 पर हार्टबीट |
| 5 | ट्रिगर से पुनर्प्राप्ति | 24 | force_reset द्वारा ट्रिगर स्थिति साफ़ की गई |
| 6 | चेतावनी-से-ट्रिगर जीवनचक्र | 23 | चेतावनी फिर तत्काल ट्रिगर |

### सत्यापन चलाना```bash
cd fpga/formal/
sby -f wd.sby

अपेक्षित आउटपुट: SymbiYosys सत्यापन आउटपुट ``` SBY [wd_prove] DONE (PASS, rc=0) summary: successful proof by k-induction. SBY [wd_cover] DONE (PASS, rc=0) summary: 6/6 cover statements reached.

### मापनीयता

सत्यापन `CLK_FREQ=1`, `TIMEOUT_SEC=5` का उपयोग करता है ताकि अवस्था स्थान प्रबंधनीय रहे। उत्पादन में `CLK_FREQ=125000000` का उपयोग होता है। RTL पैरामीटरीकृत है — वही if/else तर्क, वही अवस्था संक्रमण। घटे हुए पैमाने पर प्रमाण उत्पादन पैमाने पर शुद्धता का संकेत देता है।

देखें [`fpga/formal/README.md`](https://github.com/park07/amradio/blob/HEAD/am_radio/fpga/formal/README.md)
---

## आवश्यकताएँ

### हार्डवेयर

- Red Pitaya STEMlab 125-10
- परीक्षण के लिए AM रेडियो रिसीवर
- ईथरनेट केबल (Red Pitaya कनेक्शन के लिए)

### सॉफ्टवेयर

| निर्भरता | macOS | Windows |
|-----------|-------|---------|
| Rust + Cargo | `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \| sh` | [rustup.rs](https://rustup.rs) से `rustup-init.exe` डाउनलोड करें |
| Node.js (LTS) | `brew install node` या [nodejs.org](https://nodejs.org) | [nodejs.org](https://nodejs.org) |
| Xcode Command Line Tools (केवल macOS) | `xcode-select --install` | — |
| Visual Studio Build Tools (केवल Windows) | — | [डाउनलोड करें](https://visualstudio.microsoft.com/visual-cpp-build-tools/) — **"Desktop development with C++"** चुनें |

### औपचारिक सत्यापन (वैकल्पिक)

- SymbiYosys
- Yosys
- Z3 SMT solver

---

## स्थापना

### 1. रिपॉजिटरी क्लोन करें```bash
git clone https://github.com/Park07/amradio.git
cd amradio/am_radio

2. GUI बनाएँ

macOS```bash

Install Rust (if not installed)

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh source $HOME/.cargo/env

Install Xcode CLI tools (if not installed)

xcode-select --install

Install Node.js via Homebrew (if not installed)

brew install node

Build

cd gui npm install npm run build

निर्मित `.app` `gui/src-tauri/target/release/bundle/macos/` में होगा।

#### Windows (PowerShell)```powershell
# 1. Install Rust
#    Download and run rustup-init.exe from https://rustup.rs
#    Close and reopen PowerShell after install

# 2. Install Visual Studio Build Tools
#    Download from https://visualstudio.microsoft.com/visual-cpp-build-tools/
#    Select "Desktop development with C++" during installation
#    Close and reopen PowerShell after install

# 3. Install Node.js
#    Download LTS from https://nodejs.org
#    Close and reopen PowerShell after install

# 4. Verify installations
rustc --version
cargo --version
node --version
npm --version

# 5. Build
cd gui
npm install
npm run build

The built .exe will be in gui\src-tauri\target\release\.

नोट: पहली बार बनाने में ~2–3 मिनट लगते हैं (Rust संकलन)। बाद के बिल्ड तेज होते हैं।

3. Red Pitaya सेटअप करें

Red Pitaya में SSH करें:```bash ssh root@<RED_PITAYA_IP>

Default password: root

आवश्यक फ़ाइलों की प्रतिलिपि बनाएँ:```bash

scp am_scpi_server.py root@<RED_PITAYA_IP>:/root/
scp axi_audio_sequence_loop.py root@<RED_PITAYA_IP>:/root/
scp alarm_fast.wav 0009_part1.wav 0009_part2_fast.wav root@<RED_PITAYA_IP>:/root/
scp fpga/red_pitaya_top.bit root@<RED_PITAYA_IP>:/root/

नोट

Bitstream पहले से ही विकास के दौरान Red Pitaya SD कार्ड पर मौजूद है।

पुनर्निर्माण के लिए: Vivado में project_William.xpr खोलें, bitstream जनरेट करें, फिर नई .bit फ़ाइल को scp के माध्यम से Red Pitaya पर भेजें।

4. Python वातावरण (Red Pitaya)

Red Pitaya Alpine Linux और Python 3.5 के साथ चलता है। SCPI सर्वर पर कोई बाहरी निर्भरता नहीं है (केवल stdlib)। ऑडियो लोडर को numpy की आवश्यकता है:```bash

On Red Pitaya

pip install numpy

> **नोट:** Red Pitaya का Python 3.5 `venv` को आउट ऑफ द बॉक्स सपोर्ट नहीं करता है और रूट के रूप में चलता है, इसलिए पैकेज वैश्विक रूप से स्थापित होते हैं। यह ठीक है — यह एक एम्बेडेड उपकरण है, साझा सर्वर नहीं।

### 5. Python Environment (Local Development — optional)

यदि आप Python स्क्रिप्ट को स्थानीय रूप से चलाना या संशोधित करना चाहते हैं (उदाहरण के लिए, Red Pitaya के बिना ऑडियो प्रोसेसिंग का परीक्षण करने के लिए):```bash
python3 -m venv venv
source venv/bin/activate        # macOS/Linux
# or
.\venv\Scripts\activate         # Windows PowerShell

pip install -r requirements.txt

यदि पहले से मौजूद नहीं है तो .gitignore में venv/ जोड़ें।

ऑडियो फ़ाइलें

सिस्टम तीन ऑडियो फ़ाइलों को एक लूप में चलाता है: अलार्म → भाग 1 → भाग 2 → (दोहराएँ)।

फ़ाइल	विवरण	अवधि
`alarm_fast.wav`	अलार्म टोन	~4 सेकंड

सभी ऑडियो को FPGA के 16,384-नमूने वाले BRAM बफर में फिट करने के लिए ~5 kHz पर डाउनसैंपल किया जाता है। axi_audio_sequence_loop.py स्क्रिप्ट स्वचालित रूप से रीसैंपलिंग, 14-बिट रूपांतरण और अनुक्रमिक लोडिंग संभालती है।

उपयोग

आपको Red Pitaya के लिए तीन SSH टर्मिनल खुले रखने होंगे, साथ ही GUI के लिए एक स्थानीय टर्मिनल।

नोट: Red Pitaya का IP पता हर बार चालू होने पर बदल सकता है। इसे खोजने के लिए अपने राउटर की DHCP क्लाइंट सूची देखें या ping rp-f0866a.local का उपयोग करें।

चरण 1: Red Pitaya से कनेक्ट करें

एक टर्मिनल खोलें और SSH करें:```bash ssh root@<RED_PITAYA_IP>

Password: root

### चरण 2: FPGA बिटस्ट्रीम लोड करें

Red Pitaya पर (पहला SSH टर्मिनल):```bash
cat /root/red_pitaya_top.bit > /dev/xdevcfg

यह AM रेडियो डिज़ाइन को FPGA पर लोड करता है। प्रत्येक पावर साइकिल के बाद आवश्यक है।

चरण 3: SCPI सर्वर प्रारंभ करें

Red Pitaya (उसी या दूसरे SSH टर्मिनल) पर:```bash python3 /root/am_scpi_server.py

इसे चलने दें — यह GUI से FPGA रजिस्टरों तक TCP कमांड को जोड़ता है।

### चरण 4: ऑडियो लूप शुरू करें

Red Pitaya के लिए दूसरा SSH टर्मिनल खोलें:```bash
ssh root@<RED_PITAYA_IP>
sudo python3 /root/axi_audio_sequence_loop.py

अपेक्षित आउटपुट:```

AXI AUDIO SEQUENCE - AUTO LOOP Alarm -> Part 1 -> Part 2 -> (repeat)

Buffer: 16384 samples FPGA playback rate: 5000 Hz Press Ctrl+C to stop

### चरण 5: GUI चलाएं

अपनी स्थानीय मशीन पर:```bash
cd gui
npm run dev

या निर्मित बाइनरी को सीधे src-tauri/target/release/ से चलाएँ।

चरण 6: कनेक्ट करें और प्रसारण करें

Red Pitaya IP पता दर्ज करें
कनेक्ट पर क्लिक करें
वांछित चैनल (1–12) सक्षम करें
यदि आवश्यक हो तो आवृत्तियाँ समायोजित करें
START BROADCAST पर क्लिक करें
किसी भी सक्षम आवृत्ति पर एक AM रेडियो ट्यून करें

विवाडो (केवल FPGA विकास के लिए)

यदि आपको FPGA डिज़ाइन को संशोधित करने और बिटस्ट्रीम को पुनर्निर्माण करने की आवश्यकता है, तो Vivado 2020.1 स्थापित करें। Red Pitaya यहाँ एक सेटअप गाइड प्रदान करता है:

https://redpitaya.readthedocs.io/en/latest/developerGuide/fpga/getting_started/vivado_install.html

सभी बुनियादी Red Pitaya सेटिंग्स और ट्यूटोरियल Red Pitaya आधिकारिक दस्तावेज़ीकरण पर उपलब्ध हैं।

फ़ाइल संरचना```

am_radio/ ├── gui/ │ ├── src/ │ │ ├── index.html # HTML + CSS │ │ └── js/ │ │ ├── event_bus.js # Frontend pub/sub + Tauri listener │ │ ├── model.js # Rust API calls (stateless) │ │ ├── view.js # DOM rendering │ │ └── controller.js # Event handlers │ └── src-tauri/src/ │ ├── main.rs # Entry point │ ├── model.rs # NetworkManager + DeviceState │ ├── commands.rs # Tauri command bridge │ ├── event_bus.rs # Rust pub/sub + Tauri emit │ ├── state_machine.rs # Broadcast state transitions │ └── config.rs # Constants ├── fpga/ │ ├── formal/ │ │ ├── wd.v # Watchdog + 14 formal properties │ │ ├── wd.sby # SymbiYosys config │ │ └── README.md # Formal verification docs │ ├── am_mod.sv # AM modulation module │ ├── am_radio_ctrl.v # 12-channel AM radio controller │ ├── axi_audio_buffer.v # AXI audio buffer for BRAM playback │ ├── nco_sin.v # Numerically Controlled Oscillator │ ├── red_pitaya_top.sv # Top-level FPGA integration │ ├── sine_lut_4096.mem # 4096-point sine lookup table │ └── watchdog_timer.v # Watchdog timer module (production) ├── am_scpi_server.py # SCPI server (runs on Red Pitaya) ├── axi_audio_sequence_loop.py # Audio sequence loader (alarm → part1 → part2 loop) ├── alarm_fast.wav # Alarm tone ├── 0009_part1.wav # Emergency message part 1 ├── 0009_part2_fast.wav # Emergency message part 2 ├── requirements.txt # Python dependencies (numpy) └── README.md

---

## चैनल आवृत्तियाँ (डिफ़ॉल्ट)

| चैनल | आवृत्ति |
|---------|-----------|
| CH1 | 505 kHz |
| CH2 | 605 kHz |
| CH3 | 705 kHz |
| CH4 | 805 kHz |
| CH5 | 905 kHz |
| CH6 | 1005 kHz |
| CH7 | 1105 kHz |
| CH8 | 1205 kHz |
| CH9 | 1305 kHz |
| CH10 | 1405 kHz |
| CH11 | 1505 kHz |
| CH12 | 1605 kHz |

आवृत्तियाँ रनटाइम पर समायोज्य (500–1700 kHz रेंज).

---

## वॉचडॉग सुरक्षा डिज़ाइन
![Watchdog State Machine](https://assets.kitploit.com/production/public/readmes/11878/6531091e26d450ab35e4e20c91ca2b88952b40ccf8a195443fe782cb413f45c5.png)```
Standard watchdog:  device hangs → timer overflows → restarts device → back to normal
This watchdog:      GUI dies → counter hits timeout → kills RF output → stays dead until operator resets

क्यों अलग: एक बिना चालक सुरंग में रेडियो ट्रांसमीटर को स्वचालित रूप से पुनः आरंभ करना खतरनाक है। सिस्टम को RF आउटपुट फिर से शुरू होने से पहले मानव पुष्टि की आवश्यकता होती है। विफल-सुरक्षित, विफल-पुनर्प्राप्ति नहीं।

सुरक्षा मार्जिन: GUI हर 500ms पर पोल करता है। वॉचडॉग टाइमआउट 5 सेकंड है। ट्रिगर होने से पहले लगातार 10 हार्टबीट मिस होते हैं — क्षणिक नेटवर्क विलंब के खिलाफ लचीला।

प्रदर्शन नोट्स

अनुशंसा: विश्वसनीय रिसेप्शन के लिए अधिकतम 4–5 चैनल।

SCPI कमांड संदर्भ

परीक्षण

Rust यूनिट टेस्ट

बैकएंड में 11 परीक्षण — स्टेट मशीन ट्रांज़िशन, इवेंट बस पब/सब, रीट्री लॉजिक, और कॉन्फ़िग वैलिडेशन।```bash cd gui/src-tauri cargo test

### औपचारिक सत्यापन (FPGA)

वॉचडॉग टाइमर पर 14 गणितीय रूप से सिद्ध सुरक्षा गुण। ऊपर [औपचारिक सत्यापन](#formal-verification) अनुभाग देखें।

### मॉक सर्वर

Red Pitaya कनेक्ट किए बिना GUI का परीक्षण करने के लिए:```bash
# Terminal 1 — start mock FPGA
cd gui
npm run mock

# Terminal 2 — start GUI
cd gui
npm run dev

फिर GUI में 127.0.0.1:5000 से कनेक्ट करें।

समस्या निवारण

भविष्य के डेवलपर्स के लिए

यह प्रोजेक्ट अगली EPI कोहोर्ट को विरासत में मिलेगा। यहाँ वह है जो आपको जानना चाहिए।

क्या काम करता है

पूरी सिग्नल श्रृंखला कार्यात्मक है: GUI → Rust बैकएंड → TCP/SCPI → Red Pitaya → FPGA → RF आउटपुट। ऑडियो प्लेबैक स्वचालित रूप से लूप होता है। यदि GUI डिस्कनेक्ट होता है तो वॉचडॉग RF को बंद कर देता है। यह सब हार्डवेयर पर लाइव प्रदर्शित किया गया है।

क्या सुधारना है

FPGA ऑडियो बफर BRAM में 16,384 नमूनों तक सीमित है, जो ~5 kHz तक डाउनसैंपलिंग को मजबूर करता है। लंबे या उच्च गुणवत्ता वाले ऑडियो के लिए बाहरी मेमोरी (DDR या SD कार्ड) की आवश्यकता होगी। axi_audio_sequence_loop.py स्क्रिप्ट ऑडियो को AXI पर पुनः लोड करती है जिसमें ट्रैक के बीच ~1.4 सेकंड का अंतर होता है — DMA इसे समाप्त कर देगा। वर्तमान में उपयोगी सिग्नल शक्ति पर केवल 4–5 चैनल व्यावहारिक हैं; एक बाहरी RF एम्पलीफायर चरण सभी 12 चैनलों को एक साथ सक्षम करेगा।

पहले समझने के लिए मुख्य फ़ाइलें

model.rs (Rust बैकएंड — सभी नेटवर्क लॉजिक यहाँ रहता है), am_scpi_server.py (TCP कमांड और FPGA रजिस्टरों के बीच पुल), और am_radio_ctrl.v (सॉफ्टवेयर और हार्डवेयर के बीच रजिस्टर इंटरफ़ेस) पढ़ें। ये तीन फ़ाइलें सिस्टम की हर परत के बीच हैंडशेक पॉइंट हैं।

Red Pitaya एक्सेस

विकास के दौरान Red Pitaya IP 192.168.0.101 था। SSH क्रेडेंशियल्स root/root हैं। FPGA बिटस्ट्रीम बूट पर SD कार्ड से स्वचालित रूप से लोड होती है। यदि बिटस्ट्रीम गायब या दूषित है, तो आपको fpga/ में .sv/.v स्रोतों से इसे पुनः बनाने के लिए Vivado की आवश्यकता होगी।

विकास कार्यप्रवाह

GUI परिवर्तनों के लिए: gui/src/ में JS/HTML संपादित करें, npm run dev चलाएं — फ्रंटएंड हॉट-रिलोड होता है। Rust बैकएंड परिवर्तनों के लिए: gui/src-tauri/src/ में फ़ाइलें संपादित करें, डेव सर्वर स्वचालित रूप से पुनः संकलित होता है (कुछ सेकंड लगते हैं)। FPGA परिवर्तनों के लिए: fpga/ में Verilog संपादित करें, Vivado में सिंथेसाइज़ करें, नई बिटस्ट्रीम जनरेट करें, Red Pitaya SD कार्ड पर कॉपी करें।

महत्वपूर्ण नोट!:

मेरे काम के लिए, ऑडियो फ़ाइलें वास्तव में Red Pitaya के अंदर संग्रहीत थीं। और चूंकि इसमें 32k अधिकतम मेमोरी बफर है, हमें आपातकालीन ऑडियो को 3 भागों (~4 सेकंड प्रत्येक) में विभाजित करना पड़ा, और यह पिछले ऑडियो को फिर से लिखेगा।
ऑडियो फ़ाइलें इस रिपॉजिटरी में नहीं मिलती हैं लेकिन बेझिझक इसे समझें। मैं बेहतर लाइव स्ट्रीमिंग के लिए Red Pitaya 14वें संस्करण का उपयोग करने की सलाह देता हूँ। 125-10 बहुत पुराना है और इनमें से अधिकांश मेमोरी समस्याएं 125-15 में अपग्रेड करके आसानी से हल की जा सकती हैं। पावेल के पास एक बेहतरीन नोट हो सकता है जो 125-14 के लिए भी प्रासंगिक हो।

लेखक

("जेवू") विलियम पार्क (JW P) — सॉफ्टवेयर आर्किटेक्चर (GUI, MVC, इवेंट-ड्रिवन आर्किटेक्चर), फ्रंटएंड (JS), बैकएंड (Rust), हार्डवेयर वॉचडॉग टाइमर, औपचारिक सत्यापन, स्टेट मशीन
बोवेन डेंग — FPGA विकास (NCO, AM मॉड्यूलेशन, RF आउटपुट)

आभार

University of New South Wales
रॉबर्ट महूड — इंजीनियरिंग पर्यवेक्षक
एंड्रयू वोंग (UNSW) — शैक्षणिक पर्यवेक्षक

अंतिम संस्करण: 13 फरवरी 2026

1–2	उत्कृष्ट	✅ सर्वोत्तम गुणवत्ता
3–4	अच्छा	✅ अनुशंसित अधिकतम
5–8	मध्यम	⚠️ एम्पलीफायर की आवश्यकता हो सकती है
9–12	कमज़ोर	⚠️ केवल छोटी दूरी

`*IDN?`	डिवाइस पहचान
`STATUS?`	पूर्ण डिवाइस स्थिति
`OUTPUT:STATE ON/OFF`	मास्टर प्रसारण सक्षम
`CH1:FREQ 505000`	CH1 आवृत्ति सेट करें (Hz)
`CH1:OUTPUT ON/OFF`	CH1 सक्षम/अक्षम करें
`SOURCE:MSG 1`	ऑडियो संदेश चुनें
`WATCHDOG:RESET`	वॉचडॉग टाइमर रीसेट करें
`WATCHDOG:STATUS?`	वॉचडॉग स्थिति पूछें

पावर साइकिल के बाद कोई RF आउटपुट नहीं	बिटस्ट्रीम पुनः लोड करें: `cat /root/red_pitaya_top.bit > /dev/xdevcfg`
GUI कनेक्ट नहीं हो रहा	IP जांचें, सुनिश्चित करें कि SCPI सर्वर चल रहा है
कोई ऑडियो नहीं, केवल कैरियर	ऑडियो लूप शुरू करें: `sudo python3 /root/axi_audio_sequence_loop.py`
`file does not start with RIFF id`	ऑडियो फ़ाइल मान्य WAV नहीं है — `ffmpeg -i input -ac 1 -ar 44100 output.wav` के साथ पुनः कन्वर्ट करें
कमजोर सिग्नल	सक्षम चैनल कम करें (अधिकतम 4–5)
कनेक्शन टाइमआउट	नेटवर्क जांचें, Red Pitaya पावर जांचें
वॉचडॉग अप्रत्याशित रूप से ट्रिगर हुआ	नेटवर्क स्थिरता जांचें, यदि आवश्यक हो तो टाइमआउट बढ़ाएं
`linker 'link.exe' not found` (Windows)	Visual Studio Build Tools को "Desktop development with C++" के साथ इंस्टॉल करें
`cargo not found`	Rust इंस्टॉल के बाद टर्मिनल पुनः प्रारंभ करें
`npm not found`	Node.js इंस्टॉल के बाद टर्मिनल पुनः प्रारंभ करें
`xcode-select` errors (macOS)	`xcode-select --install` चलाएं

amradio

सबसे लोकप्रिय