FMBerry, UKW-Sender mit einem Raspberry

**saarfranzose** · December 30, 2018 at 1:48 AM

kleine Bastelei am Rande.

Die Sony Ericsson Transmitter-Module bekommt man z.B. im 5er-Pack für knapp 5 Euro inkl. Porto (aus Deutschland!)

Eine Anleitung findet man u.a. bei GitHub

Build an open source fm radio station with your raspberry pi

mit weiterführendem link zur hardware

FMBerry - Hardware

schöne Videos gibt es natürlich auch

External Content www.youtube.com

Content embedded from external sources will not be displayed without your consent.

Through the activation of external content, you agree that personal data may be transferred to third party platforms. We have provided more information on this in our privacy policy.

man kann nicht so sehr viel falsch machen, und die Sendeleistung ist einigermassen unkritisch (0,5mW im unteren level). Trotzdem hab ich in der ganzen Etage, spätestens nach Ausrichten der Telekop- bzw. Wurfantenne, wunderbaren Empfang in optimaler Qualität. Hier läuft wie im Video der mplayer mit einem Internetradio-Stream.

**saarfranzose** · December 30, 2018 at 6:34 PM

bei mir muss ja niemand nacket rumlaufen. Statt 3D-Druck heute nur etwas Holzbearbeitung. Jetzt kann ich mit der Box im Einzugsbereich meines WLAN im Haus rumlaufen und UKW-Empfänger mit Rockantenne-Classic-Perlen füttern.

***navi*** · December 30, 2018 at 10:32 PM

AlfredG · December 31, 2018 at 5:51 PM

Hallo, das ist ja wirklich eine günstige Sache. Für die Zukunft suche ich noch einen Modulator der gleichzeitig 10 Sender aussendet. Aber ich denke da gibt es Probleme wenn ich die Ausgänge von den Teilen einfach parallel auf eine Antenne gebe. Irgendwann ist ja mal Schluss mit UKW und da will ich dann einfach am Radio "drehen" können,

Alfred

O***B***r · December 31, 2018 at 6:16 PM

Auch das geht Alfred mit dem Raspberry oder einem anderen Linux. Du brauchst nur ein Programm bzw. den Signalpfad für mehrere Sender in einem grafischen Programm zeichnen und übersetzen lassen. Schau mal hier.

http://wiki.opendigitalradio.org/Multiple_stati…_using_gnuradio

Hier im Bild sind drei UKW Sender mit drei Modulationsquellen verbunden.

