Close
0%
0%

ΣΔπ - TX

8Bit / ~2MHz bandwidth SDR-TX with RPI

Similar projects worth following
Using an external rf-mixer together with an sigmadelta-DAC I would like to create a minimalistic hardware that transforms the raspberry pi into something close to a SDR-TX platform capeable of transmitting ~2MHz Bandwidth with 8Bit resolution in various bands.

Inspired by the works of Oliver Mattos and Oskar Weigl the creators of pifm and Evariste Okcestbon the creator of rpitx, I would like to push the boundaries of radio-transmission on the rpi platform. My main interesst lies in the transmission of multiple audio channels at the same time, this requires a decent amount of bandwidth and some dynamic range to function.


In my eyes the beauty of pifm and rpitx is that basic radio-transmission functionality is implemented using existing rpi-hardware peripherals in unorthodox ways together with clever programming. Only an output filter is recommended for operation. So the question arises what would theoretically be possible by adding just a little more hardware to this equation - namely an external mixer IC (SA602). We still would need a digital-to-analog converter in order to generate the required baseband which would be upconverted by the mixer to the desired band. Building an ~4MSPS/8Bit DAC can be done using the PWM-peripheral (in serial output mode) and a software SigmaDelta-modulator, this reduces the required external hardware to some filtering and the external mixer.

The project can be split up in the following subtasks:

* (arm-)optimized SigmaDelta function
* DMA enabled driver to feed the SigmaDelta-data to the PWM
* Low-Pass Filtering for the SigmaDelta-Output
* Mixer circuit
* Low or Bandpass-Filter of the Mixer-Ouput


Software is licensed under GPL2
Hardware is licensed under CC-BY-SA 3.0


Warning: Always check that you have the legal requirements to transmit and use appropriate filtering to not generate unwanted noise in the spectrum.

  • 1 × SA602A RF-Mixer

  • Testing the PWM Output

    georg ottinger04/24/2016 at 18:41 0 comments

    For a quick test if the PWM-is capable of outputing the Bitstream fast enough I wrote a small testprogram ( by modifiying the rpitx-Source). This testprogram initializes the PWM-Periperal with 125 MHz Clock (125Mhz clock and 32 oversampling translates to 3,9 MSPS)

    The testprogram generates alternating pattern of 0xFFFF0050 and 0xFF000020 - the
    result looks quite workable (see picture below)


    there are some glitches from time to time - which can be expected on an
    multitasking OS - but maybe with DMA this issue could be solved aswell.

  • SigmaDelta Function Compiler

    georg ottinger04/24/2016 at 18:32 0 comments

    SigmaDelta-modulators use a method called oversampling to generate the desired dynamic range.

    For the first experiments with the SigmaDelta-Modulator I tried to implement a 2nd Order 32 Oversampling SigmaDelta-Modulator - which should result in a SNR compareable sligthly above 8Bits-DACs.

    N-times Oversampling means that the for each sample the SigmaDelta() has to do the necessary calculations N-times - which can be a quite CPU-Cycles hungry venture - so in order to address this issue - I wrote a small SigmaDelta-function compiler - which gernerates an ARM optimzied C function using inline assembler.

    I managed to write a function that only needs 6 CPU-Cycles per sample for one iteration of the oversampling process on ARM11 - and on CPUs like the Cortex-A7 (partial dual-issue) or Cortex-A53 (dual-issue) the calculation can be done with 5 CPU-Cycles. Additional ~32 Cycles per Sample for all oversampling iterations must be added as well mainly for storing results and entering and exiting the C-Function

    This function allow us on RPI2 (Cortex A7) and RPI3 (Cortex A53) to implement a 4MSPS 2nd-Order 32x Oversampling Sigmadelta-Function which consumes roughly 768 MHz of a single CPU Core. ( 768 MHz = 4M*(5 Cycles*32+32 Cycles))

    On RPI1 (ARM11) which would need overclocking to 900Mhz a 3MSPS 2nd-Order 32x Oversampling Sigmadelta-Function should be possible - this would consume 672 MHz of the CPU. ( 672 MHz = 3M*(6 Cycles*32+32 Cycles))

    Using Octave I can evaluate the ouput of this SigmaDelta() without actually building it - I feed the SigmaDelta() with multiple sine-signals (spaced at 150kHz) and the result looks like this:

    The Source-Code for the optimized SigmaDelta-Function Compiler can be found on github:

    https://github.com/ottingerg/sigmadelta_compiler

View all 2 project logs

Enjoy this project?

Share      

Discussions

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates