+# get the OS Name
+UNAME_S := $(shell uname -s)
+
# Get git commit version and date
GIT_DATE := $(firstword $(shell git --no-pager show --date=short --format="%ai" --name-only))
GIT_VERSION := $(shell git describe --abbrev=0 --tags)
-ISSUE := $(shell cat /etc/issue.net)
-ifneq ($(filter %Raspbian,$(ISSUE)),)
- OSFLAG=-D RASPBIAN
-endif
-
# uncomment the following line to force 480x320 screen
#SMALL_SCREEN_OPTIONS=-D SMALL_SCREEN
#LOCALCW_INCLUDE=LOCALCW
# uncomment the line below for SoapySDR
-#SOAPYSDR_INCLUDE=SOAPYSDR
+SOAPYSDR_INCLUDE=SOAPYSDR
# uncomment the line to below include support for sx1509 i2c expander
#SX1509_INCLUDE=sx1509
#STEMLAB_DISCOVERY=STEMLAB_DISCOVERY_NOAVAHI
# uncomment the line below to include MIDI support
-#MIDI_INCLUDE=MIDI
+MIDI_INCLUDE=MIDI
# uncomment the line below for various debug facilities
#DEBUG_OPTION=-D DEBUG
ifeq ($(MIDI_INCLUDE),MIDI)
MIDI_OPTIONS=-D MIDI
-MIDI_SOURCES= alsa_midi.c midi2.c midi3.c
-MIDI_HEADERS= midi.h
-MIDI_OBJS= alsa_midi.o midi2.o midi3.o
+MIDI_HEADERS= midi.h midi_menu.h
+ifeq ($(UNAME_S), Darwin)
+MIDI_SOURCES= mac_midi.c midi2.c midi3.c
+MIDI_OBJS= mac_midi.o midi2.o midi3.o midi_menu.o
+MIDI_LIBS= -framework CoreMIDI -framework Foundation
+endif
+ifeq ($(UNAME_S), Linux)
+MIDI_SOURCES= alsa_midi.c midi2.c midi3.c midi_menu.c
+MIDI_OBJS= alsa_midi.o midi2.o midi3.o midi_menu.o
MIDI_LIBS= -lasound
endif
+endif
ifeq ($(PURESIGNAL_INCLUDE),PURESIGNAL)
PURESIGNAL_OPTIONS=-D PURESIGNAL
endif
ifeq ($(GPIO_INCLUDE),GPIO)
+GPIOD_VERSION=$(shell pkg-config --modversion libgpiod)
+ifeq ($(GPIOD_VERSION),1.2)
+GPIOD_OPTIONS=-D OLD_GPIOD
+endif
GPIO_OPTIONS=-D GPIO
GPIO_LIBS=-lgpiod -li2c
GPIO_SOURCES= \
GTKINCLUDES=`pkg-config --cflags gtk+-3.0`
GTKLIBS=`pkg-config --libs gtk+-3.0`
+ifeq ($(UNAME_S), Linux)
AUDIO_LIBS=-lpulse-simple -lpulse -lpulse-mainloop-glib
-//AUDIO_LIBS=-lasound
+AUDIO_SOURCES=pulseaudio.c
+AUDIO_OBJS=pulseaudio.o
+endif
+ifeq ($(UNAME_S), Darwin)
+AUDIO_OPTIONS=-DPORTAUDIO
+AUDIO_LIBS=-lportaudio
+AUDIO_SOURCES=portaudio.c
+AUDIO_OBJS=portaudio.o
+endif
CFLAGS= -g -Wno-deprecated-declarations -O3
OPTIONS=$(SMALL_SCREEN_OPTIONS) $(MIDI_OPTIONS) $(PURESIGNAL_OPTIONS) $(REMOTE_OPTIONS) $(USBOZY_OPTIONS) \
- $(GPIO_OPTIONS) $(SOAPYSDR_OPTIONS) $(LOCALCW_OPTIONS) \
+ $(GPIO_OPTIONS) $(GPIOD_OPTIONS) $(SOAPYSDR_OPTIONS) $(LOCALCW_OPTIONS) \
$(STEMLAB_OPTIONS) \
$(PTT_OPTIONS) \
$(SERVER_OPTIONS) \
- -D GIT_DATE='"$(GIT_DATE)"' -D GIT_VERSION='"$(GIT_VERSION)"' $(DEBUG_OPTION) $(OSFLAG)
+ $(AUDIO_OPTIONS) \
+ -D GIT_DATE='"$(GIT_DATE)"' -D GIT_VERSION='"$(GIT_VERSION)"' $(DEBUG_OPTION)
+
+
+ifeq ($(UNAME_S), Linux)
+RT_OPTION=-lrt
+endif
-LIBS=-lrt -lm -lwdsp -lpthread $(AUDIO_LIBS) $(USBOZY_LIBS) $(GTKLIBS) $(GPIO_LIBS) $(SOAPYSDRLIBS) $(STEMLAB_LIBS) $(MIDI_LIBS)
+LIBS=$(RT_OPTION) -lm -lwdsp -lpthread $(AUDIO_LIBS) $(USBOZY_LIBS) $(GTKLIBS) $(GPIO_LIBS) $(SOAPYSDRLIBS) $(STEMLAB_LIBS) $(MIDI_LIBS)
INCLUDES=$(GTKINCLUDES)
COMPILE=$(CC) $(CFLAGS) $(OPTIONS) $(INCLUDES)
PROGRAM=pihpsdr
SOURCES= \
-pulseaudio.c \
band.c \
discovered.c \
discovery.c \
cwramp.c \
protocols.c \
css.c \
-actions.c
+actions.c \
+configure.c \
+i2c.c \
+gpio.c \
+encoder_menu.c \
+switch_menu.c
+
HEADERS= \
-pulseaudio.h \
agc.h \
alex.h \
band.h \
error_handler.h \
protocols.h \
css.h \
-actions.h
+actions.h \
+configure.h \
+i2c.h \
+gpio.h \
+encoder_menu.h \
+switch_menu.h
+
OBJS= \
-pulseaudio.o \
band.o \
discovered.o \
discovery.o \
cwramp.o \
protocols.o \
css.o \
-actions.o
-
-$(PROGRAM): $(OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) $(SOAPYSDR_OBJS) \
- $(LOCALCW_OBJS) $(GPIO_OBJS) $(PURESIGNAL_OBJS) \
+actions.o \
+configure.o \
+i2c.o \
+gpio.o \
+encoder_menu.o \
+switch_menu.o
+
+$(PROGRAM): $(OBJS) $(AUDIO_OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) $(SOAPYSDR_OBJS) \
+ $(LOCALCW_OBJS) $(PURESIGNAL_OBJS) \
$(MIDI_OBJS) $(STEMLAB_OBJS) $(SERVER_OBJS)
- $(LINK) -o $(PROGRAM) $(OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) $(GPIO_OBJS) \
+ $(LINK) -o $(PROGRAM) $(OBJS) $(AUDIO_OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) \
$(SOAPYSDR_OBJS) $(LOCALCW_OBJS) $(PURESIGNAL_OBJS) \
$(MIDI_OBJS) $(STEMLAB_OBJS) $(SERVER_OBJS) $(LIBS)
.PHONY: all
-all: prebuild $(PROGRAM) $(HEADERS) $(USBOZY_HEADERS) $(SOAPYSDR_HEADERS) \
- $(LOCALCW_HEADERS) $(GPIO_HEADERS) \
+all: prebuild $(PROGRAM) $(HEADERS) $(AUDIO_HEADERS) $(USBOZY_HEADERS) $(SOAPYSDR_HEADERS) \
+ $(LOCALCW_HEADERS) \
$(PURESIGNAL_HEADERS) $(MIDI_HEADERS) $(STEMLAB_HEADERS) $(SERVER_HEADERS)\
- $(SOURCES) \
- $(USBOZY_SOURCES) $(SOAPYSDR_SOURCES) $(LOCALCW_SOURCE) $(GPIO_SOURCES) \
+ $(AUDIO_SOURCES) $(SOURCES) \
+ $(USBOZY_SOURCES) $(SOAPYSDR_SOURCES) $(LOCALCW_SOURCE)
$(PURESIGNAL_SOURCES) $(MIDI_SOURCES) $(STEMLAB_SOURCES) $(SERVER_SOURCES)
.PHONY: prebuild
.PHONY: cppcheck
cppcheck:
- cppcheck $(CPPOPTIONS) $(OPTIONS) $(CPPINCLUDES) $(SOURCES) $(REMOTE_SOURCES) \
- $(USBOZY_SOURCES) $(SOAPYSDR_SOURCES) $(GPIO_SOURCES) \
+ cppcheck $(CPPOPTIONS) $(OPTIONS) $(CPPINCLUDES) $(AUDIO_SOURCES) $(SOURCES) $(REMOTE_SOURCES) \
+ $(USBOZY_SOURCES) $(SOAPYSDR_SOURCES) \
$(PURESIGNAL_SOURCES) $(MIDI_SOURCES) $(STEMLAB_SOURCES) $(LOCALCW_SOURCES) \
$(SERVER_SOURCES)
+++ /dev/null
-# Get git commit version and date
-GIT_DATE := $(firstword $(shell git --no-pager show --date=short --format="%ai" --name-only))
-GIT_VERSION := $(shell git describe --abbrev=0 --tags)
-
-# uncomment the line below to include USB Ozy support
-# USBOZY_INCLUDE=USBOZY
-
-# uncomment the line below to include Pure Signal support
-PURESIGNAL_INCLUDE=PURESIGNAL
-
-# uncomment the line to below include support local CW keyer
-LOCALCW_INCLUDE=LOCALCW
-
-# uncomment the line below for SoapySDR
-#SOAPYSDR_INCLUDE=SOAPYSDR
-
-# uncomment the line to below include support for sx1509 i2c expander
-#SX1509_INCLUDE=sx1509
-
-# uncomment the line below to include support for STEMlab discovery (WITH AVAHI)
-#STEMLAB_DISCOVERY=STEMLAB_DISCOVERY
-
-# uncomment the line below to include support for STEMlab discovery (WITHOUT AVAHI)
-STEMLAB_DISCOVERY=STEMLAB_DISCOVERY_NOAVAHI
-
-# uncomment the line below to include MIDI support
-MIDI_INCLUDE=MIDI
-
-# very early code not included yet
-#SERVER_INCLUDE=SERVER
-
-# uncomment the line below for various debug facilities
-#DEBUG_OPTION=-D DEBUG
-
-CC=gcc
-LINK=gcc
-
-ifeq ($(CONTROLLER2_V2_INCLUDE),CONTROLLER2_V2)
-CONTROLLER2_OPTIONS=-D CONTROLLER2_V2
-endif
-ifeq ($(CONTROLLER2_V1_INCLUDE),CONTROLLER2_V1)
-CONTROLLER2_OPTIONS=-D CONTROLLER2_V1
-endif
-
-ifeq ($(MIDI_INCLUDE),MIDI)
-MIDI_OPTIONS=-D MIDI
-MIDI_SOURCES= mac_midi.c midi2.c midi3.c
-MIDI_HEADERS= midi.h
-MIDI_OBJS= mac_midi.o midi2.o midi3.o
-MIDI_LIBS= -framework CoreMIDI -framework Foundation
-endif
-
-ifeq ($(PURESIGNAL_INCLUDE),PURESIGNAL)
-PURESIGNAL_OPTIONS=-D PURESIGNAL
-PURESIGNAL_SOURCES= \
-ps_menu.c
-PURESIGNAL_HEADERS= \
-ps_menu.h
-PURESIGNAL_OBJS= \
-ps_menu.o
-endif
-
-ifeq ($(REMOTE_INCLUDE),REMOTE)
-REMOTE_OPTIONS=-D REMOTE
-REMOTE_SOURCES= \
-remote_radio.c \
-remote_receiver.c
-REMOTE_HEADERS= \
-remote_radio.h \
-remote_receiver.h
-REMOTE_OBJS= \
-remote_radio.o \
-remote_receiver.o
-endif
-
-ifeq ($(USBOZY_INCLUDE),USBOZY)
-USBOZY_OPTIONS=-D USBOZY
-USBOZY_LIBS=-lusb-1.0
-USBOZY_SOURCES= \
-ozyio.c
-USBOZY_HEADERS= \
-ozyio.h
-USBOZY_OBJS= \
-ozyio.o
-endif
-
-ifeq ($(SOAPYSDR_INCLUDE),SOAPYSDR)
-SOAPYSDR_OPTIONS=-D SOAPYSDR
-SOAPYSDRLIBS=-lSoapySDR
-SOAPYSDR_SOURCES= \
-soapy_discovery.c \
-soapy_protocol.c
-SOAPYSDR_HEADERS= \
-soapy_discovery.h \
-soapy_protocol.h
-SOAPYSDR_OBJS= \
-soapy_discovery.o \
-soapy_protocol.o
-endif
-
-ifeq ($(LOCALCW_INCLUDE),LOCALCW)
-LOCALCW_OPTIONS=-D LOCALCW
-LOCALCW_SOURCES= iambic.c
-LOCALCW_HEADERS= iambic.h
-LOCALCW_OBJS = iambic.o
-endif
-
-#
-# We have two versions of STEMLAB_DISCOVERY here,
-# the second one has to be used
-# if you do not have the avahi (devel-) libraries
-# on your system.
-#
-ifeq ($(STEMLAB_DISCOVERY), STEMLAB_DISCOVERY)
-STEMLAB_OPTIONS=-D STEMLAB_DISCOVERY \
- `pkg-config --cflags avahi-gobject` \
- `pkg-config --cflags libcurl`
-STEMLAB_LIBS=`pkg-config --libs avahi-gobject` `pkg-config --libs libcurl`
-STEMLAB_SOURCES=stemlab_discovery.c
-STEMLAB_HEADERS=stemlab_discovery.h
-STEMLAB_OBJS=stemlab_discovery.o
-endif
-
-ifeq ($(STEMLAB_DISCOVERY), STEMLAB_DISCOVERY_NOAVAHI)
-STEMLAB_OPTIONS=-D STEMLAB_DISCOVERY -D NO_AVAHI `pkg-config --cflags libcurl`
-STEMLAB_LIBS=`pkg-config --libs libcurl`
-STEMLAB_SOURCES=stemlab_discovery.c
-STEMLAB_HEADERS=stemlab_discovery.h
-STEMLAB_OBJS=stemlab_discovery.o
-endif
-
-ifeq ($(SERVER_INCLUDE), SERVER)
-SERVER_OPTIONS=-D SERVER
-SERVER_SOURCES= \
-hpsdr_server.c
-SERVER_HEADERS= \
-hpsdr_server.h
-SERVER_OBJS= \
-hpsdr_server.o
-endif
-
-GTKINCLUDES=`pkg-config --cflags gtk+-3.0`
-GTKLIBS=`pkg-config --libs gtk+-3.0`
-
-AUDIO_OPTIONS=-DPORTAUDIO
-AUDIO_LIBS=-lportaudio -O3
-
-CFLAGS= -g -Wno-deprecated-declarations
-OPTIONS=$(MIDI_OPTIONS) $(PURESIGNAL_OPTIONS) $(REMOTE_OPTIONS) $(USBOZY_OPTIONS) \
- $(SOAPYSDR_OPTIONS) $(LOCALCW_OPTIONS) \
- $(STEMLAB_OPTIONS) \
- $(CONTROLLER2_OPTIONS) $(AUDIO_OPTIONS) \
- -D GIT_DATE='"$(GIT_DATE)"' -D GIT_VERSION='"$(GIT_VERSION)"' $(DEBUG_OPTION)
-
-LIBS= -lm -lwdsp -lpthread $(AUDIO_LIBS) $(USBOZY_LIBS) $(GTKLIBS) $(SOAPYSDRLIBS) $(STEMLAB_LIBS) $(MIDI_LIBS)
-INCLUDES=$(GTKINCLUDES)
-
-COMPILE=$(CC) $(CFLAGS) $(OPTIONS) $(INCLUDES)
-
-.c.o:
- $(COMPILE) -c -o $@ $<
-
-PROGRAM=pihpsdr
-
-SOURCES= \
-audio.c \
-band.c \
-configure.c \
-discovered.c \
-discovery.c \
-filter.c \
-main.c \
-new_menu.c \
-about_menu.c \
-exit_menu.c \
-radio_menu.c \
-rx_menu.c \
-ant_menu.c \
-display_menu.c \
-dsp_menu.c \
-pa_menu.c \
-cw_menu.c \
-oc_menu.c \
-portaudio.c \
-xvtr_menu.c \
-equalizer_menu.c \
-step_menu.c \
-meter_menu.c \
-band_menu.c \
-bandstack_menu.c \
-mode_menu.c \
-filter_menu.c \
-noise_menu.c \
-agc_menu.c \
-vox_menu.c \
-fft_menu.c \
-diversity_menu.c \
-tx_menu.c \
-vfo_menu.c \
-test_menu.c \
-meter.c \
-mode.c \
-old_discovery.c \
-new_discovery.c \
-old_protocol.c \
-new_protocol.c \
-new_protocol_programmer.c \
-rx_panadapter.c \
-tx_panadapter.c \
-property.c \
-radio.c \
-receiver.c \
-rigctl.c \
-rigctl_menu.c \
-toolbar.c \
-transmitter.c \
-zoompan.c \
-sliders.c \
-version.c \
-vfo.c \
-waterfall.c \
-button_text.c \
-vox.c \
-update.c \
-store.c \
-store_menu.c \
-memory.c \
-led.c \
-ext.c \
-error_handler.c \
-cwramp.c \
-protocols.c
-
-
-HEADERS= \
-audio.h \
-agc.h \
-alex.h \
-band.h \
-configure.h \
-bandstack.h \
-channel.h \
-discovered.h \
-discovery.h \
-filter.h \
-new_menu.h \
-about_menu.h \
-rx_menu.h \
-exit_menu.h \
-radio_menu.h \
-ant_menu.h \
-display_menu.h \
-dsp_menu.h \
-pa_menu.h \
-cw_menu.h \
-oc_menu.h \
-xvtr_menu.h \
-equalizer_menu.h \
-step_menu.h \
-meter_menu.h \
-band_menu.h \
-bandstack_menu.h \
-mode_menu.h \
-filter_menu.h \
-noise_menu.h \
-agc_menu.h \
-vox_menu.h \
-fft_menu.h \
-diversity_menu.h \
-tx_menu.h \
-vfo_menu.h \
-test_menu.h \
-meter.h \
-mode.h \
-old_discovery.h \
-new_discovery.h \
-old_protocol.h \
-new_protocol.h \
-rx_panadapter.h \
-tx_panadapter.h \
-property.h \
-radio.h \
-receiver.h \
-rigctl.h \
-rigctl_menu.h \
-toolbar.h \
-transmitter.h \
-zoompan.h \
-sliders.h \
-version.h \
-vfo.h \
-waterfall.h \
-button_text.h \
-vox.h \
-update.h \
-store.h \
-store_menu.h \
-memory.h \
-led.h \
-ext.h \
-error_handler.h \
-protocols.h
-
-
-OBJS= \
-audio.o \
-portaudio.o \
-band.o \
-configure.o \
-discovered.o \
-discovery.o \
-filter.o \
-version.o \
-main.o \
-new_menu.o \
-about_menu.o \
-rx_menu.o \
-exit_menu.o \
-radio_menu.o \
-ant_menu.o \
-display_menu.o \
-dsp_menu.o \
-pa_menu.o \
-cw_menu.o \
-oc_menu.o \
-xvtr_menu.o \
-equalizer_menu.o \
-step_menu.o \
-meter_menu.o \
-band_menu.o \
-bandstack_menu.o \
-mode_menu.o \
-filter_menu.o \
-noise_menu.o \
-agc_menu.o \
-vox_menu.o \
-fft_menu.o \
-diversity_menu.o \
-tx_menu.o \
-vfo_menu.o \
-test_menu.o \
-meter.o \
-mode.o \
-old_discovery.o \
-new_discovery.o \
-old_protocol.o \
-new_protocol.o \
-new_protocol_programmer.o \
-rx_panadapter.o \
-tx_panadapter.o \
-property.o \
-radio.o \
-receiver.o \
-rigctl.o \
-rigctl_menu.o \
-toolbar.o \
-transmitter.o \
-zoompan.o \
-sliders.o \
-vfo.o \
-waterfall.o \
-button_text.o \
-vox.o \
-update.o \
-store.o \
-store_menu.o \
-memory.o \
-led.o \
-ext.o \
-error_handler.o \
-cwramp.o \
-protocols.o
-
-$(PROGRAM): $(OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) $(SOAPYSDR_OBJS) \
- $(LOCALCW_OBJS) $(PURESIGNAL_OBJS) \
- $(MIDI_OBJS) $(STEMLAB_OBJS)
- $(LINK) -o $(PROGRAM) $(OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) \
- $(SOAPYSDR_OBJS) $(LOCALCW_OBJS) $(PURESIGNAL_OBJS) \
- $(MIDI_OBJS) $(STEMLAB_OBJS) $(LIBS)
-
-all: prebuild $(PROGRAM) $(HEADERS) $(REMOTE_HEADERS) $(USBOZY_HEADERS) $(SOAPYSDR_HEADERS) \
- $(LOCALCW_HEADERS) \
- $(PURESIGNAL_HEADERS) $(MIDI_HEADERS) $(STEMLAB_HEADERS) $(SOURCES) $(REMOTE_SOURCES) \
- $(USBOZY_SOURCES) $(SOAPYSDR_SOURCES) \
- $(PURESIGNAL_SOURCES) $(MIDI_SOURCES) $(STEMLAB_SOURCES) $(LOCALCW_SOURCES)
-
-prebuild:
- rm -f version.o
-
-#
-# On some platforms, INCLUDES contains "-pthread" (from a pkg-config output)
-# which is not a valid cppcheck option
-# Therefore, correct this here. Furthermore, we can add additional options to CPP
-# in the variable CPPOPTIONS
-#
-CPPOPTIONS= --enable=all --suppress=shadowVariable --suppress=variableScope -D__APPLE__
-CPPINCLUDES:=$(shell echo $(INCLUDES) | sed -e "s/-pthread / /" )
-
-.PHONY: cppcheck
-cppcheck:
- cppcheck $(CPPOPTIONS) $(OPTIONS) $(CPPINCLUDES) $(SOURCES) $(REMOTE_SOURCES) \
- $(USBOZY_SOURCES) $(SOAPYSDR_SOURCES) \
- $(PURESIGNAL_SOURCES) $(MIDI_SOURCES) $(STEMLAB_SOURCES) $(LOCALCW_SOURCES)
-
-clean:
- -rm -f *.o
- -rm -f $(PROGRAM) hpsdrsim
- -rm -rf $(PROGRAM).app
-
-install: $(PROGRAM)
- cp $(PROGRAM) /usr/local/bin
-
-release: $(PROGRAM)
- cp $(PROGRAM) release/pihpsdr
- cd release; tar cvf pihpsdr.tar pihpsdr
- cd release; tar cvf pihpsdr-$(GIT_VERSION).tar pihpsdr
-
-nocontroller: clean controller1 $(PROGRAM)
- cp $(PROGRAM) release/pihpsdr
- cd release; tar cvf pihpsdr-nocontroller.$(GIT_VERSION).tar pihpsdr
-
-controller1: clean $(PROGRAM)
- cp $(PROGRAM) release/pihpsdr
- cd release; tar cvf pihpsdr-controller1.$(GIT_VERSION).tar pihpsdr
-
-controller2v1: clean $(PROGRAM)
- cp $(PROGRAM) release/pihpsdr
- cd release; tar cvf pihpsdr-controller2-v1.$(GIT_VERSION).tar pihpsdr
-
-controller2v2: clean $(PROGRAM)
- cp $(PROGRAM) release/pihpsdr
- cd release; tar cvf pihpsdr-controller2-v2.$(GIT_VERSION).tar pihpsdr
-
-
-#############################################################################
-#
-# hpsdrsim is a cool program that emulates an SDR board with UDP and TCP
-# facilities. It even feeds back the TX signal and distorts it, so that
-# you can test PURESIGNAL.
-# This feature only works if the sample rate is 48000
-#
-#############################################################################
-
-hpsdrsim.o: hpsdrsim.c hpsdrsim.h
- $(CC) -c -O -DPORTAUDIO hpsdrsim.c
-
-newhpsdrsim.o: newhpsdrsim.c hpsdrsim.h
- $(CC) -c -O newhpsdrsim.c
-
-hpsdrsim: hpsdrsim.o newhpsdrsim.o
- $(LINK) -o hpsdrsim hpsdrsim.o newhpsdrsim.o -lportaudio -lm -lpthread
-
-#############################################################################
-#
-# This is for MacOS "app" creation ONLY
-#
-# Note: Note that we need a wrapper script to start the program, and
-# that it requires a working GTK installation on the Mac.
-# The program will not work if the
-# libgtk, libgdk, libglib, libgobj, libgio libraries
-# are copied to the Frameworks dir and "activated", because
-# this stuff depends on tons of other files in /usr/local.
-#
-# We bundle the "app" with the other libraries such as WDSP,
-# portaudio, fftw etc. such that the "app" runs on Macs which
-# do not have them. But it is *very* hard to do this with GTK.
-#
-# piHPSDR working dir
-# ===================
-#
-# The piHPSDR working directory is
-# $HOME -> Application Support -> piHPSDR
-#
-# That is the directory where the WDSP wisdom file (created upon first
-# start of piHPSDR) but also the radio settings and the midi.props file
-# are stored.
-#
-#############################################################################
-app: $(OBJS) $(REMOTE_OBJS) $(USBOZY_OBJS) \
- $(LOCALCW_OBJS) \
- $(PURESIGNAL_OBJS) $(MIDI_OBJS) $(STEMLAB_OBJS)
- $(LINK) -headerpad_max_install_names -o $(PROGRAM) $(OBJS) $(REMOTE_OBJS) \
- $(USBOZY_OBJS) \
- $(LOCALCW_OBJS) $(PURESIGNAL_OBJS) \
- $(MIDI_OBJS) $(STEMLAB_OBJS) $(LIBS)
- @rm -rf pihpsdr.app
- @mkdir -p pihpsdr.app/Contents/MacOS
- @mkdir -p pihpsdr.app/Contents/Frameworks
- @mkdir -p pihpsdr.app/Contents/Resources
- @cp pihpsdr pihpsdr.app/Contents/MacOS/pihpsdr-bin
- @cp MacOS/PkgInfo pihpsdr.app/Contents
- @cp MacOS/Info.plist pihpsdr.app/Contents
- @cp MacOS/hpsdr.icns pihpsdr.app/Contents/Resources/hpsdr.icns
- @cp MacOS/pihpsdr.sh pihpsdr.app/Contents/MacOS/pihpsdr
- @cp MacOS/hpsdr.png pihpsdr.app/Contents/Resources
- @for lib in `otool -L pihpsdr.app/Contents/MacOS/pihpsdr-bin | grep dylib | sed -e "s/ (.*//" | grep -Ev "/(usr/lib|System)" | grep -Ev /libg | grep -Ev pango | grep -Ev cairo`; do \
- libfn="`basename $$lib`"; \
- cp "$$lib" "pihpsdr.app/Contents/Frameworks/$$libfn"; \
- chmod u+w "pihpsdr.app/Contents/Frameworks/$$libfn"; \
- install_name_tool -id "@executable_path/../Frameworks/$$libfn" "pihpsdr.app/Contents/Frameworks/$$libfn"; \
- install_name_tool -change "$$lib" "@executable_path/../Frameworks/$$libfn" pihpsdr.app/Contents/MacOS/pihpsdr-bin; \
- done
- @# once more to install libraries on which libs just copied depend (such as wdsp -> fftw)
- @for file in pihpsdr.app/Contents/Frameworks/*.dylib; do \
- for lib in `otool -L pihpsdr.app/Contents/Frameworks/*.dylib | grep -v pihpsdr.app | grep -v "executable_path" | grep dylib | sed -e "s/ (.*//" | grep -Ev "/(usr/lib|System)" | grep -Ev /libg | grep -Ev pango | grep -Ev cairo`; do \
- libfn="`basename $$lib`"; \
- cp "$$lib" "pihpsdr.app/Contents/Frameworks/$$libfn"; \
- chmod u+w "pihpsdr.app/Contents/Frameworks/$$libfn"; \
- install_name_tool -id "@executable_path/../Frameworks/$$libfn" "pihpsdr.app/Contents/Frameworks/$$libfn"; \
- install_name_tool -change "$$lib" "@executable_path/../Frameworks/$$libfn" $$file; \
- done; \
- done
-#############################################################################
-
gint attenuation;
gboolean enable_step_attenuation;
#ifdef SOAPYSDR
- gint *rx_gain;
+ gdouble gain;
gboolean agc;
#endif
} ADC;
* program amidi.c in alsautils.
*/
+#include <gtk/gtk.h>
+
#include "midi.h"
+#include "midi_menu.h"
+#include "alsa_midi.h"
#ifndef __APPLE__
static pthread_t midi_thread_id;
static void* midi_thread(void *);
+MIDI_DEVICE midi_devices[MAX_MIDI_DEVICES];
+int n_midi_devices;
+int running;
+
static char portname[64];
static enum {
CMD_PITCH,
} command;
+static gboolean configure=FALSE;
+
+static snd_rawmidi_t *input;
+
+void configure_midi_device(gboolean state) {
+ configure=state;
+}
+
static void *midi_thread(void *arg) {
int ret;
- snd_rawmidi_t *input;
+ MIDI_DEVICE *midi_device=(MIDI_DEVICE *)arg;
int npfds;
struct pollfd *pfds;
unsigned char buf[32];
int i;
int chan,arg1,arg2;
- if ((ret = snd_rawmidi_open(&input, NULL, portname, SND_RAWMIDI_NONBLOCK)) < 0) {
- fprintf(stderr,"cannot open port \"%s\": %s\n", portname, snd_strerror(ret));
+ /*
+ if ((ret = snd_rawmidi_open(&input, NULL, midi_device->port, SND_RAWMIDI_NONBLOCK)) < 0) {
+ fprintf(stderr,"cannot open port \"%s\": %s\n", midi_device->port, snd_strerror(ret));
return NULL;
}
+ */
+
+ running=1;
+
snd_rawmidi_read(input, NULL, 0); /* trigger reading */
npfds = snd_rawmidi_poll_descriptors_count(input);
pfds = alloca(npfds * sizeof(struct pollfd));
snd_rawmidi_poll_descriptors(input, pfds, npfds);
- for (;;) {
+ while (running) {
ret = poll(pfds, npfds, 250);
if (ret < 0) {
fprintf(stderr,"poll failed: %s\n", strerror(errno));
// Do not give up, but also do not fire too rapidly
usleep(250000);
}
+ if(!running) continue;
if (ret <= 0) continue; // nothing arrived, do next poll()
if ((ret = snd_rawmidi_poll_descriptors_revents(input, pfds, npfds, &revents)) < 0) {
fprintf(stderr,"cannot get poll events: %s\n", snd_strerror(errno));
// messages with velocity == 0 when releasing
// a push-button
if (arg2 == 0) {
- NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_NOTE, chan, arg1, 0);
+ } else {
+ NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ }
} else {
- NewMidiEvent(MIDI_NOTE, chan, arg1, 1);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_NOTE, chan, arg1, 1);
+ } else {
+ NewMidiEvent(MIDI_NOTE, chan, arg1, 1);
+ }
}
break;
case CMD_NOTEOFF:
- NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_NOTE, chan, arg1, 0);
+ } else {
+ NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ }
break;
case CMD_CTRL:
- NewMidiEvent(MIDI_CTRL, chan, arg1, arg2);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_CTRL, chan, arg1, arg2);
+ } else {
+ NewMidiEvent(MIDI_CTRL, chan, arg1, arg2);
+ }
break;
case CMD_PITCH:
- NewMidiEvent(MIDI_PITCH, chan, 0, arg1+128*arg2);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_PITCH, chan, 0, arg1+128*arg2);
+ } else {
+ NewMidiEvent(MIDI_PITCH, chan, 0, arg1+128*arg2);
+ }
break;
}
state=STATE_SKIP;
}
}
-void register_midi_device(char *myname) {
+int register_midi_device(char *myname) {
+ int i;
+ int ret=0;
+
+ configure=FALSE;
+
+ for(i=0;i<n_midi_devices;i++) {
+ if(strcmp(myname,midi_devices[i].name)==0) {
+ strcpy(portname,midi_devices[i].port);
+ if ((ret = snd_rawmidi_open(&input, NULL, midi_devices[i].port, SND_RAWMIDI_NONBLOCK)) < 0) {
+ g_print("%s: cannot open port \"%s\": %s\n", __FUNCTION__, midi_devices[i].port, snd_strerror(ret));
+ break;
+ }
+
+ g_print("%s: %s Opened\n",__FUNCTION__,myname);
+
+ ret = pthread_create(&midi_thread_id, NULL, midi_thread, &midi_devices[i]);
+ if (ret < 0) {
+ g_print("%s: Failed to create MIDI read thread\n",__FUNCTION__);
+ }
+ break;
+ }
+ }
+ if(i>=n_midi_devices) {
+ g_print("%s: Cannot find MIDI device: %s\n",__FUNCTION__,myname);
+ ret=-1;
+ }
+}
+
+void close_midi_device() {
+ int ret;
+
+ g_print("%s\n",__FUNCTION__);
+ if(input!=NULL) {
+ g_print("%s: snd_rawmidi_close\n",__FUNCTION__);
+ running=0;
+ if((ret = snd_rawmidi_close(input)) < 0) {
+ g_print("%s: cannot close port: %s\n",__FUNCTION__, snd_strerror(ret));
+ }
+ input=NULL;
+ usleep(250000L);
+ }
+}
+
+void get_midi_devices() {
- int mylen=strlen(myname);
snd_ctl_t *ctl;
snd_rawmidi_info_t *info;
int card, device, subs, sub, ret;
int found=0;
char name[64];
+ n_midi_devices=0;
card=-1;
if ((ret = snd_card_next(&card)) < 0) {
fprintf(stderr,"cannot determine card number: %s\n", snd_strerror(ret));
return;
}
while (card >= 0) {
- fprintf(stderr,"Found Sound Card=%d\n",card);
+ //fprintf(stderr,"Found Sound Card=%d\n",card);
sprintf(name,"hw:%d", card);
if ((ret = snd_ctl_open(&ctl, name, 0)) < 0) {
fprintf(stderr,"cannot open control for card %d: %s\n", card, snd_strerror(ret));
break;
}
if (device < 0) break;
- fprintf(stderr,"Found Device=%d on Card=%d\n", device, card);
+ //fprintf(stderr,"Found Device=%d on Card=%d\n", device, card);
// found sub-device
snd_rawmidi_info_alloca(&info);
snd_rawmidi_info_set_device(info, device);
} else {
subs = 0;
}
- fprintf(stderr,"Number of MIDI input devices: %d\n", subs);
+ //fprintf(stderr,"Number of MIDI input devices: %d\n", subs);
if (!subs) break;
// subs: number of sub-devices to device on card
for (sub = 0; sub < subs; ++sub) {
sprintf(portname,"hw:%d,%d,%d", card, device, sub);
devnam=subnam;
}
- if (!strncmp(myname, devnam, mylen)) {
- found=1;
- fprintf(stderr,"MIDI device %s selected (PortName=%s)\n", devnam, portname);
- } else {
- fprintf(stderr,"MIDI device found BUT NOT SELECTED: %s\n", devnam);
- }
+
+ midi_devices[n_midi_devices].name=g_new(gchar,strlen(devnam)+1);
+ strcpy(midi_devices[n_midi_devices].name,devnam);
+
+ midi_devices[n_midi_devices].port=g_new(gchar,strlen(portname)+1);
+ strcpy(midi_devices[n_midi_devices].port,portname);
+ n_midi_devices++;
}
}
snd_ctl_close(ctl);
break;
}
}
- if (!found) {
- fprintf(stderr,"MIDI device %s NOT FOUND!\n", myname);
- return;
- }
- // Found our MIDI input device. Spawn off a thread reading data
- ret = pthread_create(&midi_thread_id, NULL, midi_thread, NULL);
- if (ret < 0) {
- fprintf(stderr,"Failed to create MIDI read thread\n");
+
+ for(int i=0;i<n_midi_devices;i++) {
+ g_print("%s: %d: %s %s\n",__FUNCTION__,i,midi_devices[i].name,midi_devices[i].port);
}
}
#endif
#include "receiver.h"
#include "vfo.h"
#include "button_text.h"
+#ifdef CLIENT_SERVER
#include "client_server.h"
+#endif
static GtkWidget *parent_window=NULL;
typedef struct _dac {
gint antenna;
- gint *tx_gain;
+ gdouble gain;
} DAC;
#endif
char hardware_key[64];
char driver_key[64];
int rtlsdr_count;
+ int sdrplay_count;
int sample_rate;
size_t rx_channels;
size_t rx_gains;
SoapySDRRange *tx_range;
size_t tx_antennas;
char **tx_antenna;
+ size_t sensors;
+ char **sensor;
+ gboolean has_temp;
+ char address[64];
} soapy;
#endif
} info;
break;
#ifdef SOAPYSDR
case SOAPYSDR_PROTOCOL:
- sprintf(text,"%s (Protocol SOAPY_SDR %s) on USB",d->name,d->info.soapy.version);
+ sprintf(text,"%s (Protocol SOAPY_SDR %s) on %s",d->name,d->info.soapy.version,d->info.soapy.address);
break;
+
#endif
#ifdef STEMLAB_DISCOVERY
case STEMLAB_PROTOCOL:
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(gpio),NULL,"Controller1");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(gpio),NULL,"Controller2 V1");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(gpio),NULL,"Controller2 V2");
- gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(gpio),NULL,"Controller I2C");
+ //gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(gpio),NULL,"Controller I2C");
gtk_grid_attach(GTK_GRID(grid),gpio,0,row,1,1);
gtk_combo_box_set_active(GTK_COMBO_BOX(gpio),controller);
g_signal_connect (protocols_b, "button-press-event", G_CALLBACK(protocols_cb), NULL);
gtk_grid_attach(GTK_GRID(grid),protocols_b,2,row,1,1);
+/*
#ifdef MIDI
GtkWidget *midi_b=gtk_button_new_with_label("ImportMIDI");
g_signal_connect (midi_b, "button-press-event", G_CALLBACK(midi_cb), NULL);
gtk_grid_attach(GTK_GRID(grid),midi_b,3,row,1,1);
#endif
-
+*/
row++;
#ifdef GPIO
col++;
- if(controller!=CONTROLLER_I2C) {
- GtkWidget *b_display_sliders=gtk_check_button_new_with_label("Display Sliders");
- //gtk_widget_override_font(b_display_sliders, pango_font_description_from_string("Arial 18"));
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_display_sliders), display_sliders);
- gtk_widget_show(b_display_sliders);
- gtk_grid_attach(GTK_GRID(grid),b_display_sliders,col,row,1,1);
- g_signal_connect(b_display_sliders,"toggled",G_CALLBACK(display_sliders_cb),(gpointer *)NULL);
-
- col++;
-
- GtkWidget *b_display_toolbar=gtk_check_button_new_with_label("Display Toolbar");
- //gtk_widget_override_font(b_display_toolbar, pango_font_description_from_string("Arial 18"));
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_display_toolbar), display_toolbar);
- gtk_widget_show(b_display_toolbar);
- gtk_grid_attach(GTK_GRID(grid),b_display_toolbar,col,row,1,1);
- g_signal_connect(b_display_toolbar,"toggled",G_CALLBACK(display_toolbar_cb),(gpointer *)NULL);
-
- col++;
- }
+ GtkWidget *b_display_sliders=gtk_check_button_new_with_label("Display Sliders");
+ //gtk_widget_override_font(b_display_sliders, pango_font_description_from_string("Arial 18"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_display_sliders), display_sliders);
+ gtk_widget_show(b_display_sliders);
+ gtk_grid_attach(GTK_GRID(grid),b_display_sliders,col,row,1,1);
+ g_signal_connect(b_display_sliders,"toggled",G_CALLBACK(display_sliders_cb),(gpointer *)NULL);
+
+ col++;
+
+ GtkWidget *b_display_toolbar=gtk_check_button_new_with_label("Display Toolbar");
+ //gtk_widget_override_font(b_display_toolbar, pango_font_description_from_string("Arial 18"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_display_toolbar), display_toolbar);
+ gtk_widget_show(b_display_toolbar);
+ gtk_grid_attach(GTK_GRID(grid),b_display_toolbar,col,row,1,1);
+ g_signal_connect(b_display_toolbar,"toggled",G_CALLBACK(display_toolbar_cb),(gpointer *)NULL);
+
+ col++;
GtkWidget *b_display_sequence_errors=gtk_check_button_new_with_label("Display Seq Errs");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_display_sequence_errors), display_sequence_errors);
// The following calls functions can be called usig g_idle_add
+int ext_menu_filter(void *data) {
+ start_filter();
+ return 0;
+}
+
+int ext_menu_mode(void *data) {
+ start_mode();
+ return 0;
+}
+
+int ext_num_pad(void *data) {
+ gint val=GPOINTER_TO_INT(data);
+ RECEIVER *rx=active_receiver;
+ if(!vfo[rx->id].entering_frequency) {
+ vfo[rx->id].entered_frequency=0;
+ vfo[rx->id].entering_frequency=TRUE;
+ }
+ switch(val) {
+ case -1: // clear
+ vfo[rx->id].entered_frequency=0;
+ vfo[rx->id].entering_frequency=FALSE;
+ break;
+ case -2: // enter
+ if(vfo[rx->id].entered_frequency!=0) {
+ vfo[rx->id].frequency=vfo[rx->id].entered_frequency;
+ if(vfo[rx->id].ctun) {
+ vfo[rx->id].ctun=FALSE;
+ vfo[rx->id].offset=0;
+ vfo[rx->id].ctun_frequency=vfo[rx->id].frequency;
+ }
+ }
+ vfo[rx->id].entering_frequency=FALSE;
+ break;
+ default:
+ vfo[rx->id].entered_frequency=(vfo[rx->id].entered_frequency*10)+val;
+ break;
+ }
+ vfo_update(rx);
+ return 0;
+}
+
int ext_vfo_mode_changed(void * data)
{
int mode=GPOINTER_TO_INT(data);
}
}
+int ext_band_select(void *data) {
+ int b=GPOINTER_TO_INT(data);
+ g_print("%s: %d\n",__FUNCTION__,b);
+ vfo_band_changed(active_receiver->id,b);
+ return 0;
+}
+
int ext_band_plus(void *data) {
band_plus(active_receiver->id);
return 0;
extern int ext_receiver_remote_update_display(void *data);
#endif
+extern int ext_menu_filter(void *data);
+extern int ext_menu_mode(void *data);
+extern int ext_num_pad(void *data);
extern void local_set_frequency(int v,long long f);
extern int ext_discovery(void *data);
extern int ext_vfo_update(void *data);
extern int ext_nb_update(void *data);
extern int ext_snb_update(void *data);
extern int ext_anf_update(void *data);
+extern int ext_band_select(void *data);
extern void band_plus(int id);
extern int ext_band_plus(void *data);
extern void band_minus(int id);
/* Copyright (C)
* 2020 - John Melton, G0ORX/N6LYT
-*
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
#include <poll.h>
#include <sched.h>
+#ifdef GPIO
#include <gpiod.h>
#include <linux/i2c-dev.h>
#include <i2c/smbus.h>
#include <sys/ioctl.h>
+#endif
#include "band.h"
#include "channel.h"
#include "ext.h"
#include "sliders.h"
#include "new_protocol.h"
+#include "zoompan.h"
#ifdef LOCALCW
#include "iambic.h"
+
+//
+// Broadcom pins #9, 10, 11 are not used
+// by Controller1 and Controller2_V1
+// (and keep #2,3 reserved for I2C extensions)
+//
+int CWL_BUTTON=9;
+int CWR_BUTTON=11;
+int SIDETONE_GPIO=10;
+int ENABLE_GPIO_SIDETONE=0;
+int ENABLE_CW_BUTTONS=1;
+int CW_ACTIVE_LOW=1;
+#endif
+
+#ifdef PTT
+int ENABLE_PTT_GPIO=1;
+int PTT_GPIO=14;
+int PTT_ACTIVE_LOW=1;
#endif
-#include "zoompan.h"
enum {
TOP_ENCODER,
B
};
+#ifdef GPIO
char *consumer="pihpsdr";
char *gpio_device="/dev/gpiochip0";
static struct gpiod_chip *chip=NULL;
-//static struct gpiod_line *line=NULL;
+#endif
static GMutex encoder_mutex;
static GThread *monitor_thread_id;
return 0;
}
+#ifdef GPIO
static unsigned long switch_debounce;
static void process_encoder(int e,int l,int addr,int val) {
gint i;
gint t;
gboolean found;
- // check encoders
+
found=FALSE;
+#ifdef LOCALCW
+ if(ENABLE_CW_BUTTONS) {
+ if(offset==CWL_BUTTON) {
+ keyer_event(1, CW_ACTIVE_LOW ? (value==PRESSED) : value);
+ found=TRUE;
+ } else if(offset==CWR_BUTTON) {
+ keyer_event(1, CW_ACTIVE_LOW ? (value==PRESSED) : value);
+ found=TRUE;
+ }
+ }
+ if(found) return;
+#endif
+ // check encoders
for(i=0;i<MAX_ENCODERS;i++) {
if(encoders[i].bottom_encoder_enabled && encoders[i].bottom_encoder_address_a==offset) {
//g_print("%s: found %d encoder %d bottom A\n",__FUNCTION__,offset,i);
}
return GPIOD_CTXLESS_EVENT_CB_RET_OK;
}
+#endif
void gpio_set_defaults(int ctrlr) {
int i;
encoders=encoders_controller2_v2;
switches=switches_controller2_v2;
break;
- case CONTROLLER_I2C:
- encoders=encoders_no_controller;
- switches=switches_no_controller;
- break;
}
}
}
}
+#ifdef GPIO
static gpointer monitor_thread(gpointer arg) {
struct timespec t;
config.consumer=consumer;
config.request_type=GPIOD_LINE_REQUEST_DIRECTION_INPUT | GPIOD_LINE_REQUEST_EVENT_BOTH_EDGES;
-#ifdef RASPBIAN
+#ifdef OLD_GPIOD
config.flags=pullup?GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW:0;
#else
config.flags=pullup?GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP:GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN;
return 0;
}
+static int setup_output_line(struct gpiod_chip *chip, int offset, int _initial_value) {
+ int ret;
+ struct gpiod_line_request_config config;
+
+ g_print("%s: %d\n",__FUNCTION__,offset);
+ struct gpiod_line *line=gpiod_chip_get_line(chip, offset);
+ if (!line) {
+ g_print("%s: get line %d failed: %s\n",__FUNCTION__,offset,g_strerror(errno));
+ return -1;
+ }
+
+ config.consumer=consumer;
+ config.request_type=GPIOD_LINE_REQUEST_DIRECTION_OUTPUT;
+ ret=gpiod_line_request(line,&config,1);
+ if (ret<0) {
+ g_print("%s: line %d gpiod_line_request failed: %s\n",__FUNCTION__,offset,g_strerror(errno));
+ return ret;
+ }
+
+ // write initial value
+
+
+ gpiod_line_release(line);
+
+ return 0;
+}
+#endif
+
int gpio_init() {
int ret=0;
+#ifdef GPIO
initialiseEpoch();
switch_debounce=millis();
}
}
- if(controller!=NO_CONTROLLER && controller!=CONTROLLER_I2C) {
+#ifdef LOCALCW
+ g_print("%s: ENABLE_CW_BUTTONS=%d CWL_BUTTON=%d CWR_BUTTON=%d\n", __FUNCTION__, ENABLE_CW_BUTTONS, CWL_BUTTON, CWR_BUTTON);
+ if(ENABLE_CW_BUTTONS) {
+ if((ret=setup_line(chip,CWL_BUTTON,CW_ACTIVE_LOW==1))<0) {
+ goto err;
+ }
+ monitor_lines[lines]=CWL_BUTTON;
+ lines++;
+ if((ret=setup_line(chip,CWR_BUTTON,CW_ACTIVE_LOW==1))<0) {
+ goto err;
+ }
+ monitor_lines[lines]=CWR_BUTTON;
+ lines++;
+
+ }
+ if (ENABLE_GPIO_SIDETONE) {
+//
+// use this pin as an output pin and
+// set its value to LOW
+//
+ if((ret=setup_output_line(chip,SIDETONE_GPIO,0))<0) {
+ goto err;
+ }
+ }
+#endif
+
+ if(controller!=NO_CONTROLLER
+#ifdef LOCALCW
+ || ENABLE_CW_BUTTONS
+#endif
+ ) {
monitor_thread_id = g_thread_new( "gpiod monitor", monitor_thread, NULL);
if(!monitor_thread_id ) {
g_print("%s: g_thread_new failed for monitor_thread\n",__FUNCTION__);
}
- rotary_encoder_thread_id = g_thread_new( "encoders", rotary_encoder_thread, NULL);
- if(!rotary_encoder_thread_id ) {
- g_print("%s: g_thread_new failed on rotary_encoder_thread\n",__FUNCTION__);
- exit( -1 );
+ if(controller!=NO_CONTROLLER) {
+ rotary_encoder_thread_id = g_thread_new( "encoders", rotary_encoder_thread, NULL);
+ if(!rotary_encoder_thread_id ) {
+ g_print("%s: g_thread_new failed on rotary_encoder_thread\n",__FUNCTION__);
+ exit( -1 );
+ }
+ g_print("%s: rotary_encoder_thread: id=%p\n",__FUNCTION__,rotary_encoder_thread_id);
}
- g_print("%s: rotary_encoder_thread: id=%p\n",__FUNCTION__,rotary_encoder_thread_id);
}
-
+#endif
return 0;
err:
g_print("%s: err\n",__FUNCTION__);
+#ifdef GPIO
if(chip!=NULL) {
gpiod_chip_close(chip);
chip=NULL;
}
+#endif
return ret;
}
void gpio_close() {
+#ifdef GPIO
if(chip!=NULL) gpiod_chip_close(chip);
+#endif
}
#ifdef LOCALCW
void gpio_cw_sidetone_set(int level) {
+ int rc;
+ if (ENABLE_GPIO_SIDETONE) {
+ if((rc=gpiod_ctxless_set_value_ext(gpio_device,SIDETONE_GPIO,level,FALSE,consumer,NULL,NULL,0))<0) {
+ g_print("%s: err=%d\n",__FUNCTION__,rc);
+ }
+ }
}
int gpio_left_cw_key() {
}
int gpio_cw_sidetone_enabled() {
+ return ENABLE_GPIO_SIDETONE;
}
#endif
extern void gpio_save_actions();
extern int gpio_init();
extern void gpio_close();
+
+#ifdef LOCALCW
+extern int CWL_BUTTON;
+extern int CWR_BUTTON;
+extern int SIDETONE_GPIO;
+extern int ENABLE_GPIO_SIDETONE;
+extern int ENABLE_CW_BUTTONS;
+extern int CW_ACTIVE_LOW;
+extern void gpio_cw_sidetone_set(int level);
+extern int gpio_left_cw_key();
+extern int gpio_right_cw_key();
+extern int gpio_cw_sidetone_enabled();
+#endif
+
#endif
+#ifdef GPIO
#include <string.h>
#include <unistd.h>
#include <errno.h>
} while(flags!=0);
}
+#endif
**************************************************************************************************************
*/
+#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/mman.h>
-#ifdef GPIO
+#ifdef LOCALCW
#include "gpio.h"
#endif
#include "radio.h"
*
*/
+#include <gtk/gtk.h>
+#include "discovered.h"
+#include "receiver.h"
+#include "transmitter.h"
+#include "receiver.h"
+#include "adc.h"
+#include "dac.h"
+#include "radio.h"
#include "midi.h"
+#include "midi_menu.h"
#ifdef __APPLE__
+typedef struct _midi_device {
+ char *name;
+ char *port;
+} MIDI_DEVICE;
+
+#define MAX_MIDI_DEVICES 10
+
+MIDI_DEVICE midi_devices[MAX_MIDI_DEVICES];
+int n_midi_devices;
+
+
/*
* For MacOS, things are easy:
* The OS takes care of everything, we only have to register a callback
#include <CoreAudio/HostTime.h>
#include <CoreAudio/CoreAudio.h>
+MIDI_DEVICE midi_devices[MAX_MIDI_DEVICES];
+int n_midi_devices;
+int running;
+
//
// MIDI callback function
// called by MacOSX when data from the specified MIDI device arrives.
CMD_PITCH,
} command;
+static gboolean configure=FALSE;
+
static void ReadMIDIdevice(const MIDIPacketList *pktlist, void *refCon, void *connRefCon) {
int i,j,byte,chan,arg1,arg2;
MIDIPacket *packet = (MIDIPacket *)pktlist->packet;
// messages with velocity == 0 when releasing
// a push-button.
if (arg2 == 0) {
- NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_NOTE, chan, arg1, 0);
+ } else {
+ NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ }
} else {
- NewMidiEvent(MIDI_NOTE, chan, arg1, 1);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_NOTE, chan, arg1, 1);
+ } else {
+ NewMidiEvent(MIDI_NOTE, chan, arg1, 1);
+ }
}
break;
case CMD_NOTEOFF:
- NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_NOTE, chan, arg1, 0);
+ } else {
+ NewMidiEvent(MIDI_NOTE, chan, arg1, 0);
+ }
break;
case CMD_CTRL:
- NewMidiEvent(MIDI_CTRL, chan, arg1, arg2);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_CTRL, chan, arg1, arg2);
+ } else {
+ NewMidiEvent(MIDI_CTRL, chan, arg1, arg2);
+ }
break;
case CMD_PITCH:
- NewMidiEvent(MIDI_PITCH, chan, 0, arg1+128*arg2);
+ if(configure) {
+ NewMidiConfigureEvent(MIDI_PITCH, chan, 0, arg1+128*arg2);
+ } else {
+ NewMidiEvent(MIDI_PITCH, chan, 0, arg1+128*arg2);
+ }
break;
}
state=STATE_SKIP;
} // j-loop through the list of packets
}
+void close_midi_device() {
+ fprintf(stderr,"%s\n",__FUNCTION__);
+}
-void register_midi_device(char *myname) {
- unsigned long nDevices;
+int register_midi_device(char *myname) {
int i;
CFStringRef pname;
char name[100];
int FoundMIDIref=-1;
int mylen=strlen(myname);
+ int ret;
+ configure=false;
+ g_print("%s: %s\n",__FUNCTION__,myname);
//
// Go through the list of MIDI devices and
// look whether the one we are looking for is there
//
-
- nDevices=MIDIGetNumberOfSources();
- for (i=0; i<nDevices; i++) {
- MIDIEndpointRef dev = MIDIGetSource(i);
- if (dev != 0) {
- MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &pname);
- CFStringGetCString(pname, name, sizeof(name), 0);
- CFRelease(pname);
- fprintf(stderr,"MIDI device found: >>>%s<<<\n", name);
- if (!strncmp(name, myname, mylen)) {
- FoundMIDIref=i;
- fprintf(stderr,"MIDI device found and selected: >>>%s<<<\n", name);
- } else {
- fprintf(stderr,"MIDI device found BUT NOT SELECTED: >>>%s<<<\n", name);
- }
+ for (i=0; i<n_midi_devices; i++) {
+ if(!strncmp(midi_devices[i].name, myname, mylen)) {
+ FoundMIDIref=i;
+ fprintf(stderr,"MIDI device found and selected: >>>%s<<<\n", name);
+ } else {
+ fprintf(stderr,"MIDI device found BUT NOT SELECTED: >>>%s<<<\n", name);
}
}
MIDIClientCreate(CFSTR("piHPSDR"),NULL,NULL, &client);
MIDIInputPortCreate(client, CFSTR("FromMIDI"), ReadMIDIdevice, NULL, &myMIDIport);
MIDIPortConnectSource(myMIDIport,MIDIGetSource(FoundMIDIref), NULL);
+ ret=0;
+ } else {
+ ret=-1;
+ }
+
+ return ret;
+}
+
+void get_midi_devices() {
+ int n;
+ int i;
+ CFStringRef pname;
+ char name[100];
+ int FoundMIDIref=-1;
+
+ n=MIDIGetNumberOfSources();
+ n_midi_devices=0;
+ for (i=0; i<n; i++) {
+ MIDIEndpointRef dev = MIDIGetSource(i);
+ if (dev != 0) {
+ MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &pname);
+ CFStringGetCString(pname, name, sizeof(name), 0);
+ CFRelease(pname);
+ g_print("%s: %s\n",__FUNCTION__,name);
+ midi_devices[n_midi_devices].name=g_new(gchar,strlen(name)+1);
+ strcpy(midi_devices[n_midi_devices].name,name);
+ n_midi_devices++;
+ }
}
+ g_print("%s: devices=%d\n",__FUNCTION__,n_midi_devices);
}
+
+void configure_midi_device(gboolean state) {
+ configure=state;
+}
+
#endif
NO_CONTROLLER,
CONTROLLER1,
CONTROLLER2_V1,
- CONTROLLER2_V2,
- CONTROLLER_I2C
+ CONTROLLER2_V2
};
extern gint controller;
* must generate MIDI events on different channels
*/
+#ifndef _MIDI_H
+#define _MIDI_H
//
// MIDIaction encodes the "action" to be taken in Layer3
// (sorted alphabetically by the keyword)
ANF, // ANF: toggel ANF on/off
ATT, // ATT: Step attenuator or Programmable attenuator
VFO_B2A, // B2A: VFO B -> A
- BAND_DOWN, // BANDDOWN: cycle through bands downwards
- BAND_UP, // BANDUP: cycle through bands upwards
+ MIDI_BAND_10, // BAND10
+ MIDI_BAND_12, // BAND12
+ MIDI_BAND_1240, // BAND1240
+ MIDI_BAND_144, // BAND144
+ MIDI_BAND_15, // BAND15
+ MIDI_BAND_160, // BAND160
+ MIDI_BAND_17, // BAND17
+ MIDI_BAND_20, // BAND20
+ MIDI_BAND_220, // BAND220
+ MIDI_BAND_2300, // BAND2300
+ MIDI_BAND_30, // BAND30
+ MIDI_BAND_3400, // BAND3400
+ MIDI_BAND_40, // BAND40
+ MIDI_BAND_430, // BAND430
+ MIDI_BAND_6, // BAND6
+ MIDI_BAND_60, // BAND60
+ MIDI_BAND_70, // BAND70
+ MIDI_BAND_80, // BAND80
+ MIDI_BAND_902, // BAND902
+ MIDI_BAND_AIR, // BANDAIR
+ BAND_DOWN, // BANDDOWN
+ MIDI_BAND_GEN, // BANDGEN
+ BAND_UP, // BANDUP
+ MIDI_BAND_WWV, // BANDWWV
COMPRESS, // COMPRESS: TX compressor value
MIDI_CTUN, // CTUN: toggle CTUN on/off
VFO, // CURRVFO: change VFO frequency
- CWL, // CWL: Left paddle pressed (use with ONOFF)
- CWR, // CWR: Right paddle pressed (use with ONOFF)
+ CWLEFT, // CWL: Left paddle pressed (use with ONOFF)
+ CWRIGHT, // CWR: Right paddle pressed (use with ONOFF)
CWSPEED, // CWSPEED: Set speed of (iambic) CW keyer
DIV_COARSEGAIN, // DIVCOARSEGAIN: change DIVERSITY gain in large increments
DIV_COARSEPHASE, // DIVPHASE: change DIVERSITY phase in large increments
MIDI_DUP, // DUP: toggle duplex on/off
FILTER_DOWN, // FILTERDOWN: cycle through filters downwards
FILTER_UP, // FILTERUP: cycle through filters upwards
+ MENU_FILTER,
+ MENU_MODE,
MIDI_LOCK, // LOCK: lock VFOs, disable frequency changes
MIC_VOLUME, // MICGAIN: MIC gain
MODE_DOWN, // MODEDOWN: cycle through modes downwards
MIDI_MUTE, // MUTE: toggle mute on/off
MIDI_NB, // NOISEBLANKER: cycle through NoiseBlanker states (none, NB, NB2)
MIDI_NR, // NOISEREDUCTION: cycle through NoiseReduction states (none, NR, NR2)
+ NUMPAD_0, // NUMPAD0
+ NUMPAD_1, // NUMPAD1
+ NUMPAD_2, // NUMPAD2
+ NUMPAD_3, // NUMPAD3
+ NUMPAD_4, // NUMPAD4
+ NUMPAD_5, // NUMPAD5
+ NUMPAD_6, // NUMPAD6
+ NUMPAD_7, // NUMPAD7
+ NUMPAD_8, // NUMPAD8
+ NUMPAD_9, // NUMPAD9
+ NUMPAD_CL, // NUMPADCL
+ NUMPAD_ENTER, // NUMPADENTER
MIDI_PAN, // PAN: change panning of panadater/waterfall when zoomed
PAN_HIGH, // PANHIGH: "high" value of current panadapter
PAN_LOW, // PANLOW: "low" value of current panadapter
enum MIDItype {
TYPE_NONE=0,
- MIDI_KEY, // Button (press event)
- MIDI_KNOB, // Knob (value between 0 and 100)
- MIDI_WHEEL // Wheel (direction and speed)
+ MIDI_KEY=1, // Button (press event)
+ MIDI_KNOB=2, // Knob (value between 0 and 100)
+ MIDI_WHEEL=4 // Wheel (direction and speed)
};
+extern gchar *midi_types[];
+extern gchar *midi_events[];
+
//
// MIDIevent encodes the actual MIDI event "seen" in Layer-1 and
// passed to Layer-2. MIDI_NOTE events end up as MIDI_KEY and
// Data structure for Layer-2
//
+typedef struct _action_table {
+ enum MIDIaction action;
+ const char *str;
+ enum MIDItype type;
+} ACTION_TABLE;
+
+extern ACTION_TABLE ActionTable[];
+
//
// There is linked list of all specified MIDI events for a given "Note" value,
// which contains the defined actions for all MIDI_NOTE and MIDI_CTRL events
struct desc *next; // Next defined action for a controller/key with that note value (NULL for end of list)
};
-struct cmdtable{
+struct cmdtable {
struct desc *desc[128]; // description for Note On/Off and ControllerChange
struct desc *pitch; // description for PitchChanges
};
+extern struct cmdtable MidiCommandsTable;
+
+extern int midi_debug;
+
//
// Layer-1 entry point, called once for all the MIDI devices
// that have been defined. This is called upon startup by
// Layer-2 through the function MIDIstartup.
//
-void register_midi_device(char *name);
+int register_midi_device(char *name);
+void close_midi_device();
+void configure_midi_device(gboolean state);
//
// Layer-2 entry point (called by Layer1)
// for each device description that was successfully read.
void NewMidiEvent(enum MIDIevent event, int channel, int note, int val);
-void MIDIstartup();
+int MIDIstartup(char *filename);
+int MIDIstop();
//
// Layer-3 entry point (called by Layer2). In Layer-3, all the pihpsdr
//
void DoTheMidi(enum MIDIaction code, enum MIDItype type, int val);
+#endif
*/
#include <gtk/gtk.h>
+
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
+#include "receiver.h"
+#include "discovered.h"
+#include "adc.h"
+#include "dac.h"
+#include "transmitter.h"
+#include "radio.h"
+#include "main.h"
#include "midi.h"
+
struct cmdtable MidiCommandsTable;
void NewMidiEvent(enum MIDIevent event, int channel, int note, int val) {
static struct timespec tp, last_wheel_tp={0,0};
long delta;
-//g_print("%s:EVENT=%d CHAN=%d NOTE=%d VAL=%d\n",__FUNCTION__,event,channel,note,val);
+//g_print("%s: EVENT=%d CHAN=%d NOTE=%d VAL=%d\n",__FUNCTION__,event,channel,note,val);
if (event == MIDI_PITCH) {
desc=MidiCommandsTable.pitch;
} else {
desc=MidiCommandsTable.desc[note];
}
-//fprintf(stderr,"MIDI:init DESC=%p\n",desc);
+//g_print("%s: init DESC=%p\n",__FUNCTION__,desc);
while (desc) {
-//fprintf(stderr,"DESC=%p next=%p CHAN=%d EVENT=%d\n", desc,desc->next,desc->channel,desc->event);
+//g_print("%s: DESC=%p next=%p CHAN=%d EVENT=%d\n",__FUNCTION__,desc,desc->next,desc->channel,desc->event);
if ((desc->channel == channel || desc->channel == -1) && (desc->event == event)) {
// Found matching entry
switch (desc->event) {
}
// translate value to direction
new=0;
+ new=val-64;
+ /*
if ((val >= desc->vfl1) && (val <= desc->vfl2)) new=-100;
if ((val >= desc-> fl1) && (val <= desc-> fl2)) new=-10;
if ((val >= desc->lft1) && (val <= desc->lft2)) new=-1;
if ((val >= desc->rgt1) && (val <= desc->rgt2)) new= 1;
if ((val >= desc-> fr1) && (val <= desc-> fr2)) new= 10;
if ((val >= desc->vfr1) && (val <= desc->vfr2)) new= 100;
+ */
// fprintf(stderr,"WHEEL: val=%d new=%d thrs=%d/%d, %d/%d, %d/%d, %d/%d, %d/%d, %d/%d\n",
// val, new, desc->vfl1, desc->vfl2, desc->fl1, desc->fl2, desc->lft1, desc->lft2,
// desc->rgt1, desc->rgt2, desc->fr1, desc->fr2, desc->vfr1, desc->vfr2);
}
if (!desc) {
// Nothing found. This is nothing to worry about, but log the key to stderr
- if (event == MIDI_PITCH) fprintf(stderr, "Unassigned PitchBend Value=%d\n", val);
- if (event == MIDI_NOTE ) fprintf(stderr, "Unassigned Key Note=%d Val=%d\n", note, val);
- if (event == MIDI_CTRL ) fprintf(stderr, "Unassigned Controller Ctl=%d Val=%d\n", note, val);
+ if (event == MIDI_PITCH) g_print("%s: Unassigned PitchBend Value=%d\n",__FUNCTION__, val);
+ if (event == MIDI_NOTE ) g_print("%s: Unassigned Key Note=%d Val=%d\n",__FUNCTION__, note, val);
+ if (event == MIDI_CTRL ) g_print("%s: Unassigned Controller Ctl=%d Val=%d\n",__FUNCTION__, note, val);
}
}
+gchar *midi_types[] = {"NONE","KEY","KNOB/SLIDER","*INVALID*","WHEEL"};
+gchar *midi_events[] = {"NONE","NOTE","CTRL","PITCH"};
+
/*
* This data structre connects names as used in the midi.props file with
* our MIDIaction enum values.
* a match for "VFO" when the key word is "VFOA".
*/
+/*
static struct {
enum MIDIaction action;
const char *str;
+ enum MIDItype type;
} ActionTable[] = {
- { VFO_A2B, "A2B"},
- { MIDI_AF_GAIN, "AFGAIN"},
- { AGCATTACK, "AGCATTACK"},
- { MIDI_AGC, "AGCVAL"},
- { ANF, "ANF"},
- { ATT, "ATT"},
- { VFO_B2A, "B2A"},
- { BAND_DOWN, "BANDDOWN"},
- { BAND_UP, "BANDUP"},
- { COMPRESS, "COMPRESS"},
- { MIDI_CTUN, "CTUN"},
- { VFO, "CURRVFO"},
- { CWL, "CWL"},
- { CWR, "CWR"},
- { CWSPEED, "CWSPEED"},
- { DIV_COARSEGAIN, "DIVCOARSEGAIN"},
- { DIV_COARSEPHASE, "DIVCOARSEPHASE"},
- { DIV_FINEGAIN, "DIVFINEGAIN"},
- { DIV_FINEPHASE, "DIVFINEPHASE"},
- { DIV_GAIN, "DIVGAIN"},
- { DIV_PHASE, "DIVPHASE"},
- { DIV_TOGGLE, "DIVTOGGLE"},
- { MIDI_DUP, "DUP"},
- { FILTER_DOWN, "FILTERDOWN"},
- { FILTER_UP, "FILTERUP"},
- { MIDI_LOCK, "LOCK"},
- { MIC_VOLUME, "MICGAIN"},
- { MODE_DOWN, "MODEDOWN"},
- { MODE_UP, "MODEUP"},
- { MIDI_MOX, "MOX"},
- { MIDI_MUTE, "MUTE"},
- { MIDI_NB, "NOISEBLANKER"},
- { MIDI_NR, "NOISEREDUCTION"},
- { MIDI_PAN, "PAN"},
- { PAN_HIGH, "PANHIGH"},
- { PAN_LOW, "PANLOW"},
- { PRE, "PREAMP"},
- { MIDI_PS, "PURESIGNAL"},
- { MIDI_RF_GAIN, "RFGAIN"},
- { TX_DRIVE, "RFPOWER"},
- { MIDI_RIT_CLEAR, "RITCLEAR"},
- { RIT_STEP, "RITSTEP"},
- { RIT_TOGGLE, "RITTOGGLE"},
- { RIT_VAL, "RITVAL"},
- { MIDI_SAT, "SAT"},
- { SNB, "SNB"},
- { MIDI_SPLIT, "SPLIT"},
- { SWAP_RX, "SWAPRX"},
- { SWAP_VFO, "SWAPVFO"},
- { MIDI_TUNE, "TUNE"},
- { VFOA, "VFOA"},
- { VFOB, "VFOB"},
- { VFO_STEP_UP, "VFOSTEPUP"},
- { VFO_STEP_DOWN, "VFOSTEPDOWN"},
- { VOX, "VOX"},
- { VOXLEVEL, "VOXLEVEL"},
- { MIDI_XIT_CLEAR, "XITCLEAR"},
- { XIT_VAL, "XITVAL"},
- { MIDI_ZOOM, "ZOOM"},
- { ZOOM_UP, "ZOOMUP"},
- { ZOOM_DOWN, "ZOOMDOWN"},
- { ACTION_NONE, "NONE"}
+*/
+ACTION_TABLE ActionTable[] = {
+ { ACTION_NONE, "NONE", TYPE_NONE},
+ { VFO_A2B, "A2B", MIDI_KEY},
+ { MIDI_AF_GAIN, "AFGAIN", MIDI_KNOB|MIDI_WHEEL},
+ { AGCATTACK, "AGCATTACK", MIDI_KEY},
+ { MIDI_AGC, "AGCVAL", MIDI_KNOB|MIDI_WHEEL},
+ { ANF, "ANF", MIDI_KEY},
+ { ATT, "ATT", MIDI_KNOB|MIDI_WHEEL},
+ { VFO_B2A, "B2A", MIDI_KEY},
+ { MIDI_BAND_10, "BAND10", MIDI_KEY},
+ { MIDI_BAND_12, "BAND12", MIDI_KEY},
+ { MIDI_BAND_1240, "BAND1240", MIDI_KEY},
+ { MIDI_BAND_144, "BAND144", MIDI_KEY},
+ { MIDI_BAND_15, "BAND15", MIDI_KEY},
+ { MIDI_BAND_160, "BAND160", MIDI_KEY},
+ { MIDI_BAND_17, "BAND17", MIDI_KEY},
+ { MIDI_BAND_20, "BAND20", MIDI_KEY},
+ { MIDI_BAND_220, "BAND220", MIDI_KEY},
+ { MIDI_BAND_2300, "BAND2300", MIDI_KEY},
+ { MIDI_BAND_30, "BAND30", MIDI_KEY},
+ { MIDI_BAND_3400, "BAND3400", MIDI_KEY},
+ { MIDI_BAND_40, "BAND40", MIDI_KEY},
+ { MIDI_BAND_430, "BAND430", MIDI_KEY},
+ { MIDI_BAND_6, "BAND6", MIDI_KEY},
+ { MIDI_BAND_60, "BAND60", MIDI_KEY},
+ { MIDI_BAND_70, "BAND70", MIDI_KEY},
+ { MIDI_BAND_80, "BAND80", MIDI_KEY},
+ { MIDI_BAND_902, "BAND902", MIDI_KEY},
+ { MIDI_BAND_AIR, "BANDAIR", MIDI_KEY},
+ { BAND_DOWN, "BANDDOWN", MIDI_KEY},
+ { MIDI_BAND_GEN, "BANDGEN", MIDI_KEY},
+ { BAND_UP, "BANDUP", MIDI_KEY},
+ { MIDI_BAND_WWV, "BANDWWV", MIDI_KEY},
+ { COMPRESS, "COMPRESS", MIDI_KEY},
+ { MIDI_CTUN, "CTUN", MIDI_KEY},
+ { VFO, "CURRVFO", MIDI_WHEEL},
+ { CWLEFT, "CWL", MIDI_KEY},
+ { CWRIGHT, "CWR", MIDI_KEY},
+ { CWSPEED, "CWSPEED", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_COARSEGAIN, "DIVCOARSEGAIN", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_COARSEPHASE, "DIVCOARSEPHASE", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_FINEGAIN, "DIVFINEGAIN", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_FINEPHASE, "DIVFINEPHASE", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_GAIN, "DIVGAIN", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_PHASE, "DIVPHASE", MIDI_KNOB|MIDI_WHEEL},
+ { DIV_TOGGLE, "DIVTOGGLE", MIDI_KEY},
+ { MIDI_DUP, "DUP", MIDI_KEY},
+ { FILTER_DOWN, "FILTERDOWN", MIDI_KEY},
+ { FILTER_UP, "FILTERUP", MIDI_KEY},
+ { MENU_FILTER, "MENU_FILTER", MIDI_KEY},
+ { MENU_MODE, "MENU_MODE", MIDI_KEY},
+ { MIDI_LOCK, "LOCK", MIDI_KEY},
+ { MIC_VOLUME, "MICGAIN", MIDI_KNOB|MIDI_WHEEL},
+ { MODE_DOWN, "MODEDOWN", MIDI_KEY|MIDI_KNOB|MIDI_WHEEL},
+ { MODE_UP, "MODEUP", MIDI_KEY|MIDI_KNOB|MIDI_WHEEL},
+ { MIDI_MOX, "MOX", MIDI_KEY},
+ { MIDI_MUTE, "MUTE", MIDI_KEY},
+ { MIDI_NB, "NOISEBLANKER", MIDI_KEY},
+ { MIDI_NR, "NOISEREDUCTION", MIDI_KEY},
+ { NUMPAD_0, "NUMPAD0", MIDI_KEY},
+ { NUMPAD_1, "NUMPAD1", MIDI_KEY},
+ { NUMPAD_2, "NUMPAD2", MIDI_KEY},
+ { NUMPAD_3, "NUMPAD3", MIDI_KEY},
+ { NUMPAD_4, "NUMPAD4", MIDI_KEY},
+ { NUMPAD_5, "NUMPAD5", MIDI_KEY},
+ { NUMPAD_6, "NUMPAD6", MIDI_KEY},
+ { NUMPAD_7, "NUMPAD7", MIDI_KEY},
+ { NUMPAD_8, "NUMPAD8", MIDI_KEY},
+ { NUMPAD_9, "NUMPAD9", MIDI_KEY},
+ { NUMPAD_CL, "NUMPADCL", MIDI_KEY},
+ { NUMPAD_ENTER, "NUMPADENTER", MIDI_KEY},
+ { MIDI_PAN, "PAN", MIDI_KNOB|MIDI_WHEEL},
+ { PAN_HIGH, "PANHIGH", MIDI_KNOB|MIDI_WHEEL},
+ { PAN_LOW, "PANLOW", MIDI_KNOB|MIDI_WHEEL},
+ { PRE, "PREAMP", MIDI_KEY},
+ { MIDI_PS, "PURESIGNAL", MIDI_KEY},
+ { MIDI_RF_GAIN, "RFGAIN", MIDI_KNOB|MIDI_WHEEL},
+ { TX_DRIVE, "RFPOWER", MIDI_KNOB|MIDI_WHEEL},
+ { MIDI_RIT_CLEAR, "RITCLEAR", MIDI_KEY},
+ { RIT_STEP, "RITSTEP", MIDI_KNOB|MIDI_WHEEL},
+ { RIT_TOGGLE, "RITTOGGLE", MIDI_KEY},
+ { RIT_VAL, "RITVAL", MIDI_KNOB|MIDI_WHEEL},
+ { MIDI_SAT, "SAT", MIDI_KEY},
+ { SNB, "SNB", MIDI_KEY},
+ { MIDI_SPLIT, "SPLIT", MIDI_KEY},
+ { SWAP_RX, "SWAPRX", MIDI_KEY},
+ { SWAP_VFO, "SWAPVFO", MIDI_KEY},
+ { MIDI_TUNE, "TUNE", MIDI_KEY},
+ { VFOA, "VFOA", MIDI_WHEEL},
+ { VFOB, "VFOB", MIDI_WHEEL},
+ { VFO_STEP_UP, "VFOSTEPUP", MIDI_KEY},
+ { VFO_STEP_DOWN, "VFOSTEPDOWN", MIDI_KEY},
+ { VOX, "VOX", MIDI_KEY},
+ { VOXLEVEL, "VOXLEVEL", MIDI_KNOB|MIDI_WHEEL},
+ { MIDI_XIT_CLEAR, "XITCLEAR", MIDI_KEY},
+ { XIT_VAL, "XITVAL", MIDI_KNOB|MIDI_WHEEL},
+ { MIDI_ZOOM, "ZOOM", MIDI_KNOB|MIDI_WHEEL},
+ { ZOOM_UP, "ZOOMUP", MIDI_KEY},
+ { ZOOM_DOWN, "ZOOMDOWN", MIDI_KEY},
+ { ACTION_NONE, "NONE", TYPE_NONE}
};
/*
return ACTION_NONE;
}
+
+int MIDIstop() {
+ midi_enabled=FALSE;
+ close_midi_device();
+ return 0;
+}
+
/*
- * Here we read in a MIDI description file "midi.def" and fill the MidiCommandsTable
+ * Here we read in a MIDI description file and fill the MidiCommandsTable
* data structure
*/
-void MIDIstartup() {
+int MIDIstartup(char *filename) {
FILE *fpin;
char zeile[255];
char *cp,*cq;
for (i=0; i<128; i++) MidiCommandsTable.desc[i]=NULL;
MidiCommandsTable.pitch=NULL;
- fpin=fopen("midi.props", "r");
- if (!fpin) return;
+ g_print("%s: %s\n",__FUNCTION__,filename);
+ fpin=fopen(filename, "r");
+
+ g_print("%s: fpin=%p\n",__FUNCTION__,fpin);
+ if (!fpin) {
+ g_print("%s: failed to open MIDI device\n",__FUNCTION__);
+ return -1;
+ }
for (;;) {
if (fgets(zeile, 255, fpin) == NULL) break;
cp++;
}
-//fprintf(stderr,"\nMIDI:INP:%s\n",zeile);
+g_print("\n%s:INP:%s\n",__FUNCTION__,zeile);
if ((cp = strstr(zeile, "DEVICE="))) {
// Delete comments and trailing blanks
while (cq > cp+7 && (*cq == ' ' || *cq == '\t')) cq--;
*(cq+1)=0;
//fprintf(stderr,"MIDI:REG:>>>%s<<<\n",cp+7);
- register_midi_device(cp+7);
+ int result=register_midi_device(cp+7);
continue; // nothing more in this line
}
chan=-1; // default: any channel
sscanf(cp+4, "%d", &key);
event=MIDI_NOTE;
type=MIDI_KEY;
-//fprintf(stderr,"MIDI:KEY:%d\n", key);
+g_print("%s: MIDI:KEY:%d\n",__FUNCTION__, key);
}
if ((cp = strstr(zeile, "CTRL="))) {
sscanf(cp+5, "%d", &key);
event=MIDI_CTRL;
type=MIDI_KNOB;
-//fprintf(stderr,"MIDI:CTL:%d\n", key);
+g_print("%s: MIDI:CTL:%d\n",__FUNCTION__, key);
}
if ((cp = strstr(zeile, "PITCH "))) {
event=MIDI_PITCH;
type=MIDI_KNOB;
-//fprintf(stderr,"MIDI:PITCH\n");
+g_print("%s: MIDI:PITCH\n",__FUNCTION__);
}
//
// If event is still undefined, skip line
sscanf(cp+5, "%d", &chan);
chan--;
if (chan<0 || chan>15) chan=-1;
-//fprintf(stderr,"MIDI:CHA:%d\n",chan);
+g_print("%s:CHAN:%d\n",__FUNCTION__,chan);
}
if ((cp = strstr(zeile, "WHEEL")) && (type == MIDI_KNOB)) {
// change type from MIDI_KNOB to MIDI_WHEEL
type=MIDI_WHEEL;
-//fprintf(stderr,"MIDI:WHEEL\n");
+g_print("%s:WHEEL\n",__FUNCTION__);
}
if ((cp = strstr(zeile, "ONOFF"))) {
onoff=1;
-//fprintf(stderr,"MIDI:ONOFF\n");
+g_print("%s:ONOFF\n",__FUNCTION__);
}
if ((cp = strstr(zeile, "DELAY="))) {
sscanf(cp+6, "%d", &delay);
-//fprintf(stderr,"MIDI:DELAY:%d\n",delay);
+g_print("%s:DELAY:%d\n",__FUNCTION__,delay);
}
if ((cp = strstr(zeile, "THR="))) {
sscanf(cp+4, "%d %d %d %d %d %d %d %d %d %d %d %d",
while (*cq != 0 && *cq != '\n' && *cq != ' ' && *cq != '\t') cq++;
*cq=0;
action=keyword2action(cp+7);
-//fprintf(stderr,"MIDI:ACTION:%s (%d)\n",cp+7, action);
+g_print("%s: MIDI:ACTION:%s (%d)\n",__FUNCTION__,cp+7, action);
}
//
// All data for a descriptor has been read. Construct it!
}
}
if (event == MIDI_KEY || event == MIDI_CTRL) {
-//fprintf(stderr,"MIDI:TAB:Insert desc=%p in CMDS[%d] table\n",desc,key);
+g_print("%s:TAB:Insert desc=%p in CMDS[%d] table\n",__FUNCTION__,desc,key);
dp = MidiCommandsTable.desc[key];
if (dp == NULL) {
MidiCommandsTable.desc[key]=desc;
}
}
}
+
+ return 0;
}
g_idle_add(ext_vfo_b_to_a, NULL);
}
break;
+ /////////////////////////////////////////////////////////// "NUMPADxx"
+ case NUMPAD_0:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(0));
+ break;
+ case NUMPAD_1:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(1));
+ break;
+ case NUMPAD_2:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(2));
+ break;
+ case NUMPAD_3:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(3));
+ break;
+ case NUMPAD_4:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(4));
+ break;
+ case NUMPAD_5:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(5));
+ break;
+ case NUMPAD_6:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(6));
+ break;
+ case NUMPAD_7:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(7));
+ break;
+ case NUMPAD_8:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(8));
+ break;
+ case NUMPAD_9:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(9));
+ break;
+ case NUMPAD_CL:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(-1));
+ break;
+ case NUMPAD_ENTER:
+ g_idle_add(ext_num_pad,GINT_TO_POINTER(-2));
+ break;
+ break;
+
+ /////////////////////////////////////////////////////////// "BANDxxx"
+ case MIDI_BAND_10:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band10));
+ }
+ break;
+ case MIDI_BAND_12:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band12));
+ }
+ break;
+#ifdef SOAPYSDR
+ case MIDI_BAND_1240:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band1240));
+ }
+ break;
+ case MIDI_BAND_144:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band144));
+ }
+ break;
+#endif
+ case MIDI_BAND_15:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band15));
+ }
+ break;
+ case MIDI_BAND_160:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band160));
+ }
+ break;
+ case MIDI_BAND_17:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band17));
+ }
+ break;
+ case MIDI_BAND_20:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band20));
+ }
+ break;
+#ifdef SOAPYSDR
+ case MIDI_BAND_220:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band220));
+ }
+ break;
+ case MIDI_BAND_2300:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band2300));
+ }
+ break;
+#endif
+ case MIDI_BAND_30:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band30));
+ }
+ break;
+#ifdef SOAPYSDR
+ case MIDI_BAND_3400:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band3400));
+ }
+ break;
+ case MIDI_BAND_70:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band70));
+ }
+ break;
+#endif
+ case MIDI_BAND_40:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band40));
+ }
+ break;
+#ifdef SOAPYSDR
+ case MIDI_BAND_430:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band430));
+ }
+ break;
+#endif
+ case MIDI_BAND_6:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band6));
+ }
+ break;
+ case MIDI_BAND_60:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band60));
+ }
+ break;
+ case MIDI_BAND_80:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band80));
+ }
+ break;
+#ifdef SOAPYSDR
+ case MIDI_BAND_902:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(band902));
+ }
+ break;
+ case MIDI_BAND_AIR:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(bandAIR));
+ }
+ break;
+#endif
+ case MIDI_BAND_GEN:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(bandGen));
+ }
+ break;
+ case MIDI_BAND_WWV:
+ if (type == MIDI_KEY) {
+ g_idle_add(ext_band_select, GINT_TO_POINTER(bandWWV));
+ }
+ break;
/////////////////////////////////////////////////////////// "BANDDOWN"
/////////////////////////////////////////////////////////// "BANDUP"
case BAND_DOWN:
break;
/////////////////////////////////////////////////////////// "CWL"
/////////////////////////////////////////////////////////// "CWR"
- case CWL: // only key
- case CWR: // only key
+ case CWLEFT: // only key
+ case CWRIGHT: // only key
#ifdef LOCALCW
if (type == MIDI_KEY) {
- new=(action == CWL);
+ new=(action == CWLEFT);
keyer_event(new,val);
}
#else
- g_print("%s: %s:%d\n",__FUNCTION__,action==CWL?"CWL":"CWR",val);
+ g_print("%s: %s:%d\n",__FUNCTION__,action==CWLEFT?"CWL":"CWR",val);
#endif
break;
g_idle_add(ext_vfo_filter_changed, GINT_TO_POINTER(new));
}
break;
+ /////////////////////////////////////////////////////////// "MENU_FILTFILTERER"
+ case MENU_FILTER:
+ g_idle_add(ext_menu_filter, NULL);
+ break;
+ /////////////////////////////////////////////////////////// "MENU_MODE"
+ case MENU_MODE:
+ g_idle_add(ext_menu_mode, NULL);
+ break;
/////////////////////////////////////////////////////////// "LOCK"
case MIDI_LOCK: // only key supported
if (type == MIDI_KEY) {
--- /dev/null
+/* Copyright (C)
+* 2020 - John Melton, G0ORX/N6LYT
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*
+*/
+
+#include <gtk/gtk.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <termios.h>
+
+#include "discovered.h"
+#include "mode.h"
+#include "filter.h"
+#include "band.h"
+#include "receiver.h"
+#include "transmitter.h"
+#include "receiver.h"
+#include "adc.h"
+#include "dac.h"
+#include "radio.h"
+#include "midi.h"
+#include "alsa_midi.h"
+#include "new_menu.h"
+#include "midi_menu.h"
+#include "property.h"
+
+enum {
+ EVENT_COLUMN,
+ CHANNEL_COLUMN,
+ NOTE_COLUMN,
+ TYPE_COLUMN,
+ ACTION_COLUMN,
+ N_COLUMNS
+};
+
+static GtkWidget *parent_window=NULL;
+static GtkWidget *menu_b=NULL;
+static GtkWidget *dialog=NULL;
+
+static GtkWidget *midi_enable_b;
+
+static GtkListStore *store;
+static GtkWidget *view;
+static GtkWidget *scrolled_window=NULL;
+static gulong selection_signal_id;
+static GtkTreeModel *model;
+static GtkTreeIter iter;
+struct desc *current_cmd;
+
+static GtkWidget *filename;
+
+static GtkWidget *newEvent;
+static GtkWidget *newChannel;
+static GtkWidget *newNote;
+static GtkWidget *newVal;
+static GtkWidget *newType;
+static GtkWidget *newMin;
+static GtkWidget *newMax;
+static GtkWidget *newAction;
+static GtkWidget *configure_b;
+static GtkWidget *add_b;
+static GtkWidget *update_b;
+static GtkWidget *delete_b;
+
+static enum MIDIevent thisEvent=EVENT_NONE;
+static int thisChannel;
+static int thisNote;
+static int thisVal;
+static int thisMin;
+static int thisMax;
+static enum MIDItype thisType;
+static enum MIDIaction thisAction;
+
+gchar *midi_device_name=NULL;
+static gint device_index=-1;
+
+enum {
+ UPDATE_NEW,
+ UPDATE_CURRENT,
+ UPDATE_EXISTING
+};
+
+static int update(void *data);
+static void load_store();
+
+static void cleanup() {
+ if(dialog!=NULL) {
+ gtk_widget_destroy(dialog);
+ dialog=NULL;
+ sub_menu=NULL;
+ }
+}
+
+static gboolean close_cb (GtkWidget *widget, GdkEventButton *event, gpointer data) {
+ cleanup();
+ return TRUE;
+}
+
+static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data) {
+ cleanup();
+ return FALSE;
+}
+
+static gboolean midi_enable_cb(GtkWidget *widget,gpointer data) {
+ if(midi_enabled) {
+ close_midi_device();
+ }
+ midi_enabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget));
+ if(midi_enabled) {
+ if(register_midi_device(midi_device_name)<0) {
+ midi_enabled=FALSE;
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (widget), midi_enabled);
+ }
+ }
+ return TRUE;
+}
+
+static void configure_cb(GtkWidget *widget, gpointer data) {
+ gboolean conf=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget));
+ configure_midi_device(conf);
+}
+
+static void device_changed_cb(GtkWidget *widget, gpointer data) {
+ device_index = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
+ if(midi_device_name!=NULL) {
+ g_free(midi_device_name);
+ }
+ midi_device_name=g_new(gchar,strlen(midi_devices[device_index].name)+1);
+ strcpy(midi_device_name,midi_devices[device_index].name);
+ if(midi_enabled) {
+ close_midi_device();
+ if(register_midi_device(midi_device_name)) {
+ midi_enabled=FALSE;
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(midi_enable_b), midi_enabled);
+ }
+ }
+}
+
+static void type_changed_cb(GtkWidget *widget, gpointer data) {
+ int i=1;
+ int j=1;
+
+ // update actions available for the type
+ gchar *type=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widget));
+
+ g_print("%s: type=%s action=%d\n",__FUNCTION__,type,thisAction);
+ gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(newAction));
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newAction),NULL,ActionTable[0].str);
+ if(type==NULL || strcmp(type,"NONE")==0) {
+ // leave empty
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newAction),0);
+ } else if(strcmp(type,"KEY")==0) {
+ // add all the Key actions
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(ActionTable[i].type&MIDI_KEY) {
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newAction),NULL,ActionTable[i].str);
+ if(ActionTable[i].action==thisAction) {
+ gtk_combo_box_set_active(GTK_COMBO_BOX(newAction),j);
+ }
+ j++;
+ }
+ i++;
+ }
+ } else if(strcmp(type,"KNOB/SLIDER")==0) {
+ // add all the Knob actions
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(ActionTable[i].type&MIDI_KNOB) {
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newAction),NULL,ActionTable[i].str);
+ if(ActionTable[i].action==thisAction) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newAction),j);
+ }
+ j++;
+ }
+ i++;
+ }
+ } else if(strcmp(type,"WHEEL")==0) {
+ // add all the Wheel actions
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(ActionTable[i].type&MIDI_WHEEL || ActionTable[i].type&MIDI_KNOB) {
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newAction),NULL,ActionTable[i].str);
+ if(ActionTable[i].action==thisAction) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newAction),j);
+ }
+ j++;
+ }
+ i++;
+ }
+ }
+}
+
+static void row_inserted_cb(GtkTreeModel *tree_model,GtkTreePath *path, GtkTreeIter *iter,gpointer user_data) {
+ //g_print("%s\n",__FUNCTION__);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(view),path,NULL,FALSE);
+}
+
+
+static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data) {
+ char *str_event;
+ char *str_channel;
+ char *str_note;
+ char *str_type;
+ char *str_action;
+
+ //g_print("%s\n",__FUNCTION__);
+ //if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(configure_b))) {
+ if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
+ gtk_tree_model_get(model, &iter, EVENT_COLUMN, &str_event, -1);
+ gtk_tree_model_get(model, &iter, CHANNEL_COLUMN, &str_channel, -1);
+ gtk_tree_model_get(model, &iter, NOTE_COLUMN, &str_note, -1);
+ gtk_tree_model_get(model, &iter, TYPE_COLUMN, &str_type, -1);
+ gtk_tree_model_get(model, &iter, ACTION_COLUMN, &str_action, -1);
+
+ g_print("%s: %s %s %s %s %s\n",__FUNCTION__,str_event,str_channel,str_note,str_type,str_action);
+
+ if(str_event!=NULL && str_channel!=NULL && str_note!=NULL && str_type!=NULL && str_action!=NULL) {
+
+ if(strcmp(str_event,"CTRL")==0) {
+ thisEvent=MIDI_CTRL;
+ } else if(strcmp(str_event,"PITCH")==0) {
+ thisEvent=MIDI_PITCH;
+ } else if(strcmp(str_event,"NOTE")==0) {
+ thisEvent=MIDI_NOTE;
+ } else {
+ thisEvent=EVENT_NONE;
+ }
+ thisChannel=atoi(str_channel);
+ thisNote=atoi(str_note);
+ thisVal=0;
+ thisMin=0;
+ thisMax=0;
+ if(strcmp(str_type,"KEY")==0) {
+ thisType=MIDI_KEY;
+ } else if(strcmp(str_type,"KNOB/SLIDER")==0) {
+ thisType=MIDI_KNOB;
+ } else if(strcmp(str_type,"WHEEL")==0) {
+ thisType=MIDI_WHEEL;
+ } else {
+ thisType=TYPE_NONE;
+ }
+ thisAction=ACTION_NONE;
+ int i=1;
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(strcmp(ActionTable[i].str,str_action)==0) {
+ thisAction=ActionTable[i].action;
+ break;
+ }
+ i++;
+ }
+ g_idle_add(update,GINT_TO_POINTER(UPDATE_EXISTING));
+ }
+ }
+ //}
+}
+
+static void find_current_cmd() {
+ struct desc *cmd;
+ g_print("%s:\n",__FUNCTION__);
+ cmd=MidiCommandsTable.desc[thisNote];
+ while(cmd!=NULL) {
+ if((cmd->channel==thisChannel || cmd->channel==-1) && cmd->type==thisType && cmd->action==thisAction) {
+ g_print("%s: found cmd %p\n",__FUNCTION__,cmd);
+ break;
+ }
+ cmd=cmd->next;
+ }
+ current_cmd=cmd;
+}
+
+static void clear_cb(GtkWidget *widget,gpointer user_data) {
+ struct desc *cmd;
+ struct desc *next;
+ for(int i=0;i<128;i++) {
+ cmd=MidiCommandsTable.desc[i];
+ while(cmd!=NULL) {
+ next=cmd->next;
+ g_free(cmd);
+ cmd=next;
+ }
+ MidiCommandsTable.desc[i]=NULL;
+ }
+ gtk_list_store_clear(store);
+}
+
+static void save_cb(GtkWidget *widget,gpointer user_data) {
+ GtkWidget *save_dialog;
+ GtkFileChooser *chooser;
+ GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
+ gchar *filename;
+ gint res;
+ struct desc *cmd;
+
+ save_dialog = gtk_file_chooser_dialog_new ("Save File",
+ GTK_WINDOW(dialog),
+ action,
+ "_Cancel",
+ GTK_RESPONSE_CANCEL,
+ "_Save",
+ GTK_RESPONSE_ACCEPT,
+ NULL);
+ chooser = GTK_FILE_CHOOSER (save_dialog);
+ gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
+ if(midi_device_name==NULL) {
+ filename=g_new(gchar,10);
+ sprintf(filename,"midi.midi");
+ } else {
+ filename=g_new(gchar,strlen(midi_device_name)+6);
+ sprintf(filename,"%s.midi",midi_device_name);
+ }
+ gtk_file_chooser_set_current_name(chooser,filename);
+ res = gtk_dialog_run (GTK_DIALOG (save_dialog));
+ if(res==GTK_RESPONSE_ACCEPT) {
+ char *savefilename=gtk_file_chooser_get_filename(chooser);
+ clearProperties();
+ midi_save_state();
+ saveProperties(savefilename);
+ g_free(savefilename);
+ }
+ gtk_widget_destroy(save_dialog);
+ g_free(filename);
+}
+
+static void load_cb(GtkWidget *widget,gpointer user_data) {
+ GtkWidget *load_dialog;
+ GtkFileChooser *chooser;
+ GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+ gchar *filename;
+ gint res;
+ struct desc *cmd;
+
+ load_dialog = gtk_file_chooser_dialog_new ("Open MIDI File",
+ GTK_WINDOW(dialog),
+ action,
+ "_Cancel",
+ GTK_RESPONSE_CANCEL,
+ "_Save",
+ GTK_RESPONSE_ACCEPT,
+ NULL);
+ chooser = GTK_FILE_CHOOSER (load_dialog);
+ if(midi_device_name==NULL) {
+ filename=g_new(gchar,10);
+ sprintf(filename,"midi.midi");
+ } else {
+ filename=g_new(gchar,strlen(midi_device_name)+6);
+ sprintf(filename,"%s.midi",midi_device_name);
+ }
+ gtk_file_chooser_set_current_name(chooser,filename);
+ res = gtk_dialog_run (GTK_DIALOG (load_dialog));
+ if(res==GTK_RESPONSE_ACCEPT) {
+ char *loadfilename=gtk_file_chooser_get_filename(chooser);
+ clear_cb(NULL,NULL);
+ clearProperties();
+ loadProperties(loadfilename);
+ midi_restore_state();
+ load_store();
+ g_free(loadfilename);
+ }
+ gtk_widget_destroy(load_dialog);
+ g_free(filename);
+}
+
+static void load_original_cb(GtkWidget *widget,gpointer user_data) {
+ GtkWidget *load_dialog;
+ GtkFileChooser *chooser;
+ GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+ gchar *filename;
+ gint res;
+ struct desc *cmd;
+
+ load_dialog = gtk_file_chooser_dialog_new ("Open ORIGINAL MIDI File",
+ GTK_WINDOW(dialog),
+ action,
+ "_Cancel",
+ GTK_RESPONSE_CANCEL,
+ "_Save",
+ GTK_RESPONSE_ACCEPT,
+ NULL);
+ chooser = GTK_FILE_CHOOSER (load_dialog);
+ filename=g_new(gchar,strlen(midi_device_name)+6);
+ sprintf(filename,"%s.midi",midi_device_name);
+ gtk_file_chooser_set_current_name(chooser,filename);
+ res = gtk_dialog_run (GTK_DIALOG (load_dialog));
+ if(res==GTK_RESPONSE_ACCEPT) {
+ char *loadfilename=gtk_file_chooser_get_filename(chooser);
+ clear_cb(NULL,NULL);
+ MIDIstartup(loadfilename);
+ load_store();
+ g_free(loadfilename);
+ }
+ gtk_widget_destroy(load_dialog);
+ g_free(filename);
+}
+
+static void add_store(int key,struct desc *cmd) {
+ char str_event[16];
+ char str_channel[16];
+ char str_note[16];
+ char str_type[32];
+ char str_action[32];
+
+ //g_print("%s: key=%d desc=%p\n",__FUNCTION__,key,cmd);
+ switch(cmd->event) {
+ case EVENT_NONE:
+ strcpy(str_event,"NONE");
+ break;
+ case MIDI_NOTE:
+ strcpy(str_event,"NOTE");
+ break;
+ case MIDI_CTRL:
+ strcpy(str_event,"CTRL");
+ break;
+ case MIDI_PITCH:
+ strcpy(str_event,"PITCH");
+ break;
+ }
+ sprintf(str_channel,"%d",cmd->channel);
+ sprintf(str_note,"%d",key);
+ switch(cmd->type) {
+ case TYPE_NONE:
+ strcpy(str_type,"NONE");
+ break;
+ case MIDI_KEY:
+ strcpy(str_type,"KEY");
+ break;
+ case MIDI_KNOB:
+ strcpy(str_type,"KNOB/SLIDER");
+ break;
+ case MIDI_WHEEL:
+ strcpy(str_type,"WHEEL");
+ break;
+ }
+ strcpy(str_action,ActionTable[cmd->action].str);
+ gtk_list_store_prepend(store,&iter);
+ gtk_list_store_set(store,&iter,
+ EVENT_COLUMN,str_event,
+ CHANNEL_COLUMN,str_channel,
+ NOTE_COLUMN,str_note,
+ TYPE_COLUMN,str_type,
+ ACTION_COLUMN,str_action,
+ -1);
+
+ if(scrolled_window!=NULL) {
+ GtkAdjustment *adjustment=gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(scrolled_window));
+ //g_print("%s: adjustment=%f lower=%f upper=%f\n",__FUNCTION__,gtk_adjustment_get_value(adjustment),gtk_adjustment_get_lower(adjustment),gtk_adjustment_get_upper(adjustment));
+ if(gtk_adjustment_get_value(adjustment)!=0.0) {
+ gtk_adjustment_set_value(adjustment,0.0);
+ }
+ }
+}
+
+static void load_store() {
+ struct desc *cmd;
+ gtk_list_store_clear(store);
+ for(int i=0;i<128;i++) {
+ cmd=MidiCommandsTable.desc[i];
+ while(cmd!=NULL) {
+ add_store(i,cmd);
+ cmd=cmd->next;
+ }
+ }
+}
+
+static void add_cb(GtkButton *widget,gpointer user_data) {
+
+ gchar *str_type=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(newType));
+ gchar *str_action=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(newAction));
+;
+
+ gint i;
+ gint type;
+ gint action;
+
+ if(strcmp(str_type,"KEY")==0) {
+ type=MIDI_KEY;
+ } else if(strcmp(str_type,"KNOB/SLIDER")==0) {
+ type=MIDI_KNOB;
+ } else if(strcmp(str_type,"WHEEL")==0) {
+ type=MIDI_WHEEL;
+ } else {
+ type=TYPE_NONE;
+ }
+
+ action=ACTION_NONE;
+ i=1;
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(strcmp(ActionTable[i].str,str_action)==0) {
+ action=ActionTable[i].action;
+ break;
+ }
+ i++;
+ }
+
+ g_print("%s: type=%s (%d) action=%s (%d)\n",__FUNCTION__,str_type,type,str_action,action);
+
+ struct desc *desc;
+ desc = (struct desc *) malloc(sizeof(struct desc));
+ desc->next = NULL;
+ desc->action = action; // MIDIaction
+ desc->type = type; // MIDItype
+ desc->event = thisEvent; // MIDevent
+ desc->onoff = action==CWLEFT || action==CWRIGHT;
+ desc->delay = 0;
+ desc->vfl1 = -1;
+ desc->vfl2 = -1;
+ desc->fl1 = -1;
+ desc->fl2 = -1;
+ desc->lft1 = -1;
+ desc->lft2 = 63;
+ desc->rgt1 = 64;
+ desc->rgt2 = 128;
+ desc->fr1 = 128;
+ desc->fr2 = 128;
+ desc->vfr1 = 128;
+ desc->vfr2 = 128;
+ desc->channel = thisChannel;
+
+ gint key=thisNote;
+ if(key<0) key=0;
+ if(key>127) key=0;
+
+
+ if(MidiCommandsTable.desc[key]!=NULL) {
+ desc->next=MidiCommandsTable.desc[key];
+ }
+ MidiCommandsTable.desc[key]=desc;
+
+ add_store(key,desc);
+
+ gtk_widget_set_sensitive(add_b,FALSE);
+ gtk_widget_set_sensitive(update_b,TRUE);
+ gtk_widget_set_sensitive(delete_b,TRUE);
+
+}
+
+static void update_cb(GtkButton *widget,gpointer user_data) {
+ char str_event[16];
+ char str_channel[16];
+ char str_note[16];
+ int i;
+
+
+ gchar *str_type=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(newType));
+ gchar *str_action=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(newAction));
+;
+ //g_print("%s: type=%s action=%s\n",__FUNCTION__,str_type,str_action);
+
+ if(strcmp(str_type,"KEY")==0) {
+ thisType=MIDI_KEY;
+ } else if(strcmp(str_type,"KNOB/SLIDER")==0) {
+ thisType=MIDI_KNOB;
+ } else if(strcmp(str_type,"WHEEL")==0) {
+ thisType=MIDI_WHEEL;
+ } else {
+ thisType=TYPE_NONE;
+ }
+
+ thisAction=ACTION_NONE;
+ i=1;
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(strcmp(ActionTable[i].str,str_action)==0) {
+ thisAction=ActionTable[i].action;
+ break;
+ }
+ i++;
+ }
+
+ current_cmd->channel=thisChannel;
+ current_cmd->type=thisType;
+ current_cmd->action=thisAction;
+
+ switch(current_cmd->event) {
+ case EVENT_NONE:
+ strcpy(str_event,"NONE");
+ break;
+ case MIDI_NOTE:
+ strcpy(str_event,"NOTE");
+ break;
+ case MIDI_CTRL:
+ strcpy(str_event,"CTRL");
+ break;
+ case MIDI_PITCH:
+ strcpy(str_event,"PITCH");
+ break;
+ }
+ sprintf(str_channel,"%d",current_cmd->channel);
+ sprintf(str_note,"%d",thisNote);
+
+ //g_print("%s: event=%s channel=%s note=%s type=%s action=%s\n",
+ // __FUNCTION__,str_event,str_channel,str_note,str_type,str_action);
+ gtk_list_store_set(store,&iter,
+ EVENT_COLUMN,str_event,
+ CHANNEL_COLUMN,str_channel,
+ NOTE_COLUMN,str_note,
+ TYPE_COLUMN,str_type,
+ ACTION_COLUMN,str_action,
+ -1);
+}
+
+static void delete_cb(GtkButton *widget,gpointer user_data) {
+ struct desc *previous_cmd;
+ struct desc *next_cmd;
+ GtkTreeIter saved_iter;
+ g_print("%s: thisNote=%d current_cmd=%p\n",__FUNCTION__,thisNote,current_cmd);
+
+ saved_iter=iter;
+
+
+ // remove from MidiCommandsTable
+ if(MidiCommandsTable.desc[thisNote]==current_cmd) {
+ g_print("%s: remove first\n",__FUNCTION__);
+ MidiCommandsTable.desc[thisNote]=current_cmd->next;
+ g_free(current_cmd);
+ } else {
+ previous_cmd=MidiCommandsTable.desc[thisNote];
+ while(previous_cmd->next!=NULL) {
+ next_cmd=previous_cmd->next;
+ if(next_cmd==current_cmd) {
+ g_print("%s: remove next\n",__FUNCTION__);
+ previous_cmd->next=next_cmd->next;
+ g_free(next_cmd);
+ break;
+ }
+ previous_cmd=next_cmd;
+ }
+ }
+
+ // remove from list store
+ gtk_list_store_remove(store,&saved_iter);
+
+ gtk_widget_set_sensitive(add_b,TRUE);
+ gtk_widget_set_sensitive(update_b,FALSE);
+ gtk_widget_set_sensitive(delete_b,FALSE);
+
+}
+
+void midi_menu(GtkWidget *parent) {
+ int i;
+ int col=0;
+ int row=0;
+ GtkCellRenderer *renderer;
+
+ dialog=gtk_dialog_new();
+ gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(parent_window));
+ char title[64];
+ sprintf(title,"piHPSDR - MIDI");
+ gtk_window_set_title(GTK_WINDOW(dialog),title);
+ g_signal_connect (dialog, "delete_event", G_CALLBACK (delete_event), NULL);
+
+ GdkRGBA color;
+ color.red = 1.0;
+ color.green = 1.0;
+ color.blue = 1.0;
+ color.alpha = 1.0;
+ gtk_widget_override_background_color(dialog,GTK_STATE_FLAG_NORMAL,&color);
+
+ GtkWidget *content=gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+
+ GtkWidget *grid=gtk_grid_new();
+ gtk_grid_set_column_spacing (GTK_GRID(grid),2);
+
+ row=0;
+ col=0;
+
+ get_midi_devices();
+ if(n_midi_devices>0) {
+ GtkWidget *devices_label=gtk_label_new("Select MIDI device: ");
+ gtk_grid_attach(GTK_GRID(grid),devices_label,col,row,3,1);
+ col+=3;
+
+ GtkWidget *devices=gtk_combo_box_text_new();
+ for(int i=0;i<n_midi_devices;i++) {
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devices),NULL,midi_devices[i].name);
+ if(midi_device_name!=NULL) {
+ if(strcmp(midi_device_name,midi_devices[i].name)==0) {
+ device_index=i;
+ }
+ }
+ }
+ gtk_grid_attach(GTK_GRID(grid),devices,col,row,6,1);
+ gtk_combo_box_set_active(GTK_COMBO_BOX(devices),device_index);
+ g_signal_connect(devices,"changed",G_CALLBACK(device_changed_cb),NULL);
+ } else {
+ GtkWidget *message=gtk_label_new("No MIDI devices found!");
+ gtk_grid_attach(GTK_GRID(grid),message,col,row,1,1);
+ }
+ row++;
+ col=0;
+
+ midi_enable_b=gtk_check_button_new_with_label("MIDI Enable");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (midi_enable_b), midi_enabled);
+ gtk_grid_attach(GTK_GRID(grid),midi_enable_b,col,row,3,1);
+ g_signal_connect(midi_enable_b,"toggled",G_CALLBACK(midi_enable_cb),NULL);
+
+ row++;
+ col=0;
+
+ GtkWidget *clear_b=gtk_button_new_with_label("Clear");
+ gtk_grid_attach(GTK_GRID(grid),clear_b,col,row,1,1);
+ g_signal_connect(clear_b,"clicked",G_CALLBACK(clear_cb),NULL);
+ col++;
+
+ GtkWidget *save_b=gtk_button_new_with_label("Save");
+ gtk_grid_attach(GTK_GRID(grid),save_b,col,row,1,1);
+ g_signal_connect(save_b,"clicked",G_CALLBACK(save_cb),NULL);
+ col++;
+
+ GtkWidget *load_b=gtk_button_new_with_label("Load");
+ gtk_grid_attach(GTK_GRID(grid),load_b,col,row,1,1);
+ g_signal_connect(load_b,"clicked",G_CALLBACK(load_cb),NULL);
+ col++;
+
+ GtkWidget *load_original_b=gtk_button_new_with_label("Load Original");
+ gtk_grid_attach(GTK_GRID(grid),load_original_b,col,row,1,1);
+ g_signal_connect(load_original_b,"clicked",G_CALLBACK(load_original_cb),NULL);
+ col++;
+
+ row++;
+ col=0;
+
+ configure_b=gtk_check_button_new_with_label("MIDI Configure");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configure_b), FALSE);
+ gtk_grid_attach(GTK_GRID(grid),configure_b,col,row,3,1);
+ g_signal_connect(configure_b,"toggled",G_CALLBACK(configure_cb),NULL);
+
+
+ row++;
+ col=0;
+ GtkWidget *label=gtk_label_new("Evt");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Ch");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Note");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Type");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Value");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Min");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Max");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+ label=gtk_label_new("Action");
+ gtk_grid_attach(GTK_GRID(grid),label,col++,row,1,1);
+
+
+ row++;
+ col=0;
+ newEvent=gtk_label_new("");
+ gtk_grid_attach(GTK_GRID(grid),newEvent,col++,row,1,1);
+ newChannel=gtk_label_new("");
+ gtk_grid_attach(GTK_GRID(grid),newChannel,col++,row,1,1);
+ newNote=gtk_label_new("");
+ gtk_grid_attach(GTK_GRID(grid),newNote,col++,row,1,1);
+ newType=gtk_combo_box_text_new();
+ gtk_grid_attach(GTK_GRID(grid),newType,col++,row,1,1);
+ g_signal_connect(newType,"changed",G_CALLBACK(type_changed_cb),NULL);
+ newVal=gtk_label_new("");
+ gtk_grid_attach(GTK_GRID(grid),newVal,col++,row,1,1);
+ newMin=gtk_label_new("");
+ gtk_grid_attach(GTK_GRID(grid),newMin,col++,row,1,1);
+ newMax=gtk_label_new("");
+ gtk_grid_attach(GTK_GRID(grid),newMax,col++,row,1,1);
+ newAction=gtk_combo_box_text_new();
+ gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(newAction),5);
+ gtk_grid_attach(GTK_GRID(grid),newAction,col++,row,1,1);
+
+ add_b=gtk_button_new_with_label("Add");
+ g_signal_connect(add_b, "pressed", G_CALLBACK(add_cb),NULL);
+ gtk_grid_attach(GTK_GRID(grid),add_b,col++,row,1,1);
+ gtk_widget_set_sensitive(add_b,FALSE);
+
+
+ update_b=gtk_button_new_with_label("Update");
+ g_signal_connect(update_b, "pressed", G_CALLBACK(update_cb),NULL);
+ gtk_grid_attach(GTK_GRID(grid),update_b,col++,row,1,1);
+ gtk_widget_set_sensitive(update_b,FALSE);
+
+ delete_b=gtk_button_new_with_label("Delete");
+ g_signal_connect(delete_b, "pressed", G_CALLBACK(delete_cb),NULL);
+ gtk_grid_attach(GTK_GRID(grid),delete_b,col++,row,1,1);
+ gtk_widget_set_sensitive(delete_b,FALSE);
+ row++;
+ col=0;
+
+ scrolled_window=gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),GTK_POLICY_AUTOMATIC,GTK_POLICY_ALWAYS);
+ gtk_widget_set_size_request(scrolled_window,400,300);
+
+ view=gtk_tree_view_new();
+
+ renderer=gtk_cell_renderer_text_new();
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "Event", renderer, "text", EVENT_COLUMN, NULL);
+
+ renderer=gtk_cell_renderer_text_new();
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "CHANNEL", renderer, "text", CHANNEL_COLUMN, NULL);
+
+ renderer=gtk_cell_renderer_text_new();
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "NOTE", renderer, "text", NOTE_COLUMN, NULL);
+
+ renderer=gtk_cell_renderer_text_new();
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "TYPE", renderer, "text", TYPE_COLUMN, NULL);
+
+ renderer=gtk_cell_renderer_text_new();
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "ACTION", renderer, "text", ACTION_COLUMN, NULL);
+
+ store=gtk_list_store_new(N_COLUMNS,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING);
+
+ load_store();
+
+ gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
+
+ gtk_container_add(GTK_CONTAINER(scrolled_window),view);
+
+ gtk_grid_attach(GTK_GRID(grid), scrolled_window, col, row, 6, 10);
+
+ model=gtk_tree_view_get_model(GTK_TREE_VIEW(view));
+ g_signal_connect(model,"row-inserted",G_CALLBACK(row_inserted_cb),NULL);
+
+ GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
+ gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
+
+ selection_signal_id=g_signal_connect(G_OBJECT(selection),"changed",G_CALLBACK(tree_selection_changed_cb),NULL);
+
+ gtk_container_add(GTK_CONTAINER(content),grid);
+ sub_menu=dialog;
+ gtk_widget_show_all(dialog);
+}
+
+static int update(void *data) {
+ int state=GPOINTER_TO_INT(data);
+ gchar text[32];
+ gint i=1;
+
+ switch(state) {
+ case UPDATE_NEW:
+ g_print("%s: UPDATE_NEW\n",__FUNCTION__);
+ switch(thisEvent) {
+ case EVENT_NONE:
+ gtk_label_set_text(GTK_LABEL(newEvent),"NONE");
+ break;
+ case MIDI_NOTE:
+ gtk_label_set_text(GTK_LABEL(newEvent),"NOTE");
+ break;
+ case MIDI_CTRL:
+ gtk_label_set_text(GTK_LABEL(newEvent),"CTRL");
+ break;
+ case MIDI_PITCH:
+ gtk_label_set_text(GTK_LABEL(newEvent),"PITCH");
+ break;
+ }
+ sprintf(text,"%d",thisChannel);
+ gtk_label_set_text(GTK_LABEL(newChannel),text);
+ sprintf(text,"%d",thisNote);
+ gtk_label_set_text(GTK_LABEL(newNote),text);
+ gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(newType));
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"NONE");
+ switch(thisEvent) {
+ case EVENT_NONE:
+ break;
+ case MIDI_NOTE:
+ case MIDI_PITCH:
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"KEY");
+ break;
+ case MIDI_CTRL:
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"KNOB/SLIDER");
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"WHEEL");
+ break;
+ }
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),0);
+ gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(newAction));
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newAction),NULL,"NONE");
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newAction),0);
+ sprintf(text,"%d",thisVal);
+ gtk_label_set_text(GTK_LABEL(newVal),text);
+ sprintf(text,"%d",thisMin);
+ gtk_label_set_text(GTK_LABEL(newMin),text);
+ sprintf(text,"%d",thisMax);
+ gtk_label_set_text(GTK_LABEL(newMax),text);
+
+ gtk_widget_set_sensitive(add_b,TRUE);
+ gtk_widget_set_sensitive(update_b,FALSE);
+ gtk_widget_set_sensitive(delete_b,FALSE);
+ break;
+
+ case UPDATE_CURRENT:
+ g_print("%s: UPDATE_CURRENT\n",__FUNCTION__);
+ sprintf(text,"%d",thisVal);
+ gtk_label_set_text(GTK_LABEL(newVal),text);
+ sprintf(text,"%d",thisMin);
+ gtk_label_set_text(GTK_LABEL(newMin),text);
+ sprintf(text,"%d",thisMax);
+ gtk_label_set_text(GTK_LABEL(newMax),text);
+ break;
+
+ case UPDATE_EXISTING:
+ g_print("%s: UPDATE_EXISTING\n",__FUNCTION__);
+ switch(thisEvent) {
+ case EVENT_NONE:
+ gtk_label_set_text(GTK_LABEL(newEvent),"NONE");
+ break;
+ case MIDI_NOTE:
+ gtk_label_set_text(GTK_LABEL(newEvent),"NOTE");
+ break;
+ case MIDI_CTRL:
+ gtk_label_set_text(GTK_LABEL(newEvent),"CTRL");
+ break;
+ case MIDI_PITCH:
+ gtk_label_set_text(GTK_LABEL(newEvent),"PITCH");
+ break;
+ }
+ sprintf(text,"%d",thisChannel);
+ gtk_label_set_text(GTK_LABEL(newChannel),text);
+ sprintf(text,"%d",thisNote);
+ gtk_label_set_text(GTK_LABEL(newNote),text);
+ gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(newType));
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"NONE");
+ switch(thisEvent) {
+ case EVENT_NONE:
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),0);
+ break;
+ case MIDI_NOTE:
+ case MIDI_PITCH:
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"KEY");
+ if(thisType==TYPE_NONE) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),0);
+ } else if(thisType==MIDI_KEY) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),1);
+ }
+ break;
+ case MIDI_CTRL:
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"KNOB/SLIDER");
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(newType),NULL,"WHEEL");
+ if(thisType==TYPE_NONE) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),0);
+ } else if(thisType==MIDI_KNOB) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),1);
+ } else if(thisType==MIDI_WHEEL) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(newType),2);
+ }
+ break;
+ }
+ sprintf(text,"%d",thisVal);
+ gtk_label_set_text(GTK_LABEL(newVal),text);
+ sprintf(text,"%d",thisMin);
+ gtk_label_set_text(GTK_LABEL(newMin),text);
+ sprintf(text,"%d",thisMax);
+ gtk_label_set_text(GTK_LABEL(newMax),text);
+
+ find_current_cmd();
+ g_print("%s: current_cmd %p\n",__FUNCTION__,current_cmd);
+
+ gtk_widget_set_sensitive(add_b,FALSE);
+ gtk_widget_set_sensitive(update_b,TRUE);
+ gtk_widget_set_sensitive(delete_b,TRUE);
+ break;
+
+ }
+
+ return 0;
+}
+
+void NewMidiConfigureEvent(enum MIDIevent event, int channel, int note, int val) {
+
+ gboolean valid;
+ char *str_event;
+ char *str_channel;
+ char *str_note;
+ char *str_type;
+ char *str_action;
+
+ gint tree_event;
+ gint tree_channel;
+ gint tree_note;
+
+ //g_print("%s: event=%d channel=%d note=%d val=%d\n", __FUNCTION__,event,channel,note,val);
+
+ if(event==thisEvent && channel==thisChannel && note==thisNote) {
+ //g_print("%s: current event\n",__FUNCTION__);
+ thisVal=val;
+ if(val<thisMin) thisMin=val;
+ if(val>thisMax) thisMax=val;
+ g_idle_add(update,GINT_TO_POINTER(UPDATE_CURRENT));
+ } else {
+ //g_print("%s: new or existing event\n",__FUNCTION__);
+ thisEvent=event;
+ thisChannel=channel;
+ thisNote=note;
+ thisVal=val;
+ thisMin=val;
+ thisMax=val;
+ thisType=TYPE_NONE;
+ thisAction=ACTION_NONE;
+
+ // search tree to see if it is existing event
+ valid=gtk_tree_model_get_iter_first(model,&iter);
+ while(valid) {
+ gtk_tree_model_get(model, &iter, EVENT_COLUMN, &str_event, -1);
+ gtk_tree_model_get(model, &iter, CHANNEL_COLUMN, &str_channel, -1);
+ gtk_tree_model_get(model, &iter, NOTE_COLUMN, &str_note, -1);
+ gtk_tree_model_get(model, &iter, TYPE_COLUMN, &str_type, -1);
+ gtk_tree_model_get(model, &iter, ACTION_COLUMN, &str_action, -1);
+
+ //g_print("%s: %s %s %s %s %s\n",__FUNCTION__,str_event,str_channel,str_note,str_type,str_action);
+
+ if(str_event!=NULL && str_channel!=NULL && str_note!=NULL && str_type!=NULL && str_action!=NULL) {
+ if(strcmp(str_event,"CTRL")==0) {
+ tree_event=MIDI_CTRL;
+ } else if(strcmp(str_event,"PITCH")==0) {
+ tree_event=MIDI_PITCH;
+ } else if(strcmp(str_event,"NOTE")==0) {
+ tree_event=MIDI_NOTE;
+ } else {
+ tree_event=EVENT_NONE;
+ }
+ tree_channel=atoi(str_channel);
+ tree_note=atoi(str_note);
+
+ if(thisEvent==tree_event && (thisChannel==tree_channel || tree_channel==-1) && thisNote==tree_note) {
+ thisVal=0;
+ thisMin=0;
+ thisMax=0;
+ if(strcmp(str_type,"KEY")==0) {
+ thisType=MIDI_KEY;
+ } else if(strcmp(str_type,"KNOB/SLIDER")==0) {
+ thisType=MIDI_KNOB;
+ } else if(strcmp(str_type,"WHEEL")==0) {
+ thisType=MIDI_WHEEL;
+ } else {
+ thisType=TYPE_NONE;
+ }
+ thisAction=ACTION_NONE;
+ int i=1;
+ while(ActionTable[i].action!=ACTION_NONE) {
+ if(strcmp(ActionTable[i].str,str_action)==0) {
+ thisAction=ActionTable[i].action;
+ break;
+ }
+ i++;
+ }
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(view),gtk_tree_model_get_path(model,&iter),NULL,FALSE);
+ g_idle_add(update,GINT_TO_POINTER(UPDATE_EXISTING));
+ return;
+ }
+ }
+
+ valid=gtk_tree_model_iter_next(model,&iter);
+ }
+
+ g_idle_add(update,GINT_TO_POINTER(UPDATE_NEW));
+ }
+}
+
+void midi_save_state() {
+ char name[80];
+ char value[80];
+ struct desc *cmd;
+ gint channels;
+
+ if(device_index!=-1) {
+ setProperty("midi_device",midi_devices[device_index].name);
+ for(int i=0;i<128;i++) {
+ channels=0;
+ cmd=MidiCommandsTable.desc[i];
+ while(cmd!=NULL) {
+ //g_print("%s: channel=%d key=%d event=%s onoff=%d type=%s action=%s\n",__FUNCTION__,cmd->channel,i,midi_events[cmd->event],cmd->onoff,midi_types[cmd->type],ActionTable[cmd->action].str);
+
+ sprintf(name,"midi[%d].channel[%d]",i,channels);
+ sprintf(value,"%d",cmd->channel);
+ setProperty(name,value);
+ sprintf(name,"midi[%d].channel[%d].event",i,cmd->channel);
+ setProperty(name,midi_events[cmd->event]);
+ sprintf(name,"midi[%d].channel[%d].onoff",i,cmd->channel);
+ sprintf(value,"%d",cmd->onoff);
+ setProperty(name,value);
+ sprintf(name,"midi[%d].channel[%d].type",i,cmd->channel);
+ setProperty(name,midi_types[cmd->type]);
+ sprintf(name,"midi[%d].channel[%d].action",i,cmd->channel);
+ sprintf(value,"%s",ActionTable[cmd->action].str);
+ setProperty(name,value);
+ cmd=cmd->next;
+ channels++;
+ }
+
+ if(channels!=0) {
+ sprintf(name,"midi[%d].channels",i);
+ sprintf(value,"%d",channels);
+ setProperty(name,value);
+ }
+
+ }
+ }
+}
+
+void midi_restore_state() {
+ char name[80];
+ char *value;
+ gint channels;
+ gint channel;
+ gint event;
+ gint onoff;
+ gint type;
+ gint action;
+
+ struct desc *cmd;
+
+ get_midi_devices();
+
+ //g_print("%s\n",__FUNCTION__);
+ value=getProperty("midi_device");
+ if(value) {
+ //g_print("%s: device=%s\n",__FUNCTION__,value);
+ midi_device_name=g_new(gchar,strlen(value)+1);
+ strcpy(midi_device_name,value);
+
+
+ for(int i=0;i<n_midi_devices;i++) {
+ if(strcmp(midi_devices[i].name,value)==0) {
+ device_index=i;
+ g_print("%s: found device at %d\n",__FUNCTION__,i);
+ break;
+ }
+ }
+ }
+
+ for(int i=0;i<128;i++) {
+ sprintf(name,"midi[%d].channels",i);
+ value=getProperty(name);
+ if(value) {
+ channels=atoi(value);
+ for(int c=0;c<channels;c++) {
+ sprintf(name,"midi[%d].channel[%d]",i,c);
+ value=getProperty(name);
+ if(value) {
+ channel=atoi(value);
+ sprintf(name,"midi[%d].channel[%d].event",i,channel);
+ value=getProperty(name);
+ event=EVENT_NONE;
+ if(value) {
+ for(int j=0;j<4;j++) {
+ if(strcmp(value,midi_events[j])==0) {
+ event=j;
+ break;
+ }
+ }
+ }
+ sprintf(name,"midi[%d].channel[%d].onoff",i,channel);
+ value=getProperty(name);
+ if(value) onoff=atoi(value);
+ sprintf(name,"midi[%d].channel[%d].type",i,channel);
+ value=getProperty(name);
+ type=TYPE_NONE;
+ if(value) {
+ for(int j=0;j<5;j++) {
+ if(strcmp(value,midi_types[j])==0) {
+ type=j;
+ break;
+ }
+ }
+ }
+ sprintf(name,"midi[%d].channel[%d].action",i,channel);
+ value=getProperty(name);
+ action=ACTION_NONE;
+ if(value) {
+ int j=1;
+ while(ActionTable[j].type!=ACTION_NONE) {
+ if(strcmp(value,ActionTable[j].str)==0) {
+ action=ActionTable[j].action;
+ break;
+ }
+ j++;
+ }
+ }
+
+
+ struct desc *desc;
+ desc = (struct desc *) malloc(sizeof(struct desc));
+ desc->next = NULL;
+ desc->action = action; // MIDIaction
+ desc->type = type; // MIDItype
+ desc->event = event; // MIDevent
+ desc->onoff = onoff;
+ desc->delay = 0;
+ desc->vfl1 = -1;
+ desc->vfl2 = -1;
+ desc->fl1 = -1;
+ desc->fl2 = -1;
+ desc->lft1 = -1;
+ desc->lft2 = 63;
+ desc->rgt1 = 64;
+ desc->rgt2 = 128;
+ desc->fr1 = 128;
+ desc->fr2 = 128;
+ desc->vfr1 = 128;
+ desc->vfr2 = 128;
+ desc->channel = channel;
+
+ if(MidiCommandsTable.desc[i]!=NULL) {
+ desc->next=MidiCommandsTable.desc[i];
+ }
+ MidiCommandsTable.desc[i]=desc;
+ }
+ }
+ }
+ }
+
+}
+
--- /dev/null
+/* Copyright (C)
+* 2021 - John Melton, G0ORX/N6LYT
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*
+*/
+
+extern gchar *midi_device_name;
+extern void midi_menu(GtkWidget *parent);
+extern void NewMidiConfigureEvent(enum MIDIevent event, int channel, int note, int val);
+extern void midi_save_state();
+extern void midi_restore_state();
+
#include "fft_menu.h"
#include "main.h"
#include "actions.h"
-#ifdef GPIO
#include "gpio.h"
-#endif
#include "old_protocol.h"
#include "new_protocol.h"
#ifdef CLIENT_SERVER
#include "server_menu.h"
#endif
+#ifdef MIDI
+#include "midi_menu.h"
+#endif
static GtkWidget *menu_b=NULL;
encoder_menu(top_window);
return TRUE;
}
+#endif
static gboolean switch_cb (GtkWidget *widget, GdkEventButton *event, gpointer data) {
cleanup();
return TRUE;
}
-#endif
-
static gboolean cw_cb (GtkWidget *widget, GdkEventButton *event, gpointer data) {
cleanup();
cw_menu(top_window);
}
#endif
+#ifdef MIDI
+void start_midi() {
+ cleanup();
+ midi_menu(top_window);
+}
+
+static gboolean midi_cb (GtkWidget *widget, GdkEventButton *event, gpointer data) {
+ start_midi();
+ return TRUE;
+}
+#endif
+
void new_menu()
{
int i;
gtk_grid_attach(GTK_GRID(grid),rigctl_b,(i%5),i/5,1,1);
i++;
-#ifdef GPIO
switch(controller) {
case NO_CONTROLLER:
{
case CONTROLLER2_V1:
case CONTROLLER2_V2:
{
+#ifdef GPIO
GtkWidget *encoders_b=gtk_button_new_with_label("Encoders");
g_signal_connect (encoders_b, "button-press-event", G_CALLBACK(encoder_cb), NULL);
gtk_grid_attach(GTK_GRID(grid),encoders_b,(i%5),i/5,1,1);
i++;
-
+#endif
GtkWidget *switches_b=gtk_button_new_with_label("Switches");
g_signal_connect (switches_b, "button-press-event", G_CALLBACK(switch_cb), NULL);
gtk_grid_attach(GTK_GRID(grid),switches_b,(i%5),i/5,1,1);
}
break;
}
+
+#ifdef MIDI
+ GtkWidget *midi_b=gtk_button_new_with_label("MIDI");
+ g_signal_connect (midi_b, "button-press-event", G_CALLBACK(midi_cb), NULL);
+ gtk_grid_attach(GTK_GRID(grid),midi_b,(i%5),i/5,1,1);
+ i++;
#endif
//
#define RXACTION_PS 2 // deliver 2*119 samples to PS engine
#define RXACTION_DIV 3 // take 2*119 samples, mix them, deliver to a receiver
-static int rxcase[MAX_DDC];
-static int rxid [MAX_DDC];
+static int rxcase[7/*MAX_DDC*/];
+static int rxid [7/*MAX_DDC*/];
int data_socket=-1;
static struct sockaddr_in iq_addr;
static int iq_addr_length;
-static struct sockaddr_in data_addr[MAX_DDC];
-static int data_addr_length[MAX_DDC];
+static struct sockaddr_in data_addr[7/*MAX_DDC*/];
+static int data_addr_length[7/*MAX_DDC*/];
static GThread *new_protocol_thread_id;
static GThread *new_protocol_timer_thread_id;
static long general_sequence = 0;
static long rx_specific_sequence = 0;
static long tx_specific_sequence = 0;
-static long ddc_sequence[MAX_DDC];
+static long ddc_sequence[7/*MAX_DDC*/];
//static int buffer_size=BUFFER_SIZE;
//static int fft_size=4096;
#endif
static GThread *mic_line_thread_id;
#ifdef __APPLE__
-static sem_t *iq_sem_ready[MAX_DDC];
-static sem_t *iq_sem_buffer[MAX_DDC];
+static sem_t *iq_sem_ready[7/*MAX_DDC*/];
+static sem_t *iq_sem_buffer[7/*MAX_DDC*/];
#else
-static sem_t iq_sem_ready[MAX_DDC];
-static sem_t iq_sem_buffer[MAX_DDC];
+static sem_t iq_sem_ready[7/*MAX_DDC*/];
+static sem_t iq_sem_buffer[7/*MAX_DDC*/];
#endif
-static GThread *iq_thread_id[MAX_DDC];
+static GThread *iq_thread_id[7/*MAX_DDC*/];
#ifdef INCLUDED
static int outputsamples;
// Network buffers
#define NET_BUFFER_SIZE 2048
-static unsigned char *iq_buffer[MAX_DDC];
+static unsigned char *iq_buffer[7/*MAX_DDC*/];
static unsigned char *command_response_buffer;
static unsigned char *high_priority_buffer;
static unsigned char *mic_line_buffer;
return 0;
}
-int cw_audio_write(float sample) {
- RECEIVER *rx = active_receiver;
+int cw_audio_write(RECEIVER *rx,float sample) {
float *buffer = rx->local_audio_buffer;
if (rx->playback_handle != NULL && rx->local_audio_buffer != NULL) {
#include "iambic.h"
#endif
#ifdef MIDI
+#include "alsa_midi.h"
+#include "midi_menu.h"
// rather than including MIDI.h with all its internal stuff
// (e.g. enum components) we just declare the single bit thereof
// we need here to make a strict compiler happy.
-void MIDIstartup();
+//extern void MIDIstartup();
#endif
#ifdef CLIENT_SERVER
#include "client_server.h"
#define TOOLBAR_HEIGHT (30)
#define WATERFALL_HEIGHT (105)
+#ifdef MIDI
+gboolean midi_enabled;
+#endif
+
gint controller=NO_CONTROLLER;
GtkWidget *fixed;
static cairo_surface_t *encoders_surface = NULL;
#endif
*/
- gint sat_mode;
+gint sat_mode;
- int region=REGION_OTHER;
+int region=REGION_OTHER;
- int echo=0;
+int echo=0;
- int radio_sample_rate;
- gboolean iqswap;
+int radio_sample_rate;
+gboolean iqswap;
- static gint save_timer_id;
+static gint save_timer_id;
- DISCOVERED *radio=NULL;
+DISCOVERED *radio=NULL;
#ifdef CLIENT_SERVER
- gboolean radio_is_remote=FALSE;
+gboolean radio_is_remote=FALSE;
#endif
- char property_path[128];
- GMutex property_mutex;
+char property_path[128];
+GMutex property_mutex;
-RECEIVER *receiver[MAX_RECEIVERS];
+RECEIVER *receiver[7];
RECEIVER *active_receiver;
TRANSMITTER *transmitter;
+int RECEIVERS;
+int MAX_RECEIVERS;
+int MAX_DDC;
+#ifdef PURESIGNAL
+int PS_TX_FEEDBACK;
+int PS_RX_FEEDBACK;
+#endif
+
+
+
int buffer_size=1024; // 64, 128, 256, 512, 1024, 2048
int fft_size=2048; // 1024, 2048, 4096, 8192, 16384
//int drive_level=0;
//int tune_drive_level=0;
-int receivers=RECEIVERS;
+int receivers;
ADC adc[2];
DAC dac[2];
break;
#ifdef SOAPYSDR
case SOAPYSDR_PROTOCOL:
- soapy_protocol_init(0,false);
+ soapy_protocol_init(FALSE);
break;
#endif
}
y+=TOOLBAR_HEIGHT;
}
-//
-// Now, if there should only one receiver be displayed
-// at startup, do the change. We must momentarily fake
-// the number of receivers otherwise radio_change_receivers
-// will do nothing.
-//
g_print("create_visual: receivers=%d RECEIVERS=%d\n",receivers,RECEIVERS);
if (receivers != RECEIVERS) {
int r=receivers;
#ifdef SOAPYSDR
adc[0].antenna=0;
if(device==SOAPYSDR_USB_DEVICE) {
- adc[0].rx_gain=malloc(radio->info.soapy.rx_gains*sizeof(gint));
- for (size_t i = 0; i < radio->info.soapy.rx_gains; i++) {
- adc[0].rx_gain[i]=0;
- }
+ adc[0].gain=0;
adc[0].agc=FALSE;
dac[0].antenna=1;
- dac[0].tx_gain=malloc(radio->info.soapy.tx_gains*sizeof(gint));
- for (size_t i = 0; i < radio->info.soapy.tx_gains; i++) {
- dac[0].tx_gain[i]=0;
- }
+ dac[0].gain=0;
}
#endif
#ifdef SOAPYSDR
adc[1].antenna=0;
if(device==SOAPYSDR_USB_DEVICE) {
- adc[1].rx_gain=malloc(radio->info.soapy.rx_gains*sizeof(gint));
- for (size_t i = 0; i < radio->info.soapy.rx_gains; i++) {
- adc[1].rx_gain[i]=0;
- }
+ adc[1].gain=0;
adc[1].agc=FALSE;
-
- dac[1].tx_gain=malloc(radio->info.soapy.tx_gains*sizeof(gint));
- for (size_t i = 0; i < radio->info.soapy.tx_gains; i++) {
- dac[1].tx_gain[i]=0;
- }
+ dac[1].antenna=1;
+ dac[1].gain=0;
}
radio_sample_rate=radio->info.soapy.sample_rate;
display_sliders=0;
display_toolbar=0;
break;
- case CONTROLLER_I2C:
- display_zoompan=0;
- display_sliders=0;
- display_toolbar=0;
- break;
}
#else
display_zoompan=1;
display_sequence_errors=TRUE;
+ g_print("%s: setup RECEIVERS protocol=%d\n",__FUNCTION__,protocol);
+ switch(protocol) {
+#ifdef SOAPYSDR
+ case SOAPYSDR_PROTOCOL:
+ g_print("%s: setup RECEIVERS SOAPYSDR\n",__FUNCTION__);
+ RECEIVERS=1;
+ MAX_RECEIVERS=RECEIVERS;
+#ifdef PURESIGNAL
+ PS_TX_FEEDBACK=0;
+ PS_RX_FEEDBACK=0;
+#endif
+ MAX_DDC=1;
+ break;
+#endif
+ default:
+ g_print("%s: setup RECEIVERS default\n",__FUNCTION__);
+ RECEIVERS=2;
+#ifdef PURESIGNAL
+ MAX_RECEIVERS=(RECEIVERS+2);
+ PS_TX_FEEDBACK=(RECEIVERS);
+ PS_RX_FEEDBACK=(RECEIVERS+1);
+#else
+ MAX_RECEIVERS=RECEIVERS;
+#endif
+ MAX_DDC=(RECEIVERS+2);
+ break;
+ }
+
+ receivers=RECEIVERS;
+
radioRestoreState();
//
if(can_transmit) {
soapy_protocol_create_transmitter(transmitter);
soapy_protocol_set_tx_antenna(transmitter,dac[0].antenna);
-/*
- for(int i=0;i<radio->info.soapy.tx_gains;i++) {
- soapy_protocol_set_tx_gain_element(transmitter,radio->info.soapy.tx_gain[i],dac[0].tx_gain[i]);
- }
-*/
soapy_protocol_set_tx_gain(transmitter,transmitter->drive);
soapy_protocol_set_tx_frequency(transmitter);
soapy_protocol_start_transmitter(transmitter);
}
soapy_protocol_set_rx_antenna(rx,adc[0].antenna);
-/*
- for(int i=0;i<radio->info.soapy.rx_gains;i++) {
- soapy_protocol_set_gain_element(rx,radio->info.soapy.rx_gain[i],adc[0].rx_gain[i]);
- }
-*/
-
soapy_protocol_set_rx_frequency(rx,VFO_A);
soapy_protocol_set_automatic_gain(rx,adc[0].agc);
- for(int i=0;i<radio->info.soapy.rx_gains;i++) {
- soapy_protocol_set_gain_element(rx,radio->info.soapy.rx_gain[i],adc[0].rx_gain[i]);
- }
+ soapy_protocol_set_gain(rx);
if(vfo[0].ctun) {
setFrequency(vfo[0].ctun_frequency);
soapy_protocol_start_receiver(rx);
//g_print("radio: set rf_gain=%f\n",rx->rf_gain);
- soapy_protocol_set_gain(rx,rx->rf_gain);
+ soapy_protocol_set_gain(rx);
}
#endif
// running. So this is the last thing we do when starting the radio.
//
#ifdef MIDI
- MIDIstartup();
+ g_print("%s: midi_enabled=%d midi_device_name=%s\n",__FUNCTION__,midi_enabled,midi_device_name);
+ if(midi_enabled && (midi_device_name!=NULL)) {
+ if(register_midi_device(midi_device_name)<0) {
+ midi_enabled=FALSE;
+ }
+ } else {
+ midi_enabled=FALSE;
+ }
#endif
#ifdef CLIENT_SERVER
#ifdef SOAPYSDR
if(device==SOAPYSDR_USB_DEVICE) {
- char name[128];
- for(int i=0;i<radio->info.soapy.rx_gains;i++) {
- sprintf(name,"radio.adc[0].rx_gain.%s",radio->info.soapy.rx_gain[i]) ;
- value=getProperty(name);
- if(value!=NULL) adc[0].rx_gain[i]=atoi(value);
- }
+ value=getProperty("radio.adc[0].gain");
+ if(value!=NULL) adc[0].gain=atoi(value);
value=getProperty("radio.adc[0].agc");
if(value!=NULL) adc[0].agc=atoi(value);
value=getProperty("radio.adc[0].antenna");
value=getProperty("radio.dac[0].antenna");
if(value!=NULL) dac[0].antenna=atoi(value);
- for(int i=0;i<radio->info.soapy.tx_gains;i++) {
- sprintf(name,"radio.dac[0].tx_gain.%s",radio->info.soapy.tx_gain[i]);
- value=getProperty(name);
- if(value!=NULL) dac[0].tx_gain[i]=atoi(value);
- }
+ value=getProperty("radio.dac[0].gain");
+ if(value!=NULL) dac[0].gain=atoi(value);
}
#endif
+#ifdef MIDI
+ midi_restore_state();
+ value=getProperty("radio.midi_enabled");
+ if(value) midi_enabled=atoi(value);
+#endif
+
value=getProperty("radio.display_sequence_errors");
if(value!=NULL) display_sequence_errors=atoi(value);
#ifdef SOAPYSDR
if(device==SOAPYSDR_USB_DEVICE) {
- char name[128];
- for(int i=0;i<radio->info.soapy.rx_gains;i++) {
- sprintf(name,"radio.adc[0].rx_gain.%s",radio->info.soapy.rx_gain[i]);
- sprintf(value,"%d", adc[0].rx_gain[i]);
- setProperty(name,value);
- }
- sprintf(name,"radio.adc[0].agc");
+ sprintf(value,"%f", adc[0].gain);
+ setProperty("radio.adc[0].gain",value);
sprintf(value,"%d", soapy_protocol_get_automatic_gain(receiver[0]));
- setProperty(name,value);
- sprintf(name,"radio.adc[0].antenna");
+ setProperty("radio.adc[0].agc",value);
sprintf(value,"%d", adc[0].antenna);
- setProperty(name,value);
+ setProperty("radio.adc[0].antenna",value);
- sprintf(name,"radio.dac[0].antenna");
sprintf(value,"%d", dac[0].antenna);
- setProperty(name,value);
-
- for(int i=0;i<radio->info.soapy.tx_gains;i++) {
- sprintf(name,"radio.dac[0].tx_gain.%s",radio->info.soapy.tx_gain[i]);
- sprintf(value,"%d", dac[0].tx_gain[i]);
- setProperty(name,value);
- }
-
- for(int i=0;i<radio->info.soapy.rx_gains;i++) {
- sprintf(name,"radio.adc[1].rx_gain.%s",radio->info.soapy.rx_gain[i]);
- sprintf(value,"%d", adc[1].rx_gain[i]);
- setProperty(name,value);
- }
- sprintf(name,"radio.adc[1].agc");
- sprintf(value,"%d", soapy_protocol_get_automatic_gain(receiver[1]));
- setProperty(name,value);
- sprintf(name,"radio.adc[1].antenna");
- sprintf(value,"%d", adc[1].antenna);
- setProperty(name,value);
-
- sprintf(name,"radio.dac[1].antenna");
- sprintf(value,"%d", dac[1].antenna);
- setProperty(name,value);
-
- for(int i=0;i<radio->info.soapy.tx_gains;i++) {
- sprintf(name,"radio.dac[1].tx_gain.%s",radio->info.soapy.tx_gain[i]);
- sprintf(value,"%d", dac[1].tx_gain[i]);
- setProperty(name,value);
+ setProperty("radio.dac[0].antenna",value);
+
+ sprintf(value,"%f", dac[0].gain);
+ setProperty("radio.dac[0].gain",value);
+
+ if(receivers>1) {
+ sprintf(value,"%f", adc[1].gain);
+ setProperty("radio.adc[1].gain",value);
+ sprintf(value,"%d", soapy_protocol_get_automatic_gain(receiver[1]));
+ setProperty("radio.adc[1].agc",value);
+ sprintf(value,"%d", adc[1].antenna);
+ setProperty("radio.adc[1].antenna",value);
+
+ sprintf(value,"%d", dac[1].antenna);
+ setProperty("radio.dac[1].antenna",value);
+
+ sprintf(value,"%f", dac[1].gain);
+ setProperty("radio.dac[1].gain",value);
}
}
#endif
}
#endif
+#ifdef MIDI
+ sprintf(value,"%d",midi_enabled);
+ setProperty("radio.midi_enabled",value);
+ midi_save_state();
+#endif
+
saveProperties(property_path);
g_mutex_unlock(&property_mutex);
}
#ifdef CLIENT_SERVER
int remote_start(void *data) {
char *server=(char *)data;
- sprintf(property_path,"%s@%s.props",radio->name,server);
+ sprintf(property_path,"%s@%s.props",name,server);
radio_is_remote=TRUE;
#ifdef GPIO
switch(controller) {
extern int region;
-// specify how many receivers: for PURESIGNAL need two extra
-#define RECEIVERS 2
+extern int RECEIVERS;
+extern int MAX_RECEIVERS;
+extern int MAX_DDC;
#ifdef PURESIGNAL
-#define MAX_RECEIVERS (RECEIVERS+2)
-#define PS_TX_FEEDBACK (RECEIVERS)
-#define PS_RX_FEEDBACK (RECEIVERS+1)
-#else
-#define MAX_RECEIVERS RECEIVERS
+extern int PS_TX_FEEDBACK;
+extern int PS_RX_FEEDBACK;
#endif
-#define MAX_DDC (RECEIVERS+2)
+
+// specify how many receivers: for PURESIGNAL need two extra
+//#define RECEIVERS 2
+//#ifdef PURESIGNAL
+//#define MAX_RECEIVERS (RECEIVERS+2)
+//#define PS_TX_FEEDBACK (RECEIVERS)
+//#define PS_RX_FEEDBACK (RECEIVERS+1)
+//#else
+//#define MAX_RECEIVERS RECEIVERS
+//#endif
+//#define MAX_DDC (RECEIVERS+2)
extern RECEIVER *receiver[];
extern RECEIVER *active_receiver;
extern TRANSMITTER *transmitter;
+#ifdef MIDI
+extern gboolean midi_enabled;
+#endif
#define PA_DISABLED 0
#define PA_ENABLED 1
#ifdef SOAPYSDR
static void rf_gain_value_changed_cb(GtkWidget *widget, gpointer data) {
ADC *adc=(ADC *)data;
- active_receiver->rf_gain=gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
+ adc->gain=gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
if(radio->device==SOAPYSDR_USB_DEVICE) {
- soapy_protocol_set_gain(receiver[0],active_receiver->rf_gain);
+ soapy_protocol_set_gain(receiver[0]);
}
-
-/*
- for(int i=0;i<radio->info.soapy.rx_gains;i++) {
- int value=soapy_protocol_get_gain_element(active_receiver,radio->info.soapy.rx_gain[i]);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(rx_gains[i]),(double)value);
- }
-*/
-
}
static void rx_gain_value_changed_cb(GtkWidget *widget, gpointer data) {
#ifdef SOAPYSDR
case SOAPYSDR_PROTOCOL:
- {
- GtkWidget *sample_rate_label=gtk_label_new(NULL);
- gtk_label_set_markup(GTK_LABEL(sample_rate_label), "<b>Sample Rate:</b>");
- gtk_grid_attach(GTK_GRID(grid),sample_rate_label,col,row,1,1);
- row++;
+ if(strcmp(radio->name,"sdrplay")==0) {
+ GtkWidget *sample_rate_combo_box=gtk_combo_box_text_new();
+// gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(sample_rate_combo_box),NULL,"96000");
+// gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(sample_rate_combo_box),NULL,"192000");
+// gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(sample_rate_combo_box),NULL,"384000");
+ gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(sample_rate_combo_box),NULL,"768000");
+ switch(radio_sample_rate) {
+ case 96000:
+ gtk_combo_box_set_active(GTK_COMBO_BOX(sample_rate_combo_box),0);
+ break;
+ case 192000:
+ gtk_combo_box_set_active(GTK_COMBO_BOX(sample_rate_combo_box),1);
+ break;
+ case 384000:
+ gtk_combo_box_set_active(GTK_COMBO_BOX(sample_rate_combo_box),2);
+ break;
+ case 768000:
+ gtk_combo_box_set_active(GTK_COMBO_BOX(sample_rate_combo_box),3);
+ break;
+ }
+ g_signal_connect(sample_rate_combo_box,"changed",G_CALLBACK(sample_rate_cb),radio);
+ gtk_grid_attach(GTK_GRID(grid),sample_rate_combo_box,col,row,1,1);
+ row++;
+ } else {
+ GtkWidget *sample_rate_label=gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(sample_rate_label), "<b>Sample Rate:</b>");
+ gtk_grid_attach(GTK_GRID(grid),sample_rate_label,col,row,1,1);
+ row++;
- char rate[16];
- sprintf(rate,"%d",radio->info.soapy.sample_rate);
+ char rate[16];
+ sprintf(rate,"%d",radio->info.soapy.sample_rate);
- GtkWidget *sample_rate=gtk_radio_button_new_with_label(NULL,rate);
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sample_rate), radio->info.soapy.sample_rate);
- gtk_grid_attach(GTK_GRID(grid),sample_rate,col,row,1,1);
- g_signal_connect(sample_rate,"toggled",G_CALLBACK(sample_rate_cb),GINT_TO_POINTER(radio->info.soapy.sample_rate));
+ GtkWidget *sample_rate=gtk_radio_button_new_with_label(NULL,rate);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sample_rate), radio->info.soapy.sample_rate);
+ gtk_grid_attach(GTK_GRID(grid),sample_rate,col,row,1,1);
+ g_signal_connect(sample_rate,"toggled",G_CALLBACK(sample_rate_cb),GINT_TO_POINTER(radio->info.soapy.sample_rate));
- col++;
+ col++;
}
break;
#endif
col=0;
if(radio->device==SOAPYSDR_USB_DEVICE) {
int i;
-/*
if(radio->info.soapy.rx_gains>0) {
GtkWidget *rx_gain=gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(rx_gain), "<b>RX Gains:</b>");
row++;
temp_row=row;
-*/
col=0;
-/*
- //rx_gains=g_new(GtkWidget*,radio->info.soapy.rx_gains);
- for(i=0;i<radio->info.soapy.rx_gains;i++) {
+ if(strcmp(radio->name,"sdrplay")==0) {
+ for(i=0;i<radio->info.soapy.rx_gains;i++) {
+ col=0;
+ GtkWidget *rx_gain_label=gtk_label_new(radio->info.soapy.rx_gain[i]);
+ gtk_grid_attach(GTK_GRID(grid),rx_gain_label,col,row,1,1);
+ col++;
+ SoapySDRRange range=radio->info.soapy.rx_range[i];
+ if(range.step==0.0) {
+ range.step=1.0;
+ }
+ rx_gains[i]=gtk_spin_button_new_with_range(range.minimum,range.maximum,range.step);
+ gtk_widget_set_name (rx_gains[i], radio->info.soapy.rx_gain[i]);
+ int value=soapy_protocol_get_gain_element(active_receiver,radio->info.soapy.rx_gain[i]);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(rx_gains[i]),(double)value);
+ gtk_grid_attach(GTK_GRID(grid),rx_gains[i],col,row,1,1);
+ g_signal_connect(rx_gains[i],"value_changed",G_CALLBACK(rx_gain_value_changed_cb),&adc[0]);
+
+ row++;
+ }
+ } else {
+ // used single gain control - LimeSDR works out best setting for the 3 rx gains
col=0;
- GtkWidget *rx_gain_label=gtk_label_new(radio->info.soapy.rx_gain[i]);
- gtk_grid_attach(GTK_GRID(grid),rx_gain_label,col,row,1,1);
+ GtkWidget *rf_gain_label=gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(rf_gain_label), "<b>RF Gain</b>");
+ gtk_grid_attach(GTK_GRID(grid),rf_gain_label,col,row,1,1);
col++;
- SoapySDRRange range=radio->info.soapy.rx_range[i];
- if(range.step==0.0) {
- range.step=1.0;
+ double max=100;
+ if(strcmp(radio->name,"lime")==0) {
+ max=60.0;
+ } else if(strcmp(radio->name,"plutosdr")==0) {
+ max=73.0;
}
- rx_gains[i]=gtk_spin_button_new_with_range(range.minimum,range.maximum,range.step);
- gtk_widget_set_name (rx_gains[i], radio->info.soapy.rx_gain[i]);
- int value=soapy_protocol_get_gain_element(active_receiver,radio->info.soapy.rx_gain[i]);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(rx_gains[i]),(double)value);
- //gtk_spin_button_set_value(GTK_SPIN_BUTTON(rx_gains[i]),(double)adc[0].rx_gain[i]);
- gtk_grid_attach(GTK_GRID(grid),rx_gains[i],col,row,1,1);
- g_signal_connect(rx_gains[i],"value_changed",G_CALLBACK(rx_gain_value_changed_cb),&adc[0]);
-
- gtk_widget_set_sensitive(rx_gains[i], FALSE);
+ GtkWidget *rf_gain_b=gtk_spin_button_new_with_range(0.0,max,1.0);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(rf_gain_b),active_receiver->rf_gain);
+ gtk_grid_attach(GTK_GRID(grid),rf_gain_b,col,row,1,1);
+ g_signal_connect(rf_gain_b,"value_changed",G_CALLBACK(rf_gain_value_changed_cb),&adc[0]);
row++;
}
-*/
- // used single gain control - LimeSDR works out best setting for the 3 rx gains
- col=0;
- GtkWidget *rf_gain_label=gtk_label_new(NULL);
- gtk_label_set_markup(GTK_LABEL(rf_gain_label), "<b>RF Gain</b>");
- gtk_grid_attach(GTK_GRID(grid),rf_gain_label,col,row,1,1);
- col++;
- double max=100;
- if(strcmp(radio->name,"lime")==0) {
- max=60.0;
- } else if(strcmp(radio->name,"plutosdr")==0) {
- max=73.0;
- }
- GtkWidget *rf_gain_b=gtk_spin_button_new_with_range(0.0,max,1.0);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(rf_gain_b),active_receiver->rf_gain);
- gtk_grid_attach(GTK_GRID(grid),rf_gain_b,col,row,1,1);
- g_signal_connect(rf_gain_b,"value_changed",G_CALLBACK(rf_gain_value_changed_cb),&adc[0]);
-
- row++;
if(radio->info.soapy.rx_has_automatic_gain) {
GtkWidget *agc=gtk_check_button_new_with_label("Hardware AGC: ");
g_print("receiver_change_sample_rate: id=%d rate=%d scale=%d buffer_size=%d output_samples=%d\n",rx->id,sample_rate,scale,rx->buffer_size,rx->output_samples);
#ifdef PURESIGNAL
+ if(can_transmit && transmitter->puresignal) {
if (rx->id == PS_RX_FEEDBACK) {
if (protocol == ORIGINAL_PROTOCOL) {
rx->pixels = 2* scale * rx->width;
g_mutex_unlock(&rx->mutex);
return;
}
+ }
#endif
if (rx->audio_output_buffer != NULL) {
g_free(rx->audio_output_buffer);
#else
#include <pulse/pulseaudio.h>
#include <pulse/simple.h>
-//#include <alsa/asoundlib.h>
#endif
enum _audio_t {
active_receiver->rf_gain=gtk_range_get_value(GTK_RANGE(af_gain_scale));
#ifdef SOAPYSDR
if(protocol==SOAPYSDR_PROTOCOL) {
- soapy_protocol_set_gain(active_receiver,active_receiver->rf_gain);
+ soapy_protocol_set_gain(active_receiver);
}
#endif
}
receiver[rx]->rf_gain=value;
#ifdef SOAPYSDR
if(protocol==SOAPYSDR_PROTOCOL) {
- soapy_protocol_set_gain(active_receiver,active_receiver->rf_gain);
+ soapy_protocol_set_gain(active_receiver);
}
#endif
if(display_sliders) {
#include "soapy_discovery.h"
static int rtlsdr_count=0;
+static int sdrplay_count=0;
static void get_info(char *driver) {
size_t rx_rates_length, tx_rates_length, rx_gains_length, tx_gains_length, ranges_length, rx_antennas_length, tx_antennas_length, rx_bandwidth_length, tx_bandwidth_length;
int i;
SoapySDRKwargs args={};
int software_version=0;
+ char *version;
+ char *address=NULL;
int rtlsdr_val=0;
+ int sdrplay_val=0;
char fw_version[16];
char gw_version[16];
char hw_version[16];
char p_version[16];
+ char** tx_antennas;
+ char** tx_gains;
fprintf(stderr,"soapy_discovery: get_info: %s\n", driver);
SoapySDRKwargs_set(&args, "rtl", count);
rtlsdr_val=rtlsdr_count;
rtlsdr_count++;
+ } else if(strcmp(driver,"sdrplay")==0) {
+ char label[16];
+ sprintf(label,"SDRplay Dev%d",sdrplay_count);
+ SoapySDRKwargs_set(&args, "label", label);
+ sdrplay_val=sdrplay_count;
+ sdrplay_count++;
}
SoapySDRDevice *sdr = SoapySDRDevice_make(&args);
SoapySDRKwargs_clear(&args);
char *hardwarekey=SoapySDRDevice_getHardwareKey(sdr);
fprintf(stderr,"HardwareKey=%s\n",hardwarekey);
+ if(strcmp(driver,"sdrplay")==0) {
+ address=hardwarekey;
+ }
SoapySDRKwargs info=SoapySDRDevice_getHardwareInfo(sdr);
for(i=0;i<info.size;i++) {
if(strcmp(info.keys[i],"firmwareVersion")==0) {
strcpy(fw_version,info.vals[i]);
}
+ if(strcmp(info.keys[i],"fw_version")==0) {
+ version=info.vals[i];
+ }
if(strcmp(info.keys[i],"gatewareVersion")==0) {
strcpy(gw_version,info.vals[i]);
software_version=(int)(atof(info.vals[i])*100.0);
}
+ if(strcmp(info.keys[i],"sdrplay_api_api_version")==0) {
+ /* take just the first 4 characters here */
+ info.vals[i][4]='\0';
+ version=info.vals[i];
+ }
if(strcmp(info.keys[i],"hardwareVersion")==0) {
strcpy(hw_version,info.vals[i]);
}
} else if(strcmp(driver,"plutosdr")==0) {
sample_rate=768000;
} else if(strcmp(driver,"rtlsdr")==0) {
- sample_rate=1048576;
+ sample_rate=1536000;
+ } else if(strcmp(driver,"sdrplay")==0) {
+ //sample_rate=96000;
+ sample_rate=768000;
} else {
sample_rate=1048576;
}
fprintf(stderr,"sample_rate selected %d\n",sample_rate);
- SoapySDRRange *tx_rates=SoapySDRDevice_getSampleRateRange(sdr, SOAPY_SDR_TX, 1, &tx_rates_length);
- fprintf(stderr,"Tx sample rates: ");
- for (size_t i = 0; i < tx_rates_length; i++) {
- fprintf(stderr,"%f -> %f (%f),", tx_rates[i].minimum, tx_rates[i].maximum, tx_rates[i].minimum/48000.0);
+ if(tx_channels>0) {
+ SoapySDRRange *tx_rates=SoapySDRDevice_getSampleRateRange(sdr, SOAPY_SDR_TX, 1, &tx_rates_length);
+ fprintf(stderr,"Tx sample rates: ");
+ for (size_t i = 0; i < tx_rates_length; i++) {
+ fprintf(stderr,"%f -> %f (%f),", tx_rates[i].minimum, tx_rates[i].maximum, tx_rates[i].minimum/48000.0);
+ }
+ fprintf(stderr,"\n");
+ free(tx_rates);
}
- fprintf(stderr,"\n");
- free(tx_rates);
double *bandwidths=SoapySDRDevice_listBandwidths(sdr, SOAPY_SDR_RX, 0, &rx_bandwidth_length);
fprintf(stderr,"Rx bandwidths: ");
fprintf(stderr,"\n");
free(bandwidths);
- bandwidths=SoapySDRDevice_listBandwidths(sdr, SOAPY_SDR_TX, 0, &tx_bandwidth_length);
- fprintf(stderr,"Tx bandwidths: ");
- for (size_t i = 0; i < tx_bandwidth_length; i++) {
- fprintf(stderr,"%f, ", bandwidths[i]);
+ if(tx_channels>0) {
+ bandwidths=SoapySDRDevice_listBandwidths(sdr, SOAPY_SDR_TX, 0, &tx_bandwidth_length);
+ fprintf(stderr,"Tx bandwidths: ");
+ for (size_t i = 0; i < tx_bandwidth_length; i++) {
+ fprintf(stderr,"%f, ", bandwidths[i]);
+ }
+ fprintf(stderr,"\n");
+ free(bandwidths);
}
- fprintf(stderr,"\n");
- free(bandwidths);
double bandwidth=SoapySDRDevice_getBandwidth(sdr, SOAPY_SDR_RX, 0);
fprintf(stderr,"RX0: bandwidth=%f\n",bandwidth);
- bandwidth=SoapySDRDevice_getBandwidth(sdr, SOAPY_SDR_TX, 0);
- fprintf(stderr,"TX0: bandwidth=%f\n",bandwidth);
+ if(tx_channels>0) {
+ bandwidth=SoapySDRDevice_getBandwidth(sdr, SOAPY_SDR_TX, 0);
+ fprintf(stderr,"TX0: bandwidth=%f\n",bandwidth);
+ }
SoapySDRRange *ranges = SoapySDRDevice_getFrequencyRange(sdr, SOAPY_SDR_RX, 0, &ranges_length);
fprintf(stderr,"Rx freq ranges: ");
for (size_t i = 0; i < rx_antennas_length; i++) fprintf(stderr, "%s, ", rx_antennas[i]);
fprintf(stderr,"\n");
- char** tx_antennas = SoapySDRDevice_listAntennas(sdr, SOAPY_SDR_TX, 0, &tx_antennas_length);
- fprintf(stderr, "Tx antennas: ");
- for (size_t i = 0; i < tx_antennas_length; i++) fprintf(stderr, "%s, ", tx_antennas[i]);
- fprintf(stderr,"\n");
+
+ if(tx_channels>0) {
+ tx_antennas = SoapySDRDevice_listAntennas(sdr, SOAPY_SDR_TX, 0, &tx_antennas_length);
+ fprintf(stderr, "Tx antennas: ");
+ for (size_t i = 0; i < tx_antennas_length; i++) fprintf(stderr, "%s, ", tx_antennas[i]);
+ fprintf(stderr,"\n");
+ }
char **rx_gains = SoapySDRDevice_listGains(sdr, SOAPY_SDR_RX, 0, &rx_gains_length);
gboolean has_automatic_dc_offset_correction=SoapySDRDevice_hasDCOffsetMode(sdr, SOAPY_SDR_RX, 0);
fprintf(stderr,"has_automaic_dc_offset_correction=%d\n",has_automatic_dc_offset_correction);
- char **tx_gains = SoapySDRDevice_listGains(sdr, SOAPY_SDR_TX, 1, &tx_gains_length);
+ if(tx_channels>0) {
+ tx_gains = SoapySDRDevice_listGains(sdr, SOAPY_SDR_TX, 1, &tx_gains_length);
+ }
size_t formats_length;
char **formats = SoapySDRDevice_getStreamFormats(sdr,SOAPY_SDR_RX,0,&formats_length);
for (size_t i = 0; i < formats_length; i++) fprintf(stderr, "%s, ", formats[i]);
fprintf(stderr,"\n");
- fprintf(stderr,"float=%lu double=%lu\n",sizeof(float),sizeof(double));
+ size_t sensors;
+ char **sensor = SoapySDRDevice_listSensors(sdr, &sensors);
+ gboolean has_temp=FALSE;
+ char *ptr;
+ fprintf(stderr, "Sensors:\n");
+ for (size_t i = 0; i < sensors; i++) {
+ char *value=SoapySDRDevice_readSensor(sdr, sensor[i]);
+ fprintf(stderr, " %s=%s\n", sensor[i],value);
+ if((ptr=strstr(sensor[i],"temp"))!=NULL) {
+ has_temp=TRUE;
+ }
+ }
if(devices<MAX_DEVICES) {
discovered[devices].device=SOAPYSDR_USB_DEVICE;
discovered[devices].info.soapy.sample_rate=sample_rate;
if(strcmp(driver,"rtlsdr")==0) {
discovered[devices].info.soapy.rtlsdr_count=rtlsdr_val;
+ discovered[devices].info.soapy.sdrplay_count=0;
+ } else if(strcmp(driver,"sdrplay")==0) {
+ discovered[devices].info.soapy.rtlsdr_count=0;
+ discovered[devices].info.soapy.sdrplay_count=sdrplay_val;
} else {
discovered[devices].info.soapy.rtlsdr_count=0;
+ discovered[devices].info.soapy.sdrplay_count=0;
}
if(strcmp(driver,"lime")==0) {
sprintf(discovered[devices].info.soapy.version,"fw=%s gw=%s hw=%s p=%s", fw_version, gw_version, hw_version, p_version);
discovered[devices].info.soapy.rx_antenna=rx_antennas;
discovered[devices].info.soapy.tx_channels=tx_channels;
- discovered[devices].info.soapy.tx_gains=tx_gains_length;
- discovered[devices].info.soapy.tx_gain=tx_gains;
- discovered[devices].info.soapy.tx_range=malloc(tx_gains_length*sizeof(SoapySDRRange));
-fprintf(stderr,"Tx gains: \n");
- for (size_t i = 0; i < tx_gains_length; i++) {
- fprintf(stderr,"%s ", tx_gains[i]);
- SoapySDRRange tx_range=SoapySDRDevice_getGainElementRange(sdr, SOAPY_SDR_TX, 1, tx_gains[i]);
- fprintf(stderr,"%f -> %f step=%f\n",tx_range.minimum,tx_range.maximum,tx_range.step);
- discovered[devices].info.soapy.tx_range[i]=tx_range;
+ if(tx_channels>0) {
+ discovered[devices].info.soapy.tx_gains=tx_gains_length;
+ discovered[devices].info.soapy.tx_gain=tx_gains;
+ discovered[devices].info.soapy.tx_range=malloc(tx_gains_length*sizeof(SoapySDRRange));
+ fprintf(stderr,"Tx gains: \n");
+ for (size_t i = 0; i < tx_gains_length; i++) {
+ fprintf(stderr,"%s ", tx_gains[i]);
+ SoapySDRRange tx_range=SoapySDRDevice_getGainElementRange(sdr, SOAPY_SDR_TX, 1, tx_gains[i]);
+ fprintf(stderr,"%f -> %f step=%f\n",tx_range.minimum,tx_range.maximum,tx_range.step);
+ discovered[devices].info.soapy.tx_range[i]=tx_range;
+ }
+ discovered[devices].info.soapy.tx_antennas=tx_antennas_length;
+ discovered[devices].info.soapy.tx_antenna=tx_antennas;
}
- discovered[devices].info.soapy.tx_antennas=tx_antennas_length;
- discovered[devices].info.soapy.tx_antenna=tx_antennas;
+ discovered[devices].info.soapy.sensors=sensors;
+ discovered[devices].info.soapy.sensor=sensor;
+ discovered[devices].info.soapy.has_temp=has_temp;
+
+
+ if(address!=NULL) {
+ strcpy(discovered[devices].info.soapy.address,address);
+ } else {
+ strcpy(discovered[devices].info.soapy.address,"USB");
+ }
+
devices++;
}
+ SoapySDRDevice_unmake(sdr);
free(ranges);
-
}
void soapy_discovery() {
#include "SoapySDR/Device.h"
#include "SoapySDR/Formats.h"
#include "SoapySDR/Version.h"
+#include "SoapySDR/Logger.h"
//#define TIMING
#ifdef TIMING
#include "filter.h"
#include "receiver.h"
#include "transmitter.h"
-//#include "wideband.h"
-//#include "adc.h"
-//#include "dac.h"
#include "radio.h"
#include "main.h"
-//#include "protocol1.h"
#include "soapy_protocol.h"
#include "audio.h"
#include "signal.h"
#include "ext.h"
#include "error_handler.h"
-static double bandwidth=2000000.0;
-static SoapySDRDevice *soapy_device;
-static SoapySDRStream *rx_stream;
+#define MAX_CHANNELS 2
+static SoapySDRStream *rx_stream[MAX_CHANNELS];
static SoapySDRStream *tx_stream;
+static SoapySDRDevice *soapy_device;
static int max_samples;
static int samples=0;
+static double bandwidth=2000000.0;
+
static GThread *receive_thread_id;
static gpointer receive_thread(gpointer data);
}
void soapy_protocol_change_sample_rate(RECEIVER *rx) {
+ int rc;
+
// rx->mutex already locked
- if(rx->sample_rate==radio_sample_rate) {
+ if(strcmp(radio->name,"sdrplay")==0) {
+ g_print("%s: setting samplerate=%f\n",__FUNCTION__,(double)rx->sample_rate);
+ rc=SoapySDRDevice_setSampleRate(soapy_device,SOAPY_SDR_RX,rx->adc,(double)rx->sample_rate);
+ if(rc!=0) {
+ g_print("%s: SoapySDRDevice_setSampleRate(%f) failed: %s\n",__FUNCTION__,(double)rx->sample_rate,SoapySDR_errToStr(rc));
+ }
+ } else if(rx->sample_rate==radio_sample_rate) {
if(rx->resample_buffer!=NULL) {
g_free(rx->resample_buffer);
rx->resample_buffer=NULL;
mic_sample_divisor=rx->sample_rate/48000;
-fprintf(stderr,"soapy_protocol_create_receiver: setting samplerate=%f adc=%d mic_sample_divisor=%d\n",(double)radio_sample_rate,rx->adc,mic_sample_divisor);
+ g_print("%s: device=%p adc=%d setting bandwidth=%f\n",__FUNCTION__,soapy_device,rx->adc,bandwidth);
+ rc=SoapySDRDevice_setBandwidth(soapy_device,SOAPY_SDR_RX,rx->adc,bandwidth);
+ if(rc!=0) {
+ g_print("%s: SoapySDRDevice_setBandwidth(%f) failed: %s\n",__FUNCTION__,(double)bandwidth,SoapySDR_errToStr(rc));
+ }
+
+ g_print("%s: setting samplerate=%f device=%p adc=%d mic_sample_divisor=%d\n",__FUNCTION__,(double)radio_sample_rate,soapy_device,rx->adc,mic_sample_divisor);
rc=SoapySDRDevice_setSampleRate(soapy_device,SOAPY_SDR_RX,rx->adc,(double)radio_sample_rate);
if(rc!=0) {
- fprintf(stderr,"soapy_protocol_create_receiver: SoapySDRDevice_setSampleRate(%f) failed: %s\n",(double)radio_sample_rate,SoapySDR_errToStr(rc));
+ g_print("%s: SoapySDRDevice_setSampleRate(%f) failed: %s\n",__FUNCTION__,(double)radio_sample_rate,SoapySDR_errToStr(rc));
}
size_t channel=rx->adc;
#if defined(SOAPY_SDR_API_VERSION) && (SOAPY_SDR_API_VERSION < 0x00080000)
-fprintf(stderr,"soapy_protocol_create_receiver: SoapySDRDevice_setupStream(version<0x00080000): channel=%ld\n",channel);
- rc=SoapySDRDevice_setupStream(soapy_device,&rx_stream,SOAPY_SDR_RX,SOAPY_SDR_CF32,&channel,1,NULL);
+ g_print("%s: SoapySDRDevice_setupStream(version<0x00080000): channel=%ld\n",__FUNCTION__,channel);
+ rc=SoapySDRDevice_setupStream(soapy_device,&rx_stream[channel],SOAPY_SDR_RX,SOAPY_SDR_CF32,&channel,1,NULL);
if(rc!=0) {
- fprintf(stderr,"soapy_protocol_create_receiver: SoapySDRDevice_setupStream (RX) failed: %s\n",SoapySDR_errToStr(rc));
+ g_print("%s: SoapySDRDevice_setupStream (RX) failed: %s\n",__FUNCTION__,SoapySDR_errToStr(rc));
_exit(-1);
}
#else
-fprintf(stderr,"soapy_protocol_create_receiver: SoapySDRDevice_setupStream(version>=0x00080000): channel=%ld\n",channel);
- rx_stream=SoapySDRDevice_setupStream(soapy_device,SOAPY_SDR_RX,SOAPY_SDR_CF32,&channel,1,NULL);
- if(rx_stream==NULL) {
- fprintf(stderr,"soapy_protocol_create_receiver: SoapySDRDevice_setupStream (RX) failed (rx_stream is NULL)\n");
+ g_print("%s: SoapySDRDevice_setupStream(version>=0x00080000): channel=%ld\n",__FUNCTION__,channel);
+ rx_stream[channel]=SoapySDRDevice_setupStream(soapy_device,SOAPY_SDR_RX,SOAPY_SDR_CF32,&channel,1,NULL);
+ if(rx_stream[channel]==NULL) {
+ g_print("%s: SoapySDRDevice_setupStream (RX) failed (rx_stream is NULL)\n",__FUNCTION__);
_exit(-1);
}
#endif
+ g_print("%s: id=%d soapy_device=%p rx_stream=%p\n",__FUNCTION__,rx->id,soapy_device,rx_stream);
- max_samples=SoapySDRDevice_getStreamMTU(soapy_device,rx_stream);
+ max_samples=SoapySDRDevice_getStreamMTU(soapy_device,rx_stream[channel]);
+ g_print("%s: max_samples=%d\n",__FUNCTION__,max_samples);
if(max_samples>(2*rx->fft_size)) {
max_samples=2*rx->fft_size;
}
+ /*
if(max_samples>=4096) {
max_samples=4096;
} else if(max_samples>=2048) {
} else {
max_samples=1024;
}
+ */
rx->buffer=g_new(double,max_samples*2);
if(rx->sample_rate==radio_sample_rate) {
}
-fprintf(stderr,"soapy_protocol_create_receiver: max_samples=%d buffer=%p\n",max_samples,rx->buffer);
+g_print("%s: max_samples=%d buffer=%p\n",__FUNCTION__,max_samples,rx->buffer);
}
void soapy_protocol_start_receiver(RECEIVER *rx) {
int rc;
-double rate=SoapySDRDevice_getSampleRate(soapy_device,SOAPY_SDR_RX,rx->adc);
-fprintf(stderr,"soapy_protocol_start_receiver: activate_stream rate=%f\n",rate);
- rc=SoapySDRDevice_activateStream(soapy_device, rx_stream, 0, 0LL, 0);
+ g_print("%s: id=%d soapy_device=%p rx_stream=%p\n",__FUNCTION__,rx->id,soapy_device,rx_stream);
+
+ size_t channel=rx->adc;
+ double rate=SoapySDRDevice_getSampleRate(soapy_device,SOAPY_SDR_RX,rx->adc);
+ g_print("%s: rate=%f\n",__FUNCTION__,rate);
+
+ g_print("%s: activate Stream\n",__FUNCTION__);
+ rc=SoapySDRDevice_activateStream(soapy_device, rx_stream[channel], 0, 0LL, 0);
if(rc!=0) {
- fprintf(stderr,"soapy_protocol_start_receiver: SoapySDRDevice_activateStream failed: %s\n",SoapySDR_errToStr(rc));
+ g_print("%s: SoapySDRDevice_activateStream failed: %s\n",__FUNCTION__,SoapySDR_errToStr(rc));
_exit(-1);
}
-fprintf(stderr,"soapy_protocol_start_receiver: create receive_thread\n");
+ g_print("%s: create receiver_thread\n",__FUNCTION__);
receive_thread_id = g_thread_new( "soapy_rx", receive_thread, rx);
if( ! receive_thread_id )
{
- fprintf(stderr,"g_thread_new failed for receive_thread\n");
+ g_print("%s: g_thread_new failed for receive_thread\n",__FUNCTION__);
exit( -1 );
}
- fprintf(stderr, "receive_thread: id=%p\n",receive_thread_id);
+ g_print("%s: receiver_thread_id=%p\n",__FUNCTION__,receive_thread_id);
}
void soapy_protocol_create_transmitter(TRANSMITTER *tx) {
int rc;
-
-fprintf(stderr,"soapy_protocol_create_transmitter: setting samplerate=%f\n",(double)tx->iq_output_rate);
+ g_print("%s: setting samplerate=%f\n",__FUNCTION__,(double)tx->iq_output_rate);
rc=SoapySDRDevice_setSampleRate(soapy_device,SOAPY_SDR_TX,tx->dac,(double)tx->iq_output_rate);
if(rc!=0) {
- fprintf(stderr,"soapy_protocol_configure_transmitter: SoapySDRDevice_setSampleRate(%f) failed: %s\n",(double)tx->iq_output_rate,SoapySDR_errToStr(rc));
+ g_print("%s: SoapySDRDevice_setSampleRate(%f) failed: %s\n",__FUNCTION__,(double)tx->iq_output_rate,SoapySDR_errToStr(rc));
}
size_t channel=tx->dac;
-fprintf(stderr,"soapy_protocol_create_transmitter: SoapySDRDevice_setupStream: channel=%ld\n",channel);
+ g_print("%s: SoapySDRDevice_setupStream: channel=%ld\n",__FUNCTION__,channel);
#if defined(SOAPY_SDR_API_VERSION) && (SOAPY_SDR_API_VERSION < 0x00080000)
rc=SoapySDRDevice_setupStream(soapy_device,&tx_stream,SOAPY_SDR_TX,SOAPY_SDR_CF32,&channel,1,NULL);
if(rc!=0) {
- fprintf(stderr,"soapy_protocol_create_transmitter: SoapySDRDevice_setupStream (RX) failed: %s\n",SoapySDR_errToStr(rc));
+ g_print("%s: SoapySDRDevice_setupStream (RX) failed: %s\n",__FUNCTION__,SoapySDR_errToStr(rc));
_exit(-1);
}
#else
tx_stream=SoapySDRDevice_setupStream(soapy_device,SOAPY_SDR_TX,SOAPY_SDR_CF32,&channel,1,NULL);
if(tx_stream==NULL) {
- fprintf(stderr,"soapy_protocol_create_transmitter: SoapySDRDevice_setupStream (TX) failed: %s\n",SoapySDR_errToStr(rc));
+ g_print("%s: SoapySDRDevice_setupStream (TX) failed: %s\n",__FUNCTION__,SoapySDR_errToStr(rc));
_exit(-1);
}
#endif
if(max_tx_samples>(2*tx->fft_size)) {
max_tx_samples=2*tx->fft_size;
}
-fprintf(stderr,"soapy_protocol_create_transmitter: max_tx_samples=%d\n",max_tx_samples);
+ g_print("%s: max_tx_samples=%d\n",__FUNCTION__,max_tx_samples);
output_buffer=(float *)malloc(max_tx_samples*sizeof(float)*2);
}
}
}
-void soapy_protocol_init(int rx,gboolean hf) {
+void soapy_protocol_init(gboolean hf) {
SoapySDRKwargs args={};
+ char temp[32];
int rc;
int i;
-fprintf(stderr,"soapy_protocol_init: rx=%d hf=%d\n",rx,hf);
+
+ SoapySDR_setLogLevel(SOAPY_SDR_TRACE);
+
+g_print("%s: hf=%d driver=%s\n",__FUNCTION__,hf,radio->name);
// initialize the radio
-fprintf(stderr,"soapy_protocol_init: SoapySDRDevice_make\n");
SoapySDRKwargs_set(&args, "driver", radio->name);
if(strcmp(radio->name,"rtlsdr")==0) {
- char id[16];
- sprintf(id,"%d",radio->info.soapy.rtlsdr_count);
- SoapySDRKwargs_set(&args, "rtl", id);
+ sprintf(temp,"%d",radio->info.soapy.rtlsdr_count);
+ SoapySDRKwargs_set(&args, "rtl", temp);
if(hf) {
SoapySDRKwargs_set(&args, "direct_samp", "2");
} else {
SoapySDRKwargs_set(&args, "direct_samp", "0");
}
+ } else if(strcmp(radio->name,"sdrplay")==0) {
+ sprintf(temp,"SDRplay Dev%d",radio->info.soapy.sdrplay_count);
+ g_print("%s: label=%s\n",__FUNCTION__,temp);
+ SoapySDRKwargs_set(&args, "label", temp);
}
soapy_device=SoapySDRDevice_make(&args);
if(soapy_device==NULL) {
- fprintf(stderr,"soapy_protocol: SoapySDRDevice_make failed: %s\n",SoapySDRDevice_lastError());
+ g_print("%s: SoapySDRDevice_make failed: %s\n",__FUNCTION__,SoapySDRDevice_lastError());
_exit(-1);
}
SoapySDRKwargs_clear(&args);
+ g_print("%s: soapy_device=%p\n",__FUNCTION__,soapy_device);
+
if(can_transmit) {
if(transmitter->local_microphone) {
if(audio_open_input()!=0) {
- fprintf(stderr,"audio_open_input failed\n");
+ g_print("%s: audio_open_input failed\n",__FUNCTION__);
transmitter->local_microphone=0;
}
}
float fsample;
running=TRUE;
fprintf(stderr,"soapy_protocol: receive_thread\n");
+ size_t channel=rx->adc;
while(running) {
- elements=SoapySDRDevice_readStream(soapy_device,rx_stream,buffs,max_samples,&flags,&timeNs,timeoutUs);
+ elements=SoapySDRDevice_readStream(soapy_device,rx_stream[channel],buffs,max_samples,&flags,&timeNs,timeoutUs);
//fprintf(stderr,"soapy_protocol_receive_thread: SoapySDRDevice_readStream failed: max_samples=%d read=%d\n",max_samples,elements);
if(elements<0) {
continue;
}
fprintf(stderr,"soapy_protocol: receive_thread: SoapySDRDevice_deactivateStream\n");
- SoapySDRDevice_deactivateStream(soapy_device,rx_stream,0,0LL);
+ SoapySDRDevice_deactivateStream(soapy_device,rx_stream[channel],0,0LL);
fprintf(stderr,"soapy_protocol: receive_thread: SoapySDRDevice_closeStream\n");
- SoapySDRDevice_closeStream(soapy_device,rx_stream);
+ SoapySDRDevice_closeStream(soapy_device,rx_stream[channel]);
fprintf(stderr,"soapy_protocol: receive_thread: SoapySDRDevice_unmake\n");
SoapySDRDevice_unmake(soapy_device);
return NULL;
}
}
-void soapy_protocol_set_gain(RECEIVER *rx,double gain) {
+void soapy_protocol_set_gain(RECEIVER *rx) {
int rc;
//fprintf(stderr,"soapy_protocol_set_gain: adc=%d gain=%f\n",gain);
- rc=SoapySDRDevice_setGain(soapy_device,SOAPY_SDR_RX,rx->adc,gain);
+ rc=SoapySDRDevice_setGain(soapy_device,SOAPY_SDR_RX,rx->adc,adc[rx->adc].gain);
if(rc!=0) {
fprintf(stderr,"soapy_protocol: SoapySDRDevice_setGain failed: %s\n",SoapySDR_errToStr(rc));
}
void soapy_protocol_create_receiver(RECEIVER *rx);
void soapy_protocol_start_receiver(RECEIVER *rx);
-void soapy_protocol_init(int rx,gboolean hf);
+void soapy_protocol_init(gboolean hf);
void soapy_protocol_stop();
void soapy_protocol_set_rx_frequency(RECEIVER *rx,int v);
void soapy_protocol_set_rx_antenna(RECEIVER *rx,int ant);
void soapy_protocol_set_lna_gain(RECEIVER *rx,int gain);
-void soapy_protocol_set_gain(RECEIVER *rx,double gain);
+void soapy_protocol_set_gain(RECEIVER *rx);
void soapy_protocol_set_gain_element(RECEIVER *rx,char *name,int gain);
int soapy_protocol_get_gain_element(RECEIVER *rx,char *name);
void soapy_protocol_change_sample_rate(RECEIVER *rx);
gtk_grid_attach(GTK_GRID(grid),widget,col,row,1,1);
col++;
- if((controller==NO_CONTROLLER || controller==CONTROLLER1) && (i==0 || i==(max_switches-1))) {
+ if((controller==NO_CONTROLLER || controller==CONTROLLER1) && (temp_switches[i].switch_function==FUNCTION)) {
widget=gtk_label_new(NULL);
g_sprintf(label,"<b>%s</b>",sw_string[temp_switches[i].switch_function]);
gtk_label_set_markup (GTK_LABEL(widget), label);
return FALSE;
}
+/*
static void tune_value_changed_cb(GtkWidget *widget, gpointer data) {
setTuneDrive(gtk_range_get_value(GTK_RANGE(tune_scale)));
}
+*/
void tx_menu(GtkWidget *parent) {
int i;
long long af = vfo[0].ctun ? vfo[0].ctun_frequency : vfo[0].frequency;
long long bf = vfo[1].ctun ? vfo[1].ctun_frequency : vfo[1].frequency;
+ if(vfo[0].entering_frequency) {
+ af=vfo[0].entered_frequency;
+ }
+ if(vfo[1].entering_frequency) {
+ bf=vfo[1].entered_frequency;
+ }
int oob=0;
if (can_transmit) oob=transmitter->out_of_band;
+
sprintf(temp_text,"VFO A: %0lld.%06lld",af/(long long)1000000,af%(long long)1000000);
if(txvfo == 0 && (isTransmitting() || oob)) {
if (oob) sprintf(temp_text,"VFO A: Out of band");
cairo_set_source_rgb(cr, 1.0, 0.0, 0.0);
} else {
- if(id==0) {
+ if(vfo[0].entering_frequency) {
+ cairo_set_source_rgb(cr, 1.0, 1.0, 0.0);
+ } else if(id==0) {
cairo_set_source_rgb(cr, 0.0, 1.0, 0.0);
} else {
cairo_set_source_rgb(cr, 0.0, 0.65, 0.0);
if (oob) sprintf(temp_text,"VFO B: Out of band");
cairo_set_source_rgb(cr, 1.0, 0.0, 0.0);
} else {
- if(id==1) {
+ if(vfo[1].entering_frequency) {
+ cairo_set_source_rgb(cr, 1.0, 1.0, 0.0);
+ } else if(id==1) {
cairo_set_source_rgb(cr, 0.0, 1.0, 0.0);
} else {
cairo_set_source_rgb(cr, 0.0, 0.65, 0.0);
long long lo;
long long offset;
+ gboolean entering_frequency;
+ gint64 entered_frequency;
+
};
extern struct _vfo vfo[MAX_VFOS];
projects / pihpsdr.git / commitdiff