Free SKILL.md scraped from GitHub. Clone the repo or copy the file directly into your Claude Code skills directory.
npx versuz@latest install hiyenwong-ai-collection-collection-skills-event-driven-neuromorphic-transceivergit clone https://github.com/hiyenwong/ai_collection.gitcp ai_collection/SKILL.MD ~/.claude/skills/hiyenwong-ai-collection-collection-skills-event-driven-neuromorphic-transceiver/SKILL.md---
name: event-driven-neuromorphic-transceiver
description: "Event-driven impulse radio transceiver system for reliable wireless neuromorphic inference. Ultra-low power event-based communication optimized for spike-based neural network data transmission. Triggers: event-driven radio, neuromorphic transceiver, impulse radio, spike transmission, wireless SNN."
---
# Event-Driven Impulse Radio Transceiver for Reliable Neuromorphic Inference
> Ultra-low power event-driven impulse radio transceiver system enabling reliable wireless communication for distributed neuromorphic computing and brain-machine interfaces.
## Metadata
- **Source**: arXiv:2604.23559v1
- **Authors**: Yuanxun Wang, Ahmed Hamed, Mohamed El-Hadedy, Zhanwei Zhong
- **Published**: 2026-04-26
- **Categories**: eess.SP (Signal Processing), cs.AR (Hardware Architecture)
## Core Methodology
### The Wireless Neuromorphic Challenge
Traditional wireless protocols are poorly suited for neuromorphic systems:
| Challenge | Traditional Wireless | Neuromorphic Requirement |
|-----------|---------------------|-------------------------|
| **Sparsity** | Assumes continuous traffic | Spike events are sparse (<5% duty cycle) |
| **Latency** | Frame-based (ms latency) | Event-driven (μs latency) |
| **Synchronization** | Clock-heavy protocols | Asynchronous event handling |
| **Power** | Always-on radio | Sleep between spikes |
| **Data Rate** | Fixed bandwidth | Proportional to spike rate |
### Event-Driven Impulse Radio Solution
The system leverages **spike sparsity** for ultra-efficient wireless transmission:
```
Traditional Wireless: Event-Driven Impulse Radio:
┌───────────────┐ ┌───────────────┐
│ Continuous │ │ Idle │ ← Low power sleep
│ Transmission │ │ ▼ │
│ ████████████ │ │ Event │ ← Spike detected
│ ████████████ │ │ ▼ │
│ ████████████ │ │ Impulse │ ← Ultra-short pulse
└───────────────┘ │ Transmit │ (ns duration)
Always ON (10mW) │ ▼ │
│ Idle │ ← Back to sleep
└───────────────┘
Sleep mode (<50μW)
```
### Key Innovation: Event-Driven Architecture
**Ultra-Wideband (UWB) Impulse Radio**:
- **Pulse Duration**: 2-10 nanoseconds
- **Center Frequency**: 3.5-4.5 GHz
- **Bandwidth**: 500+ MHz
- **Duty Cycle**: <0.1% (proportional to spike rate)
- **Power**: <50μW average, <10mW peak
**Asynchronous Event Handling**:
- No carrier synchronization required
- No framing overhead
- Time-of-arrival preserves temporal information
- Energy detection receiver (no coherent demodulation)
## System Architecture
### Transmitter Design
```
SNN Spike Output
│
▼
┌─────────────────────────────────────┐
│ SPIKE DETECTOR │
│ • Edge detection on spike events │
│ • Timestamp capture (ns precision) │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ TIME-HOPPING ENCODER │
│ • Neuron ID → Time-hop code │
│ • Collision avoidance │
│ • Multiple access support │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ UWB PULSE GENERATOR │
│ • Gaussian monocycle pulse │
│ • Center frequency: 4 GHz │
│ • Pulse width: 2 ns │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ RF FRONTEND │
│ • Pulse shaping filter │
│ • Power amplifier │
│ • UWB antenna │
└─────────────────────────────────────┘
│
▼
RF Output
```
### Receiver Design
```
RF Input
│
▼
┌─────────────────────────────────────┐
│ RF FRONTEND │
│ • Low-noise amplifier │
│ • Bandpass filter (3.5-4.5 GHz) │
│ • Automatic gain control │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ ENERGY DETECTOR │
│ • Square-law detection │
│ • Integration window: 10 ns │
│ • Threshold comparison │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ TIME-HOPPING DECODER │
│ • Time-of-arrival measurement │
│ • Neuron ID recovery │
│ • Spike timestamp reconstruction │
└─────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ SNN INPUT DRIVER │
│ • Spike event injection │
│ • Neuromorphic core interface │
└─────────────────────────────────────┘
│
▼
SNN Spike Input
```
## Implementation Guide
### Hardware Implementation (FPGA)
#### Step 1: Spike Detection & Timestamping
```verilog
// Spike detector with timestamp capture
module spike_detector (
input wire clk, // System clock (e.g., 100 MHz)
input wire rst_n,
input wire [7:0] spike_in, // SNN spike bus (8 channels)
output reg spike_event, // Spike detected
output reg [7:0] neuron_id, // Neuron identifier
output reg [31:0] timestamp // Nanosecond timestamp
);
// 1 ns counter (using PLL for higher frequency)
reg [31:0] ns_counter;
reg spike_prev [7:0];
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
ns_counter <= 32'd0;
spike_event <= 1'b0;
neuron_id <= 8'd0;
end else begin
ns_counter <= ns_counter + 1'b1;
spike_event <= 1'b0;
// Check each spike channel
for (int i = 0; i < 8; i = i + 1) begin
if (spike_in[i] && !spike_prev[i]) begin
spike_event <= 1'b1;
neuron_id <= i[7:0];
timestamp <= ns_counter;
end
spike_prev[i] <= spike_in[i];
end
end
end
endmodule
```
#### Step 2: Time-Hopping Encoder
```verilog
// Time-hopping spread spectrum encoder
module time_hopping_encoder (
input wire clk,
input wire rst_n,
input wire spike_event,
input wire [7:0] neuron_id,
input wire [31:0] timestamp,
output reg tx_trigger, // Trigger UWB pulse transmission
output reg [15:0] tx_delay // Delay until transmission
);
// Time-hopping code lookup table
// Maps neuron ID to pseudorandom delay offset
reg [15:0] th_code [0:255];
initial begin
// Initialize with pseudorandom codes
// In practice, these would be optimized for minimal correlation
th_code[0] = 16'd0; th_code[1] = 16'd53;
th_code[2] = 16'd107; th_code[3] = 16'd160;
// ... (remaining codes)
end
// Time-hopping period: 1 μs = 1000 ns
localparam TH_PERIOD = 16'd1000;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
tx_trigger <= 1'b0;
tx_delay <= 16'd0;
end else begin
tx_trigger <= 1'b0;
if (spike_event) begin
// Calculate transmission delay
// Delay = (timestamp + TH_code[neuron_id]) mod TH_PERIOD
tx_delay <= (timestamp[15:0] + th_code[neuron_id]) % TH_PERIOD;
tx_trigger <= 1'b1;
end
end
end
endmodule
```
#### Step 3: UWB Pulse Generator
```verilog
// Gaussian monocycle UWB pulse generator
module uwb_pulse_generator (
input wire clk, // 4 GHz sampling clock
input wire rst_n,
input wire tx_trigger,
input wire [15:0] tx_delay,
output reg [7:0] dac_out // Output to DAC
);
// Gaussian monocycle pulse samples (2 ns duration, 8 samples)
// Values represent normalized pulse amplitude (-1 to +1)
reg [7:0] pulse_shape [0:7];
reg [3:0] pulse_counter;
reg tx_active;
reg [15:0] delay_counter;
initial begin
// Pre-computed Gaussian monocycle samples
// Center frequency: 4 GHz, Bandwidth: 2 GHz
pulse_shape[0] = 8'd0; // 0.0
pulse_shape[1] = 8'd90; // 0.35
pulse_shape[2] = 8'd127; // 0.5 (peak)
pulse_shape[3] = 8'd90; // 0.35
pulse_shape[4] = 8'd0; // 0.0
pulse_shape[5] = 8'd166; // -0.35 (two's complement)
pulse_shape[6] = 8'd129; // -0.5 (peak negative)
pulse_shape[7] = 8'd166; // -0.35
end
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
tx_active <= 1'b0;
pulse_counter <= 4'd0;
delay_counter <= 16'd0;
dac_out <= 8'd128; // Mid-scale (0V)
end else begin
if (tx_trigger && !tx_active) begin
// Start transmission delay
delay_counter <= tx_delay;
tx_active <= 1'b1;
pulse_counter <= 4'd0;
end else if (tx_active) begin
if (delay_counter > 0) begin
delay_counter <= delay_counter - 1'b1;
dac_out <= 8'd128; // Idle
end else begin
// Output pulse samples
dac_out <= pulse_shape[pulse_counter];
pulse_counter <= pulse_counter + 1'b1;
if (pulse_counter == 4'd7) begin
tx_active <= 1'b0;
dac_out <= 8'd128;
end
end
end else begin
dac_out <= 8'd128; // Idle
end
end
end
endmodule
```
### Receiver Implementation
```python
import numpy as np
from scipy import signal
class NeuromorphicReceiver:
"""
Software implementation of neuromorphic impulse radio receiver
"""
def __init__(self,
sampling_rate=20e9, # 20 GSa/s for 50 ps resolution
center_freq=4e9, # 4 GHz center
bandwidth=2e9, # 2 GHz bandwidth
threshold=0.3): # Detection threshold
self.fs = sampling_rate
self.fc = center_freq
self.bw = bandwidth
self.threshold = threshold
# Time-hopping codes (must match transmitter)
self.th_codes = self._generate_th_codes()
def _generate_th_codes(self, n_neurons=256):
"""Generate orthogonal time-hopping codes"""
np.random.seed(42) # Reproducible
codes = np.random.randint(0, 1000, n_neurons) # 0-1000 ns
return codes
def bandpass_filter(self, signal_in):
"""Bandpass filter for UWB signal"""
lowcut = self.fc - self.bw/2
highcut = self.fc + self.bw/2
nyq = self.fs / 2
low = lowcut / nyq
high = highcut / nyq
b, a = signal.butter(4, [low, high], btype='band')
return signal.filtfilt(b, a, signal_in)
def energy_detect(self, signal_in):
"""
Energy detection with sliding window integration
Returns:
spike_times: Detected spike times (ns)
energy_envelope: Energy detection output
"""
# Square-law detection
squared = np.abs(signal_in) ** 2
# Sliding window integration (10 ns window)
window_samples = int(10e-9 * self.fs)
window = np.ones(window_samples) / window_samples
energy_envelope = np.convolve(squared, window, mode='same')
# Threshold detection
spike_indices = np.where(energy_envelope > self.threshold)[0]
# Remove consecutive detections (same pulse)
min_separation = int(5e-9 * self.fs) # 5 ns minimum
spike_indices = self._remove_close_indices(spike_indices, min_separation)
# Convert to time
spike_times = spike_indices / self.fs * 1e9 # Convert to ns
return spike_times, energy_envelope
def _remove_close_indices(self, indices, min_sep):
"""Remove indices that are too close together"""
if len(indices) == 0:
return indices
filtered = [indices[0]]
for idx in indices[1:]:
if idx - filtered[-1] > min_sep:
filtered.append(idx)
return np.array(filtered)
def decode_spikes(self, spike_times):
"""
Decode neuron IDs from spike times using time-hopping codes
Returns:
List of (neuron_id, timestamp) tuples
"""
decoded = []
for spike_time in spike_times:
# Find closest time-hopping code
min_error = float('inf')
best_neuron = -1
for neuron_id, code in enumerate(self.th_codes):
# Expected arrival time modulo TH period (1000 ns)
expected_time = code % 1000
# Account for periodicity
for period in range(-1000, 2000, 1000):
candidate = expected_time + period
error = abs(spike_time - candidate)
if error < min_error and error < 100: # 100 ns tolerance
min_error = error
best_neuron = neuron_id
if best_neuron >= 0:
decoded.append((best_neuron, spike_time))
return decoded
# Example usage
if __name__ == "__main__":
receiver = NeuromorphicReceiver()
# Simulate received signal
t = np.arange(0, 1e-6, 1/receiver.fs) # 1 μs window
received = np.random.randn(len(t)) * 0.1 # Noise
# Add synthetic spikes (for testing)
spike_times = [200e-9, 450e-9, 700e-9] # Spike times
for st in spike_times:
idx = int(st * receiver.fs)
if idx < len(received):
# Add UWB pulse
pulse = signal.gausspulse(t[idx:idx+200], fc=4e9, bw=0.5)
received[idx:idx+len(pulse)] += pulse * 0.5
# Detect and decode
detected_times, energy = receiver.energy_detect(received)
decoded_spikes = receiver.decode_spikes(detected_times)
print(f"Detected {len(decoded_spikes)} spikes:")
for neuron_id, timestamp in decoded_spikes:
print(f" Neuron {neuron_id}: {timestamp:.1f} ns")
```
## Performance Characteristics
### Power Consumption
| Component | Traditional Radio | This System | Improvement |
|-----------|------------------|-------------|-------------|
| **Idle Power** | 10-50 mW | <50 μW | **200-1000×** |
| **Active Power** | 50-100 mW | 5-10 mW | **5-10×** |
| **Average (1% duty)** | 10-15 mW | <150 μW | **70-100×** |
### Communication Performance
| Metric | Specification |
|--------|--------------|
| **Range** | 1-10 meters (configurable) |
| **Latency** | <100 ns (event-to-transmission) |
| **Data Rate** | 1-10 Mbps (spike-dependent) |
| **Bit Error Rate** | <10^-5 (at 1m range) |
| **Multi-node Support** | Up to 256 neurons/channels |
| **Synchronization** | Asynchronous (no clock recovery) |
### Comparison with Alternatives
| Approach | Latency | Power | Complexity | Best For |
|----------|---------|-------|------------|----------|
| **This Work** | <100 ns | <150 μW | Medium | Sparse events |
| Bluetooth LE | 5-20 ms | 10-50 mW | Low | Periodic data |
| Zigbee | 15-30 ms | 20-50 mW | Low | Sensor networks |
| WiFi | 1-10 ms | 100-500 mW | Medium | High throughput |
| Custom UWB | <1 μs | 5-20 mW | High | Precision ranging |
## Applications
### 1. Brain-Machine Interfaces
**Wireless Neural Recording**:
- Implantable neural interfaces
- Untethered neural prosthetics
- Real-time brain-computer communication
**System Architecture**:
```
[Implanted Neural Probe]
↓ (spikes)
[On-chip Spike Sorting]
↓ (sorted spikes)
[Event-Driven Transceiver] ←→ Wireless Link
↑ (commands)
[External Signal Processor]
↓
[Neural Decoder]
↓
[Prosthetic Control]
```
### 2. Distributed Neuromorphic Computing
**Neuromorphic Sensor Networks**:
- Event cameras with wireless transmission
- Distributed SNN processing
- Collaborative neuromorphic systems
### 3. Wearable Health Monitoring
**Applications**:
- EEG monitoring with wireless transmission
- EMG-based prosthetic control
- Real-time physiological monitoring
## Pitfalls
### Hardware Design
1. **Antenna Matching**: UWB requires broadband antenna design
- **Solution**: Use commercial UWB chip antennas
- Consider PCB material for high-frequency performance
2. **Clock Precision**: Time-hopping requires accurate timing
- **Solution**: Use temperature-compensated crystal oscillators (TCXO)
- Implement periodic synchronization if needed
3. **RF Interference**: UWB shares spectrum with other systems
- **Solution**: Dynamic frequency selection
- Error correction coding
### System Integration
4. **Packet Loss**: Wireless channels have variable quality
- **Solution**: Spike timing tolerant to ms delays
- Redundant transmission for critical spikes
5. **Multi-node Interference**: Time-hopping collisions
- **Solution**: Orthogonal codes for different nodes
- Adaptive code assignment
6. **Synchronization Drift**: Long-term clock drift
- **Solution**: Periodic beacon synchronization
- Drift compensation algorithms
### Regulatory
7. **UWB Regulations**: FCC/ETSI compliance required
- **Solution**: Power spectral density limits
- Frequency hopping for compliance
## Related Skills
- sparsity-neuromorphic-impulse-radio
- neuromorphic-hardware-design
- snn-fpga-hardware-software-codesign
- wireless-neural-recording
- distributed-neuromorphic-computing
## References
- Wang, Y., et al. (2026). Sparsity-Aware Event-Driven Impulse Radio Transceivers for Reliable Neuromorphic Inference. arXiv:2604.23559.
- IEEE 802.15.4f - Low-Rate UWB PHY
- FCC Part 15.503 - UWB regulations
- Oppermann, et al. (2004). UWB: Theory and Applications