[Blocked Image: http://wiki.opendigitalradio.org/images/c/c4/FM_transmitter_multiple_stations.png]
Die Programmierumgebung macht aus diesem Signallaufplan bereits ein fertiges Programm.

Python

#!/usr/bin/env python
##################################################
# Gnuradio Python Flow Graph
# Title: Multiple stations FM transmitter
# Author: Mathias Coinchon
# Generated: Sat Jan  2 21:19:02 2010
##################################################


from gnuradio import blks2
from gnuradio import gr
from gnuradio.eng_option import eng_option
from gnuradio.gr import firdes
from gnuradio.wxgui import fftsink2
from gnuradio.wxgui import forms
from grc_gnuradio import usrp as grc_usrp
from grc_gnuradio import wxgui as grc_wxgui
from optparse import OptionParser
import wx


class multistations_FM_TX(grc_wxgui.top_block_gui):


	def __init__(self):
		grc_wxgui.top_block_gui.__init__(self, title="Multiple stations FM transmitter")


		##################################################
		# Variables
		##################################################
		self.samp_rate = samp_rate = 32000
		self.quad_rate = quad_rate = 1280000
		self.carrier2_frequency = carrier2_frequency = 300000
		self.carrier1_frequency = carrier1_frequency = -300000
		self.FM_frequency = FM_frequency = 107600000


		##################################################
		# Controls
		##################################################
		_carrier2_frequency_sizer = wx.BoxSizer(wx.VERTICAL)
		self._carrier2_frequency_text_box = forms.text_box(
			parent=self.GetWin(),
			sizer=_carrier2_frequency_sizer,
			value=self.carrier2_frequency,
			callback=self.set_carrier2_frequency,
			label="Carrier 2 Frequency",
			converter=forms.float_converter(),
			proportion=0,
		)
		self._carrier2_frequency_slider = forms.slider(
			parent=self.GetWin(),
			sizer=_carrier2_frequency_sizer,
			value=self.carrier2_frequency,
			callback=self.set_carrier2_frequency,
			minimum=-500000,
			maximum=500000,
			num_steps=100,
			style=wx.SL_HORIZONTAL,
			cast=float,
			proportion=1,
		)
		self.Add(_carrier2_frequency_sizer)
		_carrier1_frequency_sizer = wx.BoxSizer(wx.VERTICAL)
		self._carrier1_frequency_text_box = forms.text_box(
			parent=self.GetWin(),
			sizer=_carrier1_frequency_sizer,
			value=self.carrier1_frequency,
			callback=self.set_carrier1_frequency,
			label="Carrier 1 Frequency",
			converter=forms.float_converter(),
			proportion=0,
		)
		self._carrier1_frequency_slider = forms.slider(
			parent=self.GetWin(),
			sizer=_carrier1_frequency_sizer,
			value=self.carrier1_frequency,
			callback=self.set_carrier1_frequency,
			minimum=-500000,
			maximum=500000,
			num_steps=100,
			style=wx.SL_HORIZONTAL,
			cast=float,
			proportion=1,
		)
		self.Add(_carrier1_frequency_sizer)
		_FM_frequency_sizer = wx.BoxSizer(wx.VERTICAL)
		self._FM_frequency_text_box = forms.text_box(
			parent=self.GetWin(),
			sizer=_FM_frequency_sizer,
			value=self.FM_frequency,
			callback=self.set_FM_frequency,
			label="Central FM frequency",
			converter=forms.float_converter(),
			proportion=0,
		)
		self._FM_frequency_slider = forms.slider(
			parent=self.GetWin(),
			sizer=_FM_frequency_sizer,
			value=self.FM_frequency,
			callback=self.set_FM_frequency,
			minimum=87500000,
			maximum=108000000,
			num_steps=205,
			style=wx.SL_HORIZONTAL,
			cast=float,
			proportion=1,
		)
		self.Add(_FM_frequency_sizer)


		##################################################
		# Blocks
		##################################################
		self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_ccc(
			interpolation=4,
			decimation=1,
			taps=None,
			fractional_bw=None,
		)
		self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_ccc(
			interpolation=4,
			decimation=1,
			taps=None,
			fractional_bw=None,
		)
		self.blks2_rational_resampler_xxx_2 = blks2.rational_resampler_ccc(
			interpolation=4,
			decimation=1,
			taps=None,
			fractional_bw=None,
		)
		self.blks2_wfm_tx_0 = blks2.wfm_tx(
			audio_rate=samp_rate,
			quad_rate=320000,
			tau=50e-6,
			max_dev=75e3,
		)
		self.blks2_wfm_tx_1 = blks2.wfm_tx(
			audio_rate=samp_rate,
			quad_rate=320000,
			tau=75e-6,
			max_dev=75e3,
		)
		self.blks2_wfm_tx_2 = blks2.wfm_tx(
			audio_rate=samp_rate,
			quad_rate=320000,
			tau=75e-6,
			max_dev=75e3,
		)
		self.gr_add_xx_0 = gr.add_vcc(1)
		self.gr_file_source_0 = gr.file_source(gr.sizeof_short*1, "/home/mc/FM_demo/lemixx.fifo", True)
		self.gr_file_source_1 = gr.file_source(gr.sizeof_short*1, "/home/mc/FM_demo/banane.fifo", True)
		self.gr_file_source_2 = gr.file_source(gr.sizeof_short*1, "/home/mc/FM_demo/stream_32k.fifo", True)
		self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc((5000, ))
		self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((30e-6, ))
		self.gr_multiply_const_vxx_1_0 = gr.multiply_const_vff((30e-6, ))
		self.gr_multiply_const_vxx_1_1 = gr.multiply_const_vff((30e-6, ))
		self.gr_multiply_xx_0 = gr.multiply_vcc(1)
		self.gr_multiply_xx_1 = gr.multiply_vcc(1)
		self.gr_short_to_float_0 = gr.short_to_float()
		self.gr_short_to_float_0_0 = gr.short_to_float()
		self.gr_short_to_float_0_0_0 = gr.short_to_float()
		self.gr_sig_source_x_0 = gr.sig_source_c(quad_rate, gr.GR_COS_WAVE, carrier1_frequency, 1, 0)
		self.gr_sig_source_x_1 = gr.sig_source_c(quad_rate, gr.GR_COS_WAVE, carrier2_frequency, 1, 0)
		self.usrp_simple_sink_x_0 = grc_usrp.simple_sink_c(which=0, side="B")
		self.usrp_simple_sink_x_0.set_interp_rate(100)
		self.usrp_simple_sink_x_0.set_frequency(-FM_frequency, verbose=True)
		self.usrp_simple_sink_x_0.set_gain(0)
		self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
			self.GetWin(),
			baseband_freq=0,
			y_per_div=10,
			y_divs=10,
			ref_level=50,
			sample_rate=quad_rate,
			fft_size=1024,
			fft_rate=30,
			average=False,
			avg_alpha=None,
			title="FFT Plot",
			peak_hold=False,
		)
		self.Add(self.wxgui_fftsink2_0.win)


		##################################################
		# Connections
		##################################################
		self.connect((self.gr_multiply_const_vxx_0, 0), (self.usrp_simple_sink_x_0, 0))
		self.connect((self.gr_multiply_xx_0, 0), (self.gr_add_xx_0, 0))
		self.connect((self.gr_add_xx_0, 0), (self.gr_multiply_const_vxx_0, 0))
		self.connect((self.gr_add_xx_0, 0), (self.wxgui_fftsink2_0, 0))
		self.connect((self.blks2_rational_resampler_xxx_0, 0), (self.gr_add_xx_0, 1))
		self.connect((self.gr_multiply_xx_1, 0), (self.gr_add_xx_0, 2))
		self.connect((self.gr_sig_source_x_1, 0), (self.gr_multiply_xx_1, 1))
		self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 0))
		self.connect((self.blks2_rational_resampler_xxx_2, 0), (self.gr_multiply_xx_0, 1))
		self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.gr_multiply_xx_1, 0))
		self.connect((self.blks2_wfm_tx_0, 0), (self.blks2_rational_resampler_xxx_2, 0))
		self.connect((self.blks2_wfm_tx_2, 0), (self.blks2_rational_resampler_xxx_0, 0))
		self.connect((self.blks2_wfm_tx_1, 0), (self.blks2_rational_resampler_xxx_1, 0))
		self.connect((self.gr_short_to_float_0, 0), (self.gr_multiply_const_vxx_1, 0))
		self.connect((self.gr_file_source_1, 0), (self.gr_short_to_float_0, 0))
		self.connect((self.gr_file_source_2, 0), (self.gr_short_to_float_0_0, 0))
		self.connect((self.gr_file_source_0, 0), (self.gr_short_to_float_0_0_0, 0))
		self.connect((self.gr_short_to_float_0_0, 0), (self.gr_multiply_const_vxx_1_0, 0))
		self.connect((self.gr_short_to_float_0_0_0, 0), (self.gr_multiply_const_vxx_1_1, 0))
		self.connect((self.gr_multiply_const_vxx_1, 0), (self.blks2_wfm_tx_1, 0))
		self.connect((self.gr_multiply_const_vxx_1_0, 0), (self.blks2_wfm_tx_2, 0))
		self.connect((self.gr_multiply_const_vxx_1_1, 0), (self.blks2_wfm_tx_0, 0))


	def set_samp_rate(self, samp_rate):
		self.samp_rate = samp_rate


	def set_quad_rate(self, quad_rate):
		self.quad_rate = quad_rate
		self.wxgui_fftsink2_0.set_sample_rate(self.quad_rate)
		self.gr_sig_source_x_0.set_sampling_freq(self.quad_rate)
		self.gr_sig_source_x_1.set_sampling_freq(self.quad_rate)


	def set_carrier2_frequency(self, carrier2_frequency):
		self.carrier2_frequency = carrier2_frequency
		self._carrier2_frequency_slider.set_value(self.carrier2_frequency)
		self._carrier2_frequency_text_box.set_value(self.carrier2_frequency)
		self.gr_sig_source_x_1.set_frequency(self.carrier2_frequency)


	def set_carrier1_frequency(self, carrier1_frequency):
		self.carrier1_frequency = carrier1_frequency
		self._carrier1_frequency_slider.set_value(self.carrier1_frequency)
		self._carrier1_frequency_text_box.set_value(self.carrier1_frequency)
		self.gr_sig_source_x_0.set_frequency(self.carrier1_frequency)


	def set_FM_frequency(self, FM_frequency):
		self.FM_frequency = FM_frequency
		self._FM_frequency_slider.set_value(self.FM_frequency)
		self._FM_frequency_text_box.set_value(self.FM_frequency)
		self.usrp_simple_sink_x_0.set_frequency(-self.FM_frequency)


