kopia lustrzana https://github.com/jprochazka/adsb-receiver
832 wiersze
40 KiB
Bash
Executable File
832 wiersze
40 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
#####################################################################################
|
|
# ADS-B RECEIVER #
|
|
#####################################################################################
|
|
# #
|
|
# This script is not meant to be executed directly. #
|
|
# Instead execute install.sh to begin the installation process. #
|
|
# #
|
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
# #
|
|
# Copyright (c) 2016-2017, Joseph A. Prochazka & Romeo Golf #
|
|
# #
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy #
|
|
# of this software and associated documentation files (the "Software"), to deal #
|
|
# in the Software without restriction, including without limitation the rights #
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell #
|
|
# copies of the Software, and to permit persons to whom the Software is #
|
|
# furnished to do so, subject to the following conditions: #
|
|
# #
|
|
# The above copyright notice and this permission notice shall be included in all #
|
|
# copies or substantial portions of the Software. #
|
|
# #
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR #
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, #
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE #
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, #
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE #
|
|
# SOFTWARE. #
|
|
# #
|
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
|
|
### VARIABLES
|
|
|
|
RECEIVER_ROOT_DIRECTORY="${PWD}"
|
|
RECEIVER_BASH_DIRECTORY="${RECEIVER_ROOT_DIRECTORY}/bash"
|
|
RECEIVER_BUILD_DIRECTORY="${RECEIVER_ROOT_DIRECTORY}/build"
|
|
|
|
# Component specific variables.
|
|
COMPONENT_BUILD_DIRECTORY="${RECEIVER_BUILD_DIRECTORY}/ogn"
|
|
COMPONENT_GITHUB="https://github.com/glidernet/ogn-rf"
|
|
COMPONENT_WEBSITE="http://wiki.glidernet.org"
|
|
COMPONENT_NAME="RTLSDR-OGN"
|
|
COMPONENT_DESC="is a combined decoder and feeder for the Open Glider Network which focuses on tracking gilders and other GA aircraft equipped with FLARM, FLARM-compatible devices or OGN tracker"
|
|
COMPONENT_RADIO="Please note that a dedicated RTL-SDR dongle is required to use this decoder"
|
|
|
|
# Component service script variables.
|
|
COMPONENT_SERVICE_NAME="rtlsdr-ogn"
|
|
COMPONENT_SERVICE_SCRIPT_URL="http://download.glidernet.org/common/service/rtlsdr-ogn"
|
|
COMPONENT_SERVICE_SCRIPT_NAME="${COMPONENT_SERVICE_NAME}"
|
|
COMPONENT_SERVICE_SCRIPT_PATH="/etc/init.d/${COMPONENT_SERVICE_NAME}"
|
|
COMPONENT_SERVICE_CONFIG_PATH="/etc/${COMPONENT_SERVICE_SCRIPT_NAME}.conf"
|
|
|
|
### INCLUDE EXTERNAL SCRIPTS
|
|
|
|
source ${RECEIVER_BASH_DIRECTORY}/variables.sh
|
|
source ${RECEIVER_BASH_DIRECTORY}/functions.sh
|
|
|
|
# To be moved to functions.sh...
|
|
|
|
#################################################################################
|
|
# Blacklist DVB-T drivers for RTL-SDR devices.
|
|
|
|
function BlacklistModules () {
|
|
RECEIVER_KERNEL_MODULE_BLACKLIST="/etc/modprobe.d/rtlsdr-blacklist.conf"
|
|
if [[ ! -f "${RECEIVER_KERNEL_MODULE_BLACKLIST}" ]] || [[ `cat ${RECEIVER_KERNEL_MODULE_BLACKLIST} | wc -l` -lt 9 ]] ; then
|
|
echo -en "\e[33m Installing blacklist to prevent unwanted kernel modules from being loaded...\e[97m"
|
|
sudo tee ${RECEIVER_KERNEL_MODULE_BLACKLIST} > /dev/null <<EOF
|
|
blacklist dvb_usb_v2
|
|
blacklist dvb_usb_rtl28xxu
|
|
blacklist dvb_usb_rtl2830u
|
|
blacklist dvb_usb_rtl2832u
|
|
blacklist rtl_2830
|
|
blacklist rtl_2832
|
|
blacklist r820t
|
|
blacklist rtl2830
|
|
blacklist rtl2832
|
|
EOF
|
|
else
|
|
echo -en "\e[33m Kernel module blacklist already installed...\e[97m"
|
|
fi
|
|
}
|
|
|
|
#################################################################################
|
|
# Calculate RTL-SDR device error rate.
|
|
|
|
function CalibrateTuner () {
|
|
# Attempt to calibrate the specified tuner using GSM frequencies.
|
|
if [[ -n "$1" ]] ; then
|
|
COMPONENT_CALIBRATION_DEVICE_ID="$1"
|
|
# GSM Band is GSM850 in US and GSM900 elsewhere, should probably try to figure this out...
|
|
COMPONENT_CALIBRATION_GSM_BAND="GSM900"
|
|
# Check if gain has been specified, otherwise set to 40.
|
|
if [[ -n "${OGN_GSM_GAIN}" ]] ; then
|
|
COMPONENT_CALIBRATION_GAIN="${OGN_GSM_GAIN}"
|
|
else
|
|
COMPONENT_CALIBRATION_GAIN="40"
|
|
fi
|
|
# Use the Kalibrate 'kal' binary if available.
|
|
if [[ -x "`which kal`" ]] ; then
|
|
echo -en "\e[33m Calibrating RTL-SDR device using Kalibrate, this may take up to 10 minutes...\e[97m"
|
|
COMPONENT_CALIBRATION_GSM_SCAN=`kal -d "${COMPONENT_CALIBRATION_DEVICE_ID}" -g "${COMPONENT_CALIBRATION_GAIN}" -s ${COMPONENT_CALIBRATION_GSM_BAND} 2>&1 | grep "power:" | sort -n -r -k 7 | grep -m1 "power:"`
|
|
COMPONENT_CALIBRATION_GSM_FREQ=`echo ${COMPONENT_CALIBRATION_GSM_SCAN} | awk '{print $3}' | sed -e 's/(//g' -e 's/MHz//g'`
|
|
COMPONENT_CALIBRATION_GSM_CHAN=`echo ${COMPONENT_CALIBRATION_GSM_SCAN} | awk '{print $2}'`
|
|
if [[ -n "${COMPONENT_CALIBRATION_GSM_CHAN}" ]] ; then
|
|
COMPONENT_CALIBRATION_ERROR=`kal -d "${COMPONENT_CALIBRATION_DEVICE_ID}" -g "${COMPONENT_CALIBRATION_GAIN}" -c "${COMPONENT_CALIBRATION_GSM_CHAN}" 2>&1 | grep "^average absolute error:" | awk '{print int($4)}' | sed -e 's/\-//g'`
|
|
else
|
|
echo -en "\e[33m Unable to calibrate RTL-SDR device \"${COMPONENT_CALIBRATION_DEVICE_ID}\" on channel \"${COMPONENT_CALIBRATION_GSM_CHAN}\"...\e[97m"
|
|
false
|
|
fi
|
|
# Otherwise use the gsm_scan binary provided with the OGN package.
|
|
elif [[ -x "${COMPONENT_PROJECT_DIRECTORY}/gsm_scan" ]] ; then
|
|
echo -en "\e[33m Calibrating RTL-SDR device using gsm_scan, this may take up to 20 minutes...\e[97m"
|
|
if [[ "${COMPONENT_CALIBRATION_GSM_BAND}" = "GSM850" ]] ; then
|
|
COMPONENT_CALIBRATION_GSM_OPTS="--gsm850"
|
|
else
|
|
COMPONENT_CALIBRATION_GSM_OPTS=""
|
|
fi
|
|
COMPONENT_CALIBRATION_GSM_SCAN=`gsm_scan --device "${COMPONENT_CALIBRATION_DEVICE_ID}" --gain "${COMPONENT_CALIBRATION_GAIN}" ${COMPONENT_CALIBRATION_GSM_OPTS} 2>&1 | grep "^[0-9]*\.[0-9]*MHz:" | sed -e 's/dB://g' -e 's/\+//g' | sort -n -r -k 2 | grep -m1 "ppm"`
|
|
COMPONENT_CALIBRATION_GSM_FREQ=`echo ${COMPONENT_CALIBRATION_GSM_SCAN} | awk '{print $1}' | sed -e 's/00MHz://g'`
|
|
COMPONENT_CALIBRATION_ERROR=`echo ${COMPONENT_CALIBRATION_GSM_SCAN} | awk '{print int(($3 + $4)/2)}'`
|
|
else
|
|
# No suitable tool found to perform cailbrations.
|
|
echo -en "\e[33m Unable to calibrate RTL-SDR device \"${COMPONENT_CALIBRATION_DEVICE_ID}\"...\e[97m"
|
|
false
|
|
fi
|
|
else
|
|
# No tuner specified.
|
|
echo -en "\e[33m Unable calibrate due to invalid or no RTL-SDR device specified...\e[97m"
|
|
false
|
|
fi
|
|
}
|
|
|
|
## SET INSTALLATION VARIABLES
|
|
|
|
# Source the automated install configuration file if this is an automated installation.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "true" ]] && [[ -s "${RECEIVER_CONFIGURATION_FILE}" ]] ; then
|
|
source ${RECEIVER_CONFIGURATION_FILE}
|
|
fi
|
|
|
|
### BEGIN SETUP
|
|
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
clear
|
|
echo -e "\n\e[91m ${RECEIVER_PROJECT_TITLE}"
|
|
fi
|
|
echo -e ""
|
|
echo -e "\e[92m Setting up ${COMPONENT_NAME}..."
|
|
echo -e ""
|
|
echo -e "\e[93m ------------------------------------------------------------------------------\e[96m"
|
|
echo -e ""
|
|
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "${COMPONENT_NAME} Setup" --yesno "${COMPONENT_NAME} ${COMPONENT_DESC}.\n\n${COMPONENT_RADIO}.\n\n${COMPONENT_WEBSITE}\n\nContinue setup by installing ${COMPONENT_NAME}?" 18 78
|
|
if [[ $? -eq 1 ]] ; then
|
|
# Setup has been halted by the user.
|
|
echo -e "\e[91m \e[5mINSTALLATION HALTED!\e[25m"
|
|
echo -e " Setup has been halted at the request of the user."
|
|
echo -e ""
|
|
echo -e "\e[93m ------------------------------------------------------------------------------"
|
|
echo -e "\e[92m ${COMPONENT_NAME} setup halted.\e[39m"
|
|
echo -e ""
|
|
read -p "Press enter to continue..." CONTINUE
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
### CHECK FOR PREREQUISITE PACKAGES
|
|
|
|
echo -e "\e[95m Installing packages needed to fulfill dependencies for ${COMPONENT_NAME}...\e[97m"
|
|
echo -e ""
|
|
# Required by install script.
|
|
CheckPackage git
|
|
CheckPackage python-dev
|
|
CheckPackage python3-dev
|
|
# Required for USB SDR devices.
|
|
CheckPackage librtlsdr-dev
|
|
CheckPackage libusb-1.0-0-dev
|
|
CheckPackage rtl-sdr
|
|
# Required by component.
|
|
CheckPackage curl
|
|
CheckPackage libconfig9
|
|
CheckPackage libconfig-dev
|
|
CheckPackage libcurl3
|
|
CheckPackage libfftw3-3
|
|
CheckPackage libfftw3-dev
|
|
CheckPackage libjpeg62-turbo
|
|
CheckPackage libjpeg8
|
|
CheckPackage libjpeg-dev
|
|
CheckPackage lynx
|
|
CheckPackage procserv
|
|
CheckPackage telnet
|
|
|
|
echo -e ""
|
|
echo -e "\e[95m Configuring this device to run the ${COMPONENT_NAME} binaries...\e[97m"
|
|
echo -e ""
|
|
|
|
### BLACKLIST TO PREVENT UNWANTED RTL-SDR MODULES FROM BEING LOADED
|
|
|
|
# Use function to install kernel module blacklist.
|
|
BlacklistModules
|
|
CheckReturnCode
|
|
|
|
### CHECK FOR EXISTING INSTALL AND IF SO STOP IT
|
|
|
|
# Attempt to stop using systemd.
|
|
if [[ "`sudo systemctl status ${COMPONENT_SERVICE_NAME} 2>&1 | egrep -c "Active: active"`" -gt 0 ]] ; then
|
|
echo -e "\e[33m Stopping the ${COMPONENT_NAME} service..."
|
|
ACTION=$(sudo systemctl stop ${COMPONENT_SERVICE_NAME} 2>&1)
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# And the init script.
|
|
if [[ -f "${COMPONENT_SERVICE_SCRIPT_PATH}" ]] ; then
|
|
echo -en "\e[33m Stopping the ${COMPONENT_NAME} service...\e[97m"
|
|
ACTION=$(sudo ${COMPONENT_SERVICE_SCRIPT_PATH} stop 2>&1)
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Finally a failsafe process kill.
|
|
PIDS=`ps -efww | egrep "(\./ogn-rf\ |\./ogn-decode\ )" | awk -vpid=$$ '$2 != pid { print $2 }' | tr '\n\r' ' '`
|
|
if [ ! -z "${PIDS}" ]; then
|
|
echo -en "\e[33m Killing any running ${COMPONENT_NAME} processes...\e[97m"
|
|
ACTION=$(sudo kill -9 ${PIDS})
|
|
CheckReturnCode
|
|
fi
|
|
unset PIDS
|
|
|
|
### ASSIGN RTL-SDR DONGLES
|
|
|
|
# Count the number of tuners available.
|
|
RECEIVER_TUNERS_AVAILABLE=`rtl_eeprom 2>&1 | grep -c "^\s*[0-9]*:\s"`
|
|
|
|
# Start counting the number of tuners required with one for this component.
|
|
RECEIVER_TUNERS_REQUIRED="1"
|
|
|
|
# Check which components are installed.
|
|
echo -e "\e[95m Checking for existing decoders...\e[97m"
|
|
echo -e ""
|
|
|
|
# Check if any of the dump1090 forks are installed.
|
|
echo -en "\e[94m Checking if any of the dump1090 packages are installed...\e[97m"
|
|
# Check if the dump1090-mutability package is installed.
|
|
if [[ $(dpkg-query -W -f='${STATUS}' dump1090-mutability 2>/dev/null | grep -c "ok installed") -eq 1 ]] ; then
|
|
RECEIVER_TUNERS_REQUIRED=$((RECEIVER_TUNERS_REQUIRED+1))
|
|
DUMP1090_IS_INSTALLED="true"
|
|
# Check if the dump1090-fa package is installed.
|
|
elif [[ $(dpkg-query -W -f='${STATUS}' dump1090-fa 2>/dev/null | grep -c "ok installed") -eq 1 ]] ; then
|
|
RECEIVER_TUNERS_REQUIRED=$((RECEIVER_TUNERS_REQUIRED+1))
|
|
DUMP1090_IS_INSTALLED="true"
|
|
else
|
|
DUMP1090_IS_INSTALLED="false"
|
|
fi
|
|
CheckReturnCode
|
|
|
|
# Check if the dump978 binaries exist.
|
|
echo -en "\e[94m Checking if the dump978 binaries exist on this device...\e[97m"
|
|
if [[ -f "${RECEIVER_BUILD_DIRECTORY}/dump978/dump978" ]] && [[ -f "${RECEIVER_BUILD_DIRECTORY}/dump978/uat2text" ]] && [[ -f "${RECEIVER_BUILD_DIRECTORY}/dump978/uat2esnt" ]] && [[ -f "${RECEIVER_BUILD_DIRECTORY}/dump978/uat2json" ]] ; then
|
|
RECEIVER_TUNERS_REQUIRED=$((RECEIVER_TUNERS_REQUIRED+1))
|
|
DUMP978_IS_INSTALLED="true"
|
|
else
|
|
DUMP978_IS_INSTALLED="false"
|
|
fi
|
|
CheckReturnCode
|
|
|
|
# The two sets of if loops below will be combined into a unified tuner detection and allocation function :)
|
|
|
|
# Multiple RTL_SDR tuners found, check if device specified for this decoder is present.
|
|
if [[ "${RECEIVER_TUNERS_AVAILABLE}" -gt 1 ]] ; then
|
|
# If a device has been specified by serial number then try to match that with the currently detected tuners.
|
|
if [[ -n "${OGN_DEVICE_SERIAL}" ]] ; then
|
|
for DEVICE_ID in `seq 0 ${RECEIVER_TUNERS_AVAILABLE}` ; do
|
|
if [[ `rtl_eeprom -d ${DEVICE_ID} 2>&1 | grep -c "Serial number:\s*${OGN_DEVICE_SERIAL}$" ` -eq 1 ]] ; then
|
|
echo -en "\e[33m RTL-SDR with Serial \"${OGN_DEVICE_SERIAL}\" found at device \"${OGN_DEVICE_ID}\" and will be assigned to ${COMPONENT_NAME}...\e[97m"
|
|
OGN_DEVICE_ID=${DEVICE_ID}
|
|
fi
|
|
done
|
|
# If no match for this serial then assume the highest numbered tuner will be used.
|
|
if [[ -z "${OGN_DEVICE_ID}" ]] ; then
|
|
echo -en "\e[33m RTL-SDR with Serial \"${OGN_DEVICE_SERIAL}\" not found, assigning device \"${RECEIVER_TUNERS_AVAILABLE}\" to ${COMPONENT_NAME}...\e[97m"
|
|
OGN_DEVICE_ID=${RECEIVER_TUNERS_AVAILABLE}
|
|
fi
|
|
# Or if a device has been specified by device ID then confirm this is currently detected.
|
|
elif [[ -n "${OGN_DEVICE_ID}" ]] ; then
|
|
if [[ `rtl_eeprom -d ${OGN_DEVICE_ID} 2>&1 | grep -c "^\s*${OGN_DEVICE_ID}:\s"` -eq 1 ]] ; then
|
|
echo -en "\e[33m RTL-SDR device \"${OGN_DEVICE_ID}\" found and will be assigned to ${COMPONENT_NAME}...\e[97m"
|
|
# If no match for this serial then assume the highest numbered tuner will be used.
|
|
else
|
|
echo -en "\e[33m RTL-SDR device \"${OGN_DEVICE_ID}\" not found, assigning device \"${RECEIVER_TUNERS_AVAILABLE}\" to ${COMPONENT_NAME}...\e[97m"
|
|
OGN_DEVICE_ID=${RECEIVER_TUNERS_AVAILABLE}
|
|
fi
|
|
# Failing that configure it with device ID 0.
|
|
else
|
|
echo -en "\e[33m No RTL-SDR device specified, assigning device \"0\" to ${COMPONENT_NAME}...\e[97m"
|
|
OGN_DEVICE_ID=${RECEIVER_TUNERS_AVAILABLE}
|
|
fi
|
|
# Single tuner present so assign device 0 and stop any other running decoders, or at least dump1090-mutablity for a default install.
|
|
elif [[ "${RECEIVER_TUNERS_AVAILABLE}" -eq 1 ]] ; then
|
|
echo -en "\e[33m Single RTL-SDR device \"0\" detected and assigned to ${COMPONENT_NAME}...\e[97m"
|
|
OGN_DEVICE_ID="0"
|
|
ACTION=$(sudo /etc/init.d/dump1090-mutability stop 2>&1)
|
|
# No tuners present so assign device 0 and stop any other running decoders, or at least dump1090-mutablity for a default install.
|
|
elif [[ "${RECEIVER_TUNERS_AVAILABLE}" -lt 1 ]] ; then
|
|
echo -en "\e[33m No RTL-SDR device detected so ${COMPONENT_NAME} will be assigned device \"0\"...\e[97m"
|
|
OGN_DEVICE_ID="0"
|
|
ACTION=$(sudo /etc/init.d/dump1090-mutability stop 2>&1)
|
|
fi
|
|
CheckReturnCode
|
|
|
|
# If either dump1090 or dump978 is installed we must assign RTL-SDR dongles for each of these decoders.
|
|
if [[ "${DUMP1090_IS_INSTALLED}" = "true" ]] || [[ "${DUMP978_IS_INSTALLED}" = "true" ]] ; then
|
|
# Check if Dump1090 is installed.
|
|
if [[ "${DUMP1090_IS_INSTALLED}" = "true" ]] ; then
|
|
# The dump1090-mutability package appear to be installed.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Ask the user which USB device is to be used for dump1090.
|
|
DUMP1090_DEVICE_ID=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "Dump1090 RTL-SDR Dongle" --nocancel --inputbox "\nPlease enter the ID of the RTL-SDR dongle which you wish to use for the dump1090 decoder.." 8 78 3>&1 1>&2 2>&3)
|
|
while [[ -z "${DUMP1090_DEVICE_ID}" ]] ; do
|
|
DUMP1090_DEVICE_ID=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "Dump1090 RTL-SDR Dongle (REQUIRED)" --nocancel --inputbox "\nPlease enter the ID of the RTL-SDR dongle which you wish to use for the dump1090 decoder.." 8 78 3>&1 1>&2 2>&3)
|
|
done
|
|
else
|
|
### GET DONGLE ID FROM THE INSTALLATION CONFIGURATION FILE...
|
|
true
|
|
fi
|
|
fi
|
|
# Check if Dump978 is installed.
|
|
if [[ "${DUMP978_IS_INSTALLED}" = "true" ]] ; then
|
|
# The dump978 binaries appear to exist on this device.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Ask the user which USB device is to be use for dump978.
|
|
DUMP978_DEVICE_ID=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "Dump978 RTL-SDR Dongle" --nocancel --inputbox "\nPlease enter the ID of the RTL-SDR dongle which you wish to use for the dump978 decoder." 8 78 3>&1 1>&2 2>&3)
|
|
while [[ -z "${DUMP978_DEVICE_ID}" ]] ; do
|
|
DUMP978_DEVICE_ID=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "Dump978 RTL-SDR Dongle (REQUIRED)" --nocancel --inputbox "\nPlease enter the ID of the RTL-SDR dongle which you wish to use for the dump978 decoder." 8 78 3>&1 1>&2 2>&3)
|
|
done
|
|
else
|
|
### GET DONGLE ID FROM THE INSTALLATION CONFIGURATION FILE...
|
|
true
|
|
fi
|
|
fi
|
|
#
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Ask the user which USB device is to be use for RTL-SDR OGN.
|
|
RTLSDROGN_DEVICE_ID=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "RTL-SDR OGN RTL-SDR Dongle" --nocancel --inputbox "\nPlease enter the ID of the RTL-SDR dongle which you wish to use for the RTL-SDR OGN decoder." 8 78 3>&1 1>&2 2>&3)
|
|
while [[ -z "${RTLSDROGN_DEVICE_ID}" ]] ; do
|
|
RTLSDROGN_DEVICE_ID=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "RTL-SDR OGN RTL-SDR Dongle (REQUIRED)" --nocancel --inputbox "\nPlease enter the ID of the RTL-SDR dongle which you wish to use for the RTL-SDR OGN decoder." 8 78 3>&1 1>&2 2>&3)
|
|
done
|
|
else
|
|
### GET DONGLE ID FROM THE INSTALLATION CONFIGURATION FILE...
|
|
true
|
|
fi
|
|
# Assign the specified RTL-SDR dongle to dump1090.
|
|
if [[ "${DUMP1090_IS_INSTALLED}" = "true" ]] && [[ -n "${DUMP1090_DEVICE_ID}" ]] ; then
|
|
echo -e "\e[94m Assigning RTL-SDR dongle \"${DUMP1090_DEVICE_ID}\" to dump1090-mutability...\e[97m"
|
|
ChangeConfig "DEVICE" ${DUMP1090_DEVICE_ID} "/etc/default/dump1090-mutability"
|
|
echo -e "\e[94m Reloading dump1090-mutability...\e[97m"
|
|
echo -e ""
|
|
ACTION=$(sudo /etc/init.d/dump1090-mutability force-reload 2>&1)
|
|
echo -e ""
|
|
fi
|
|
# Assign the specified RTL-SDR dongle to dump978
|
|
if [[ "${DUMP978_IS_INSTALLED}" = "true" ]] && [[ -n "${DUMP978_DEVICE_ID}" ]] ; then
|
|
echo -e "\e[94m Assigning RTL-SDR dongle \"${DUMP978_DEVICE_ID}\" to dump978...\e[97m"
|
|
### ADD DEVICE TO MAINTENANCE SCRIPT...
|
|
echo -e "\e[94m Reloading dump978...\e[97m"
|
|
### KILL EXISTING DUMP978 PROCESSES...
|
|
echo -e ""
|
|
### RESTART DUMP978...
|
|
echo -e ""
|
|
fi
|
|
else
|
|
if [[ -z "${RTLSDROGN_DEVICE_ID}" ]] ; then
|
|
# If no other decoders are installed then assume device ID 0 can be used by this decoder.
|
|
echo -e "\e[94m Assigning RTL-SDR dongle \"0\" to RTL-SDR OGN...\e[97m"
|
|
RTLSDROGN_DEVICE_ID="0"
|
|
fi
|
|
fi
|
|
|
|
### ASSIGN RTL-SDR DONGLE FOR RTL-SDR OGN...
|
|
|
|
### DOWNLOAD AND SET UP THE BINARIES
|
|
|
|
# Create build directory if not already present.
|
|
if [[ ! -d "${COMPONENT_BUILD_DIRECTORY}" ]] ; then
|
|
echo -en "\e[33m Creating build directory \"\e[37m${COMPONENT_BUILD_DIRECTORY}\e[33m\"...\e[97m"
|
|
ACTION=$(mkdir -vp ${COMPONENT_BUILD_DIRECTORY} 2>&1)
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Enter the build directory.
|
|
if [[ ! "${PWD}" = "${COMPONENT_BUILD_DIRECTORY}" ]] ; then
|
|
echo -en "\e[33m Entering build directory \"\e[37m${COMPONENT_BUILD_DIRECTORY}\e[33m\"...\e[97m"
|
|
cd ${COMPONENT_BUILD_DIRECTORY} 2>&1
|
|
ACTION=${PWD}
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Use function to detect cpu architecture.
|
|
if [[ -z "${CPU_ARCHITECTURE}" ]] ; then
|
|
Check_CPU
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Identify the correct binaries to download.
|
|
case ${CPU_ARCHITECTURE} in
|
|
"armv6l")
|
|
# Raspberry Pi 1.
|
|
COMPONENT_BINARY_URL="http://download.glidernet.org/rpi-gpu/rtlsdr-ogn-bin-RPI-GPU-${RTLSDROGN_VERSION}.tgz"
|
|
;;
|
|
"armv7l")
|
|
# Raspberry Pi 2 onwards.
|
|
COMPONENT_BINARY_URL="http://download.glidernet.org/arm/rtlsdr-ogn-bin-ARM-${RTLSDROGN_VERSION}.tgz"
|
|
;;
|
|
"x86_64")
|
|
# 64 Bit.
|
|
COMPONENT_BINARY_URL="http://download.glidernet.org/x64/rtlsdr-ogn-bin-x64-${RTLSDROGN_VERSION}.tgz"
|
|
;;
|
|
*)
|
|
# 32 Bit (default install if no others matched).
|
|
COMPONENT_BINARY_URL="http://download.glidernet.org/x86/rtlsdr-ogn-bin-x86-${RTLSDROGN_VERSION}.tgz"
|
|
;;
|
|
esac
|
|
|
|
# Attempt to download and extract binaries.
|
|
if [[ `echo "${COMPONENT_BINARY_URL}" | grep -c "^http"` -gt 0 ]] ; then
|
|
# Download binaries.
|
|
echo -en "\e[33m Downloading ${COMPONENT_NAME} binaries for \"\e[37m${CPU_ARCHITECTURE}\e[33m\" architecture...\e[97m"
|
|
COMPONENT_BINARY_FILE=`echo ${COMPONENT_BINARY_URL} | awk -F "/" '{print $NF}'`
|
|
ACTION=$(curl -L ${COMPONENT_BINARY_URL} -o ${COMPONENT_BUILD_DIRECTORY}/${COMPONENT_BINARY_FILE} 2>&1)
|
|
CheckReturnCode
|
|
# Extract binaries.
|
|
echo -en "\e[33m Extracting ${COMPONENT_NAME} package \"\e[37m${COMPONENT_BINARY_FILE}\e[33m\"...\e[97m"
|
|
ACTION=$(tar -vxzf "${COMPONENT_BUILD_DIRECTORY}/${COMPONENT_BINARY_FILE}" -C "${COMPONENT_BUILD_DIRECTORY}" 2>&1)
|
|
CheckReturnCode
|
|
else
|
|
# Unable to download bimary due to invalid URL.
|
|
echo -e "\e[33m Error invalid COMPONENT_BINARY_URL \"\e[37m${COMPONENT_BINARY_URL}\e[33m\"...\e[97m"
|
|
exit 1
|
|
fi
|
|
|
|
# Change to component work directory for post-build actions.
|
|
COMPONENT_PROJECT_DIRECTORY="${COMPONENT_BUILD_DIRECTORY}/rtlsdr-ogn"
|
|
if [[ -d "${COMPONENT_PROJECT_DIRECTORY}" ]] ; then
|
|
cd ${COMPONENT_PROJECT_DIRECTORY} 2>&1
|
|
else
|
|
echo -e "\e[33m Error unable to access \"\e[37m${COMPONENT_PROJECT_DIRECTORY}\e[33m\"...\e[97m"
|
|
exit 1
|
|
fi
|
|
|
|
# Create named pipe if required.
|
|
if [[ ! -p "${COMPONENT_PROJECT_DIRECTORY}/ogn-rf.fifo" ]] ; then
|
|
echo -en "\e[33m Creating named pipe...\e[97m"
|
|
ACTION=$(sudo mkfifo ${COMPONENT_PROJECT_DIRECTORY}/ogn-rf.fifo 2>&1)
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Set file permissions.
|
|
echo -en "\e[33m Setting proper file permissions...\e[97m"
|
|
COMPONENT_SETUID_BINARIES="gsm_scan ogn-rf rtlsdr-ogn"
|
|
COMPONENT_SETUID_COUNT="0"
|
|
for COMPONENT_SETUID_BINARY in ${COMPONENT_SETUID_BINARIES} ; do
|
|
COMPONENT_SETUID_COUNT=$((COMPONENT_SETUID_COUNT+1))
|
|
ACTION=$(sudo chown -v root ${COMPONENT_SETUID_BINARY} 2>&1)
|
|
ACTION=$(sudo chmod -v a+s ${COMPONENT_SETUID_BINARY} 2>&1)
|
|
done
|
|
# And check that the file permissions have been applied.
|
|
if [[ `ls -l ${COMPONENT_SETUID_BINARIES} | grep -c "\-rwsr-sr-x"` -eq "${COMPONENT_SETUID_COUNT}" ]] ; then
|
|
true
|
|
else
|
|
false
|
|
fi
|
|
CheckReturnCode
|
|
|
|
# Creat GPU device if required.
|
|
if [[ ! -c "${COMPONENT_PROJECT_DIRECTORY}/gpu_dev" ]] ; then
|
|
# The mknod major_version number varies with kernel version.
|
|
echo -en "\e[33m Getting the version of the kernel currently running...\e[97m"
|
|
KERNEL=`uname -r`
|
|
KERNEL_VERSION=`echo ${KERNEL} | cut -d \. -f 1`.`echo ${KERNEL} | cut -d \. -f 2`
|
|
CheckReturnCode
|
|
# Check if the currently running kernel is version 4.1 or higher.
|
|
if [[ "${KERNEL_VERSION}" < 4.1 ]] ; then
|
|
# Kernel is older than version 4.1.
|
|
echo -en "\e[33m Executing mknod for older kernels...\e[97m"
|
|
ACTION=$(sudo mknod ${COMPONENT_PROJECT_DIRECTORY}/gpu_dev c 100 0 2>&1)
|
|
else
|
|
# Kernel is version 4.1 or newer.
|
|
echo -en "\e[33m Executing mknod for newer kernels...\e[97m"
|
|
ACTION=$(sudo mknod ${COMPONENT_PROJECT_DIRECTORY}/gpu_dev c 249 0 2>&1)
|
|
fi
|
|
CheckReturnCode
|
|
fi
|
|
|
|
## GATHER INFORMATION FROM USER
|
|
|
|
# Skip over this dialog if this installation is set to be automated.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Explain to the user that the receiver's latitude and longitude is required.
|
|
whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "Receiver Latitude and Longitude" --msgbox "Your receivers latitude and longitude are required for distance calculations, you will now be asked to supply these values for your receiver.\n\nIf you do not have this information you can obtain it using the web based \"Geocode by Address\" utility hosted on another of the lead developers websites:\n\n https://www.swiftbyte.com/toolbox/geocode" 16 78
|
|
fi
|
|
|
|
# Latitude.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Ask the user to confirm the receivers latitude, this will be populated with the latitude configured in dump1090-mutability.
|
|
COMPONENT_LATITUDE_TITLE="Receiver Latitude"
|
|
while [[ -z "${COMPONENT_LATITUDE}" ]] ; do
|
|
if [[ -n "${RECEIVER_LATITUDE}" ]] ; then
|
|
COMPONENT_LATITUDE="${RECEIVER_LATITUDE}"
|
|
COMPONENT_LATITUDE_SOURCE="the ${RECEIVER_PROJECT_TITLE} configuration file"
|
|
elif [[ -s /etc/default/dump1090-mutability ]] && [[ `grep -c "^LAT" "/etc/default/dump1090-mutability"` -gt 0 ]] ; then
|
|
COMPONENT_LATITUDE=$(GetConfig "LAT" "/etc/default/dump1090-mutability")
|
|
COMPONENT_LATITUDE_SOURCE="the Dump1090-mutability configuration file"
|
|
fi
|
|
if [[ -n "${COMPONENT_LATITUDE_SOURCE}" ]] ; then
|
|
COMPONENT_LATITUDE_SOURCE_MESSAGE=", the value below is obtained from ${COMPONENT_LATITUDE_SOURCE}"
|
|
fi
|
|
COMPONENT_LATITUDE=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "${COMPONENT_LATITUDE_TITLE}" --nocancel --inputbox "\nPlease confirm your receiver's latitude${COMPONENT_LATITUDE_SOURCE_MESSAGE}:\n" 10 78 -- "${COMPONENT_LATITUDE}" 3>&1 1>&2 2>&3)
|
|
COMPONENT_LATITUDE_TITLE="Receiver Latitude (REQUIRED)"
|
|
done
|
|
else
|
|
# Use receiver coordinates if already know, otherwise populate with dummy values to ensure valid config generation.
|
|
if [[ -n "${RECEIVER_LATITUDE}" ]] ; then
|
|
COMPONENT_LATITUDE="${RECEIVER_LATITUDE}"
|
|
elif [[ -s /etc/default/dump1090-mutability ]] && [[ `grep -c "^LAT" "/etc/default/dump1090-mutability"` -gt 0 ]] ; then
|
|
COMPONENT_LATITUDE=$(GetConfig "LAT" "/etc/default/dump1090-mutability")
|
|
else
|
|
COMPONENT_LATITUDE="0.000"
|
|
fi
|
|
fi
|
|
|
|
# Longitude.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Ask the user to confirm the receivers longitude, this will be populated with the longitude configured in dump1090-mutability.
|
|
COMPONENT_LONGITUDE_TITLE="Receiver Longitude"
|
|
while [[ -z "${COMPONENT_LONGITUDE}" ]] ; do
|
|
if [[ -n "${RECEIVER_LONGITUDE}" ]] ; then
|
|
COMPONENT_LONGITUDE="${RECEIVER_LONGITUDE}"
|
|
COMPONENT_LONGITUDE_SOURCE="the ${RECEIVER_PROJECT_TITLE} configuration file"
|
|
elif [[ -s /etc/default/dump1090-mutability ]] && [[ `grep -c "^LON" "/etc/default/dump1090-mutability"` -gt 0 ]] ; then
|
|
COMPONENT_LONGITUDE=$(GetConfig "LON" "/etc/default/dump1090-mutability")
|
|
COMPONENT_LONGITUDE_SOURCE="the Dump1090-mutability configuration file"
|
|
fi
|
|
if [[ -n "${COMPONENT_LONGITUDE_SOURCE}" ]] ; then
|
|
COMPONENT_LONGITUDE_SOURCE_MESSAGE=", the value below is obtained from ${COMPONENT_LONGITUDE_SOURCE}"
|
|
fi
|
|
COMPONENT_LONGITUDE=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "${COMPONENT_LONGITUDE_TITLE}" --nocancel --inputbox "\nPlease confirm your receiver's longitude${COMPONENT_LONGITUDE_SOURCE_MESSAGE}:\n" 10 78 -- "${COMPONENT_LONGITUDE}" 3>&1 1>&2 2>&3)
|
|
COMPONENT_LONGITUDE_TITLE="Receiver Longitude (REQUIRED)"
|
|
done
|
|
else
|
|
# Use receiver coordinates if already know, otherwise populate with dummy values to ensure valid config generation.
|
|
if [[ -n "${RECEIVER_LONGITUDE}" ]] ; then
|
|
COMPONENT_LONGITUDE="${RECEIVER_LONGITUDE}"
|
|
elif [[ -s /etc/default/dump1090-mutability ]] && [[ `grep -c "^LON" "/etc/default/dump1090-mutability"` -gt 0 ]] ; then
|
|
COMPONENT_LONGITUDE=$(GetConfig "LON" "/etc/default/dump1090-mutability")
|
|
else
|
|
COMPONENT_LONGITUDE="0.000"
|
|
fi
|
|
fi
|
|
|
|
# Altitude.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
# Ask the user to confirm the receivers altitude, this will be populated with an altutude value derived from the configured LAT/LON.
|
|
COMPONENT_ALTITUDE_TITLE="Receiver Altitude"
|
|
while [[ -z "${COMPONENT_ALTITUDE}" ]] ; do
|
|
if [[ -n "${COMPONENT_LATITUDE}" ]] && [[ -n "${COMPONENT_LONGITUDE}" ]] ; then
|
|
COMPONENT_ALTITUDE=$(curl -s https://maps.googleapis.com/maps/api/elevation/json?locations=${COMPONENT_LATITUDE},${COMPONENT_LONGITUDE} | python -c "import json,sys;obj=json.load(sys.stdin);print obj['results'][0]['elevation'];" | awk '{printf("%.2f\n", $1)}')
|
|
COMPONENT_ALTITUDE_SOURCE="Google; however should be increased to reflect your antennas height above ground level"
|
|
fi
|
|
if [[ -n "${COMPONENT_ALTITUDE_SOURCE}" ]] ; then
|
|
COMPONENT_ALTITUDE_SOURCE_MESSAGE=", the value below is obtained from ${COMPONENT_ALTITUDE_SOURCE}"
|
|
fi
|
|
COMPONENT_ALTITUDE=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "${COMPONENT_ALTITUDE_TITLE}" --nocancel --inputbox "\nPlease confirm your receiver's altitude in meters${COMPONENT_ALTITUDE_SOURCE_MESSAGE}:\n" 10 78 -- "${COMPONENT_ALTITUDE}" 3>&1 1>&2 2>&3)
|
|
COMPONENT_ALTITUDE_TITLE="Receiver Altitude (REQUIRED)"
|
|
done
|
|
else
|
|
# Use receiver coordinates if already know, otherwise populate with dummy values to ensure valid config generation.
|
|
if [[ -n "${RECEIVER_ALTITUDE}" ]] ; then
|
|
COMPONENT_ALTITUDE="${RECEIVER_ALTITUDE}"
|
|
elif [[ -n "${COMPONENT_LATITUDE}" ]] && [[ -n "${COMPONENT_LONGITUDE}" ]] ; then
|
|
COMPONENT_ALTITUDE=$(curl -s https://maps.googleapis.com/maps/api/elevation/json?locations=${RECEIVER_LATITUDE},${RECEIVER_LONGITUDE} | python -c "import json,sys;obj=json.load(sys.stdin);print obj['results'][0]['elevation'];" | awk '{printf("%.2f\n", $1)}')
|
|
else
|
|
COMPONENT_ALTITUDE="0.000"
|
|
fi
|
|
fi
|
|
|
|
# Check for component specific variables, otherwise populate with dummy values to ensure valid config generation.
|
|
|
|
# Set receiver callsign for this decoder.
|
|
# This should be between 3 and 9 alphanumeric charactors, with no punctuation.
|
|
# Please see: http://wiki.glidernet.org/receiver-naming-convention
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
COMPONENT_RECEIVER_NAME_TITLE="Receiver Name"
|
|
while [[ -z "${COMPONENT_RECEIVER_NAME}" ]] || [[ `echo -n ${COMPONENT_RECEIVER_NAME} | wc -c` -gt 9 ]] ; do
|
|
if [[ -n "${COMPONENT_SERVICE_CONFIG_PATH}" ]] && [[ `grep -c "ogn-decode" ${COMPONENT_SERVICE_CONFIG_PATH}` -gt 0 ]] ; then
|
|
COMPONENT_RECEIVER_NAME=`grep "ogn-decode" ${COMPONENT_SERVICE_CONFIG_PATH} | awk '{print $5}' | awk -F "." '{print $1}' `
|
|
fi
|
|
COMPONENT_RECEIVER_NAME=$(whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "${COMPONENT_RECEIVER_NAME_TITLE}" --nocancel --inputbox "\nPlease confirm your receiver name, this should be between 3 and 9 alphanumeric charactors and contain no punctuation or special charactors:\n" 10 78 -- "${COMPONENT_RECEIVER_NAME}" 3>&1 1>&2 2>&3)
|
|
COMPONENT_RECEIVER_NAME_TITLE="Receiver Name (REQUIRED)"
|
|
done
|
|
else
|
|
if [[ -n "${OGN_RECEIVER_NAME}" ]] ; then
|
|
COMPONENT_RECEIVER_NAME=`echo ${OGN_RECEIVER_NAME} | tr -cd '[:alnum:]' | cut -c -9`
|
|
else
|
|
COMPONENT_RECEIVER_NAME=`hostname -s | tr -cd '[:alnum:]' | cut -c -9`
|
|
fi
|
|
fi
|
|
|
|
# Geoid separation: FLARM transmits GPS altitude, APRS uses means Sea level altitude.
|
|
# To find value you can check: http://geographiclib.sourceforge.net/cgi-bin/GeoidEval
|
|
# Need to derive from co-ords but will set to altitude as a placeholders.
|
|
if [[ -z "${OGN_GEOID}" ]] ; then
|
|
if [[ -n "${COMPONENT_ALTITUDE}" ]] ; then
|
|
OGN_GEOID="${COMPONENT_ALTITUDE}"
|
|
else
|
|
OGN_GEOID="0"
|
|
fi
|
|
fi
|
|
|
|
# Future option to enable OGN whitelist.
|
|
if [[ -z "${OGN_WHITELIST}" ]] ; then
|
|
OGN_WHITELIST="0"
|
|
fi
|
|
|
|
# Gain value for RTL-SDR device.
|
|
if [[ -z "${OGN_GSM_GAIN}" ]] ; then
|
|
if [[ -n "${COMPONENT_CALIBRATION_GAIN}" ]] ; then
|
|
OGN_GSM_GAIN="${COMPONENT_CALIBRATION_GAIN}"
|
|
else
|
|
OGN_GSM_GAIN="40"
|
|
fi
|
|
fi
|
|
|
|
# Ask if user would like to calibrate the tuner.
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
whiptail --backtitle "${RECEIVER_PROJECT_TITLE}" --title "Tuner Calibration" --yesno "Would you like to calibrate the device \"${OGN_DEVICE_ID}\" which has been configured for use with ${COMPONENT_NAME}?\n\nPlease be aware this may take between 10 and 20 minutes." 8 78
|
|
if [[ $? -eq 0 ]] ; then
|
|
# User would like to calibrate the tuner.
|
|
COMPONENT_DO_CALIBRATE="true"
|
|
fi
|
|
elif [[ -z "${OGN_FREQ_CORR}" ]] || [[ -z "${OGN_GSM_FREQ}" ]] ; then
|
|
COMPONENT_DO_CALIBRATE="true"
|
|
fi
|
|
|
|
# Calculate RTL-SDR device error rate.
|
|
if [[ "${COMPONENT_DO_CALIBRATE}" ]] ; then
|
|
# Requires a device to be specified.
|
|
if [[ -n "${OGN_DEVICE_ID}" ]] ; then
|
|
CalibrateTuner ${OGN_DEVICE_ID}
|
|
else
|
|
echo -en "\e[33m The specified device is either invalid or does not exist...\e[97m"
|
|
false
|
|
fi
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Set Frequency Correction.
|
|
if [[ -z "${OGN_FREQ_CORR}" ]] ; then
|
|
# Using the value derived from calibration, if available.
|
|
if [[ -n "${COMPONENT_CALIBRATION_ERROR}" ]] ; then
|
|
OGN_FREQ_CORR="${COMPONENT_CALIBRATION_ERROR}"
|
|
else
|
|
OGN_FREQ_CORR="0"
|
|
fi
|
|
fi
|
|
|
|
# Set GSM Reference signal frequency.
|
|
if [[ -z "${OGN_GSM_FREQ}" ]] ; then
|
|
# Using the value derived from calibration, if available.
|
|
if [[ -n "${COMPONENT_CALIBRATION_GSM_FREQ}" ]] ; then
|
|
OGN_GSM_FREQ="${COMPONENT_CALIBRATION_GSM_FREQ}"
|
|
else
|
|
OGN_GSM_FREQ="958"
|
|
fi
|
|
fi
|
|
|
|
### CREATE THE CONFIGURATION FILE
|
|
|
|
# Update existing or create new config file.
|
|
if [[ -n "${COMPONENT_RECEIVER_NAME}" ]] ; then
|
|
COMPONENT_CONFIG_FILE_NAME="${COMPONENT_RECEIVER_NAME}.conf"
|
|
if [[ -s "${COMPONENT_PROJECT_DIRECTORY}/${COMPONENT_CONFIG_FILE_NAME}" ]] ; then
|
|
echo -en "\e[33m Updating existing ${COMPONENT_NAME} config file at \"\e[37m${COMPONENT_CONFIG_FILE_NAME}\e[33m\"...\e[97m"
|
|
else
|
|
echo -en "\e[33m Generating new ${COMPONENT_NAME} config file as \"\e[37m${COMPONENT_CONFIG_FILE_NAME}\e[33m\"...\e[97m"
|
|
fi
|
|
sudo tee ${COMPONENT_PROJECT_DIRECTORY}/${COMPONENT_CONFIG_FILE_NAME} > /dev/null 2>&1 <<EOF
|
|
#########################################################
|
|
# #
|
|
# CONFIGURATION FILE BASED ON #
|
|
# #
|
|
# http://wiki.glidernet.org/wiki:receiver-config-file #
|
|
# #
|
|
#########################################################
|
|
#
|
|
RF:
|
|
{
|
|
FreqCorr = ${OGN_FREQ_CORR}; # [ppm] Some R820T sticks require a correction of up to 80ppm, measure it with gsm_scan.
|
|
Device = ${OGN_DEVICE_ID}; # Device index of the USB RTL-SDR device to be selected.
|
|
# DeviceSerial = ${OGN_DEVICE_SERIAL}; # char[12] Serial number of the USB RTL-SDR device to be selected.
|
|
GSM:
|
|
{
|
|
CenterFreq = ${OGN_GSM_FREQ}; # [MHz] Fnd the best GSM frequency with gsm_scan.
|
|
Gain = ${OGN_GSM_GAIN}; # [0.1 dB] RF input gain for frequency calibration, beware GSM signals are very strong.
|
|
} ;
|
|
} ;
|
|
#
|
|
Position:
|
|
{
|
|
Latitude = ${COMPONENT_LATITUDE}; # [deg] Antenna coordinates in decimal degrees.
|
|
Longitude = ${COMPONENT_LONGITUDE}; # [deg] Antenna coordinates in decimal degrees.
|
|
Altitude = ${COMPONENT_ALTITUDE}; # [m] Altitude above sea leavel.
|
|
GeoidSepar = ${OGN_GEOID}; # [m] Geoid separation: FLARM transmits GPS altitude, APRS uses means Sea level altitude.
|
|
} ;
|
|
#
|
|
APRS:
|
|
{
|
|
Call = "${COMPONENT_RECEIVER_NAME}"; # char[9] APRS callsign (max. 9 characters).
|
|
} ;
|
|
#
|
|
DDB:
|
|
{
|
|
UseAsWhitelist = ${OGN_WHITELIST}; # [0|1] Setting to 1 enforces strict opt in to OGN Whitelist.
|
|
} ;
|
|
#
|
|
EOF
|
|
# Update ownership of new config file.
|
|
ACTION=$(sudo chown -v pi:pi ${COMPONENT_PROJECT_DIRECTORY}/${COMPONENT_CONFIG_FILE_NAME} 2>&1)
|
|
else
|
|
echo -en "\e[33m Unable to create ${COMPONENT_NAME} config file...\e[97m"
|
|
false
|
|
fi
|
|
CheckReturnCode
|
|
|
|
### INSTALL AS A SERVICE
|
|
|
|
# Install service script.
|
|
if [[ -f "${COMPONENT_SERVICE_SCRIPT_NAME}" ]] ; then
|
|
# Check for local copy of service script.
|
|
if [[ `grep -c "conf=${COMPONENT_SERVICE_CONFIG_PATH}" ${COMPONENT_SERVICE_SCRIPT_NAME}` -eq 1 ]] ; then
|
|
echo -en "\e[33m Installing service script at \"\e[37m${COMPONENT_SERVICE_SCRIPT_PATH}\e[33m\"...\e[97m"
|
|
ACTION=$(sudo cp -v ${COMPONENT_SERVICE_SCRIPT_NAME} ${COMPONENT_SERVICE_SCRIPT_PATH} 2>&1)
|
|
ACTION=$(sudo chmod -v +x ${COMPONENT_SERVICE_SCRIPT_PATH} 2>&1)
|
|
else
|
|
echo -en "\e[33m Invalid service script \"\e[37m${COMPONENT_SERVICE_SCRIPT_NAME}\e[33m\"...\e[97m"
|
|
false
|
|
fi
|
|
elif [[ -n "${COMPONENT_SERVICE_SCRIPT_URL}" ]] ; then
|
|
# Otherwise attempt to download service script.
|
|
if [[ `echo ${COMPONENT_SERVICE_SCRIPT_URL} | grep -c "^http"` -gt 0 ]] ; then
|
|
echo -en "\e[33m Downloading service script to \"\e[37m${COMPONENT_SERVICE_SCRIPT_PATH}\e[33m\"...\e[97m"
|
|
ACTION=$(sudo curl -L ${COMPONENT_SERVICE_SCRIPT_URL} -o ${COMPONENT_SERVICE_SCRIPT_PATH} 2>&1)
|
|
ACTION=$(sudo chmod -v +x ${COMPONENT_SERVICE_SCRIPT_PATH} 2>&1)
|
|
else
|
|
echo -en "\e[33m Invalid service script url \"\e[37m${COMPONENT_SERVICE_SCRIPT_URL}\e[33m\"...\e[97m"
|
|
false
|
|
fi
|
|
else
|
|
# Otherwise error if unable to use local or downloaded service script
|
|
echo -en "\e[33m Unable to install service script at \"\e[37m${COMPONENT_SERVICE_SCRIPT_PATH}\e[33m\"...\e[97m"
|
|
false
|
|
fi
|
|
CheckReturnCode
|
|
|
|
# Generate and install service script configuration file.
|
|
if [[ -n "${COMPONENT_SERVICE_CONFIG_PATH}" ]] ; then
|
|
echo -en "\e[33m Creating service config file \"\e[37m${COMPONENT_SERVICE_CONFIG_PATH}\e[33m\"...\e[97m"
|
|
sudo tee ${COMPONENT_SERVICE_CONFIG_PATH} > /dev/null 2>&1 <<EOF
|
|
#shellbox configuration file
|
|
#Starts commands inside a "box" with a telnet-like server.
|
|
#Contact the shell with: telnet <hostname> <port>
|
|
#Syntax:
|
|
#port user directory command args
|
|
50000 pi ${COMPONENT_PROJECT_DIRECTORY} ./ogn-rf ${COMPONENT_RECEIVER_NAME}.conf
|
|
50001 pi ${COMPONENT_PROJECT_DIRECTORY} ./ogn-decode ${COMPONENT_RECEIVER_NAME}.conf
|
|
EOF
|
|
ACTION=$(sudo chown -v pi:pi ${COMPONENT_SERVICE_CONFIG_PATH} 2>&1)
|
|
else
|
|
echo -en "\e[33m Unable to create service config file \"\e[37m${COMPONENT_SERVICE_CONFIG_PATH}\e[33m\"...\e[97m"
|
|
false
|
|
fi
|
|
CheckReturnCode
|
|
|
|
# Potentially obsolete tuner detection code.
|
|
if [[ "${RECEIVER_TUNERS_AVAILABLE}" -lt 2 ]] ; then
|
|
# Less than 2 tuners present so we must stop other services before starting this decoder.
|
|
echo -en "\e[33m Found less than 2 tuners so other decoders will be disabled...\e[97m"
|
|
SERVICES_DISABLE="dump1090-mutability"
|
|
for SERVICE in ${SERVICES_DISABLE} ; do
|
|
if [[ `sudo systemctl status ${SERVICE} | grep -c "Active: active"` -gt 0 ]] ; then
|
|
ACTION=$(sudo update-rc.d ${SERVICE} disable 2>&1)
|
|
fi
|
|
done
|
|
CheckReturnCode
|
|
fi
|
|
|
|
# Configure component as a service.
|
|
echo -en "\e[33m Configuring ${COMPONENT_NAME} as a service...\e[97m"
|
|
ACTION=$(sudo update-rc.d ${COMPONENT_SERVICE_NAME} defaults 2>&1)
|
|
CheckReturnCode
|
|
|
|
# (re)start the component service.
|
|
if [[ "`sudo systemctl status ${COMPONENT_SERVICE_NAME} 2>&1 | egrep -c "Active: active"`" -gt 0 ]] ; then
|
|
echo -e "\e[33m Restarting the ${COMPONENT_NAME} service..."
|
|
ACTION=$(sudo systemctl restart ${COMPONENT_SERVICE_NAME} 2>&1)
|
|
else
|
|
echo -e "\e[33m Starting the ${COMPONENT_NAME} service..."
|
|
ACTION=$(sudo systemctl start ${COMPONENT_SERVICE_NAME} 2>&1)
|
|
fi
|
|
CheckReturnCode
|
|
|
|
### SETUP COMPLETE
|
|
|
|
# Return to the project root directory.
|
|
echo -en "\e[94m Returning to ${RECEIVER_PROJECT_TITLE} root directory...\e[97m"
|
|
cd ${RECEIVER_ROOT_DIRECTORY} 2>&1
|
|
ACTION=${PWD}
|
|
CheckReturnCode
|
|
|
|
echo -e "\e[93m ------------------------------------------------------------------------------\n"
|
|
echo -e "\e[92m ${COMPONENT_NAME} setup is complete.\e[39m"
|
|
echo -e ""
|
|
if [[ "${RECEIVER_AUTOMATED_INSTALL}" = "false" ]] ; then
|
|
read -p "Press enter to continue..." CONTINUE
|
|
fi
|
|
|
|
# Unset component specific variables.
|
|
for VARIABLE in `grep "[A-Z]=" $0 | awk -F "=" '{print $1}'| sed -e 's/ //g' | grep "^COMPONENT_" | sort | uniq` ; do
|
|
unset ${VARIABLE}
|
|
done
|
|
|
|
exit 0
|