event-driven-neuromorphic-transceiver

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

// 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

// 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

// 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

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/
        highcut = .fc + .bw/
        
        nyq = .fs / 
        low = lowcut / nyq
        high = highcut / nyq
        
        b, a = signal.butter(, [low, high], btype=)
         signal.filtfilt(b, a, signal_in)
    
     ():
        
        
        squared = np.(signal_in) ** 
        
        
        window_samples = ( * .fs)
        window = np.ones(window_samples) / window_samples
        energy_envelope = np.convolve(squared, window, mode=)
        
        
        spike_indices = np.where(energy_envelope > .threshold)[]
        
        
        min_separation = ( * .fs)  
        spike_indices = ._remove_close_indices(spike_indices, min_separation)
        
        
        spike_times = spike_indices / .fs *   
        
         spike_times, energy_envelope
    
     ():
        
         (indices) == :
             indices
        
        filtered = [indices[]]
         idx  indices[:]:
             idx - filtered[-] > min_sep:
                filtered.append(idx)
         np.array(filtered)
    
     ():
        
        decoded = []
        
         spike_time  spike_times:
            
            min_error = ()
            best_neuron = -
            
             neuron_id, code  (.th_codes):
                
                expected_time = code % 
                
                
                 period  (-, , ):
                    candidate = expected_time + period
                    error = (spike_time - candidate)
                    
                     error < min_error  error < :  
                        min_error = error
                        best_neuron = neuron_id
            
             best_neuron >= :
                decoded.append((best_neuron, spike_time))
        
         decoded


 __name__ == :
    receiver = NeuromorphicReceiver()
    
    
    t = np.arange(, , /receiver.fs)  
    received = np.random.randn((t)) *   
    
    
    spike_times = [, , ]  
     st  spike_times:
        idx = (st * receiver.fs)
         idx < (received):
            
            pulse = signal.gausspulse(t[idx:idx+], fc=, bw=)
            received[idx:idx+(pulse)] += pulse * 
    
    
    detected_times, energy = receiver.energy_detect(received)
    decoded_spikes = receiver.decode_spikes(detected_times)
    
    ()
     neuron_id, timestamp  decoded_spikes:
        ()

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