if __name__ == '__main__':
	parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
	(options, args) = parser.parse_args()
	tb = multistations_FM_TX()
	tb.Run(True)

Display More

Startet man das Programm werden die drei Modulationsquellen ausgelesen, die Sender erzeugt und dann zu einem schnellen Analog Digital Wandler gesendet der diese drei UKW-Sender ausgibt. Man kann auch 5 oder 10 Stationen anlegen und ausgeben lassen. Experimentiere jetzt schon ein paar Wochen damit und es ist einfach genial diese Digitale Signalverarbeitung am PC.

Otto.

**saarfranzose** · December 31, 2018 at 7:10 PM

bei dem Sony Ericsson Modul stellt sich ein Antennenproblem nicht. Es gibt keine externe Antenne.

Heute entdeckt: ein webinterface für FMBerry

FMBerryRemote

Bernhard45 · December 31, 2018 at 8:16 PM

Hallo,

neben der SDR-Lösung wäre folgendes Anwendungsszenario mit dem FMBerry möglich. Der FMBerry verfügt ja über einen I2C-Bus. Daran kann man normalerweise mehrere Teilnehmer dranhängen. Leider haben alle Sendemodule die gleiche Adresse, man müsste also vor jedem Modul noch einen kleinen Mikrokontroller hängen, der als Übersetzer den Berry mit unterschiedlichen Adressen an den I2C Bus bringt. Jeder uC hat dann eine frei konfigurierbare Busadresse und übersetzt die Befehle für das Sendemodul auf die fixe (interen) Adresse. Über einen Bus-Master, das kann der Pi sein, werden dann beliebig viele Sender gesteuert. Man kann auch ohne Probleme das Webinterface dafür umschreiben, das man beliebig viele Sender konfigurieren kann. Als Modulationsquellen könnten externe USB-Soundkarten herhalten die dann ein (von einander verschiedenes!) Internetradioprogramm zugespielt bekommen. So wäre eine All-in-One Lösung als ein Gerät umsetzbar. Im Nachbau sicher komplizierter als Ottos-SDR Lösung, aber wahrscheinlich ein paar Euro preiswerter.

Viele Grüße
Bernhard

Nachtrag: der FM-Berry hat ja einen ATMega als Steuercontroller drauf und die Firmware scheint dafür erhältlich. Somit kann man die Busadresse sicher direkt im Modul durch Änderung der Firmware modifizieren. Ein zusätzlicher uC als Übersetzer wäre damit hinfällig und es könnten nahezu beliebig viele Berrys am Bus hängen.

**saarfranzose** · December 31, 2018 at 8:40 PM

Einen Parallelbetrieb hatte ich schon mal als ich versehentlich die Software zweimal startete. Natürlich die gleiche Quelle auf der gleichen Sendefrequenz mit zeitlichem Versatz

AlfredG · December 31, 2018 at 9:17 PM

@Otto, genau das ist das was ich suche. Nur mit der Programmiererei hapert's bei mir. Auch zeitmäßig, es haben sich mittlerweile zuviele Radiobaustellen angesammelt. Und derzeit wird ein Röhrenverstärker mit dicken Röhren gebaut.

Alfred

**saarfranzose** · January 1, 2019 at 3:58 PM

etwas Eigenwerbung muss auch mal sein

**Franz Bernhard** · January 7, 2019 at 6:34 PM

Hallo,

als Änfänger in der Anwendung des Raspberry, hier noch ein paar grundsätzliche Fragen:
1. Mit welchem Betriebssytem sollte der Rasberry ausgerüstet sein?
2. Mit welcher Software auf dem Raspberry sollte der Stream für das Internetradio erzeugt werden?
3. und wie stelle ich die Sendefrequenz ein?

Geht das Ganze auch mit Volumio? Volumio benutze ich auf dem Raspberry als Internetradio als ganz einfache Lösung.

Bernhard45 · January 7, 2019 at 7:31 PM

Hallo Bernhard,

alle deine Fragen werden eigentlich in Jupps ersten Beitrag unter dem genannten Link (https://github.com/Manawyrm/FMBerry) beantwortet.

zu 1. also: ein Betriebssystem auf dem das Github-Projekt compilierbar ist
zu 2. jeder Mediaplayer der aus dem Netz einen Stream abspielen kann und für das Betriebssystem verfügbar ist
zu 3. siehe Link oben, Sektion "commands"

It currently allows the following commands:

ctlfmberry set freq 99000 - Frequency in kHz (76000 - 108000)
ctlfmberry poweron
ctlfmberry poweroff
ctlfmberry set rdsid DEADBEEF (8 chars! Longer strings will be truncated, shorter - padded with spaces)
ctlfmberry set rdstext Mike Oldfield - Pictures in the Dark (max. 64 chars. Longer strings will be truncated)
ctlfmberry set txpwr 0 - 0.5 mW Outputpower
ctlfmberry set txpwr 1 - 0.8 mW Outputpower
ctlfmberry set txpwr 2 - 1.0 mW Outputpower
ctlfmberry set txpwr 3 - 2.0 mW Outputpower (Default.)
ctlfmberry stereo on - Enables stereo signal (Default)
ctlfmberry stereo off - Disables stereo signal
ctlfmberry muteon - Mute audio
ctlfmberry muteoff - Unmute audio
ctlfmberry gainlow - Audio gain -9dB
ctlfmberry gainoff - Audio gain 0dB"
ctlfmberry set volume 0-6 Audio volume level 0 to 6, equal -9dB to +9db, 3dB step
ctlfmberry status - Print current status
ctlfmberry stop - Stop FMBerry daemon

**saarfranzose** · January 7, 2019 at 7:32 PM

es spielt keine Rolle wo die NF herkommt, die Übergabe an FMBerry geschieht an der Audiobuchse. Das kann also VLC, MPD, mplayer, volumio oder sogar eine externe Audioquelle sein.

Die Steuerung von FMBerry geschieht durch Anweisungen die ich in die rc.local eingetragen habe. Bei mir wird der mplayer mit einem Internetradiostream gestartet. Ich höre nur den einen Sender damit. Meine Sendebox hat keine Bedienteile. Sie läuft automatisch an wenn ich meinen Arbeitsplatz anschalte und 20sec. später kann ich auf meinen UKW-Radios "Rockantenne Classic Perlen" hören.

Die Übersicht der Befehle (der link ist im ersten post angegeben):

Code

It currently allows the following commands:


    ctlfmberry set freq 99000 - Frequency in kHz (76000 - 108000)
    ctlfmberry poweron
    ctlfmberry poweroff
    ctlfmberry set rdsid DEADBEEF (8 chars! Longer strings will be truncated, shorter - padded with spaces)
    ctlfmberry set rdstext Mike Oldfield - Pictures in the Dark (max. 64 chars. Longer strings will be truncated)
    ctlfmberry set txpwr 0 - 0.5 mW Outputpower
    ctlfmberry set txpwr 1 - 0.8 mW Outputpower
    ctlfmberry set txpwr 2 - 1.0 mW Outputpower
    ctlfmberry set txpwr 3 - 2.0 mW Outputpower (Default.)
    ctlfmberry stereo on - Enables stereo signal (Default)
    ctlfmberry stereo off - Disables stereo signal
    ctlfmberry muteon - Mute audio
    ctlfmberry muteoff - Unmute audio
    ctlfmberry gainlow - Audio gain -9dB
    ctlfmberry gainoff - Audio gain 0dB"
    ctlfmberry set volume 0-6 Audio volume level 0 to 6, equal -9dB to +9db, 3dB step
    ctlfmberry status - Print current status
    ctlfmberry stop - Stop FMBerry daemon

Display More

**saarfranzose** · January 7, 2019 at 7:34 PM

ups hat sich mit Bernhard überschnitten. Es empfiehlt sich das Raspbian Stretch lite als Betriebssystem.

**saarfranzose** · May 14, 2019 at 11:53 PM

Umbau des FMBerry auf iRadio

dieser Umbau ersetzt den mplayer durch den vlcd und bringt die ganzen Annehmlichkeiten von iRadio mit sich, wie Steuerung über webinterface, Taster oder Encoder, die Möglichkeit ein Display einzusetzen, und die Aktualisierungsmöglichkeiten von playlist und WLAN-Zugangsdaten.

Als erstes sichern wir die doch recht aufwändige rc.local, da iRadio diese überschreibt.

cd /etc
sudo cp rc.local rc.rette

dann erfolgt eine ganz normale iRadio-Installation

git clone https://github.com/BM45/iRadio.git

an der Stelle können wir bereits einen GPIO-Konflikt beseitigen. FMBerry belegt GPIO 17 (Pin 11) für den RDS-Interrupt. iRadio hat an dem Pin aber standardmässig eine der Sendersteuerungsleitungen.

wir definieren also in der rotary.c (für Drehencoder-Steuerung) die GPIO's z.B. so (meine bevorzugte Belegung auch in Hinsicht auf Konflikte mit Displays):

Code

#define  RoAPin    23  // GPIO-Pin 13, Pinnummer 33
#define  RoBPin    24  // GPIO-Pin 19, Pinnummer 35

und können sodann das iRadio-script und im Anschluss das Drehencoder-script starten:

cd /home/pi/iRadio
sudo ./install.sh

danach:

sudo ./install_Drehencoder.sh

die gesicherte und die neu erzeugte rc.local führen wir zusammen. In meinem Beispiel inkl. Lautstärkeerhöhung:

Code

....
ctlfmberry set freq 107900
ctlfmberry set rdsid saarfrze
ctlfmberry set rdstext "Jupp's Internetradio"
ctlfmberry set txpwr 0
ctlfmberry stereo off
ctlfmberry set volume 0


#mplayer -ao alsa -playlist http://www.rockantenne.de/webradio/channels/classic-perlen.m3u


/usr/bin/vlcd
#/usr/bin/displayd &
/usr/bin/gpiod &
sleep 10
echo "play" | nc 127.0.0.1 9294 -N


amixer -M set PCM 85%


exit 0

Display More

falls nach dem Neustart keine Modulation zu hören ist ist evtl. mit raspi-config die Audioausgabe noch nicht auf Klinke geschaltet. Auch musste ich in der vlcd noch wie gehabt den gain-Wert ergänzen.

sudo nano /usr/bin/vlcd

Code

...
--compressor-makeup-gain 0.0 \
--gain 3 \
...

Bernhard45 · May 15, 2019 at 1:27 AM

Wie sauber bringt der MMR-70 das Signal denn in die Luft? Hast Du das mal an einem richtigem SA (oder Software SA wie hier für 10 Euro, https://github.com/SV8ARJ/spektrum) angeschaut? Denk auch an die 50nW Jupp! set txpwr 3 !

Gruß Bernhard

**saarfranzose** · May 15, 2019 at 8:58 AM

danke Bernhard, den txpwr - Wert hab ich auf 0 geändert. Das ist legaler und genügt in meinem Bereich auch problemlos.

Spektrum-Messungen hab ich keine durchgeführt, der RTL-Stick liegt noch verpackt in meinem to-do - Schrank. Der subjektive Höreindruck läßt keine Wünsche übrig.

Bernhard45 · May 17, 2019 at 1:25 PM

Hallo Jupp,

ich habe mir mal den Sender von Amazon besorgt, das HF-Spektrum sieht eigentlich ganz gut aus, zumindest bedarf es keiner nachträglichen Filterung oder Abschwächer. Problematisch ist jedoch die Stromaufnahme, der Transmitter sollte unbedingt aus der 5V Leitung des Raspberrys mit nachgeschalteten 3.3V Spannungsregler versorgt werden. Versorgt man den Sender aus dem 3.3V Anschluß des Pi (zum Beispiel 3A+), dann funktioniert das bei gleichzeitigen Betrieb des WLAN Moduls noch gerade so. Geht das iRadio aber in den Bluetoothmodus schafft der Regler auf dem Pi nicht mehr alle Komponenten mit einer stabilen Spannung zu versorgen, es kommt zu hörbaren Störungen in der BT-Übertragung.
Also Raspi 5V - 3.3 V Regler - Sender, dann funktioniert das Gesamtpaket gut.

***navi*** · May 17, 2019 at 1:27 PM

Quote from saarfranzose

etwas Eigenwerbung muss auch mal sein

**saarfranzose** · May 17, 2019 at 2:11 PM

danke für die Recherche, Bernhard. Ich verdrahte grad einen weiteren FMBerry, der bekommt auch ein OLED oder LCD. Da werde ich den zusätzlichen Spannungsregler berücksichtigen.

Participate now!