Update README.md

I was today years old when I learned software gets deprecated not depreciated.

.gitignore

@@ -1,8 +1,12 @@
+.idea/
+.vscode/
 dump978/extract_nexrad
 dump978/uat2esnt
 dump978/uat2json
 dump978/uat2text
 gen_gdl90
+libdump978.so
+fancontrol
 
 *.mp4
 
@@ -10,4 +14,31 @@ gen_gdl90
 
 *.zip
 
-*.log
+test/bmp180_read
+
+test/es_dump_csv
+
+test/extract_latlng
+
+test/extract_metar
+
+test/getairmet
+
+test/icao2reg
+
+test/maxgap
+
+test/nexrad_annunciator
+
+test/packetrate
+
+test/replay
+
+test/sensortest
+
+test/uat_read
+
+test/uatsummary
+
+.DS_Store
+

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "dump1090"]
+	path = dump1090
+	url = https://github.com/stratux/dump1090
+[submodule "goflying"]
+	path = goflying
+	url = https://github.com/cyoung/goflying

CONTRIBUTING.md

@@ -0,0 +1,3 @@
+## Issues
+
+Please use the [issue template](https://github.com/cyoung/stratux/issues/new?title=description+of+issue&body=1.%20Stratux%20version%3A%0A2.%20Stratux%20config%3A%20single%2Fdual%20SDR%2C%20GPS%20yes%2Fno%20(type%3F)%2C%20AHRS%20yes%2Fno%2C%20battery%2C%20battery%20cable.%0A3.%20EFB%20app%20and%20version%20(e.g.%2C%20WingX%20Pro7%208.6.2).%20EFB%20platform%20(e.g.%2C%20iOS%209.2).%20EFB%20hardware%20(e.g.%2C%20iPad%20Mini%202).%0A4.%20Description%20of%20your%20issue.%20If%20possible%2C%20enable%20%22Replay%20Logs%22%2C%20reproduce%20the%20problem%2C%20and%20provide%20a%20copy%20of%20the%20logs%20in%20http%3A%2F%2F192.168.10.1%2Flogs%2Fstratux%2F%20and%20http%3A%2F%2F192.168.10.1%2Flogs%2Fstratux.log.) to report an issue.

ISSUE_TEMPLATE.md

@@ -0,0 +1,29 @@
+1. Stratux version:
+2. Stratux config:
+
+    SDR
+      - [ ] single
+      - [ ] dual
+
+    GPS
+      - [ ] yes
+      - [ ] no
+      type:
+
+    AHRS
+      - [ ] yes
+      - [ ] no
+
+    power source:
+
+    usb cable:
+
+3. EFB app and version: (e.g., WingX Pro7 8.6.2)
+
+    EFB platform: (e.g., iOS 9.2)
+
+    EFB hardware: (e.g., iPad Mini 2)
+
+4. Description of your issue:
+
+If possible, enable "Replay Logs", reproduce the problem, and provide a copy of the logs in http://192.168.10.1/logs/stratux/ and http://192.168.10.1/logs/stratux.log.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Christopher Young.
+Copyright (c) 2015-2016 Christopher Young ("Copyright Holder").
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -9,7 +9,7 @@ modification, are permitted provided that the following conditions are met:
     * Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
-    * Neither the name of the Christopher Young nor the
+    * Neither the name of the copyright holder nor the
       names of its contributors may be used to endorse or promote products
       derived from this software without specific prior written permission.
 

Makefile

@@ -1,16 +1,63 @@
-GOOS   ?= linux
-GOARCH ?= arm
-GOARM  ?= 7
+
+ifeq "$(CIRCLECI)" "true"
+	BUILDINFO=
+	PLATFORMDEPENDENT=
+else
+	LDFLAGS_VERSION=-X main.stratuxVersion=`git describe --tags --abbrev=0` -X main.stratuxBuild=`git log -n 1 --pretty=%H`
+	BUILDINFO=-ldflags "$(LDFLAGS_VERSION)"
+	BUILDINFO_STATIC=-ldflags "-extldflags -static $(LDFLAGS_VERSION)"
+$(if $(GOROOT),,$(error GOROOT is not set!))
+	PLATFORMDEPENDENT=fancontrol
+endif
 
 all:
-#	GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) go get -t -d -v ./...
-	GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) go build main/gen_gdl90.go main/traffic.go main/ry835ai.go main/network.go main/managementinterface.go main/sdr.go
+	make xdump978 xdump1090 xgen_gdl90 $(PLATFORMDEPENDENT)
 
+xgen_gdl90:
+	go get -t -d -v ./main ./godump978 ./uatparse ./sensors
+	go build $(BUILDINFO) -p 4 main/gen_gdl90.go main/traffic.go main/gps.go main/network.go main/managementinterface.go main/sdr.go main/ping.go main/uibroadcast.go main/monotonic.go main/datalog.go main/equations.go main/sensors.go main/cputemp.go main/lowpower_uat.go
+
+fancontrol:
+	go get -t -d -v ./main
+	go build $(BUILDINFO_STATIC) -p 4 main/fancontrol.go main/equations.go main/cputemp.go
+
+xdump1090:
+	git submodule update --init
+	cd dump1090 && make
+
+xdump978:
+	cd dump978 && make lib
+	sudo cp -f ./libdump978.so /usr/lib/libdump978.so
+
+.PHONY: test
 test:
-	sh -c true
+	make -C test	
+
+www:
+	cd web && make
 
 install:
 	cp -f gen_gdl90 /usr/bin/gen_gdl90
 	chmod 755 /usr/bin/gen_gdl90
+	cp -f fancontrol /usr/bin/fancontrol
+	chmod 755 /usr/bin/fancontrol
+	-/usr/bin/fancontrol remove
+	/usr/bin/fancontrol install
+	cp image/10-stratux.rules /etc/udev/rules.d/10-stratux.rules
+	cp image/99-uavionix.rules /etc/udev/rules.d/99-uavionix.rules
+	rm -f /etc/init.d/stratux
+	cp __lib__systemd__system__stratux.service /lib/systemd/system/stratux.service
+	cp __root__stratux-pre-start.sh /root/stratux-pre-start.sh
+	chmod 644 /lib/systemd/system/stratux.service
+	chmod 744 /root/stratux-pre-start.sh
+	ln -fs /lib/systemd/system/stratux.service /etc/systemd/system/multi-user.target.wants/stratux.service
+	make www
+	cp -f libdump978.so /usr/lib/libdump978.so
+	cp -f dump1090/dump1090 /usr/bin/
+	cp -f image/hostapd_manager.sh /usr/sbin/
+	cp -f image/stratux-wifi.sh /usr/sbin/
+
 clean:
-	rm -f gen_gdl90
+	rm -f gen_gdl90 libdump978.so fancontrol ahrs_approx
+	cd dump1090 && make clean
+	cd dump978 && make clean

README.md

@@ -1,24 +1,63 @@
-# stratux
+[![stratux version](https://img.shields.io/github/tag/cyoung/stratux.svg?style=flat&label=stratux)](https://github.com/b3nn0/stratux/releases)
+[![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)](https://tldrlegal.com/license/bsd-3-clause-license-%28revised%29)
+[![](https://dcbadge.limes.pink/api/server/https://discord.gg/D9NQ6xe4nF)](https://discord.gg/D9NQ6xe4nF)
+
+# Stratux - deprecated branch (as of 2020)
+This branch is no longer maintained. Do not report issues here! Active development is taking place on the [@b3nn0 branch](https://github.com/b3nn0/stratux).
+
+**[Current branch](https://github.com/b3nn0/stratux)**
+
+[Current release](https://github.com/b3nn0/stratux/releases)
+
+[Stratux developer Discord](https://discord.gg/D9NQ6xe4nF)
+
+## History
+Stratux was founded in 2015 by [@cyoung](https://github.com/cyoung) and other developers with the mission of creating an open-source, modular, ADS-B solution using affordable microchips and a Raspberry Pi board. After building the project to include a dual band receiver, GPS, and AHRS [@cyoung](https://github.com/cyoung) moved on to other projects in 2020. [@b3nn0](https://github.com/b3nn0) took the reins as the main developer building out many features for the OpenGliderNetwork (OGN) and other Europe specific enhancements while maintaining the Stratux code base for users around the world.
+
+Stratux is still under active development with hardward upgrades, new features, [Reddit](https://www.reddit.com/r/stratux) and [Discord](https://discord.gg/D9NQ6xe4nF) communities. You can find parts, pre-built units, and build guides on the [Stratux website](http://stratux.me). You can also [support the developers](https://www.paypal.com/paypalme/stratuxeu) or reach out to the community with new ideas.
+
+## Old readme
+
 RTL-SDR UAT tools
 
+Use with Raspberry Pi 3B. The 3B+ and Pi 4B will work but use a lot more power.
 
-Use Pi 2 and ForeFlight 7.3 (Sep 14, 2015).
+Tested and works well with most common R820T and R820T2 RTL-SDR devices.
 
-
-Supported WiFi adapters:
-* Edimax EW-7811Un
-* TP-LINK TL-WN725N
-
-Tested RTL-SDR:
-* NooElec NESDR Mini 2
-* Generic R820T (degraded performance)
+Apps with stratux recognition/support:
+* ForeFlight 10+ - weather, traffic, AHRS.
+* Seattle Avionics FlyQ EFB 2.1.1+.
+* AvNav EFB 2.0.0+.
+* Naviator.
+* WingX Pro7 8.6.2+
+* FltPlan Go.
+* AerovieReports.
+* AvPlan EFB.
+* iFly GPS 9.4+.
+* DroidEFB 2.1.1+.
+* kwikEFIS
+* Pilots Atlas
 
 Tested weather/traffic displays:
-* ForeFlight 7.2 (Jul 13, 2015) - weather, traffic, AHRS.
-* Naviator - weather, traffic, AHRS.
-* WingX - weather & traffic.
 * Avare
-* iFly 740 - weather & traffic.
 
+Other EFBs? See the [app vendor integration guide](https://github.com/cyoung/stratux/blob/master/notes/app-vendor-integration.md).
 
-https://www.reddit.com/r/stratux
+Questions?  [See the FAQ](https://github.com/cyoung/stratux/wiki/FAQ)
+
+http://stratux.me/
+
+http://slack.stratux.me/
+
+https://www.reddit.com/r/stratux
+
+Jet tests (high gain antennas):
+
+* Dassault Falcon 20
+* Embraer ERJ 145
+* Cessna Citation 501
+* Citation Sovereign+
+* Lear 35
+* Rockwell B-1b
+* Boeing C-17
+* Gulfstream G450

__lib__systemd__system__stratux.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=Stratux
+After=network.target
+
+[Service]
+ExecStartPre=/root/stratux-pre-start.sh
+ExecStart=/usr/bin/gen_gdl90
+ExecStop=/usr/bin/pkill dump1090
+KillMode=process
+Restart=always
+RestartSec=5
+LimitCORE=1073741824
+
+[Install]
+WantedBy=multi-user.target
+

__root__stratux-pre-start.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+echo powersave >/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+
+#Logging Function
+SCRIPT=`basename ${BASH_SOURCE[0]}`
+STX_LOG="/var/log/stratux.log"
+function wLog () {
+	echo "$(date +"%Y/%m/%d %H:%m:%S")  - $SCRIPT - $1" >> ${STX_LOG}
+}
+wLog "Running Stratux Updater Script."
+
+SCRIPT_MASK="update*stratux*v*.sh"
+TEMP_LOCATION="/boot/StratuxUpdates/$SCRIPT_MASK"
+UPDATE_LOCATION="/root/$SCRIPT_MASK"
+
+if [ -e ${TEMP_LOCATION} ]; then
+	wLog "Found Update Script in $TEMP_LOCATION$SCRIPT_MASK"
+	TEMP_SCRIPT=`ls -1t ${TEMP_LOCATION} | head -1`
+	wLog "Moving Script $TEMP_SCRIPT"
+	cp -r ${TEMP_SCRIPT} /root/
+	wLog "Changing permissions to chmod a+x $UPDATE_LOCATION"
+	chmod a+x ${UPDATE_LOCATION}
+	wLog "Removing Update file from $TEMP_LOCATION"
+	rm -rf ${TEMP_SCRIPT}
+fi
+
+# Check if we need to run an update.
+if [ -e ${UPDATE_LOCATION} ]; then
+	UPDATE_SCRIPT=`ls -1t ${UPDATE_LOCATION} | head -1`
+	if [ -n ${UPDATE_SCRIPT} ] ; then
+		# Execute the script, remove it, then reboot.
+		wLog "Running update script ${UPDATE_SCRIPT}..."
+		bash ${UPDATE_SCRIPT}
+		wLog "Removing Update SH"
+		rm -f ${UPDATE_SCRIPT}
+		wLog "Finished... Rebooting... Bye"
+		reboot
+	fi
+fi
+wLog "Exited without updating anything..."

circle.yml

@@ -1,6 +1,20 @@
+machine:
+  environment:
+    PATH: $HOME/go/bin:$HOME/gopath/bin:$PATH
+    GOPATH: $HOME/gopath
+
 dependencies:
+  pre:
+    - sudo apt-get update; sudo apt-get install libusb-1.0-0-dev mercurial; cd ~/; git clone https://github.com/jpoirier/librtlsdr; cd librtlsdr; mkdir build; cd build; cmake ../; make; sudo make install; sudo ldconfig; cd ~/; rm -rf gopath; mkdir gopath; wget https://dl.google.com/go/go1.9.2.linux-amd64.tar.gz; tar -zxvf go1.9.2.linux-amd64.tar.gz; go version; env
   override:
-    - make
+    - cd .. ; rm -rf stratux ; git clone --recursive https://github.com/cyoung/stratux ; cd stratux ; git config --add remote.origin.fetch "+refs/pull/*/head:refs/remotes/origin/pr/*" ; git fetch origin ; BRANCH=`echo "$CIRCLE_BRANCH" | sed 's/pull\//pr\//g'` ; git checkout $BRANCH ; make
+
 test:
   override:
-    - make test
+    - make
+
+deployment:
+  production:
+    branch: master
+    commands:
+      - yes | ssh -i ~/.ssh/id_updates.stratux.me stratux-updates@updates.stratux.me "touch queue/`git log -n 1 --pretty=%H`"

docs/UBX-CFG-default.txt

@@ -0,0 +1,76 @@
+MON-VER - 0A 04 BE 00 32 2E 30 31 20 28 37 35 33 35 30 29 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 30 30 30 38 30 30 30 30 00 00 32 2E 30 31 20 28 37 35 33 33 31 29 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 50 52 4F 54 56 45 52 20 31 35 2E 30 30 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 46 49 53 20 30 78 45 46 34 30 31 35 20 28 37 39 31 38 39 29 00 00 00 00 00 00 00 00 00 00 4D 4F 44 20 4E 45 4F 2D 4D 38 4E 2D 30 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 47 50 53 3B 53 42 41 53 3B 47 4C 4F 3B 42 44 53 3B 51 5A 53 53 00 00 00 00 00 00 00 00 00
+CFG-ANT - 06 13 04 00 1B 00 F0 FD
+CFG-DAT - 06 06 02 00 00 00
+CFG-GNSS - 06 3E 2C 00 00 20 20 05 00 08 10 00 01 00 01 01 01 01 03 00 01 00 01 01 03 00 10 00 00 00 01 01 05 00 03 00 00 00 01 01 06 04 0E 00 00 00 01 01
+CFG-INF - 06 02 0A 00 00 00 00 00 00 00 00 00 00 00
+CFG-INF - 06 02 0A 00 01 00 00 00 87 87 87 87 87 87
+CFG-INF - 06 02 0A 00 03 00 00 00 00 00 00 00 00 00
+CFG-ITFM - 06 39 08 00 F3 AC 62 2D 1E 03 00 00
+CFG-LOGFILTER - 06 47 0C 00 01 00 00 00 00 00 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 30 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 33 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 31 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 01 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 21 08 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 0B 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 09 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 02 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 06 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 07 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 21 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 08 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 60 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 22 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 31 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 04 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 09 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 34 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 01 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 02 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 07 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 35 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 32 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 06 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 03 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 30 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 20 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 21 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 11 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 12 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 02 20 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0D 03 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0D 01 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 00 01 01 01 01 01 01
+CFG-MSG - 06 01 08 00 F0 01 00 00 00 00 00 01
+CFG-MSG - 06 01 08 00 F0 02 01 01 01 01 01 01
+CFG-MSG - 06 01 08 00 F0 03 05 05 05 05 05 01
+CFG-MSG - 06 01 08 00 F0 01 01 01 01 01 01 01
+CFG-MSG - 06 01 08 00 F0 05 01 01 01 01 01 01
+CFG-MSG - 06 01 08 00 F0 06 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 07 05 05 05 05 05 00
+CFG-MSG - 06 01 08 00 F0 08 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 09 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0A 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0D 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0E 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0F 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F1 00 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F1 03 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F1 04 00 00 00 00 00 00
+CFG-NAV5 - 06 24 24 00 FF FF 07 03 00 00 00 00 10 27 00 00 05 00 FA 00 FA 00 64 00 2C 01 00 00 00 00 00 00 C8 00 00 00 00 00 00 00
+CFG-NAVX5 - 06 23 28 00 00 00 FF FF 1F 00 00 00 03 02 03 14 06 00 00 01 00 00 DC 06 00 00 00 00 01 01 00 00 00 64 64 00 00 01 10 00 00 00 00 00
+CFG-NMEA - 06 17 14 00 00 40 00 02 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00
+CFG-ODO - 06 1E 14 00 00 00 00 00 00 00 00 00 19 46 19 66 0A 32 00 00 99 4C 00 00
+CFG-PM2 - 06 3B 2C 00 01 06 00 00 00 90 02 00 E8 03 00 00 10 27 00 00 00 00 00 00 00 00 00 00 2C 01 00 00 4F C1 03 00 86 02 00 00 FE 00 00 00 64 40 01 00
+CFG-PRT - 06 00 14 00 00 00 00 00 84 00 00 00 00 00 00 00 07 00 03 00 00 00 00 00
+CFG-PRT - 06 00 14 00 01 00 00 00 C0 08 00 00 80 25 00 00 03 00 02 00 00 00 00 00
+CFG-PRT - 06 00 14 00 02 00 00 00 C0 38 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+CFG-PRT - 06 00 14 00 03 00 00 00 00 00 00 00 00 00 00 00 07 00 03 00 00 00 00 00
+CFG-PRT - 06 00 14 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+CFG-RATE - 06 08 06 00 E8 03 01 00 01 00
+CFG-RINV - 06 34 18 00 00 4E 6F 74 69 63 65 3A 20 6E 6F 20 64 61 74 61 20 73 61 76 65 64 21 00
+CFG-RXM - 06 11 02 00 08 00
+CFG-SBAS - 06 16 08 00 01 07 03 00 00 00 00 00
+CFG-TP5 - 06 31 20 00 00 ED 02 00 32 00 00 00 40 42 0F 00 40 42 0F 00 00 00 00 00 A0 86 01 00 00 00 00 00 77 00 00 00
+CFG-TP5 - 06 31 20 00 01 ED 02 00 32 00 00 00 04 00 00 00 01 00 00 00 48 E8 01 00 A0 86 01 00 00 00 00 00 7E 00 00 00
+CFG-USB - 06 1B 6C 00 46 15 A8 01 00 00 00 00 64 00 22 00 75 2D 62 6C 6F 78 20 41 47 20 2D 20 77 77 77 2E 75 2D 62 6C 6F 78 2E 63 6F 6D 00 00 00 00 00 00 75 2D 62 6C 6F 78 20 47 4E 53 53 20 72 65 63 65 69 76 65 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

docs/UBX-CFG-stratux-38400baud.txt

@@ -0,0 +1,76 @@
+MON-VER - 0A 04 BE 00 32 2E 30 31 20 28 37 35 33 35 30 29 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 30 30 30 38 30 30 30 30 00 00 32 2E 30 31 20 28 37 35 33 33 31 29 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 50 52 4F 54 56 45 52 20 31 35 2E 30 30 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 46 49 53 20 30 78 45 46 34 30 31 35 20 28 37 39 31 38 39 29 00 00 00 00 00 00 00 00 00 00 4D 4F 44 20 4E 45 4F 2D 4D 38 4E 2D 30 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 47 50 53 3B 53 42 41 53 3B 47 4C 4F 3B 42 44 53 3B 51 5A 53 53 00 00 00 00 00 00 00 00 00
+CFG-ANT - 06 13 04 00 1B 00 F0 FD
+CFG-DAT - 06 06 02 00 00 00
+CFG-GNSS - 06 3E 2C 00 00 20 20 05 00 08 10 00 01 00 01 01 01 01 03 00 01 00 01 01 03 00 10 00 00 00 01 01 05 00 03 00 00 00 01 01 06 04 0E 00 00 00 01 01
+CFG-INF - 06 02 0A 00 00 00 00 00 00 00 00 00 00 00
+CFG-INF - 06 02 0A 00 01 00 00 00 87 87 87 87 87 87
+CFG-INF - 06 02 0A 00 03 00 00 00 00 00 00 00 00 00
+CFG-ITFM - 06 39 08 00 F3 AC 62 2D 1E 03 00 00
+CFG-LOGFILTER - 06 47 0C 00 01 00 00 00 00 00 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 30 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 33 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 31 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0B 01 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 21 08 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 0B 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 09 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 02 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 06 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 07 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 21 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0A 08 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 60 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 22 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 31 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 04 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 09 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 34 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 01 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 02 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 07 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 35 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 32 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 06 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 03 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 30 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 20 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 21 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 11 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 01 12 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 02 20 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0D 03 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 0D 01 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 00 00 0A 00 0A 00 01
+CFG-MSG - 06 01 08 00 F0 01 00 00 00 00 00 01
+CFG-MSG - 06 01 08 00 F0 02 00 00 00 00 00 01
+CFG-MSG - 06 01 08 00 F0 03 00 00 00 00 00 01
+CFG-MSG - 06 01 08 00 F0 04 00 00 00 00 00 01
+CFG-MSG - 06 01 08 00 F0 05 00 00 00 00 00 01
+CFG-MSG - 06 01 08 00 F0 06 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 07 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 08 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 09 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0A 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0D 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0E 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F0 0F 00 00 00 00 00 00
+CFG-MSG - 06 01 08 00 F1 00 01 01 01 01 01 00
+CFG-MSG - 06 01 08 00 F1 03 0A 0A 0A 0A 0A 00
+CFG-MSG - 06 01 08 00 F1 04 0A 0A 0A 0A 0A 00
+CFG-NAV5 - 06 24 24 00 FF FF 07 03 00 00 00 00 10 27 00 00 05 00 FA 00 FA 00 64 00 2C 01 00 00 00 00 00 00 C8 00 00 00 00 00 00 00
+CFG-NAVX5 - 06 23 28 00 00 00 FF FF 1F 00 00 00 03 02 03 14 06 00 00 01 00 00 DC 06 00 00 00 00 01 01 00 00 00 64 64 00 00 01 10 00 00 00 00 00
+CFG-NMEA - 06 17 14 00 00 40 00 02 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00
+CFG-ODO - 06 1E 14 00 00 00 00 00 00 00 00 00 19 46 19 66 0A 32 00 00 99 4C 00 00
+CFG-PM2 - 06 3B 2C 00 01 06 00 00 00 90 02 00 E8 03 00 00 10 27 00 00 00 00 00 00 00 00 00 00 2C 01 00 00 4F C1 03 00 86 02 00 00 FE 00 00 00 64 40 01 00
+CFG-PRT - 06 00 14 00 00 00 00 00 84 00 00 00 00 00 00 00 07 00 03 00 00 00 00 00
+CFG-PRT - 06 00 14 00 01 00 00 00 C0 08 00 00 00 96 00 00 03 00 02 00 00 00 00 00
+CFG-PRT - 06 00 14 00 02 00 00 00 C0 38 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+CFG-PRT - 06 00 14 00 03 00 00 00 00 00 00 00 00 00 00 00 07 00 03 00 00 00 00 00
+CFG-PRT - 06 00 14 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+CFG-RATE - 06 08 06 00 64 00 01 00 01 00
+CFG-RINV - 06 34 18 00 00 4E 6F 74 69 63 65 3A 20 6E 6F 20 64 61 74 61 20 73 61 76 65 64 21 00
+CFG-RXM - 06 11 02 00 08 00
+CFG-SBAS - 06 16 08 00 01 07 03 00 00 00 00 00
+CFG-TP5 - 06 31 20 00 00 ED 02 00 32 00 00 00 40 42 0F 00 40 42 0F 00 00 00 00 00 A0 86 01 00 00 00 00 00 77 00 00 00
+CFG-TP5 - 06 31 20 00 01 ED 02 00 32 00 00 00 04 00 00 00 01 00 00 00 48 E8 01 00 A0 86 01 00 00 00 00 00 7E 00 00 00
+CFG-USB - 06 1B 6C 00 46 15 A8 01 00 00 00 00 64 00 22 00 75 2D 62 6C 6F 78 20 41 47 20 2D 20 77 77 77 2E 75 2D 62 6C 6F 78 2E 63 6F 6D 00 00 00 00 00 00 75 2D 62 6C 6F 78 20 47 4E 53 53 20 72 65 63 65 69 76 65 72 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

dump1090

@@ -0,0 +1 @@
+Subproject commit 9a4fb850937565cfeadd1e5889cddbf93f45faf5

dump1090/Makefile

@@ -1,15 +0,0 @@
-CFLAGS?=-O2 -g -Wall -W $(shell pkg-config --cflags librtlsdr)
-LDLIBS+=$(shell pkg-config --libs librtlsdr) -lpthread -lm
-CC?=gcc
-PROGNAME=dump1090
-
-all: dump1090
-
-%.o: %.c
-	$(CC) $(CFLAGS) -c $<
-
-dump1090: dump1090.o anet.o
-	$(CC) -g -o dump1090 dump1090.o anet.o $(LDFLAGS) $(LDLIBS)
-
-clean:
-	rm -f *.o dump1090

dump1090/README.md

@@ -1,284 +0,0 @@
-Dump1090 README
-===
-
-Dump 1090 is a Mode S decoder specifically designed for RTLSDR devices.
-
-The main features are:
-
-* Robust decoding of weak messages, with mode1090 many users observed
-  improved range compared to other popular decoders.
-* Network support: TCP30003 stream (MSG5...), Raw packets, HTTP.
-* Embedded HTTP server that displays the currently detected aircrafts on
-  Google Map.
-* Single bit errors correction using the 24 bit CRC.
-* Ability to decode DF11, DF17 messages.
-* Ability to decode DF formats like DF0, DF4, DF5, DF16, DF20 and DF21
-  where the checksum is xored with the ICAO address by brute forcing the
-  checksum field using recently seen ICAO addresses.
-* Decode raw IQ samples from file (using --ifile command line switch).
-* Interactive command-line-interfae mode where aircrafts currently detected
-  are shown as a list refreshing as more data arrives.
-* CPR coordinates decoding and track calculation from velocity.
-* TCP server streaming and receiving raw data to/from connected clients
-  (using --net).
-
-While from time to time I still add / fix stuff in my fork, I target
-minimalism of the implementation. However there is a
-[much more feature complete fork](https://github.com/MalcolmRobb/dump1090)
-available, developed by MalcolmRobb.
-
-Installation
----
-
-Type "make".
-
-Normal usage
----
-
-To capture traffic directly from your RTL device and show the captured traffic
-on standard output, just run the program without options at all:
-
-    ./dump1090
-
-To just output hexadecimal messages:
-
-    ./dump1090 --raw
-
-To run the program in interactive mode:
-
-    ./dump1090 --interactive
-
-To run the program in interactive mode, with networking support, and connect
-with your browser to http://localhost:8080 to see live traffic:
-
-    ./dump1090 --interactive --net
-
-In iteractive mode it is possible to have a less information dense but more
-"arcade style" output, where the screen is refreshed every second displaying
-all the recently seen aircrafts with some additional information such as
-altitude and flight number, extracted from the received Mode S packets.
-
-Using files as source of data
----
-
-To decode data from file, use:
-
-    ./dump1090 --ifile /path/to/binfile
-
-The binary file should be created using `rtl_sdr` like this (or with any other
-program that is able to output 8-bit unsigned IQ samples at 2Mhz sample rate).
-
-    rtl_sdr -f 1090000000 -s 2000000 -g 50 output.bin
-
-In the example `rtl_sdr` a gain of 50 is used, simply you should use the highest
-gain availabe for your tuner. This is not needed when calling Dump1090 itself
-as it is able to select the highest gain supported automatically.
-
-It is possible to feed the program with data via standard input using
-the --ifile option with "-" as argument.
-
-Additional options
----
-
-Dump1090 can be called with other command line options to set a different
-gain, frequency, and so forth. For a list of options use:
-
-    ./dump1090 --help
-
-Everything is not documented here should be obvious, and for most users calling
-it without arguments at all is the best thing to do.
-
-Reliability
----
-
-By default Dump1090 tries to fix single bit errors using the checksum.
-Basically the program will try to flip every bit of the message and check if
-the checksum of the resulting message matches.
-
-This is indeed able to fix errors and works reliably in my experience,
-however if you are interested in very reliable data I suggest to use
-the --no-fix command line switch in order to disable error fixing.
-
-Performances and sensibility of detection
----
-
-In my limited experience Dump1090 was able to decode a big number of messages
-even in conditions where I encountered problems using other programs, however
-no formal test was performed so I can't really claim that this program is
-better or worse compared to other similar programs.
-
-If you can capture traffic that Dump1090 is not able to decode properly, drop
-me an email with a download link. I may try to improve the detection during
-my free time (this is just an hobby project).
-
-Network server features
----
-
-By enabling the networking support with --net Dump1090 starts listening
-for clients connections on port 30002 and 30001 (you can change both the
-ports if you want, see --help output).
-
-Port 30002
----
-
-Connected clients are served with data ASAP as they arrive from the device
-(or from file if --ifile is used) in the raw format similar to the following:
-
-    *8D451E8B99019699C00B0A81F36E;
-
-Every entry is separated by a simple newline (LF character, hex 0x0A).
-
-Port 30001
----
-
-Port 30001 is the raw input port, and can be used to feed Dump1090 with
-data in the same format as specified above, with hex messages starting with
-a `*` and ending with a `;` character.
-
-So for instance if there is another remote Dump1090 instance collecting data
-it is possible to sum the output to a local Dump1090 instance doing something
-like this:
-
-    nc remote-dump1090.example.net 30002 | nc localhost 30001
-
-It is important to note that what is received via port 30001 is also
-broadcasted to clients listening to port 30002.
-
-In general everything received from port 30001 is handled exactly like the
-normal traffic from RTL devices or from file when --ifile is used.
-
-It is possible to use Dump1090 just as an hub using --ifile with /dev/zero
-as argument as in the following example:
-
-    ./dump1090 --net-only
-
-Or alternatively to see what's happening on the screen:
-
-    ./dump1090 --net-only --interactive
-
-Then you can feed it from different data sources from the internet.
-
-Port 30003
----
-
-Connected clients are served with messages in SBS1 (BaseStation) format,
-similar to:
-
-    MSG,4,,,738065,,,,,,,,420,179,,,0,,0,0,0,0
-    MSG,3,,,738065,,,,,,,35000,,,34.81609,34.07810,,,0,0,0,0
-
-This can be used to feed data to various sharing sites without the need to use another decoder.
-
-Antenna
----
-
-Mode S messages are transmitted in the 1090 Mhz frequency. If you have a decent
-antenna you'll be able to pick up signals from aircrafts pretty far from your
-position, especially if you are outdoor and in a position with a good sky view.
-
-You can easily build a very cheap antenna following the istructions at:
-
-    http://antirez.com/news/46
-
-With this trivial antenna I was able to pick up signals of aircrafts 200+ Km
-away from me.
-
-If you are interested in a more serious antenna check the following
-resources:
-
-* http://gnuradio.org/redmine/attachments/download/246/06-foster-adsb.pdf
-* http://www.lll.lu/~edward/edward/adsb/antenna/ADSBantenna.html
-* http://modesbeast.com/pix/adsb-ant-drawing.gif
-
-Aggressive mode
----
-
-With --aggressive it is possible to activate the *aggressive mode* that is a
-modified version of the Mode S packet detection and decoding.
-THe aggresive mode uses more CPU usually (especially if there are many planes
-sending DF17 packets), but can detect a few more messages.
-
-The algorithm in aggressive mode is modified in the following ways:
-
-* Up to two demodulation errors are tolerated (adjacent entires in the magnitude
-  vector with the same eight). Normally only messages without errors are
-  checked.
-* It tries to fix DF17 messages trying every two bits combination.
-
-The use of aggressive mdoe is only advised in places where there is low traffic
-in order to have a chance to capture some more messages.
-
-Debug mode
----
-
-The Debug mode is a visual help to improve the detection algorithm or to
-understand why the program is not working for a given input.
-
-In this mode messages are displayed in an ASCII-art style graphical
-representation, where the individial magnitude bars sampled at 2Mhz are
-displayed.
-
-An index shows the sample number, where 0 is the sample where the first
-Mode S peak was found. Some additional background noise is also added
-before the first peak to provide some context.
-
-To enable debug mode and check what combinations of packets you can
-log, use `mode1090 --help` to obtain a list of available debug flags.
-
-Debug mode includes an optional javascript output that is used to visualize
-packets using a web browser, you can use the file debug.html under the
-'tools' directory to load the generated frames.js file.
-
-How this program works?
----
-
-The code is very documented and written in order to be easy to understand.
-For the diligent programmer with a Mode S specification on his hands it
-should be trivial to understand how it works.
-
-The algorithms I used were obtained basically looking at many messages
-as displayed using a trow-away SDL program, and trying to model the algorithm
-based on how the messages look graphically.
-
-How to test the program?
----
-
-If you have an RTLSDR device and you happen to be in an area where there
-are aircrafts flying over your head, just run the program and check for signals.
-
-However if you don't have an RTLSDR device, or if in your area the presence
-of aircrafts is very limited, you may want to try the sample file distributed
-with the Dump1090 distribution under the "testfiles" directory.
-
-Just run it like this:
-
-    ./dump1090 --ifile testfiles/modes1.bin
-
-What is --strip mode?
----
-
-It is just a simple filter that will get raw IQ 8 bit samples in input
-and will output a file missing all the parts of the file where I and Q
-are lower than the specified <level> for more than 32 samples.
-
-Use it like this:
-
-    cat big.bin | ./dump1090 --snip 25 > small.bin
-
-I used it in order to create a small test file to include inside this
-program source code distribution.
-
-Contributing
----
-
-Dump1090 was written during some free time during xmas 2012, it is an hobby
-project so I'll be able to address issues and improve it only during
-free time, however you are incouraged to send pull requests in order to
-improve the program. A good starting point can be the TODO list included in
-the source distribution.
-
-Credits
----
-
-Dump1090 was written by Salvatore Sanfilippo <antirez@gmail.com> and is
-released under the BSD three clause license.

dump1090/TODO

@@ -1,5 +0,0 @@
-TODO
-
-* Extract more information from captured Mode S messages.
-* Improve the web interface gmap.html.
-* Enhance the algorithm to reliably decode more messages.

dump1090/anet.c

@@ -1,382 +0,0 @@
-/* anet.c -- Basic TCP socket stuff made a bit less boring
- *
- * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/un.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
-#include <netdb.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "anet.h"
-
-static void anetSetError(char *err, const char *fmt, ...)
-{
-    va_list ap;
-
-    if (!err) return;
-    va_start(ap, fmt);
-    vsnprintf(err, ANET_ERR_LEN, fmt, ap);
-    va_end(ap);
-}
-
-int anetNonBlock(char *err, int fd)
-{
-    int flags;
-
-    /* Set the socket nonblocking.
-     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
-     * interrupted by a signal. */
-    if ((flags = fcntl(fd, F_GETFL)) == -1) {
-        anetSetError(err, "fcntl(F_GETFL): %s", strerror(errno));
-        return ANET_ERR;
-    }
-    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
-        anetSetError(err, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
-        return ANET_ERR;
-    }
-    return ANET_OK;
-}
-
-int anetTcpNoDelay(char *err, int fd)
-{
-    int yes = 1;
-    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1)
-    {
-        anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno));
-        return ANET_ERR;
-    }
-    return ANET_OK;
-}
-
-int anetSetSendBuffer(char *err, int fd, int buffsize)
-{
-    if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buffsize, sizeof(buffsize)) == -1)
-    {
-        anetSetError(err, "setsockopt SO_SNDBUF: %s", strerror(errno));
-        return ANET_ERR;
-    }
-    return ANET_OK;
-}
-
-int anetTcpKeepAlive(char *err, int fd)
-{
-    int yes = 1;
-    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) == -1) {
-        anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno));
-        return ANET_ERR;
-    }
-    return ANET_OK;
-}
-
-int anetResolve(char *err, char *host, char *ipbuf)
-{
-    struct sockaddr_in sa;
-
-    sa.sin_family = AF_INET;
-    if (inet_aton(host, &sa.sin_addr) == 0) {
-        struct hostent *he;
-
-        he = gethostbyname(host);
-        if (he == NULL) {
-            anetSetError(err, "can't resolve: %s", host);
-            return ANET_ERR;
-        }
-        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
-    }
-    strcpy(ipbuf,inet_ntoa(sa.sin_addr));
-    return ANET_OK;
-}
-
-static int anetCreateSocket(char *err, int domain) {
-    int s, on = 1;
-    if ((s = socket(domain, SOCK_STREAM, 0)) == -1) {
-        anetSetError(err, "creating socket: %s", strerror(errno));
-        return ANET_ERR;
-    }
-
-    /* Make sure connection-intensive things like the redis benckmark
-     * will be able to close/open sockets a zillion of times */
-    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
-        anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
-        return ANET_ERR;
-    }
-    return s;
-}
-
-#define ANET_CONNECT_NONE 0
-#define ANET_CONNECT_NONBLOCK 1
-static int anetTcpGenericConnect(char *err, char *addr, int port, int flags)
-{
-    int s;
-    struct sockaddr_in sa;
-
-    if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
-        return ANET_ERR;
-
-    sa.sin_family = AF_INET;
-    sa.sin_port = htons(port);
-    if (inet_aton(addr, &sa.sin_addr) == 0) {
-        struct hostent *he;
-
-        he = gethostbyname(addr);
-        if (he == NULL) {
-            anetSetError(err, "can't resolve: %s", addr);
-            close(s);
-            return ANET_ERR;
-        }
-        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
-    }
-    if (flags & ANET_CONNECT_NONBLOCK) {
-        if (anetNonBlock(err,s) != ANET_OK)
-            return ANET_ERR;
-    }
-    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
-        if (errno == EINPROGRESS &&
-            flags & ANET_CONNECT_NONBLOCK)
-            return s;
-
-        anetSetError(err, "connect: %s", strerror(errno));
-        close(s);
-        return ANET_ERR;
-    }
-    return s;
-}
-
-int anetTcpConnect(char *err, char *addr, int port)
-{
-    return anetTcpGenericConnect(err,addr,port,ANET_CONNECT_NONE);
-}
-
-int anetTcpNonBlockConnect(char *err, char *addr, int port)
-{
-    return anetTcpGenericConnect(err,addr,port,ANET_CONNECT_NONBLOCK);
-}
-
-int anetUnixGenericConnect(char *err, char *path, int flags)
-{
-    int s;
-    struct sockaddr_un sa;
-
-    if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
-        return ANET_ERR;
-
-    sa.sun_family = AF_LOCAL;
-    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
-    if (flags & ANET_CONNECT_NONBLOCK) {
-        if (anetNonBlock(err,s) != ANET_OK)
-            return ANET_ERR;
-    }
-    if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) == -1) {
-        if (errno == EINPROGRESS &&
-            flags & ANET_CONNECT_NONBLOCK)
-            return s;
-
-        anetSetError(err, "connect: %s", strerror(errno));
-        close(s);
-        return ANET_ERR;
-    }
-    return s;
-}
-
-int anetUnixConnect(char *err, char *path)
-{
-    return anetUnixGenericConnect(err,path,ANET_CONNECT_NONE);
-}
-
-int anetUnixNonBlockConnect(char *err, char *path)
-{
-    return anetUnixGenericConnect(err,path,ANET_CONNECT_NONBLOCK);
-}
-
-/* Like read(2) but make sure 'count' is read before to return
- * (unless error or EOF condition is encountered) */
-int anetRead(int fd, char *buf, int count)
-{
-    int nread, totlen = 0;
-    while(totlen != count) {
-        nread = read(fd,buf,count-totlen);
-        if (nread == 0) return totlen;
-        if (nread == -1) return -1;
-        totlen += nread;
-        buf += nread;
-    }
-    return totlen;
-}
-
-/* Like write(2) but make sure 'count' is read before to return
- * (unless error is encountered) */
-int anetWrite(int fd, char *buf, int count)
-{
-    int nwritten, totlen = 0;
-    while(totlen != count) {
-        nwritten = write(fd,buf,count-totlen);
-        if (nwritten == 0) return totlen;
-        if (nwritten == -1) return -1;
-        totlen += nwritten;
-        buf += nwritten;
-    }
-    return totlen;
-}
-
-static int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len) {
-    if (bind(s,sa,len) == -1) {
-        anetSetError(err, "bind: %s", strerror(errno));
-        close(s);
-        return ANET_ERR;
-    }
-
-    /* Use a backlog of 512 entries. We pass 511 to the listen() call because
-     * the kernel does: backlogsize = roundup_pow_of_two(backlogsize + 1);
-     * which will thus give us a backlog of 512 entries */
-    if (listen(s, 511) == -1) {
-        anetSetError(err, "listen: %s", strerror(errno));
-        close(s);
-        return ANET_ERR;
-    }
-    return ANET_OK;
-}
-
-int anetTcpServer(char *err, int port, char *bindaddr)
-{
-    int s;
-    struct sockaddr_in sa;
-
-    if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
-        return ANET_ERR;
-
-    memset(&sa,0,sizeof(sa));
-    sa.sin_family = AF_INET;
-    sa.sin_port = htons(port);
-    sa.sin_addr.s_addr = htonl(INADDR_ANY);
-    if (bindaddr && inet_aton(bindaddr, &sa.sin_addr) == 0) {
-        anetSetError(err, "invalid bind address");
-        close(s);
-        return ANET_ERR;
-    }
-    if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
-        return ANET_ERR;
-    return s;
-}
-
-int anetUnixServer(char *err, char *path, mode_t perm)
-{
-    int s;
-    struct sockaddr_un sa;
-
-    if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
-        return ANET_ERR;
-
-    memset(&sa,0,sizeof(sa));
-    sa.sun_family = AF_LOCAL;
-    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
-    if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
-        return ANET_ERR;
-    if (perm)
-        chmod(sa.sun_path, perm);
-    return s;
-}
-
-static int anetGenericAccept(char *err, int s, struct sockaddr *sa, socklen_t *len) {
-    int fd;
-    while(1) {
-        fd = accept(s,sa,len);
-        if (fd == -1) {
-            if (errno == EINTR)
-                continue;
-            else {
-                anetSetError(err, "accept: %s", strerror(errno));
-                return ANET_ERR;
-            }
-        }
-        break;
-    }
-    return fd;
-}
-
-int anetTcpAccept(char *err, int s, char *ip, int *port) {
-    int fd;
-    struct sockaddr_in sa;
-    socklen_t salen = sizeof(sa);
-    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
-        return ANET_ERR;
-
-    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
-    if (port) *port = ntohs(sa.sin_port);
-    return fd;
-}
-
-int anetUnixAccept(char *err, int s) {
-    int fd;
-    struct sockaddr_un sa;
-    socklen_t salen = sizeof(sa);
-    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
-        return ANET_ERR;
-
-    return fd;
-}
-
-int anetPeerToString(int fd, char *ip, int *port) {
-    struct sockaddr_in sa;
-    socklen_t salen = sizeof(sa);
-
-    if (getpeername(fd,(struct sockaddr*)&sa,&salen) == -1) {
-        *port = 0;
-        ip[0] = '?';
-        ip[1] = '\0';
-        return -1;
-    }
-    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
-    if (port) *port = ntohs(sa.sin_port);
-    return 0;
-}
-
-int anetSockName(int fd, char *ip, int *port) {
-    struct sockaddr_in sa;
-    socklen_t salen = sizeof(sa);
-
-    if (getsockname(fd,(struct sockaddr*)&sa,&salen) == -1) {
-        *port = 0;
-        ip[0] = '?';
-        ip[1] = '\0';
-        return -1;
-    }
-    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
-    if (port) *port = ntohs(sa.sin_port);
-    return 0;
-}

dump1090/anet.h

@@ -1,59 +0,0 @@
-/* anet.c -- Basic TCP socket stuff made a bit less boring
- *
- * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef ANET_H
-#define ANET_H
-
-#define ANET_OK 0
-#define ANET_ERR -1
-#define ANET_ERR_LEN 256
-
-#if defined(__sun)
-#define AF_LOCAL AF_UNIX
-#endif
-
-int anetTcpConnect(char *err, char *addr, int port);
-int anetTcpNonBlockConnect(char *err, char *addr, int port);
-int anetUnixConnect(char *err, char *path);
-int anetUnixNonBlockConnect(char *err, char *path);
-int anetRead(int fd, char *buf, int count);
-int anetResolve(char *err, char *host, char *ipbuf);
-int anetTcpServer(char *err, int port, char *bindaddr);
-int anetUnixServer(char *err, char *path, mode_t perm);
-int anetTcpAccept(char *err, int serversock, char *ip, int *port);
-int anetUnixAccept(char *err, int serversock);
-int anetWrite(int fd, char *buf, int count);
-int anetNonBlock(char *err, int fd);
-int anetTcpNoDelay(char *err, int fd);
-int anetTcpKeepAlive(char *err, int fd);
-int anetPeerToString(int fd, char *ip, int *port);
-int anetSetSendBuffer(char *err, int fd, int buffsize);
-
-#endif

dump1090/gmap.html

@@ -1,180 +0,0 @@
-<!DOCTYPE html>
-
-<html>
-  <head>
-    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
-    <style type="text/css">
-      html { height: 100% }
-      body { height: 100%; margin: 0; padding: 0 }
-      #map_canvas { height: 100% }
-      #info {
-        position: absolute;
-        width:20%;
-        height:100%;
-        bottom:0px;
-        right:0px;
-        top:0px;
-        background-color: white;
-        border-left:1px #666 solid;
-        font-family:Helvetica;
-      }
-      #info div {
-        padding:0px;
-        padding-left:10px;
-        margin:0px;
-      }
-      #info div h1 {
-        margin-top:10px;
-        font-size:16px;
-      }
-      #info div p {
-        font-size:14px;
-        color:#333;
-      }
-    </style>
-    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js">
-    </script>
-    <script type="text/javascript"
-      src="https://maps.googleapis.com/maps/api/js?sensor=true">
-    </script>
-    <script type="text/javascript">
-    Map=null;
-    CenterLat=45.0;
-    CenterLon=9.0;
-    Planes={};
-    NumPlanes = 0;
-    Selected=null
-
-    function getIconForPlane(plane) {
-        var r = 255, g = 255, b = 0;
-        var maxalt = 40000; /* Max altitude in the average case */
-        var invalt = maxalt-plane.altitude;
-        var selected = (Selected == plane.hex);
-
-        if (invalt < 0) invalt = 0;
-        b = parseInt(255/maxalt*invalt);
-        return {
-            strokeWeight: (selected ? 2 : 1),
-            path: google.maps.SymbolPath.FORWARD_CLOSED_ARROW,
-            scale: 5,
-            fillColor: 'rgb('+r+','+g+','+b+')',
-            fillOpacity: 0.9,
-            rotation: plane.track
-        };
-    }
-
-    function selectPlane() {
-        if (!Planes[this.planehex]) return;
-        var old = Selected;
-        Selected = this.planehex;
-        if (Planes[old]) {
-            /* Remove the highlight in the previously selected plane. */
-            Planes[old].marker.setIcon(getIconForPlane(Planes[old]));
-        }
-        Planes[Selected].marker.setIcon(getIconForPlane(Planes[Selected]));
-        refreshSelectedInfo();
-    }
-    
-    function refreshGeneralInfo() {
-        var i = document.getElementById('geninfo');
-
-        i.innerHTML = NumPlanes+' planes on screen.';
-    }
-
-    function refreshSelectedInfo() {
-        var i = document.getElementById('selinfo');
-        var p = Planes[Selected];
-
-        if (!p) return;
-        var html = 'ICAO: '+p.hex+'<br>';
-        if (p.flight.length) {
-            html += '<b>'+p.flight+'</b><br>';
-        }
-        html += 'Altitude: '+p.altitude+' feet<br>';
-        html += 'Speed: '+p.speed+' knots<br>';
-        html += 'Coordinates: '+p.lat+', '+p.lon+'<br>';
-        i.innerHTML = html;
-    }
-
-    function fetchData() {
-        $.getJSON('/data.json', function(data) {
-            var stillhere = {}
-            for (var j=0; j < data.length; j++) {
-                var plane = data[j];
-                var marker = null;
-                stillhere[plane.hex] = true;
-                plane.flight = $.trim(plane.flight);
-
-                if (Planes[plane.hex]) {
-                    var myplane = Planes[plane.hex];
-                    marker = myplane.marker;
-                    var icon = marker.getIcon();
-                    var newpos = new google.maps.LatLng(plane.lat, plane.lon);
-                    marker.setPosition(newpos);
-                    marker.setIcon(getIconForPlane(plane));
-                    myplane.altitude = plane.altitude;
-                    myplane.speed = plane.speed;
-                    myplane.lat = plane.lat;
-                    myplane.lon = plane.lon;
-                    myplane.track = plane.track;
-                    myplane.flight = plane.flight;
-                    if (myplane.hex == Selected)
-                        refreshSelectedInfo();
-                } else {
-                    marker = new google.maps.Marker({
-                        position: new google.maps.LatLng(plane.lat, plane.lon),
-                        map: Map,
-                        icon: getIconForPlane(plane)
-                    });
-                    plane.marker = marker;
-                    marker.planehex = plane.hex;
-                    Planes[plane.hex] = plane;
-
-                    /* Trap clicks for this marker. */
-                    google.maps.event.addListener(marker, 'click', selectPlane);
-                }
-                if (plane.flight.length == 0)
-                    marker.setTitle(plane.hex)
-                else
-                    marker.setTitle(plane.flight+' ('+plane.hex+')')
-            }
-            NumPlanes = data.length;
-
-            /* Remove idle planes. */
-            for (var p in Planes) {
-                if (!stillhere[p]) {
-                    Planes[p].marker.setMap(null);
-                    delete Planes[p];
-                }
-            }
-        });
-    }
-
-    function initialize() {
-        var mapOptions = {
-            center: new google.maps.LatLng(CenterLat, CenterLon),
-            zoom: 5,
-            mapTypeId: google.maps.MapTypeId.ROADMAP
-        };
-        Map = new google.maps.Map(document.getElementById("map_canvas"), mapOptions);
-
-        /* Setup our timer to poll from the server. */
-        window.setInterval(function() {
-            fetchData();
-            refreshGeneralInfo();
-        }, 1000);
-    }
-
-    </script>
-  </head>
-  <body onload="initialize()">
-    <div id="map_canvas" style="width:80%; height:100%"></div>
-    <div id="info">
-      <div>
-        <h1>Dump1090</h1>
-        <p id="geninfo"></p>
-        <p id="selinfo">Click on a plane for info.</p>
-      </div>
-    </div>
-  </body>
-</html>

dump1090/tools/debug.html

@@ -1,193 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-<head>
-<script>
-var frames = [];
-var currentFrame = 0;
-
-var modes_checksum_table = [
-0x3935ea, 0x1c9af5, 0xf1b77e, 0x78dbbf, 0xc397db, 0x9e31e9, 0xb0e2f0, 0x587178,
-0x2c38bc, 0x161c5e, 0x0b0e2f, 0xfa7d13, 0x82c48d, 0xbe9842, 0x5f4c21, 0xd05c14,
-0x682e0a, 0x341705, 0xe5f186, 0x72f8c3, 0xc68665, 0x9cb936, 0x4e5c9b, 0xd8d449,
-0x939020, 0x49c810, 0x24e408, 0x127204, 0x093902, 0x049c81, 0xfdb444, 0x7eda22,
-0x3f6d11, 0xe04c8c, 0x702646, 0x381323, 0xe3f395, 0x8e03ce, 0x4701e7, 0xdc7af7,
-0x91c77f, 0xb719bb, 0xa476d9, 0xadc168, 0x56e0b4, 0x2b705a, 0x15b82d, 0xf52612,
-0x7a9309, 0xc2b380, 0x6159c0, 0x30ace0, 0x185670, 0x0c2b38, 0x06159c, 0x030ace,
-0x018567, 0xff38b7, 0x80665f, 0xbfc92b, 0xa01e91, 0xaff54c, 0x57faa6, 0x2bfd53,
-0xea04ad, 0x8af852, 0x457c29, 0xdd4410, 0x6ea208, 0x375104, 0x1ba882, 0x0dd441,
-0xf91024, 0x7c8812, 0x3e4409, 0xe0d800, 0x706c00, 0x383600, 0x1c1b00, 0x0e0d80,
-0x0706c0, 0x038360, 0x01c1b0, 0x00e0d8, 0x00706c, 0x003836, 0x001c1b, 0xfff409,
-0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
-0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
-0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000
-];
-
-function modesChecksum(frame) {
-    var crc = 0;
-    var bits = frame.bits;
-    var offset = (bits == 112) ? 0 : (112-56);
-
-    for(var j = 0; j < bits; j++) {
-        var byte = j/8;
-        var bit = j%8;
-        var bitmask = 1 << (7-bit);
-
-        /* If bit is set, xor with corresponding table entry. */
-        if (frame.hex.charCodeAt(byte) & bitmask)
-            crc ^= modes_checksum_table[j+offset];
-    }
-    return crc; /* 24 bit checksum. */
-}
-
-function getFrameChecksum(frame) {
-    var res = "";
-    for (j = 0; j < frame.hex.length; j++) {
-        var val = frame.hex.charCodeAt(j);
-        var h = val.toString(16);
-        if (h.length == 1) h = "0"+h;
-        res += h;
-    }
-    return res;
-}
-
-function displayFrame(i) {
-    var div = document.getElementById("frame");
-    var msgbits = 8+112;
-    var frame = frames[i];
-    var padding = frame.mag.length - msgbits*2;
-
-    /* Remove the old representation. */
-    var nodes = div.childNodes.length;
-    for(var j = 0; j < nodes; j++) {
-        div.removeChild(div.firstChild);
-    }
-
-    /* Display the new one. */
-    for (var j = -padding; j < msgbits*2+padding; j++) {
-        var m = frame.mag[j+padding];
-        var type;
-
-        if (j < 0) type = "noise";
-        if (j >= 0 && j < 16) type = "pre";
-        if (j >= 16) {
-            if (!(j % 2)) {
-                var next = frame.mag[j+padding+1];
-                if (m > next)
-                    type = "one";
-                else
-                    type = "zero";
-            }
-            var bit = (j-16)/2;
-            if (bit == frame.fix1 ||
-                bit == frame.fix2)
-                type = "err";
-        }
-        var sample = document.createElement("div");
-        sample.setAttribute("class","sample "+type);
-        sample.setAttribute("title","sample "+j+" ("+m+")");
-        sample.style.left = ""+((j+padding)*4)+"px";
-        sample.style.height = ""+(m/256)+"px";
-        div.appendChild(sample);
-    }
-    document.getElementById("info").innerHTML =
-        "#"+currentFrame+" "+frame.descr+"<br>"+
-        "Bits:"+frame.bits+"<br>"+
-        "DF  : "+(frame.hex.charCodeAt(0) >> 3)+"<br>"+
-        "fix1: "+frame.fix1+"<br>"+
-        "fix2: "+frame.fix2+"<br>"+
-        "hex : "+getFrameChecksum(frame)+"<br>"+
-        "crc (computed): "+modesChecksum(frame).toString(16)+"<br>";
-}
-
-function recomputeHex(frame) {
-    var padding = frame.mag.length - (112+8)*2;
-    var b = [];
-    var hex = "";
-
-    /* Get bits */
-    for (var j = 0; j < frame.bits*2; j += 2) {
-        var bit;
-        var l = frame.mag[padding+j+16];
-        var r = frame.mag[padding+j+1+16];
-        if (l > r)
-            bit = 1;
-        else
-            bit = 0;
-        b.push(bit);
-    }
-    /* Pack into bytes */
-    for (j = 0; j < frame.bits; j+= 8) {
-        hex += String.fromCharCode(
-            b[j]<<7 |
-            b[j+1]<<6 |
-            b[j+2]<<5 |
-            b[j+3]<<4 |
-            b[j+4]<<3 |
-            b[j+5]<<2 |
-            b[j+6]<<1 |
-            b[j+7]);
-    }
-    frame.hex = hex;
-}
-
-window.onload = function() {
-    document.getElementById("next").onclick = function() {
-        if (currentFrame != frames.length-1) currentFrame++;
-        displayFrame(currentFrame);
-    }
-    document.getElementById("prev").onclick = function() {
-        if (currentFrame != 0) currentFrame--;
-        displayFrame(currentFrame);
-    }
-    document.getElementById("re").onclick = function() {
-        recomputeHex(frames[currentFrame]);
-        displayFrame(currentFrame);
-    }
-    displayFrame(currentFrame);
-}
-</script>
-<script src="frames.js"></script>
-<style>
-#frame {
-    width: 1024px;
-    height: 255px;
-    border: 1px #aaa solid;
-    position: relative;
-}
-.sample {
-    position: absolute;
-    bottom: 0px;
-}
-.pre {
-    width:4px;
-    background-color: orange;
-}
-.one {
-    width:4px;
-    background-color: #0000cc;
-}
-.zero {
-    width:4px;
-    background-color: #aaaaaa;
-}
-.err {
-    width:4px;
-    background-color: #cc6666;
-}
-.noise {
-    width:2px;
-    background-color: #ffffff;
-    border: 1px #aaa dotted;
-}
-</style>
-</head>
-<div id="frame">
-</div>
-<pre id="info">
-</pre>
-<input type="button" id="prev" value="Prev frame">
-<input type="button" id="next" value="Next frame">
-<input type="button" id="re" value="Recompute Hex">
-</body>
-</html>

dump978/Makefile

@@ -1,4 +1,4 @@
-CFLAGS+=-O2 -g -Wall -Werror -Ifec
+CFLAGS+=-O2 -Wall -Werror -Ifec
 LDFLAGS=
 LIBS=-lm
 CC=gcc

dump978/dump978.c

@@ -33,227 +33,259 @@ static void make_atan2_table(void);
 #ifndef BUILD_LIB
 static void read_from_stdin(void);
 #endif
-static int process_buffer(uint16_t *phi, int len, uint64_t offset);
+static int process_buffer(uint16_t *phi, uint16_t *raw, int len,
+                          uint64_t offset);
 static int demod_adsb_frame(uint16_t *phi, uint8_t *to, int *rs_errors);
 static int demod_uplink_frame(uint16_t *phi, uint8_t *to, int *rs_errors);
-static void demod_frame(uint16_t *phi, uint8_t *frame, int bytes, int16_t center_dphi);
+static void demod_frame(uint16_t *phi, uint8_t *frame, int bytes,
+                        int16_t center_dphi);
 static void handle_adsb_frame(uint64_t timestamp, uint8_t *frame, int rs);
 static void handle_uplink_frame(uint64_t timestamp, uint8_t *frame, int rs);
 
 #define SYNC_BITS (36)
-#define ADSB_SYNC_WORD   0xEACDDA4E2UL
+#define ADSB_SYNC_WORD 0xEACDDA4E2UL
 #define UPLINK_SYNC_WORD 0x153225B1DUL
 
 // relying on signed overflow is theoretically bad. Let's do it properly.
 
 #ifdef USE_SIGNED_OVERFLOW
-#define phi_difference(from,to) ((int16_t)((to) - (from)))
+#define phi_difference(from, to) ((int16_t)((to) - (from)))
 #else
-inline int16_t phi_difference(uint16_t from, uint16_t to)
-{
-    int32_t difference = to - from; // lies in the range -65535 .. +65535
-    if (difference >= 32768)        //   +32768..+65535
-        return difference - 65536;  //   -> -32768..-1: always in range
-    else if (difference < -32768)   //   -65535..-32769
-        return difference + 65536;  //   -> +1..32767: always in range
-    else
-        return difference;
+inline int16_t phi_difference(uint16_t from, uint16_t to) {
+  int32_t difference = to - from; // lies in the range -65535 .. +65535
+  if (difference >= 32768)        //   +32768..+65535
+    return difference - 65536;    //   -> -32768..-1: always in range
+  else if (difference < -32768)   //   -65535..-32769
+    return difference + 65536;    //   -> +1..32767: always in range
+  else
+    return difference;
 }
 #endif
 
 #ifndef BUILD_LIB
-int main(int argc, char **argv)
-{
-    make_atan2_table();
-    init_fec();
-    read_from_stdin();
-    return 0;
+int main(int argc, char **argv) {
+  make_atan2_table();
+  init_fec();
+  read_from_stdin();
+  return 0;
 }
 #else
 static CallBack userCB = NULL;
-void Dump978Init(CallBack cb)
-{
-    make_atan2_table();
-    init_fec();
-    userCB = cb;
+void Dump978Init(CallBack cb) {
+  make_atan2_table();
+  init_fec();
+  userCB = cb;
 }
 #endif
 
-static void dump_raw_message(char updown, uint8_t *data, int len, int rs_errors)
-{
+static int signal_strength = 0;
+
+static void dump_raw_message(char updown, uint8_t *data, int len,
+                             int rs_errors) {
 #ifndef BUILD_LIB
-    int i;
+  int i;
 
-    fprintf(stdout, "%c", updown);
-    for (i = 0; i < len; ++i) {
-        fprintf(stdout, "%02x", data[i]);
-    }
+  fprintf(stdout, "%c", updown);
+  for (i = 0; i < len; ++i) {
+    fprintf(stdout, "%02x", data[i]);
+  }
 
-    if (rs_errors)
-        fprintf(stdout, ";rs=%d", rs_errors);
-    fprintf(stdout, ";\n");
+  if (rs_errors)
+    fprintf(stdout, ";rs=%d", rs_errors);
+  fprintf(stdout, ";ss=%d", signal_strength);
+  fprintf(stdout, ";\n");
 #else
-    userCB(updown, data, len);
+  userCB(updown, data, len, rs_errors, signal_strength);
 #endif
 }
 
-static void handle_adsb_frame(uint64_t timestamp, uint8_t *frame, int rs)
-{
-    dump_raw_message('-', frame, (frame[0]>>3) == 0 ? SHORT_FRAME_DATA_BYTES : LONG_FRAME_DATA_BYTES, rs);
-    fflush(stdout);
+static void handle_adsb_frame(uint64_t timestamp, uint8_t *frame, int rs) {
+  dump_raw_message('-', frame, (frame[0] >> 3) == 0 ? SHORT_FRAME_DATA_BYTES
+                                                    : LONG_FRAME_DATA_BYTES,
+                   rs);
+  fflush(stdout);
 }
 
-static void handle_uplink_frame(uint64_t timestamp, uint8_t *frame, int rs)
-{
-    dump_raw_message('+', frame, UPLINK_FRAME_DATA_BYTES, rs);
-    fflush(stdout);
+static void handle_uplink_frame(uint64_t timestamp, uint8_t *frame, int rs) {
+  dump_raw_message('+', frame, UPLINK_FRAME_DATA_BYTES, rs);
+  fflush(stdout);
 }
 
 uint16_t iqphase[65536]; // contains value [0..65536) -> [0, 2*pi)
 
-void make_atan2_table(void)
-{
-    unsigned i,q;
-    union {
-        uint8_t iq[2];
-        uint16_t iq16;
-    } u;
+uint16_t iqamplitude[65536]; // contains value [0..65536) -> [0, 1000*sqrt(2))
 
-    for (i = 0; i < 256; ++i) {
-        for (q = 0; q < 256; ++q) {
-            double d_i = (i - 127.5);
-            double d_q = (q - 127.5);
-            double ang = atan2(d_q, d_i) + M_PI; // atan2 returns [-pi..pi], normalize to [0..2*pi]
-            double scaled_ang = round(32768 * ang / M_PI);
+void make_atan2_table(void) {
+  unsigned i, q;
+  union {
+    uint8_t iq[2];
+    uint16_t iq16;
+  } u;
 
-            u.iq[0] = i;
-            u.iq[1] = q;
-            iqphase[u.iq16] = (scaled_ang < 0 ? 0 : scaled_ang > 65535 ? 65535 : (uint16_t)scaled_ang);
-        }
+  for (i = 0; i < 256; ++i) {
+    for (q = 0; q < 256; ++q) {
+      double d_i = (i - 127.5);
+      double d_q = (q - 127.5);
+      double ang = atan2(d_q, d_i) +
+                   M_PI; // atan2 returns [-pi..pi], normalize to [0..2*pi]
+      double scaled_ang = round(32768 * ang / M_PI);
+
+      double amp = sqrt(d_i * d_i + d_q * d_q);
+      uint16_t scaled_amp = amp * 1000.0 / 127.5;
+
+      u.iq[0] = i;
+      u.iq[1] = q;
+      iqphase[u.iq16] =
+          (scaled_ang < 0 ? 0 : scaled_ang > 65535 ? 65535
+                                                   : (uint16_t)scaled_ang);
+      iqamplitude[u.iq16] = scaled_amp;
     }
+  }
 }
 
-static void convert_to_phi(uint16_t *buffer, int n)
-{
+static void convert_to_phi(uint16_t *dest, uint16_t *src, int n) {
     int i;
 
-    for (i = 0; i < n; ++i)
-        buffer[i] = iqphase[buffer[i]];
+    // unroll the loop. n is always > 2048, usually 36864
+    for (i = 0; i+8 <= n; i += 8) {
+        dest[i] = iqphase[src[i]];
+        dest[i+1] = iqphase[src[i+1]];
+        dest[i+2] = iqphase[src[i+2]];
+        dest[i+3] = iqphase[src[i+3]];
+        dest[i+4] = iqphase[src[i+4]];
+        dest[i+5] = iqphase[src[i+5]];
+        dest[i+6] = iqphase[src[i+6]];
+        dest[i+7] = iqphase[src[i+7]];
+    }
+    for (; i < n; ++i)
+        dest[i] = iqphase[src[i]];
+}
+
+static void calc_power(uint16_t *samples, int len) { // sets signal_strength to scaled amplitude. 0 = no signal, 1000 = saturated receiver on all samples in measurement.
+  long avg = 0;
+  int n = len;
+  while (n--) {
+    avg += iqamplitude[*samples++];
+  }
+  signal_strength = avg / len;
 }
 
 #ifndef BUILD_LIB
-void read_from_stdin(void)
-{
-    char buffer[65536*2];
-    int n;
-    int used = 0;
-    uint64_t offset = 0;
+void read_from_stdin(void) {
+  char buffer[65536 * 2];
+  uint16_t phi[65536];
 
-    while ( (n = read(0, buffer+used, sizeof(buffer)-used)) > 0 ) {
-        int processed;
+  int n;
+  int used = 0;
+  uint64_t offset = 0;
 
-        convert_to_phi((uint16_t*) (buffer+(used&~1)), ((used&1)+n)/2);
+  while ((n = read(0, buffer + used, sizeof(buffer) - used)) > 0) {
+    int processed;
 
-        used += n;
-        processed = process_buffer((uint16_t*) buffer, used/2, offset);
-        used -= processed * 2;
-        offset += processed;
-        if (used > 0) {
-            memmove(buffer, buffer+processed*2, used);
-        }
+    convert_to_phi(phi + used / 2, (uint16_t *)(buffer + (used & ~1)),
+                   ((used & 1) + n) / 2);
+
+    used += n;
+    processed = process_buffer(phi, (uint16_t *)buffer, used / 2, offset);
+    used -= processed * 2;
+    offset += processed;
+    if (used > 0) {
+      memmove(buffer, buffer + processed * 2, used);
+      memmove(phi, phi + processed, used);
     }
+  }
 }
 #else
 // #define DEFAULT_SAMPLE_RATE       2048000
 // #define DEFAULT_BUF_LENGTH      (262144) 16*16384
-static char buffer[65536*2]; // 131072, max received should be 113120
-int process_data(char *data, int dlen)
-{
-    int n;
-    int processed;
-    int doffset = 0;
-    static int used = 0;
-    static uint64_t offset = 0;
+static char buffer[65536 * 2]; // 131072, max received should be 113120
+static uint16_t phi[65536];
+int process_data(char *data, int dlen) {
+  int n;
+  int processed;
+  int doffset = 0;
+  static int used = 0;
+  static uint64_t offset = 0;
 
-    while (dlen > 0) {
-        n = (sizeof(buffer)-used) >= dlen ? dlen : (sizeof(buffer)-used);
-        memcpy(buffer+used, data+doffset, n);
+  while (dlen > 0) {
+    n = (sizeof(buffer) - used) >= dlen ? dlen : (sizeof(buffer) - used);
+    memcpy(buffer + used, data + doffset, n);
 
-        convert_to_phi((uint16_t*) (buffer+(used&~1)), ((used&1)+n)/2);
+    convert_to_phi(phi + used / 2, (uint16_t *)(buffer + (used & ~1)),
+                   ((used & 1) + n) / 2);
 
-        used += n;
-        processed = process_buffer((uint16_t*)buffer, used/2, offset);
-        used -= processed * 2;
-        offset += processed;
-        if (used > 0) {
-            memmove(buffer, buffer+processed*2, used);
-        }
-
-        doffset += n;
-        dlen -= n;
+    used += n;
+    processed = process_buffer(phi, (uint16_t *)buffer, used / 2, offset);
+    used -= processed * 2;
+    offset += processed;
+    if (used > 0) {
+      memmove(buffer, buffer + processed * 2, used);
+      memmove(phi, phi + processed, used);
     }
-    return dlen;
+
+    doffset += n;
+    dlen -= n;
+  }
+  return dlen;
 }
 #endif
 
-
 // Return 1 if word is "equal enough" to expected
-static inline int sync_word_fuzzy_compare(uint64_t word, uint64_t expected)
-{
-    uint64_t diff;
+static inline int sync_word_fuzzy_compare(uint64_t word, uint64_t expected) {
+  uint64_t diff;
 
-    if (word == expected)
-        return 1;
+  if (word == expected)
+    return 1;
 
-    diff = word ^ expected; // guaranteed nonzero
+  diff = word ^ expected; // guaranteed nonzero
 
-    // This is a bit-twiddling popcount
-    // hack, tweaked as we only care about
-    // "<N" or ">=N" set bits for fixed N -
-    // so we can bail out early after seeing N
-    // set bits.
-    //
-    // It relies on starting with a nonzero value
-    // with zero or more trailing clear bits
-    // after the last set bit:
-    //
-    //    010101010101010000
-    //                 ^
-    // Subtracting one, will flip the
-    // bits starting at the last set bit:
-    //
-    //    010101010101001111
-    //                 ^
-    // then we can use that as a bitwise-and
-    // mask to clear the lowest set bit:
-    //
-    //    010101010101000000
-    //                 ^
-    // And repeat until the value is zero
-    // or we have seen too many set bits.
+  // This is a bit-twiddling popcount
+  // hack, tweaked as we only care about
+  // "<N" or ">=N" set bits for fixed N -
+  // so we can bail out early after seeing N
+  // set bits.
+  //
+  // It relies on starting with a nonzero value
+  // with zero or more trailing clear bits
+  // after the last set bit:
+  //
+  //    010101010101010000
+  //                 ^
+  // Subtracting one, will flip the
+  // bits starting at the last set bit:
+  //
+  //    010101010101001111
+  //                 ^
+  // then we can use that as a bitwise-and
+  // mask to clear the lowest set bit:
+  //
+  //    010101010101000000
+  //                 ^
+  // And repeat until the value is zero
+  // or we have seen too many set bits.
 
-    // >= 1 bit
-    diff &= (diff-1);   // clear lowest set bit
-    if (!diff)
-        return 1; // 1 bit error
+  // >= 1 bit
+  diff &= (diff - 1); // clear lowest set bit
+  if (!diff)
+    return 1; // 1 bit error
 
-    // >= 2 bits
-    diff &= (diff-1);   // clear lowest set bit
-    if (!diff)
-        return 1; // 2 bits error
+  // >= 2 bits
+  diff &= (diff - 1); // clear lowest set bit
+  if (!diff)
+    return 1; // 2 bits error
 
-    // >= 3 bits
-    diff &= (diff-1);   // clear lowest set bit
-    if (!diff)
-        return 1; // 3 bits error
+  // >= 3 bits
+  diff &= (diff - 1); // clear lowest set bit
+  if (!diff)
+    return 1; // 3 bits error
 
-    // >= 4 bits
-    diff &= (diff-1);   // clear lowest set bit
-    if (!diff)
-        return 1; // 4 bits error
+  // >= 4 bits
+  diff &= (diff - 1); // clear lowest set bit
+  if (!diff)
+    return 1; // 4 bits error
 
-    // > 4 bits in error, give up
-    return 0;
+  // > 4 bits in error, give up
+  return 0;
 }
 
 #define MAX_SYNC_ERRORS 4
@@ -262,172 +294,185 @@ static inline int sync_word_fuzzy_compare(uint64_t word, uint64_t expected)
 // that matches the sync word 'pattern'. Place the dphi
 // threshold to use for bit slicing in '*center'. Return 1
 // if the sync word is OK, 0 on failure
-int check_sync_word(uint16_t *phi, uint64_t pattern, int16_t *center)
-{
-    int i;
-    int32_t dphi_zero_total = 0;
-    int zero_bits = 0;
-    int32_t dphi_one_total = 0;
-    int one_bits = 0;
-    int error_bits;
+int check_sync_word(uint16_t *phi, uint64_t pattern, int16_t *center) {
+  int i;
+  int32_t dphi_zero_total = 0;
+  int zero_bits = 0;
+  int32_t dphi_one_total = 0;
+  int one_bits = 0;
+  int error_bits;
 
-    // find mean dphi for zero and one bits;
-    // take the mean of the two as our central value
+  // find mean dphi for zero and one bits;
+  // take the mean of the two as our central value
 
-    for (i = 0; i < SYNC_BITS; ++i) {
-        int16_t dphi = phi_difference(phi[i*2], phi[i*2+1]);
+  for (i = 0; i < SYNC_BITS; ++i) {
+    int16_t dphi = phi_difference(phi[i * 2], phi[i * 2 + 1]);
 
-        if (pattern & (1UL << (35-i))) {
-            ++one_bits;
-            dphi_one_total += dphi;
-        } else {
-            ++zero_bits;
-            dphi_zero_total += dphi;
-        }
+    if (pattern & (1UL << (35 - i))) {
+      ++one_bits;
+      dphi_one_total += dphi;
+    } else {
+      ++zero_bits;
+      dphi_zero_total += dphi;
     }
+  }
 
-    dphi_zero_total /= zero_bits;
-    dphi_one_total /= one_bits;
+  dphi_zero_total /= zero_bits;
+  dphi_one_total /= one_bits;
 
-    *center = (dphi_one_total + dphi_zero_total) / 2;
+  *center = (dphi_one_total + dphi_zero_total) / 2;
 
-    // recheck sync word using our center value
-    error_bits = 0;
-    for (i = 0; i < SYNC_BITS; ++i) {
-        int16_t dphi = phi_difference(phi[i*2], phi[i*2+1]);
+  // recheck sync word using our center value
+  error_bits = 0;
+  for (i = 0; i < SYNC_BITS; ++i) {
+    int16_t dphi = phi_difference(phi[i * 2], phi[i * 2 + 1]);
 
-        if (pattern & (1UL << (35-i))) {
-            if (dphi < *center)
-                ++error_bits;
-        } else {
-            if (dphi >= *center)
-                ++error_bits;
-        }
+    if (pattern & (1UL << (35 - i))) {
+      if (dphi < *center)
+        ++error_bits;
+    } else {
+      if (dphi >= *center)
+        ++error_bits;
     }
+  }
 
-    //fprintf(stdout, "check_sync_word: center=%.0fkHz, errors=%d\n", *center * 2083334.0 / 65536 / 1000, error_bits);
+  // fprintf(stdout, "check_sync_word: center=%.0fkHz, errors=%d\n", *center *
+  // 2083334.0 / 65536 / 1000, error_bits);
 
-    return (error_bits <= MAX_SYNC_ERRORS);
+  return (error_bits <= MAX_SYNC_ERRORS);
 }
 
-#define SYNC_MASK ((((uint64_t)1)<<SYNC_BITS)-1)
+#define SYNC_MASK ((((uint64_t)1) << SYNC_BITS) - 1)
 
-int process_buffer(uint16_t *phi, int len, uint64_t offset)
-{
-    uint64_t sync0 = 0, sync1 = 0;
-    int lenbits;
-    int bit;
+int process_buffer(uint16_t *phi, uint16_t *raw, int len, uint64_t offset) {
+  uint64_t sync0 = 0, sync1 = 0;
+  int lenbits;
+  int bit;
 
-    uint8_t demod_buf_a[UPLINK_FRAME_BYTES];
-    uint8_t demod_buf_b[UPLINK_FRAME_BYTES];
+  uint8_t demod_buf_a[UPLINK_FRAME_BYTES];
+  uint8_t demod_buf_b[UPLINK_FRAME_BYTES];
 
-    // We expect samples at twice the UAT bitrate.
-    // We look at phase difference between pairs of adjacent samples, i.e.
-    //  sample 1 - sample 0   -> sync0
-    //  sample 2 - sample 1   -> sync1
-    //  sample 3 - sample 2   -> sync0
-    //  sample 4 - sample 3   -> sync1
-    // ...
-    //
-    // We accumulate bits into two buffers, sync0 and sync1.
-    // Then we compare those buffers to the expected 36-bit sync word that
-    // should be at the start of each UAT frame. When (if) we find it,
-    // that tells us which sample to start decoding from.
+  // We expect samples at twice the UAT bitrate.
+  // We look at phase difference between pairs of adjacent samples, i.e.
+  //  sample 1 - sample 0   -> sync0
+  //  sample 2 - sample 1   -> sync1
+  //  sample 3 - sample 2   -> sync0
+  //  sample 4 - sample 3   -> sync1
+  // ...
+  //
+  // We accumulate bits into two buffers, sync0 and sync1.
+  // Then we compare those buffers to the expected 36-bit sync word that
+  // should be at the start of each UAT frame. When (if) we find it,
+  // that tells us which sample to start decoding from.
 
-    // Stop when we run out of remaining samples for a max-sized frame.
-    // Arrange for our caller to pass the trailing data back to us next time;
-    // ensure we don't consume any partial sync word we might be part-way
-    // through. This means we don't need to maintain state between calls.
+  // Stop when we run out of remaining samples for a max-sized frame.
+  // Arrange for our caller to pass the trailing data back to us next time;
+  // ensure we don't consume any partial sync word we might be part-way
+  // through. This means we don't need to maintain state between calls.
 
-    lenbits = len/2 - (SYNC_BITS + UPLINK_FRAME_BITS);
-    for (bit = 0; bit < lenbits; ++bit) {
-        int16_t dphi0 = phi_difference(phi[bit*2], phi[bit*2+1]);
-        int16_t dphi1 = phi_difference(phi[bit*2+1], phi[bit*2+2]);
+  lenbits = len / 2 - (SYNC_BITS + UPLINK_FRAME_BITS);
+  for (bit = 0; bit < lenbits; ++bit) {
+    int16_t dphi0 = phi_difference(phi[bit * 2], phi[bit * 2 + 1]);
+    int16_t dphi1 = phi_difference(phi[bit * 2 + 1], phi[bit * 2 + 2]);
 
-        sync0 = ((sync0 << 1) | (dphi0 > 0 ? 1 : 0)) & SYNC_MASK;
-        sync1 = ((sync1 << 1) | (dphi1 > 0 ? 1 : 0)) & SYNC_MASK;
+    sync0 = ((sync0 << 1) | (dphi0 > 0 ? 1 : 0)) & SYNC_MASK;
+    sync1 = ((sync1 << 1) | (dphi1 > 0 ? 1 : 0)) & SYNC_MASK;
 
-        if (bit < SYNC_BITS)
-            continue; // haven't fully populated sync0/1 yet
+    if (bit < SYNC_BITS)
+      continue; // haven't fully populated sync0/1 yet
 
-        // see if we have (the start of) a valid sync word
-        // It would be nice to look at popcount(expected ^ sync)
-        // so we can tolerate some errors, but that turns out
-        // to be very expensive to do on every sample
+    // see if we have (the start of) a valid sync word
+    // It would be nice to look at popcount(expected ^ sync)
+    // so we can tolerate some errors, but that turns out
+    // to be very expensive to do on every sample
 
-        // when we find a match, try to demodulate both with that match
-        // and with the next position, and pick the one with fewer
-        // errors.
+    // when we find a match, try to demodulate both with that match
+    // and with the next position, and pick the one with fewer
+    // errors.
 
-        // check for downlink frames:
-        if (sync_word_fuzzy_compare(sync0, ADSB_SYNC_WORD) || sync_word_fuzzy_compare(sync1, ADSB_SYNC_WORD)) {
-            int startbit = (bit-SYNC_BITS+1);
-            int shift = (sync_word_fuzzy_compare(sync0, ADSB_SYNC_WORD) ? 0 : 1);
-            int index = startbit*2+shift;
+    // check for downlink frames:
+    if (sync_word_fuzzy_compare(sync0, ADSB_SYNC_WORD) ||
+        sync_word_fuzzy_compare(sync1, ADSB_SYNC_WORD)) {
+      int startbit = (bit - SYNC_BITS + 1);
+      int shift = (sync_word_fuzzy_compare(sync0, ADSB_SYNC_WORD) ? 0 : 1);
+      int index = startbit * 2 + shift;
 
-            int skip_0, skip_1;
-            int rs_0 = -1, rs_1 = -1;
+      int skip_0, skip_1;
+      int rs_0 = -1, rs_1 = -1;
 
-            skip_0 = demod_adsb_frame(phi+index, demod_buf_a, &rs_0);
-            skip_1 = demod_adsb_frame(phi+index+1, demod_buf_b, &rs_1);
-            if (skip_0 && rs_0 <= rs_1) {
-                handle_adsb_frame(offset+index, demod_buf_a, rs_0);
-                bit = startbit + skip_0;
-                continue;
-            } else if (skip_1 && rs_1 <= rs_0) {
-                handle_adsb_frame(offset+index+1, demod_buf_b, rs_1);
-                bit = startbit + skip_1;
-                continue;
-            } else {
-                // demod failed
-            }
-        }
-
-        // check for uplink frames:
-        else if (sync_word_fuzzy_compare(sync0, UPLINK_SYNC_WORD) || sync_word_fuzzy_compare(sync1, UPLINK_SYNC_WORD)) {
-            int startbit = (bit-SYNC_BITS+1);
-            int shift = (sync_word_fuzzy_compare(sync0, UPLINK_SYNC_WORD) ? 0 : 1);
-            int index = startbit*2+shift;
-
-            int skip_0, skip_1;
-            int rs_0 = -1, rs_1 = -1;
-
-            skip_0 = demod_uplink_frame(phi+index, demod_buf_a, &rs_0);
-            skip_1 = demod_uplink_frame(phi+index+1, demod_buf_b, &rs_1);
-            if (skip_0 && rs_0 <= rs_1) {
-                handle_uplink_frame(offset+index, demod_buf_a, rs_0);
-                bit = startbit + skip_0;
-                continue;
-            } else if (skip_1 && rs_1 <= rs_0) {
-                handle_uplink_frame(offset+index+1, demod_buf_b, rs_1);
-                bit = startbit + skip_1;
-                continue;
-            } else {
-                // demod failed
-            }
-        }
+      skip_0 = demod_adsb_frame(phi + index, demod_buf_a, &rs_0);
+      skip_1 = demod_adsb_frame(phi + index + 1, demod_buf_b, &rs_1);
+      if (skip_0 && rs_0 <= rs_1) {
+        calc_power(raw + index, skip_0 * 2);
+        handle_adsb_frame(offset + index, demod_buf_a, rs_0);
+        bit = startbit + skip_0;
+        continue;
+      } else if (skip_1 && rs_1 <= rs_0) {
+        calc_power(raw + index + 1, skip_1 * 2);
+        handle_adsb_frame(offset + index + 1, demod_buf_b, rs_1);
+        bit = startbit + skip_1;
+        continue;
+      } else {
+        // demod failed
+      }
     }
 
-    return (bit - SYNC_BITS)*2;
+    // check for uplink frames:
+    else if (sync_word_fuzzy_compare(sync0, UPLINK_SYNC_WORD) ||
+             sync_word_fuzzy_compare(sync1, UPLINK_SYNC_WORD)) {
+      int startbit = (bit - SYNC_BITS + 1);
+      int shift = (sync_word_fuzzy_compare(sync0, UPLINK_SYNC_WORD) ? 0 : 1);
+      int index = startbit * 2 + shift;
+
+      int skip_0, skip_1;
+      int rs_0 = -1, rs_1 = -1;
+
+      skip_0 = demod_uplink_frame(phi + index, demod_buf_a, &rs_0);
+      skip_1 = demod_uplink_frame(phi + index + 1, demod_buf_b, &rs_1);
+      if (skip_0 && rs_0 <= rs_1) {
+        calc_power(raw + index, skip_0 * 2);
+        handle_uplink_frame(offset + index, demod_buf_a, rs_0);
+        bit = startbit + skip_0;
+        continue;
+      } else if (skip_1 && rs_1 <= rs_0) {
+        calc_power(raw + index, skip_1 * 2);
+        handle_uplink_frame(offset + index + 1, demod_buf_b, rs_1);
+        bit = startbit + skip_1;
+        continue;
+      } else {
+        // demod failed
+      }
+    }
+  }
+
+  return (bit - SYNC_BITS) * 2;
 }
 
 // demodulate 'bytes' bytes from samples at 'phi' into 'frame',
 // using 'center_dphi' as the bit slicing threshold
-static void demod_frame(uint16_t *phi, uint8_t *frame, int bytes, int16_t center_dphi)
-{
-    while (--bytes >= 0) {
-        uint8_t b = 0;
-        if (phi_difference(phi[0], phi[1]) > center_dphi) b |= 0x80;
-        if (phi_difference(phi[2], phi[3]) > center_dphi) b |= 0x40;
-        if (phi_difference(phi[4], phi[5]) > center_dphi) b |= 0x20;
-        if (phi_difference(phi[6], phi[7]) > center_dphi) b |= 0x10;
-        if (phi_difference(phi[8], phi[9]) > center_dphi) b |= 0x08;
-        if (phi_difference(phi[10], phi[11]) > center_dphi) b |= 0x04;
-        if (phi_difference(phi[12], phi[13]) > center_dphi) b |= 0x02;
-        if (phi_difference(phi[14], phi[15]) > center_dphi) b |= 0x01;
-        *frame++ = b;
-        phi += 16;
-    }
+static void demod_frame(uint16_t *phi, uint8_t *frame, int bytes,
+                        int16_t center_dphi) {
+  while (--bytes >= 0) {
+    uint8_t b = 0;
+    if (phi_difference(phi[0], phi[1]) > center_dphi)
+      b |= 0x80;
+    if (phi_difference(phi[2], phi[3]) > center_dphi)
+      b |= 0x40;
+    if (phi_difference(phi[4], phi[5]) > center_dphi)
+      b |= 0x20;
+    if (phi_difference(phi[6], phi[7]) > center_dphi)
+      b |= 0x10;
+    if (phi_difference(phi[8], phi[9]) > center_dphi)
+      b |= 0x08;
+    if (phi_difference(phi[10], phi[11]) > center_dphi)
+      b |= 0x04;
+    if (phi_difference(phi[12], phi[13]) > center_dphi)
+      b |= 0x02;
+    if (phi_difference(phi[14], phi[15]) > center_dphi)
+      b |= 0x01;
+    *frame++ = b;
+    phi += 16;
+  }
 }
 
 // Demodulate an ADSB (Long UAT or Basic UAT) downlink frame
@@ -436,24 +481,23 @@ static void demod_frame(uint16_t *phi, uint8_t *frame, int bytes, int16_t center
 // number of corrected errors, or 9999 if demodulation failed.
 // Return 0 if demodulation failed, or the number of bits (not
 // samples) consumed if demodulation was OK.
-static int demod_adsb_frame(uint16_t *phi, uint8_t *to, int *rs_errors)
-{
-    int16_t center_dphi;
-    int frametype;
+static int demod_adsb_frame(uint16_t *phi, uint8_t *to, int *rs_errors) {
+  int16_t center_dphi;
+  int frametype;
 
-    if (!check_sync_word(phi, ADSB_SYNC_WORD, &center_dphi)) {
-        *rs_errors = 9999;
-        return 0;
-    }
+  if (!check_sync_word(phi, ADSB_SYNC_WORD, &center_dphi)) {
+    *rs_errors = 9999;
+    return 0;
+  }
 
-    demod_frame(phi + SYNC_BITS*2, to, LONG_FRAME_BYTES, center_dphi);
-    frametype = correct_adsb_frame(to, rs_errors);
-    if (frametype == 1)
-        return (SYNC_BITS + SHORT_FRAME_BITS);
-    else if (frametype == 2)
-        return (SYNC_BITS + LONG_FRAME_BITS);
-    else
-        return 0;
+  demod_frame(phi + SYNC_BITS * 2, to, LONG_FRAME_BYTES, center_dphi);
+  frametype = correct_adsb_frame(to, rs_errors);
+  if (frametype == 1)
+    return (SYNC_BITS + SHORT_FRAME_BITS);
+  else if (frametype == 2)
+    return (SYNC_BITS + LONG_FRAME_BITS);
+  else
+    return 0;
 }
 
 // Demodulate an uplink frame
@@ -462,21 +506,21 @@ static int demod_adsb_frame(uint16_t *phi, uint8_t *to, int *rs_errors)
 // number of corrected errors, or 9999 if demodulation failed.
 // Return 0 if demodulation failed, or the number of bits (not
 // samples) consumed if demodulation was OK.
-static int demod_uplink_frame(uint16_t *phi, uint8_t *to, int *rs_errors)
-{
-    int16_t center_dphi;
-    uint8_t interleaved[UPLINK_FRAME_BYTES];
+static int demod_uplink_frame(uint16_t *phi, uint8_t *to, int *rs_errors) {
+  int16_t center_dphi;
+  uint8_t interleaved[UPLINK_FRAME_BYTES];
 
-    if (!check_sync_word(phi, UPLINK_SYNC_WORD, &center_dphi)) {
-        *rs_errors = 9999;
-        return 0;
-    }
+  if (!check_sync_word(phi, UPLINK_SYNC_WORD, &center_dphi)) {
+    *rs_errors = 9999;
+    return 0;
+  }
 
-    demod_frame(phi + SYNC_BITS*2, interleaved, UPLINK_FRAME_BYTES, center_dphi);
+  demod_frame(phi + SYNC_BITS * 2, interleaved, UPLINK_FRAME_BYTES,
+              center_dphi);
 
-    // deinterleave and correct
-    if (correct_uplink_frame(interleaved, to, rs_errors) == 1)
-        return (UPLINK_FRAME_BITS+SYNC_BITS);
-    else
-        return 0;
-}
+  // deinterleave and correct
+  if (correct_uplink_frame(interleaved, to, rs_errors) == 1)
+    return (UPLINK_FRAME_BITS + SYNC_BITS);
+  else
+    return 0;
+}

dump978/dump978.h

@@ -4,7 +4,7 @@
 // $ gcc -c -O2 -g -Wall -Werror -Ifec -fpic -DBUILD_LIB=1 dump978.c fec.c fec/decode_rs_char.c fec/init_rs_char.c
 // $ gcc -shared -lm -o ../libdump978.so dump978.o fec.o decode_rs_char.o init_rs_char.o
 
-typedef void (*CallBack)(char updown, uint8_t *data, int len);
+typedef void (*CallBack)(char updown, uint8_t *data, int len, int rs_errors, int signal_strength);
 
 extern void Dump978Init(CallBack cb);
 extern int process_data(char *data, int dlen);

dump978/uat_decode.c

@@ -267,7 +267,8 @@ static void uat_display_sv(const struct uat_adsb_mdb *mdb, FILE *to)
             mdb->tisb_site_id);
 }
 
-static char base40_alphabet[40] = "0123456789ABCDEFGHIJKLMNOPQRTSUVWXYZ  ..";
+static char base40_alphabet[40] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ  ..";
+
 static void uat_decode_ms(uint8_t *frame, struct uat_adsb_mdb *mdb)
 {
     uint16_t v;

godump978/godump978.go

@@ -19,16 +19,16 @@
 package godump978
 
 /*
-#cgo linux LDFLAGS: -L. -ldump978
-#cgo darwin LDFLAGS: -L. -ldump978
+#cgo linux LDFLAGS: -ldump978 -lm
+#cgo darwin LDFLAGS: -ldump978 -lm
 #cgo windows CFLAGS: -IC:/WINDOWS/system32
-#cgo windows LDFLAGS: -L. -lrtlsdr -LC:/WINDOWS/system32
+#cgo windows LDFLAGS: -L. -ldump978 -LC:/WINDOWS/system32
 
 #include <stdlib.h>
 #include <stdint.h>
 #include "../dump978/dump978.h"
 
-extern void dump978Cb(char updown, uint8_t *data, int len);
+extern void dump978Cb(char updown, uint8_t *data, int len, int rs_errors, int signal_strength);
 static inline CallBack GetGoCb() {
 	return (CallBack)dump978Cb;
 }
@@ -42,10 +42,9 @@ var PackageVersion = "v0.1"
 // InChan is a buffered input channel for raw data.
 var InChan = make(chan []byte, 100)
 
-type UserCbT func(C.char, *C.uint8_t, C.int)
+type UserCbT func(C.char, *C.uint8_t, C.int, C.int, C.int)
 
-// Dump978Init must be the first function called in this package.
-func Dump978Init() {
+func init() {
 	C.Dump978Init((C.CallBack)(C.GetGoCb()))
 }
 

godump978/godump978_exports.go

@@ -10,9 +10,12 @@ import (
 	"fmt"
 	"reflect"
 	"unsafe"
+	"strconv"
 )
-
+ 
 /*
+#cgo CFLAGS: -L../
+
 #include <stdint.h>
 #include "../dump978/dump978.h"
 */
@@ -22,7 +25,7 @@ import "C"
 var OutChan = make(chan string, 100)
 
 //export dump978Cb
-func dump978Cb(updown C.char, data *C.uint8_t, length C.int) {
+func dump978Cb(updown C.char, data *C.uint8_t, length C.int, rs_errors C.int, signal_strength C.int) {
 	// c buffer to go slice without copying
 	var buf []byte
 
@@ -37,5 +40,7 @@ func dump978Cb(updown C.char, data *C.uint8_t, length C.int) {
 		outData += fmt.Sprintf("%02x", buf[i])
 	}
 
+	outData += ";rs=" + strconv.Itoa(int(rs_errors)) + ";ss=" + strconv.Itoa(int(signal_strength)) + ";"
+
 	OutChan <- outData
 }

goflying

@@ -0,0 +1 @@
+Subproject commit 1da95360a858bfdc5af2b4e7d5caa66542f164e1

image/10-stratux.rules

@@ -0,0 +1,48 @@
+# To be placed in /etc/udev/rules.d.
+#  Auto-detect common USB stratux peripherals.
+
+# u-blox devices. Known devices include
+#   ublox9: experimental boards
+#   ublox8: RY835AI, RY836AI, GPYes 2.0
+#   ublox7: VK-172, RY725AI, GPYes
+#   ublox6: VK-162
+
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a9", SYMLINK+="ublox9"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a8", SYMLINK+="ublox8"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a7", SYMLINK+="ublox7"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a6", SYMLINK+="ublox6"
+#SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a7", SYMLINK+="vk172"
+#SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a6", SYMLINK+="vk162"
+
+# Stratux uatradio.
+#  0403:7028 (Stratux UATRadio)
+ATTRS{idProduct}=="7028", ATTRS{idVendor}=="0403", RUN+="/sbin/modprobe -q ftdi_sio" RUN+="/bin/sh -c 'echo 0403 7028 > /sys/bus/usb-serial/drivers/ftdi_sio/new_id'", OWNER="root", MODE="0666", SYMLINK+="uatradio"
+
+
+
+# pl2303 devices are indistinguishable using idVendor and idProduct.
+#  Currently the BU-353-S4 and the TU-S9 (serialout) use the pl2303.
+
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", SYMLINK+="prolific%n"
+
+#SUBSYSTEMS=="usb", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", SYMLINK+="bu353s4"
+#SUBSYSTEMS=="usb", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", SYMLINK+="tu-s9"
+
+# CP2102-based serial adapters. Assume that all devices plugged in with this idVendor and idProduct are for serialout.
+#cp210x-program --write-cp210x -m 10C4:EA60 \
+#                 --set-product-string="Stratux Serialout" \
+#                 --set-max-power=100 \
+#                 --set-bus-powered=no
+
+SUBSYSTEMS=="usb", ATTRS{interface}=="Stratux Serialout", SYMLINK+="serialout%n"
+
+
+# SoftRF.
+
+# SoftRF Standalone (NodeMCU or DoIt ESP32 devkit with CP2102 chip)
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="ea60", ATTRS{product}=="DIY SoftRF", SYMLINK+="softrf"
+# TTGO T-Beam (ESP32 with OTP CP2104 chip)
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="ea60", ATTRS{product}=="CP2104 USB to UART Bridge Controller", SYMLINK+="softrf"
+# Dongle Edition (LilyGO & SoftRF T-Motion. USB CDC ACM output)
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="5740", SYMLINK+="softrf"
+# end of SoftRF section

image/99-uavionix.rules

@@ -0,0 +1,6 @@
+# uAvionix Ping Mavlink
+ATTRS{idProduct}=="74f0", ATTRS{idVendor}=="0403", RUN+="/sbin/modprobe -q ftdi_sio" RUN+="/bin/sh -c 'echo 0403 74f0 > /sys/bus/usb-serial/drivers/ftdi_sio/new_id'", OWNER="root", MODE="0666", SYMLINK+="ping"
+
+# uAvionix Ping Raw
+ATTRS{idProduct}=="74f1", ATTRS{idVendor}=="0403", RUN+="/sbin/modprobe -q ftdi_sio" RUN+="/bin/sh -c 'echo 0403 74f1 > /sys/bus/usb-serial/drivers/ftdi_sio/new_id'", OWNER="root", MODE="0666", SYMLINK+="ping"
+

image/bashrc.txt

@@ -0,0 +1,31 @@
+# ~/.bashrc: executed by bash(1) for non-login shells.
+
+# Note: PS1 and umask are already set in /etc/profile. You should not
+# need this unless you want different defaults for root.
+# PS1='${debian_chroot:+($debian_chroot)}\h:\w\$ '
+# umask 022
+
+# You may uncomment the following lines if you want `ls' to be colorized:
+# export LS_OPTIONS='--color=auto'
+# eval "`dircolors`"
+# alias ls='ls $LS_OPTIONS'
+# alias ll='ls $LS_OPTIONS -l'
+# alias l='ls $LS_OPTIONS -lA'
+#
+# Some more alias to avoid making mistakes:
+# alias rm='rm -i'
+# alias cp='cp -i'
+# alias mv='mv -i'
+export PATH=/root/go/bin:${PATH}
+export GOROOT=/root/go
+export GOPATH=/root/go_path
+
+# This will allow users to keep an alias file after this file is added
+if [ -f /root/.aliases ]; then
+. /root/.aliases
+fi
+
+# Useful aliases for stratux debugging
+if [ -f /root/.stxAliases ]; then
+. /root/.stxAliases
+fi

image/config.txt

@@ -0,0 +1,20 @@
+# RPi /boot/config.txt
+
+dtparam=audio=on
+max_usb_current=1
+dtparam=i2c_arm=on
+dtparam=i2c1=on
+dtparam=i2c1_baudrate=400000
+dtparam=i2c_arm_baudrate=400000
+
+# move RPi3 Bluetooth off of hardware UART to free up connection for GPS
+dtoverlay=pi3-miniuart-bt
+
+# disable default (mmc0) behavior on the ACT LED.
+dtparam=act_led_trigger=none
+dtparam=act_led_activelow=off
+
+# The below has been added as a proposed EMI reduction measure. Issue #573.
+sdram_freq=450
+core_freq=450
+arm_freq=900

image/dhcpd-not_smart.conf

@@ -0,0 +1,14 @@
+ddns-update-style none;
+default-lease-time 86400;	# 24 hours
+max-lease-time 172800;		# 48 hours
+authoritative;
+log-facility local7;
+subnet 192.168.10.0 netmask 255.255.255.0 {
+	range 192.168.10.10 192.168.10.50;
+	option broadcast-address 192.168.10.255;
+	option routers 192.168.10.1;
+	default-lease-time 12000;
+	max-lease-time 12000;
+	option domain-name "stratux.local";
+	option domain-name-servers 4.2.2.2;
+}

image/dhcpd-smart.conf

@@ -0,0 +1,13 @@
+ddns-update-style none;
+default-lease-time 86400;	# 24 hours
+max-lease-time 172800;		# 48 hours
+authoritative;
+log-facility local7;
+subnet 192.168.10.0 netmask 255.255.255.0 {
+	range 192.168.10.10 192.168.10.50;
+	option broadcast-address 192.168.10.255;
+	default-lease-time 12000;
+	max-lease-time 12000;
+	option domain-name "stratux.local";
+	option domain-name-servers 4.2.2.2;
+}

image/dhcpd.conf

@@ -1,118 +0,0 @@
-#
-# Sample configuration file for ISC dhcpd for Debian
-#
-#
-
-# The ddns-updates-style parameter controls whether or not the server will
-# attempt to do a DNS update when a lease is confirmed. We default to the
-# behavior of the version 2 packages ('none', since DHCP v2 didn't
-# have support for DDNS.)
-ddns-update-style none;
-
-
-# option definitions common to all supported networks...
-#option domain-name "stratux.local";
-#option domain-name-servers ns1.example.org, ns2.example.org;
-
-default-lease-time 86400;	# 24 hours
-max-lease-time 172800;		# 48 hours
-
-# If this DHCP server is the official DHCP server for the local
-# network, the authoritative directive should be uncommented.
-authoritative;
-
-# Use this to send dhcp log messages to a different log file (you also
-# have to hack syslog.conf to complete the redirection).
-log-facility local7;
-
-# No service will be given on this subnet, but declaring it helps the 
-# DHCP server to understand the network topology.
-
-#subnet 10.152.187.0 netmask 255.255.255.0 {
-#}
-
-# This is a very basic subnet declaration.
-
-#subnet 10.254.239.0 netmask 255.255.255.224 {
-#  range 10.254.239.10 10.254.239.20;
-#  option routers rtr-239-0-1.example.org, rtr-239-0-2.example.org;
-#}
-
-# This declaration allows BOOTP clients to get dynamic addresses,
-# which we don't really recommend.
-
-#subnet 10.254.239.32 netmask 255.255.255.224 {
-#  range dynamic-bootp 10.254.239.40 10.254.239.60;
-#  option broadcast-address 10.254.239.31;
-#  option routers rtr-239-32-1.example.org;
-#}
-
-# A slightly different configuration for an internal subnet.
-#subnet 10.5.5.0 netmask 255.255.255.224 {
-#  range 10.5.5.26 10.5.5.30;
-#  option domain-name-servers ns1.internal.example.org;
-#  option domain-name "internal.example.org";
-#  option routers 10.5.5.1;
-#  option broadcast-address 10.5.5.31;
-#  default-lease-time 600;
-#  max-lease-time 7200;
-#}
-
-# Hosts which require special configuration options can be listed in
-# host statements.   If no address is specified, the address will be
-# allocated dynamically (if possible), but the host-specific information
-# will still come from the host declaration.
-
-#host passacaglia {
-#  hardware ethernet 0:0:c0:5d:bd:95;
-#  filename "vmunix.passacaglia";
-#  server-name "toccata.fugue.com";
-#}
-
-# Fixed IP addresses can also be specified for hosts.   These addresses
-# should not also be listed as being available for dynamic assignment.
-# Hosts for which fixed IP addresses have been specified can boot using
-# BOOTP or DHCP.   Hosts for which no fixed address is specified can only
-# be booted with DHCP, unless there is an address range on the subnet
-# to which a BOOTP client is connected which has the dynamic-bootp flag
-# set.
-#host fantasia {
-#  hardware ethernet 08:00:07:26:c0:a5;
-#  fixed-address fantasia.fugue.com;
-#}
-
-# You can declare a class of clients and then do address allocation
-# based on that.   The example below shows a case where all clients
-# in a certain class get addresses on the 10.17.224/24 subnet, and all
-# other clients get addresses on the 10.0.29/24 subnet.
-
-#class "foo" {
-#  match if substring (option vendor-class-identifier, 0, 4) = "SUNW";
-#}
-
-#shared-network 224-29 {
-#  subnet 10.17.224.0 netmask 255.255.255.0 {
-#    option routers rtr-224.example.org;
-#  }
-#  subnet 10.0.29.0 netmask 255.255.255.0 {
-#    option routers rtr-29.example.org;
-#  }
-#  pool {
-#    allow members of "foo";
-#    range 10.17.224.10 10.17.224.250;
-#  }
-#  pool {
-#    deny members of "foo";
-#    range 10.0.29.10 10.0.29.230;
-#  }
-#}
-
-subnet 192.168.10.0 netmask 255.255.255.0 {
-	range 192.168.10.10 192.168.10.50;
-	option broadcast-address 192.168.10.255;
-	option routers 0.0.0.0;
-	default-lease-time 12000;
-	max-lease-time 12000;
-	option domain-name "stratux.local";
-	option domain-name-servers 4.2.2.2;
-}

image/hostapd-edimax.conf

@@ -0,0 +1,6 @@
+interface=wlan0
+driver=rtl871xdrv
+hw_mode=g
+wme_enabled=1
+ieee80211n=1
+ignore_broadcast_ssid=0

image/hostapd.conf

@@ -1,8 +1,5 @@
 interface=wlan0
-driver=rtl871xdrv
-ssid=stratux
 hw_mode=g
-channel=1
-wme_enabled=1
+wmm_enabled=1
 ieee80211n=1
 ignore_broadcast_ssid=0

image/hostapd_manager.sh

@@ -0,0 +1,319 @@
+#!/bin/bash
+######################################################################
+#                      STRATUX HOSTAPD MANAGER                      #
+######################################################################
+
+#Logging Function
+SCRIPT=`basename ${BASH_SOURCE[0]}`
+STX_LOG="/var/log/stratux.log"
+function wLog () {
+	echo "$(date +"%Y/%m/%d %H:%m:%S")  - $SCRIPT - $1" >> $STX_LOG
+}
+wLog "Running Hostapd Manager Script."
+
+# files to edit
+HOSTAPD=('/etc/hostapd/hostapd.user')
+
+# values to be added to hostapd.user for security.
+HOSTAPD_SECURE_VALUES_DELETE=('auth_algs=1' 'wpa=3' 'wpa_passphrase=' 'wpa_key_mgmt=WPA-PSK' 'wpa_pairwise=TKIP' 'rsn_pairwise=CCMP')
+
+# 'wpa_passphrase=' was left out of this to set it with the $wifiPass. I assume you can not evaluate a variable from within an array variable
+HOSTAPD_SECURE_VALUES_WRITE=('auth_algs=1' 'wpa=3' 'wpa_key_mgmt=WPA-PSK' 'wpa_pairwise=TKIP' 'rsn_pairwise=CCMP')
+
+#Initialize variables to default values.
+OPT_S=false
+OPT_C=false
+OPT_E=false
+OPT_O=false
+OPT_P=false
+wifiPass="SquawkDirtyToMe!"
+
+parm="*"
+err="####"
+att="+++"
+
+#Set fonts for Help.
+BOLD=$(tput bold)
+STOT=$(tput smso)
+UNDR=$(tput smul)
+REV=$(tput rev)
+RED=$(tput setaf 1)
+GREEN=$(tput setaf 2)
+YELLOW=$(tput setaf 3)
+MAGENTA=$(tput setaf 5)
+WHITE=$(tput setaf 7)
+NORM=$(tput sgr0)
+NORMAL=$(tput sgr0)
+
+#Help function
+function HELP {
+  echo -e \\n"Help documentation for ${BOLD}${SCRIPT}.${NORM}"\\n
+  echo -e "${REV}Basic usage:${NORM} ${BOLD}$SCRIPT -s ssid -c chan -p pass ${NORM}"\\n
+  echo "The following command line switches are recognized."
+  echo "${REV}-s${NORM}  --Sets the SSID to ${BOLD}ssid${NORM}. \"-s stratux\""
+  echo "${REV}-c${NORM}  --Sets the channel to ${BOLD}chan${NORM}. \"-c 1\""
+  echo "${REV}-o${NORM}  --Turns off encryption and sets network to open. Cannot be used with -e or -p."
+  echo "${REV}-e${NORM}  --Turns on encryption with passphrase ${BOLD}$wifiPass${NORM}. Cannot be used with -o or -p"
+  echo "${REV}-p${NORM}  --Turns on encryption with your chosen passphrase ${BOLD}pass${NORM}. 8-63 Printable Characters(ascii 32-126). Cannot be used with -o or -e. \"-p password!\""
+  echo -e "${REV}-h${NORM}  --Displays this help message. No further functions are performed."\\n
+  echo -e "Example: ${BOLD}$SCRIPT -s Stratux-N3558D -c 5 -p SquawkDirty!${NORM}"\\n
+  exit 1
+}
+
+function confirm() {
+	# call with a prompt string or use a default
+	read -r -p "$1 " response
+	case "$response" in
+		[yY][eE][sS]|[yY]) 
+		true
+	;;
+		*)
+		exit 1
+	;;
+	esac
+}
+
+function cleanhostapd () {
+	wLog "Cleaning hostapd config at $1"
+	for j in "${HOSTAPD_SECURE_VALUES_DELETE[@]}"
+	do
+		sed -i "/$j/ d" ${1}
+	done
+	sed -i '/^\s*$/d' ${1}
+}
+
+function writehostapd () {
+	wLog "Writing hostapd config at $1"
+	sed -i '/^\s*$/d' ${1}
+	echo "" >> ${1}
+	for j in "${HOSTAPD_SECURE_VALUES_WRITE[@]}"
+	do
+		echo "${j}" >> ${1}
+	done
+	echo "wpa_passphrase=$wifiPass" >> ${1}
+}
+
+#apply settings and restart all processes
+function APPLYSETTINGS {
+	wLog "Restarting all wifi settings."
+	echo "${RED}${BOLD} $att At this time the script will restart your WiFi services.${WHITE}${NORMAL}"
+	echo "If you are connected to Stratux through the ${BOLD}192.168.10.1${NORMAL} interface then you will be disconnected"
+	echo "Please wait up to 1 min and look for the new SSID on your wireless device."
+	sleep 3
+	echo "${YELLOW}$att Restarting Stratux WiFi Services... $att ${WHITE}"
+	echo "${YELLOW}$att SSH will now disconnect if connected to http://192.168.10.1 ... $att ${WHITE}"
+	echo "ifdown wlan0..."
+	ifdown wlan0
+	sleep 0.5
+	echo "ifup wlan0..."
+	echo "Calling Stratux WiFI Start Script(stratux-wifi.sh) via ifup wlan0..."
+	ifup wlan0
+	sleep 0.5
+	echo ""
+	echo ""
+	echo "All systems should be up and running and you should see your new SSID!"
+}
+
+clear
+
+echo ""
+echo "#### Stratux HOSTAPD Settings ####"
+echo ""
+
+if [ $(whoami) != 'root' ]; then
+	echo "${BOLD}${RED}This script must be executed as root, exiting...${WHITE}${NORMAL}"
+	echo "${BOLD}${RED}USAGE${WHITE}${NORMAL}"
+	exit 1
+fi
+
+#Check the number of arguments. If none are passed, print help and exit.
+NUMARGS=$#
+if [ $NUMARGS -eq 0 ]; then
+  HELP
+fi
+
+### Start getopts code ###
+
+#Parse command line flags
+#If an option should be followed by an argument, it should be followed by a ":".
+#Notice there is no ":" after "eoqh". The leading ":" suppresses error messages from
+#getopts. This is required to get my unrecognized option code to work.
+options=':s:c:p:eoh'
+#options=':s:c:h'
+while getopts $options option; do
+  case $option in
+    s)  #set option "s"
+      if [[ -z "${OPTARG}" || "${OPTARG}" == *[[:space:]]* || "${OPTARG}" == -* ]]; then
+          echo "${BOLD}${RED}$err No SSID for -s, exiting...${WHITE}${NORMAL}"
+		  wLog "No SSID for -s, exiting..."
+          exit 1
+      else
+          OPT_S=$OPTARG
+          echo "$parm SSID Option -s used: $OPT_S"
+          echo "${GREEN}    SSID will now be ${BOLD}${UNDR}$OPT_S${NORMAL}.${WHITE}"
+      fi
+      ;;
+    c)  #set option "c"
+      if [[ -z "${OPTARG}" || "${OPTARG}" == *[[:space:]]* || "${OPTARG}" == -* ]]; then
+          echo "${BOLD}${RED}$err Channel option(-c) used without value, exiting... ${WHITE}${NORMAL}"
+		  wLog "Channel option(-c) used without value, exiting..."
+          exit 1
+      else
+          OPT_C=$OPTARG
+          echo "$parm Channel option -c used: $OPT_C"
+          if [[ "$OPT_C" =~ ^[0-9]+$ ]] && [ "$OPT_C" -ge 1 -a "$OPT_C" -le 13  ]; then
+          	echo "${GREEN}    Channel will now be set to ${BOLD}${UNDR}$OPT_C${WHITE}${NORMAL}."
+          else
+            echo "${BOLD}${RED}$err Channel is not within acceptable values, exiting...${WHITE}${NORMAL}"
+			wLog "Channel is not within acceptable values, exiting..."
+            exit 1
+          fi
+      fi
+      ;;
+    e)  #set option "e" with default passphrase
+		if [[ -z "${OPTARG}" || "${OPTARG}" == *[[:space:]]* || "${OPTARG}" == -* ]]; then
+          echo "$parm Encrypted WiFI Option -e used."
+          OPT_E=$wifiPass
+		  echo "${GREEN}     WiFi will be encrypted using ${BOLD}${UNDR}$OPT_E${NORMAL}${GREEN} as the passphrase!${WHITE}${NORMAL}"
+      else
+          echo "${BOLD}${RED}$err Option -e does not require argument. exiting...${WHITE}${NORMAL}"
+		  wLog "Option -e does not require argument."
+          exit 1
+      fi
+      ;;
+	p) #set encryption with user specified passphrase
+		if [[ -z "${OPTARG}" || "${OPTARG}" =~ ^[[:space:]]*$ || "${OPTARG}" == -* ]]; then
+			echo "${BOLD}${RED}$err Encryption option(-p) used without passphrase!${WHITE}${NORMAL}"
+			echo "${BOLD}${RED}$err Encryption option(-p) required an argument \"-p passphrase\". exiting...${WHITE}${NORMAL}"
+			wLog "Encryption option(-p) used without passphrase!"
+		else
+			OPT_P=$OPTARG
+			wifiPass=$OPTARG
+		fi
+		echo "$parm Encryption option -p used:"
+		if [ -z `echo $OPT_P | tr -d "[:print:]"` ] && [ ${#OPT_P} -ge 8 ]  && [ ${#OPT_P} -le 63 ]; then
+			echo "${GREEN}     WiFi will be encrypted using ${BOLD}${UNDR}$OPT_P${NORMAL}${GREEN} as the passphrase!${WHITE}${NORMAL}"
+		else
+			echo  "${BOLD}${RED}$err Invalid PASSWORD: 8 - 63 printable characters, exiting...${WHITE}${NORMAL}"
+			wLog "Invalid PASSWORD: 8 - 63 printable characters, exiting..."
+			exit 1
+		fi
+    ;;
+    o)  #set option "o"
+      if [[ -z "${OPTARG}" || "${OPTARG}" == *[[:space:]]* || "${OPTARG}" == -* ]]; then
+          echo "$parm Open WiFI Option -o used."
+          echo "${GREEN}    WiFi will be set to ${BOLD}${UNDR}OPEN${NORMAL}${GREEN} or ${BOLD}${UNDR}UNSECURE${WHITE}${NORMAL}"
+          OPT_O=true
+      else
+          echo "${BOLD}${RED}$err Option -o does not require argument. exiting...${WHITE}${NORMAL}"
+		  wLog "Option -o does not require argument. exiting..."
+          exit 1
+      fi
+      ;;
+    h)  #show help
+      HELP
+      ;;
+   \?) # invalid option
+     echo "${BOLD}${RED}$err Invalid option -$OPTARG ${WHITE}${NORMAL}" >&2
+     HELP
+     exit 1
+     ;;
+   :) # Missing Arg 
+     echo "${BOLD}${RED}$err Missing option for argument -$OPTARG ${WHITE}${NORMAL}" >&2
+     HELP
+     exit 1
+     ;;
+   *) # Invalid
+     echo "${BOLD}${RED}$err Unimplemented option -$OPTARG ${WHITE}${NORMAL}" >&2
+     HELP
+     exit 1
+     ;;
+  esac
+done
+
+shift $((OPTIND-1))  #This tells getopts to move on to the next argument.
+
+### End getopts code ###
+
+
+### Main loop to process files ###
+
+#This is where your main file processing will take place. This example is just
+#printing the files and extensions to the terminal. You should place any other
+#file processing tasks within the while-do loop.
+
+if [[ $OPT_O == true  && (  $OPT_E != false || $OPT_P != false ) ]]; then
+  echo "${BOLD}${RED}$err Option -e , -p and -o cannot be used simultaneously. Exiting... ${WHITE}${NORMAL}"
+  wLog "Option -e , -p and -o cannot be used simultaneously."
+  exit 1
+fi
+
+if [ $OPT_P != false ] && [ $OPT_E != false ]; then
+  echo "${BOLD}${RED}$err Option -e and -p cannot be used simultaneously. Exiting... ${WHITE}${NORMAL}"
+  wLog "Option -e and -p cannot be used simultaneously."
+  exit 1
+fi
+
+echo ""
+echo "${BOLD}No errors found. Continuing...${NORMAL}"
+echo ""
+
+confirm "Are you ready to apply these settings? [y/n]"
+
+####
+#### File modification loop
+####
+for i in "${HOSTAPD[@]}"
+do
+  if [ -f ${i} ]; then
+    echo "Working on $i..."
+    wLog "Working on $i..."
+	if [ $OPT_S != false ]; then
+		wLog "Writing SSID $OPT_S to file $i"
+    	echo "${MAGENTA}Setting ${YELLOW}SSID${MAGENTA} to ${YELLOW}$OPT_S ${MAGENTA}in $i...${WHITE}"
+        if grep -q "^ssid=" ${HOSTAPD[$x]}; then
+        sed -i "s/^ssid=.*/ssid=${OPT_S}/" ${i}
+      else
+        echo ${OPT_S} >> ${i}
+      fi
+    fi
+
+    if [ $OPT_C != false ]; then
+		wLog "Writing channel $OPT_C to file $i"
+    	echo "${MAGENTA}Setting ${YELLOW}Channel${MAGENTA} to ${YELLOW}$OPT_C ${MAGENTA}in $i...${WHITE}"
+        if grep -q "^channel=" ${i}; then
+            sed -i "s/^channel=.*/channel=${OPT_C}/" ${i}
+        else
+            echo ${OPT_C} >> ${i}
+        fi
+    fi
+
+    if [ $OPT_E != false ] || [ $OPT_P  != false ]; then
+		wLog "Writing security and setting passphrase to $wifiPass to file $i"
+        echo "${MAGENTA}Adding WPA encryption with passphrase: ${YELLOW}$wifiPass ${MAGENTA}to $i...${WHITE}"
+        cleanhostapd $i
+		writehostapd $i
+    fi
+
+    if [ $OPT_O != false ]; then
+		wLog "Removing WiFi security in file $i"
+        echo "${MAGENTA}Removing WPA encryption in $i...${WHITE}"
+        cleanhostapd $i
+    fi
+
+	echo "${GREEN}Modified ${i}...done${WHITE}"
+	echo ""
+  else
+    echo "${MAGENTA}No ${i} file found...${WHITE}${NORMAL}"
+	echo ""
+  fi
+done
+
+
+
+### End main loop ###
+
+### Apply Settings and restart all services
+APPLYSETTINGS
+
+exit 0

image/interfaces

@@ -1,14 +1,59 @@
 auto lo
 
 iface lo inet loopback
+
+allow-hotplug eth0
 iface eth0 inet dhcp
 
 allow-hotplug wlan0
-#iface wlan0 inet manual
-#wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
-#iface default inet dhcp
-
 
 iface wlan0 inet static
   address 192.168.10.1
   netmask 255.255.255.0
+  post-up /usr/sbin/stratux-wifi.sh
+  wireless-power off
+
+
+#####################################################################
+##               Custom settings not for novice users!!!!!!  
+##               Modify at your own risk!!!!!!!!!!!!!!!!!!!
+##
+##   Second Wifi Dongle for local work and internet access
+##   This template is for adding a second wifi dongle to your PI for internet access while debugging
+##     Modify /etc/wpa_supplicant/wpa_supplicant.conf with your settings also( see below )
+##
+##  Uncomment the following lines as needed. 
+
+# allow-hotplug wlan1
+# iface wlan1 inet manual
+#     wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
+# iface name_of_WPA_Config inet dhcp
+# iface name_of_other_WPA_Config inet dhcp
+
+
+## End of interfaces
+
+
+#contents of wpa_supplicant.conf
+#############################################################
+# ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
+# update_config=1
+
+# network={
+#     ssid="SSID_1"
+#     id_str="name_of_WPA_Config"
+#     scan_ssid=1
+#     key_mgmt=WPA-PSK
+#     psk="mypassword"
+#     priority=1
+# }
+
+# network={
+#     ssid="SSID_2"
+#     id_str="name_of_other_WPA_Config"
+#     scan_ssid=1
+#     key_mgmt=WPA-PSK
+#     psk="mypassword"
+#     priority=3
+# }
+#############################################################

image/logrotate.conf

@@ -0,0 +1,32 @@
+# see "man logrotate" for details
+# rotate log files weekly
+daily
+
+# keep 2 days worth of backlogs
+rotate 2
+
+# create new (empty) log files after rotating old ones
+create
+
+# uncomment this if you want your log files compressed
+compress
+
+# packages drop log rotation information into this directory
+include /etc/logrotate.d
+
+# no packages own wtmp, or btmp -- we'll rotate them here
+/var/log/wtmp {
+    missingok
+    monthly
+    create 0664 root utmp
+    rotate 1
+}
+
+/var/log/btmp {
+    missingok
+    monthly
+    create 0660 root utmp
+    rotate 1
+}
+
+# system-specific logs may be configured here

image/logrotate_d_stratux

@@ -0,0 +1,12 @@
+# Keep 10 days of stratux logfiles.
+/var/log/stratux.log
+{
+	rotate 10
+	daily
+	missingok
+	notifempty
+	compress
+        postrotate
+		/usr/bin/killall -HUP gen_gdl90
+	endscript
+}

image/mkimg.sh

@@ -0,0 +1,172 @@
+#!/bin/bash
+
+
+#kpartx -a asdfsadf.img
+
+##dd if=/dev/zero bs=1M count=200 >>2016-02-26-raspbian-jessie-lite.img
+
+#mount root partition
+##mount -o loop,offset=67108864 2016-02-26-raspbian-jessie-lite.img mnt/
+##resize2fs /dev/loop0
+#mount boot partition
+##mount -o loop,offset=4194304 2016-02-26-raspbian-jessie-lite.img mnt/boot/
+
+chroot mnt/ apt-get update
+
+#update firmware
+chroot mnt/ apt-get -y install rpi-update
+chroot mnt/ rpi-update
+#wifi
+chroot mnt/ apt-get install -y hostapd isc-dhcp-server
+#troubleshooting
+chroot mnt/ apt-get install -y tcpdump
+#wifi startup
+chroot mnt/ systemctl enable isc-dhcp-server
+#ssh startup
+chroot mnt/ systemctl enable ssh
+
+#disable ntpd autostart
+chroot mnt/ systemctl disable ntp
+
+#root key
+mkdir -p mnt/etc/ssh/authorized_keys
+cp -f root mnt/etc/ssh/authorized_keys/root
+chown root.root mnt/etc/ssh/authorized_keys/root
+chmod 644 mnt/etc/ssh/authorized_keys/root
+
+#motd
+cp -f motd mnt/etc/motd
+
+#dhcpd config
+cp -f dhcpd.conf mnt/etc/dhcp/dhcpd.conf
+
+#hostapd config
+cp -f hostapd.conf mnt/etc/hostapd/hostapd.conf
+cp -f hostapd-edimax.conf mnt/etc/hostapd/hostapd-edimax.conf
+#hostapd manager script
+cp -f hostapd_manager.sh mnt/usr/sbin/hostapd_manager.sh
+chmod 755 mnt/usr/sbin/hostapd_manager.sh
+#hostapd
+cp -f hostapd-edimax mnt/usr/sbin/hostapd-edimax
+chmod 755 mnt/usr/sbin/hostapd-edimax
+#remove hostapd startup scripts
+rm -f mnt/etc/rc*.d/*hostapd mnt/etc/network/if-pre-up.d/hostapd mnt/etc/network/if-post-down.d/hostapd mnt/etc/init.d/hostapd mnt/etc/default/hostapd
+#interface config
+cp -f interfaces mnt/etc/network/interfaces
+#custom hostapd start script
+cp stratux-wifi.sh mnt/usr/sbin/
+chmod 755 mnt/usr/sbin/stratux-wifi.sh
+
+#SDR Serial Script
+cp -f sdr-tool.sh mnt/usr/sbin/sdr-tool.sh
+chmod 755 mnt/usr/sbin/sdr-tool.sh
+
+#ping udev
+cp -f 99-uavionix.rules mnt/etc/udev/rules.d
+
+#logrotate conf
+cp -f logrotate.conf mnt/etc/logrotate.conf
+
+#fan/temp control script
+#remove old script
+rm -rf mnt/usr/bin/fancontrol.py
+#install new program
+cp ../fancontrol mnt/usr/bin
+chmod 755 mnt/usr/bin/fancontrol
+chroot mnt/ /usr/bin/fancontrol remove
+chroot mnt/ /usr/bin/fancontrol install
+
+
+#isc-dhcp-server config
+cp -f isc-dhcp-server mnt/etc/default/isc-dhcp-server
+
+#sshd config
+cp -f sshd_config mnt/etc/ssh/sshd_config
+
+#udev config
+cp -f 10-stratux.rules mnt/etc/udev/rules.d
+
+#stratux files
+cp -f ../libdump978.so mnt/usr/lib/libdump978.so
+
+#go1.5.1 setup
+cp -rf /root/go mnt/root/
+cp -f bashrc.txt mnt/root/.bashrc
+
+#debug aliases
+cp -f stxAliases.txt mnt/root/.stxAliases
+
+#rtl-sdr setup
+cp -f rtl-sdr-blacklist.conf mnt/etc/modprobe.d/
+
+chroot mnt/ apt-get install -y git cmake libusb-1.0-0.dev build-essential
+rm -rf mnt/root/librtlsdr
+git clone https://github.com/jpoirier/librtlsdr mnt/root/librtlsdr
+mkdir -p mnt/root/librtlsdr/build
+#FIXME
+chroot mnt/ 'cd /root/librtlsdr/build && cmake ../ && make && make install && ldconfig'
+
+
+#stratux setup
+cd /root
+apt-get install -y mercurial
+apt-get install -y build-essential
+rm -rf stratux
+git clone https://github.com/cyoung/stratux --recursive
+cd stratux
+make
+make install
+
+#system tweaks
+cp -f modules.txt mnt/etc/modules
+
+#kalibrate-rtl
+cd /root
+rm -rf kalibrate-rtl
+git clone https://github.com/steve-m/kalibrate-rtl
+cd kalibrate-rtl
+apt-get install -y autoconf fftw3 fftw3-dev libtool
+./bootstrap
+./configure
+make
+make install
+
+#disable serial console
+sed -i mnt/boot/cmdline.txt -e "s/console=ttyAMA0,[0-9]\+ //"
+
+#Set the keyboard layout to US.
+sed -i mnt/etc/default/keyboard -e "/^XKBLAYOUT/s/\".*\"/\"us\"/"
+
+#boot settings
+cp -f config.txt mnt/boot/
+
+#external OLED screen
+apt-get install -y libjpeg-dev i2c-tools python-smbus python-pip python-dev python-pil python-daemon screen
+#for fancontrol.py:
+pip install wiringpi
+cd /root
+git clone https://github.com/rm-hull/ssd1306
+cd ssd1306
+# Force an older version of ssd1306, since recent changes have caused a lot of compatibility issues.
+git reset --hard 232fc801b0b8bd551290e26a13122c42d628fd39
+python setup.py install
+
+
+cp /root/stratux/test/screen/screen.py /usr/bin/stratux-screen.py
+mkdir -p /etc/stratux-screen/
+cp -f /root/stratux/test/screen/stratux-logo-64x64.bmp /etc/stratux-screen/stratux-logo-64x64.bmp
+cp -f /root/stratux/test/screen/CnC_Red_Alert.ttf /etc/stratux-screen/CnC_Red_Alert.ttf
+
+#startup scripts
+cp -f ../__lib__systemd__system__stratux.service mnt/lib/systemd/system/stratux.service
+cp -f ../__root__stratux-pre-start.sh mnt/root/stratux-pre-start.sh
+cp -f rc.local mnt/etc/rc.local
+
+#dhcpcd causes first boot hanging.
+chroot mnt/ systemctl disable dhcpcd
+
+#disable hciuart - interferes with ttyAMA0 as a serial port.
+chroot mnt/ systemctl disable hciuart
+
+#clean up for release images.
+rm -rf mnt/root/stratux mnt/root/go

image/modules.txt

@@ -0,0 +1,7 @@
+# /etc/modules: kernel modules to load at boot time.
+#
+# This file contains the names of kernel modules that should be loaded
+# at boot time, one per line. Lines beginning with "#" are ignored.
+
+i2c-bcm2708
+i2c-dev

image/motd

@@ -0,0 +1,20 @@
+                                                                                              
+ ad88888ba  888888888888  88888888ba          db    888888888888  88        88  8b        d8  
+d8"     "8b      88       88      "8b        d88b        88       88        88   Y8,    ,8P   
+Y8,              88       88      ,8P       d8'`8b       88       88        88    `8b  d8'    
+`Y8aaaaa,        88       88aaaaaa8P'      d8'  `8b      88       88        88      Y88P      
+  `"""""8b,      88       88""""88'       d8YaaaaY8b     88       88        88      d88b      
+        `8b      88       88    `8b      d8""""""""8b    88       88        88    ,8P  Y8,    
+Y8a     a8P      88       88     `8b    d8'        `8b   88       Y8a.    .a8P   d8'    `8b   
+ "Y88888P"       88       88      `8b  d8'          `8b  88        `"Y8888Y"'   8P        Y8  
+                                                                                              
+                                                                                              
+
+NOTE TO DEVELOPERS: Make sure that your system has an acceptable clock source, i.e., a GPS
+with sufficient signal or enable ntpd (internet connection required).
+
+
+Everything here comes with ABSOLUTELY NO WARRANTY, to the extent
+permitted by applicable law.
+
+Type 'stratux-help' (as root) for a few debugging commands.

image/rc.local

@@ -0,0 +1,29 @@
+#!/bin/sh -e
+#
+# rc.local
+#
+# This script is executed at the end of each multiuser runlevel.
+# Make sure that the script will "exit 0" on success or any other
+# value on error.
+#
+# In order to enable or disable this script just change the execution
+# bits.
+#
+# By default this script does nothing.
+
+# Print the IP address
+_IP=$(hostname -I) || true
+if [ "$_IP" ]; then
+  printf "My IP address is %s\n" "$_IP"
+fi
+
+
+#
+# Rotate logs on boot.
+#
+/usr/sbin/logrotate /etc/logrotate.conf
+
+
+/usr/bin/stratux-screen.py start
+
+exit 0

image/rsyslog_d_stratux

@@ -0,0 +1,2 @@
+# Ignore gen_gdl90. stratux.log is written directly from the process.
+if $programname == 'gen_gdl90' then ~

image/rtl-sdr-blacklist.conf

@@ -0,0 +1,4 @@
+blacklist dvb_usb_rtl28xxu
+blacklist e4000
+blacklist rtl2832
+blacklist dvb_usb_rtl2832u

image/sdr-tool.sh

@@ -0,0 +1,317 @@
+#!/bin/bash
+
+######################################################################
+#                      STRATUX SDR MANAGER                           #
+######################################################################
+
+#Set Script Name variable
+SCRIPT=`basename ${BASH_SOURCE[0]}`
+
+# rtl_eeprom -d 0 -s <String>:<Freq>:<PPM>
+#Initialize variables to default values.
+SERVICE=stratux.service
+WhichSDR=1090
+FallBack=true
+PPMValue=0
+
+parm="*"
+err="####"
+att="+++"
+
+#Set fonts for Help.
+BOLD=$(tput bold)
+STOT=$(tput smso)
+DIM=$(tput dim)
+UNDR=$(tput smul)
+REV=$(tput rev)
+RED=$(tput setaf 1)
+GREEN=$(tput setaf 2)
+YELLOW=$(tput setaf 3)
+MAGENTA=$(tput setaf 5)
+WHITE=$(tput setaf 7)
+NORM=$(tput sgr0)
+NORMAL=$(tput sgr0)
+
+#This is the Title
+function HEAD {
+	clear
+	echo "######################################################################"
+	echo "#                     STRATUX SDR SERIAL TOOL                        #"
+	echo "######################################################################"
+	echo " "
+}
+
+function STOPSTRATUX {
+	HEAD
+	echo "Give me a few seconds to check if STRATUX is running..."
+	# The service we want to check (according to systemctl)
+	if [ "`systemctl is-active $SERVICE`" = "active" ] 
+	then
+	    echo "$SERVICE is currently running"
+	    echo "Stopping..."
+	    SDRs=`systemctl stop stratux.service`
+	fi
+	sleep 3
+}
+
+function STARTSTRATUX {
+	HEAD
+	echo "Give me a few seconds to get STRATUX running again..."
+	SDRs=`systemctl start stratux.service`
+	sleep 3
+	if [ "`systemctl is-active $SERVICE`" = "active" ] 
+	then
+	    echo "$SERVICE is now running"
+	else 
+		echo "$SERVICE did not restart. Try 'reboot' to restart your RaspberryPI"
+	fi
+}
+
+#Function to set the serial function
+function SETSDRSERIAL {
+	HEAD
+    echo "#            Setting ${WhichSDR}mhz SDR Serial Data                  #"
+	#Build this string
+	# rtl_eeprom -d 0 -s <String>:<Freq>:<PPM>
+	echo " SETTING SERIAL: "
+	echo " rtl_eeprom -d 0 -s stx:${WhichSDR}:${PPMValue} "
+    echo " "
+    echo "${REV}Answer 'y' to the qustion: 'Write new configuration to device [y/n]?'${NORM}"
+    echo " "
+    SDRs=`rtl_eeprom -d 0 -s stx:${WhichSDR}:${PPMValue}`
+    sleep 2
+    echo " "
+    echo "Do you have another SDR to program?"
+    echo "     'Yes' will shutdown your STRATUX and allow you to swap SDRs."
+    echo "     'No' will reboot your STRATUX and return your STRATUX to normal operation."
+    echo "     'exit' will exit the script and return you to your shell prompt"
+    choices=( 'Yes' 'No' 'exit' )
+	# Present the choices.
+	# The user chooses by entering the *number* before the desired choice.
+	select choice in "${choices[@]}"; do
+
+  		# If an invalid number was chosen, $choice will be empty.
+  		# Report an error and prompt again.
+		[[ -n $choice ]] || { echo "Invalid choice." >&2; continue; }	
+
+  		case $choice in
+    		'Yes')
+            		echo "Shutting down..."
+    	    		SDRs=`shutdown -h now`
+    	    	;;
+    		'No')
+    	  		echo "Rebooting..."
+                	SDRs=`reboot`
+    	  	;;
+    		exit)
+			STARTSTRATUX
+    	  		echo "Exiting. "
+    	  	exit 0
+  		esac
+    break
+    done
+}
+
+
+function SDRInfo {
+	HEAD
+    echo "#              Building ${WhichSDR}mhz SDR Serial                     #"
+    echo " "
+    echo "Do you have a PPM value to enter?"
+    echo "If not, its ok... Just choose 'No'"
+    choices=( 'Yes' 'No' 'exit' )
+	# Present the choices.
+	# The user chooses by entering the *number* before the desired choice.
+	select choice in "${choices[@]}"; do
+
+  		# If an invalid number was chosen, $choice will be empty.
+  		# Report an error and prompt again.
+		[[ -n $choice ]] || { echo "Invalid choice." >&2; continue; }	
+
+  		case $choice in
+    		'Yes')
+    	    	echo "Please enter your PPM value for your 978mhz SDR:"
+				read PPMValue
+    	    ;;
+    		'No')
+    	  		echo " "
+    	  	;;
+    		exit)
+			STARTSTRATUX
+    	  		echo "Exiting. "
+    	  	exit 0
+  		esac
+    break
+    done
+	SETSDRSERIAL
+}
+
+function PICKFALLBACK {
+	HEAD
+    echo "#             Gathering ${WhichSDR}mhz SDR Serial                    #"
+    echo " "
+    echo "${RED}${BOLD}IMPORTANT INFORMATION: READ CAREFULLY${NORM}"
+    echo "${BOLD}DO you want to set the 1090mhz SDR to Fall Back to 978mhz in the event of the 978mhx SDR failing inflight?${NORM}"
+    echo "If no serials are set on any of the attached SDRs then STRATUX will assign 978mhz to the first SDR found and 1090mhz to the remaining SDR. This is a safety featre of STRATUX to always allow users to always have access to WEATHER and METAR data in the event of one SDR failing in flight. "
+    echo " "
+    echo "When a user assigns a frequency to an SDR, via setting serials, STRATUX will always assign that frequency. NO MATTER WHAT."
+    echo "This could cause issues if an SDR fails in flight. If the 978mhz SDR fails in flight and the other SDR is assigned the 1090 serial this SDR will never be set to 978mhz and the user will not have access to WEATHER and METAR data" 
+    echo " "
+    echo "Choosing the Fall Back mode will allow the remaining SDR to be assigned to 978mhz while keeping the PPM value, allowing the user to continue to receive WEATHER and METAR data."
+    echo "Fall Back mode is reccomended!"
+    
+    choices=( 'FallBack' '1090mhz' 'exit' )
+	# Present the choices.
+	# The user chooses by entering the *number* before the desired choice.
+	select choice in "${choices[@]}"; do
+
+  		# If an invalid number was chosen, $choice will be empty.
+  		# Report an error and prompt again.
+		[[ -n $choice ]] || { echo "Invalid choice." >&2; continue; }	
+
+  		case $choice in
+    		'FallBack')
+            	WhichSDR=0
+    	    ;;
+    		'1090mhz')
+				echo " "
+    	  	;;
+    		exit)
+			STARTSTRATUX
+    	  		echo "Exiting. "
+    	  	exit 0
+  		esac
+    break
+    done
+
+}
+
+function PICKFREQ {
+	HEAD
+    echo "#                Selecting Radio to set Serial                       #"
+    echo " "
+    echo "${BOLD}Which SDR are you setting up?${NORM}"
+    echo "${DIM}If you have tuned antennas make sure you have the correct SDR and antenna combination hooked up at this time and remember which antenna connection is for which antenna.${NORM}"
+    choices=( '978mhz' '1090mhz' 'exit' )
+	# Present the choices.
+	# The user chooses by entering the *number* before the desired choice.
+	select choice in "${choices[@]}"; do
+
+  		# If an invalid number was chosen, $choice will be empty.
+  		# Report an error and prompt again.
+		[[ -n $choice ]] || { echo "Invalid choice." >&2; continue; }	
+
+  		case $choice in
+    		'978mhz')
+            	WhichSDR=978
+    	    	SDRInfo
+    	    ;;
+    		'1090mhz')
+                PICKFALLBACK
+    	  		SDRInfo
+    	  	;;
+    		exit)
+    	  		STARTSTRATUX
+			echo "Exiting. "
+    	  	exit 0
+  		esac
+    break
+    done
+}
+
+function MAINMENU {
+	HEAD
+	echo "Loading SDR info..."
+    	sleep 2
+	HEAD
+	echo "#                CONFIRM ONLY ONE SDR INSTALLED                      #"
+	echo "----------------------------------------------------------------------"
+	SDRs=`rtl_eeprom`
+    echo "----------------------------------------------------------------------"
+	echo " "
+	echo "${BOLD}${RED}Read the lines above.${NORM}"
+	echo "${BOLD}How many SDRs were found?${NORM}"
+
+	# Define the choices to present to the user, which will be
+	# presented line by line, prefixed by a sequential number
+	# (E.g., '1) copy', ...)
+	choices=( 'Only 1' '2 or more' 'exit' )
+	# Present the choices.
+	# The user chooses by entering the *number* before the desired choice.
+	select choice in "${choices[@]}"; do
+	
+		# If an invalid number was chosen, $choice will be empty.
+  		# Report an error and prompt again.
+  		[[ -n $choice ]] || { echo "Invalid choice." >&2; continue; }
+
+		case $choice in
+    		'Only 1')
+		      PICKFREQ
+      		;;
+		    '2 or more')
+				echo "#####################################################################################"
+				echo "#      ${RED}Too Many SDRs Plugged in. Unplug all SDRs except one and try again!!${NORM}         #"
+				echo "#####################################################################################"
+				STARTSTRATUX
+				echo "Exiting. "
+		      exit 0
+		      ;;
+		    exit)
+		    	STARTSTRATUX
+		    	echo "Exiting... "
+		    	exit 0
+		  esac
+ 	# Getting here means that a valid choice was made,
+  	# so break out of the select statement and continue below,
+  	# if desired.
+  	# Note that without an explicit break (or exit) statement, 
+  	# bash will continue to prompt.
+  	break
+	done
+}
+
+function START {
+  echo "Help documentation for ${BOLD}${SCRIPT}.${NORM}"
+  echo " "
+  echo "This script will help you in setting your SDR serials. Please read carefully before continuing.  There are many options in settings the SDR serials. Programming the SDR serials does 2 things. "
+  echo " "
+  echo "${BOLD}First:${NORM}"
+  echo "Setting the serials will tell your STRATUX which SDR is attached to which tuned antenna."
+  echo " "
+  echo "${BOLD}Second:${NORM}"
+  echo "Setting the PPM value will enhance the reception of your SDR by correcting the Frequency Error in each SDR.  Each PPM value is unique to each SDR. For more info on this please refer to the Settings page in the WebUI and click on the Help in the top right."
+  echo " "
+  echo "Steps we will take:"
+  echo "1) Make sure you have ${BOLD}${REV}ONLY ONE${NORM} SDR plugged in at a time. Plugging in one SDR at a time will ensure they are not mixed up."
+  echo "2) Select which SDR we are setting the serial for."
+  echo "3) Add a PPM value. If you do not know or do not want to set this value this will be set to 0. "
+  echo "4) Write the serial to the SDR."
+  echo " "
+  echo "If you are ready to begin choose ${BOLD}Continue${NORM} to begin."
+  echo "     Continuing will stop the STRATUX service to release the SDRs for setting the serials"
+   
+	choices=( 'Continue' 'Exit' )
+	# Present the choices.
+	# The user chooses by entering the *number* before the desired choice.
+	select choice in "${choices[@]}"; do
+
+  		# If an invalid number was chosen, $choice will be empty.
+  		# Report an error and prompt again.
+		[[ -n $choice ]] || { echo "Invalid choice." >&2; continue; }	
+
+  		case $choice in
+    		'Continue')
+				STOPSTRATUX
+    	    	MAINMENU
+    	    ;;
+    		exit)
+			STARTSTRATUX
+    	  		echo "Exiting. "
+    	  	exit 0
+  		esac
+    break
+    done
+}
+
+HEAD
+START

image/spindle/common

@@ -10,7 +10,7 @@ set -e
 run_qemu() {
   rm fifo.out fifo.in || true
   mkfifo fifo.out fifo.in
-  qemu-system-arm -M versatilepb -cpu arm1136-r2 -m 256 -nographic -no-reboot \
+  qemu-system-arm -M versatilepb -cpu arm1136-r2 -m 256 -display none -no-reboot \
         -kernel zImage -hda qemu_rootfs.sqf -drive file=$1,index=1,media=disk,cache=unsafe \
         -drive file=wheezy_apt_cache.$IMGFORMAT,index=2,media=disk,cache=unsafe \
         -append "root=/dev/sda rw init=/sbin/init.sh panic=1 PATH=/bin:/sbin console=ttyAMA0 HOST=armv6l"\

image/spindle/wheezy-stage4

@@ -20,6 +20,13 @@ setup_stratux_bootconfig() {
 	echo "max_usb_current=1" >>boot/config.txt
 	#i2c
 	echo "dtparam=i2c1=on" >>boot/config.txt
+	echo "dtparam=i2c1_baudrate=400000" >>boot/config.txt
+	echo "dtparam=i2c_arm_baudrate=400000" >>boot/config.txt
+	#fixed arm/sdram/core freq.
+	echo "arm_freq=900" >>boot/config.txt
+	echo "sdram_freq=450" >>boot/config.txt
+	echo "core_freq=450" >>boot/config.txt
+
 	#disable serial console
     sed -i boot/cmdline.txt -e "s/console=ttyAMA0,[0-9]\+ //"
 }
@@ -30,8 +37,7 @@ setup_stratux() {
 echo "**** STRATUX SETUP *****"
 
   ssh_in_to_qemu chroot /mnt sh -l -ex - <<\EOF
-#general
-apt-get install -y screen
+
 #wifi
 apt-get install -y hostapd isc-dhcp-server
 #troubleshooting
@@ -39,6 +45,8 @@ apt-get install -y tcpdump
 #wifi startup
 update-rc.d hostapd enable
 update-rc.d isc-dhcp-server enable
+#disable ntpd autostart
+update-rc.d ntp disable
 EOF
 
 scp_in_to_qemu /root/spindle/hostapd-edimax /tmp/hostapd.in
@@ -49,9 +57,13 @@ scp_in_to_qemu /root/spindle/hostapd.conf /tmp/hostapd.conf.in
 scp_in_to_qemu /root/spindle/isc-dhcp-server /tmp/isc-dhcp-server.in
 scp_in_to_qemu /root/spindle/sshd_config /tmp/sshd_config.in
 scp_in_to_qemu /root/spindle/libdump978.so /tmp/libdump978.so.in
+scp_in_to_qemu /root/spindle/libimu.so /tmp/libimu.so.in
+scp_in_to_qemu /root/spindle/go.tgz /mnt/root/go.tgz
+
 
  ssh_in_to_qemu chroot /mnt sh -l -ex - <<\EOF
 mv /tmp/libdump978.so.in /usr/lib/libdump978.so
+mv /tmp/libimu.so.in /usr/lib/libimu.so
 mv -f /tmp/hostapd.in /usr/sbin/hostapd
 chown root.root /usr/sbin/hostapd
 chmod 755 /usr/sbin/hostapd
@@ -78,6 +90,20 @@ echo blacklist rtl2832 >>/etc/modprobe.d/rtl-sdr-blacklist.conf
 echo "# prevent power down of wireless when idle" >>/etc/modprobe.d/8192cu.conf
 echo "options 8192cu rtw_power_mgnt=0 rtw_enusbss=0" >>/etc/modprobe.d/8192cu.conf
 
+#Set up Go1.5.1.
+echo export PATH=/root/go/bin:\$\{PATH\} >>/root/.bashrc
+echo export GOROOT=/root/go >>/root/.bashrc
+echo export GOPATH=/root/go_path >>/root/.bashrc
+
+
+cd /root
+tar -zxvf go.tgz
+rm -f go.tgz
+
+#ifndef DEBUG
+#rm -rf go
+#endif
+
 EOF
 
 echo "*** STRATUX COMPILE/PACKAGE INSTALL ***"
@@ -88,9 +114,9 @@ apt-get install -y git cmake libusb-1.0-0.dev build-essential
 
 
 cd /root
-rm -rf rtl-sdr
-git clone git://git.osmocom.org/rtl-sdr.git
-cd rtl-sdr
+rm -rf librtlsdr
+git clone https://github.com/jpoirier/librtlsdr
+cd librtlsdr
 mkdir build
 cd build
 cmake ../
@@ -99,58 +125,64 @@ make install
 ldconfig
 EOF
 
-echo " - dump1090"
-  ssh_in_to_qemu chroot /mnt sh -l -ex - <<\EOF
-cd /root
-rm -rf dump1090
-git clone https://github.com/antirez/dump1090
-cd dump1090
-make
-cp dump1090 /usr/bin/
-EOF
-
 echo " - Stratux"
 
 scp_in_to_qemu /root/spindle/gen_gdl90 /tmp/gen_gdl90
 
-  ssh_in_to_qemu chroot /mnt sh -l -ex - <<\EOF
+  ssh_in_to_qemu chroot /mnt bash -l -ex - <<\EOF
+source /root/.bashrc
 cd /root
 
+apt-get install -y mercurial
+
 rm -rf stratux
-git clone https://github.com/cyoung/stratux
+git clone https://github.com/cyoung/stratux --recursive
 cd stratux
-mkdir -p /var/www
-cp -r web/* /var/www/
-cd dump978
-make
-cp dump978 /usr/bin/
-cd ..
+make www
+make xdump978
+make xdump1090
+cp -f dump1090/dump1090 /usr/bin/
 
 mv /tmp/gen_gdl90 /usr/bin/gen_gdl90
 chmod +x /usr/bin/gen_gdl90
-cp start_uat.sh /usr/bin/start_uat
+
+#Startup script.
 cp init.d-stratux /etc/init.d/stratux
-cp start_stratux.sh /usr/sbin/stratux
-chmod 755 /usr/bin/start_uat
-chmod 755 /usr/sbin/stratux
 chmod 755 /etc/init.d/stratux
 ln -s /etc/init.d/stratux /etc/rc2.d/S01stratux
 ln -s /etc/init.d/stratux /etc/rc6.d/K01stratux
 
 update-rc.d stratux enable
 
+mkdir -p /root/go_path
+#FIXME
+#export PATH=/root/go/bin:${PATH}
+#export GOROOT=/root/go
+#export GOPATH=/root/go_path
+#make
+EOF
 
+ssh_in_to_qemu chroot /mnt sh -l -ex - <<\EOF
 #i2c
 echo "i2c-bcm2708" >>/etc/modules
 echo "i2c-dev" >>/etc/modules
 
 
+#sysctl tweaks
+
+echo "net.core.rmem_max = 167772160" >>/etc/sysctl.conf
+echo "net.core.rmem_default = 167772160" >>/etc/sysctl.conf
+echo "net.core.wmem_max = 167772160" >>/etc/sysctl.conf
+echo "net.core.wmem_default = 167772160" >>/etc/sysctl.conf
+
+
 
 #kalibrate-rl
 cd /root
 git clone https://github.com/steve-m/kalibrate-rtl
 cd kalibrate-rtl
 apt-get install -y autoconf fftw3 fftw3-dev
+apt-get install -y libtool
 
 ./bootstrap
 ./configure
@@ -160,6 +192,13 @@ make install
 #disable serial console
 sed -i /etc/inittab -e "s|^.*:.*:respawn:.*ttyAMA0|#&|"
 
+#Set the keyboard layout to US.
+sed -i /etc/default/keyboard -e "/^XKBLAYOUT/s/\".*\"/\"us\"/"
+
+
+
+
+
 EOF
 
 echo "**** END STRATUX SETUP *****"

image/stratux-wifi.sh

@@ -0,0 +1,106 @@
+#!/bin/bash
+#####
+#####	Wifi/AP control file
+#####
+#####	Description: All the scripting related to the AP and wireless functions for Stratux should be placed in this file
+#####	This file is called when wlan0 is started i.e. "ifup wlan0"
+#####	This script is called from /etc/network/interfaces by the line "post-up /usr/sbin/stratux-wifi.sh" under the wlan0 configuration
+#####
+
+# common variables
+DAEMON_USER_PREF=/etc/hostapd/hostapd.user
+
+#Logging Function
+SCRIPT=`basename ${BASH_SOURCE[0]}`
+STX_LOG="/var/log/stratux.log"
+function wLog () {
+       echo "$(date +"%Y/%m/%d %H:%m:%S")  - $SCRIPT - $1" >> ${STX_LOG}
+}
+wLog "Running Stratux WiFI Script."
+
+##### Function for setting up new file structure for hostapd settings
+##### Look for hostapd.user and if found do nothing.
+##### If not assume because of previous version and convert to new file structure
+
+function hostapd-upgrade {
+	DAEMON_CONF=/etc/hostapd/hostapd.conf
+	DAEMON_CONF_EDIMAX=/etc/hostapd/hostapd-edimax.conf
+	HOSTAPD_VALUES=('ssid=' 'channel=' 'auth_algs=' 'wpa=' 'wpa_passphrase=' 'wpa_key_mgmt=' 'wpa_pairwise=' 'rsn_pairwise=')
+
+    wLog "Moving existing values from $DAEMON_CONF to $DAEMON_USER_PREF if found"
+	for i in "${HOSTAPD_VALUES[@]}"
+	do
+		if grep -q "^$i" $DAEMON_CONF
+        then
+			grep "^$i" $DAEMON_CONF >> $DAEMON_USER_PREF
+			sed -i '/^'"$i"'/d' $DAEMON_CONF
+			sed -i '/^'"$i"'/d' $DAEMON_CONF_EDIMAX
+		fi
+	done
+	sleep 1     #make sure there is time to get the file written before checking for it again
+	# If once the code above runs and there is still no hostapd.user file then something is wrong and we will just create the file with basic settings. 
+	# Any more then this they somebody was messing with things and its not our fault things are this bad
+	wLog "Rechecking if $DAEMON_USER_PREF exists after moving files."
+	if [ ! -f $DAEMON_USER_PREF ]; then
+	    wLog "File not found. Creating default file. "
+		echo "ssid=stratux" > $DAEMON_USER_PREF
+		echo "channel=1" >> $DAEMON_USER_PREF
+	fi
+}
+##### End hostapd settings structure function
+
+##### Hostapd Driver check function #####
+function ap-start {
+
+	# Preliminaries. Kill off old services.
+	wLog "Killing Hostapd services "
+    /usr/bin/killall -9 hostapd hostapd-edimax
+    wLog "Stopping DHCP services "
+	/usr/sbin/service isc-dhcp-server stop
+
+	#EDIMAX Mac Addresses from http://www.adminsub.net/mac-address-finder/edimax
+	#for logic check all addresses must be lowercase
+	# 74:da:38 is my MAC on my NANO
+	edimaxMac=(80:1f:02 74:da:38 00:50:fc 00:1f:1f 00:0e:2e 00:00:b4)
+
+	#Assume PI3 settings
+	DAEMON_CONF=/etc/hostapd/hostapd.conf
+	DAEMON_SBIN=/usr/sbin/hostapd
+
+	# Location of temporary hostapd.conf built by combining
+	# non-editable /etc/hostapd/hostapd.conf or hostapd-edimax.conf
+	# and the user configurable /etc/hostapd/hostapd.conf
+	DAEMON_TMP=/tmp/hostapd.conf
+
+	#get the first 3 octets of the MAC(XX:XX:XX) at wlan0
+	wlan0mac=$(head -c 8 /sys/class/net/wlan0/address)
+
+	# Is there an Edimax Mac Address at wlan0
+	if [[ ${edimaxMac[*]} =~ "$wlan0mac" ]]; then
+        DAEMON_CONF=/etc/hostapd/hostapd-edimax.conf
+        DAEMON_SBIN=/usr/sbin/hostapd-edimax
+        wLog "Edimax Dongle found at WLAN0. Using Edimad conf files $DAEMON_SBIN : $DAEMON_CONF"
+	fi
+
+	#Make a new hostapd or hostapd-edimax conf file based on logic above
+	cat ${DAEMON_USER_PREF} <(echo) ${DAEMON_CONF} > ${DAEMON_TMP}
+
+	${DAEMON_SBIN} -B ${DAEMON_TMP}
+
+	sleep 2
+
+	wLog "Restarting DHCP services"
+
+	/usr/sbin/service isc-dhcp-server start
+}
+##### End Hostapd driver check function #####
+
+#Do we need to upgrade the hostapd configuration files
+wLog "Checking if $DAEMON_USER_PREF file exists"
+if [ ! -f $DAEMON_USER_PREF ]; then
+    wLog "File not found. Upgrading to new file structure."
+	hostapd-upgrade
+fi
+
+# function to build /tmp/hostapd.conf and start AP
+ap-start

image/stxAliases.txt

@@ -0,0 +1,71 @@
+alias stratux-off='shutdown -P now'
+
+alias eeprom='rtl_eeprom'
+alias sa='service --status-all'
+alias stxrestart='service stratux restart'
+alias stxstop='service stratux stop'
+alias stxstart='service stratux start'
+
+alias sdr0='rtl_eeprom -d 0'
+alias sdr1='rtl_eeprom -d 1'
+
+alias sdrs='sdr0 || sdr1'
+
+alias d90='dump1090'
+alias d900='dump1090 --device-index 0 --interactive'
+alias d901='dump1090 --device-index 1 --interactive'
+
+alias kal0='kal -d 0 -s GSM850 -g 47'
+alias kal1='kal -d 1 -s GSM850 -g 47'
+
+alias kalChan0='function _kalChan0 () { kal -d 0 -g 47 -c $1; unset -f _kalChan0; }; _kalChan0'
+alias kalChan1='function _kalChan1 () { kal -d 1 -g 47 -c $1; unset -f _kalChan1; }; _kalChan1'
+
+alias setSerial0='function _setSerial0 () { rtl_eeprom -d 0 -s stx:0:$1; unset -f _setSerial0; }; _setSerial0'
+alias setSerial1='function _setSerial1 () { rtl_eeprom -d 1 -s stx:0:$1; unset -f _setSerial1; }; _setSerial1'
+
+alias secure='hostapd_manager.sh -e'
+alias open='hostapd_manager.sh -o'
+
+alias stratux-help='_stxhelp'
+
+function _stxhelp() {
+clear
+echo ""
+echo "########################################################"
+echo ""
+echo "These are commands avalible to you. Use at your own Risk"
+echo ""
+echo "########################################################"
+echo ""
+echo " Common tools "
+echo "########################################################"
+echo ""
+echo "secure                    Turns on WiFi Security"
+echo "open                      Turns off WiFi Security"
+echo "stratux-off               Shutdown Stratux"
+echo "hostapd_manager.sh        Sets the Change SSID, Channel, or Encryption for your Stratux"
+echo "sdr-tool.sh               Tool to walk you though setting your SDRs Serials"
+echo ""
+echo " Developer Tools "
+echo "########################################################"
+echo ""
+echo "sa                        List all services running"
+echo "stxrestart                Restart Startux service only"
+echo "stxstop                   Stop Stratux Service."
+echo "stxstart                  Start Stratux Service."
+echo "sdr0                      Test to see if sdr0 is in use by Stratux."
+echo "sdr1                      Test to see if sdr1 is in use by Startux."
+echo "sdrs                      Test to see if both SDRs are in use by Stratux."
+echo "d90                       Run dump1090 on SDR0"
+echo "d900                      Run dump1090 on SDR0 in interactive mode."
+echo "d901                      Run dump1090 on SDR1 in interactive mode."
+echo "kal0                      Find Channels for calibrating PPM of SDR0."
+echo "kal1                      Find Channels for calibrating PPM of SDR1."
+echo "kalChan0                  Use the Chan from above to get ppm pf SDR0. Example: kalChan0 151"
+echo "kalChan1                  Use the Chan from above to get ppm pf SDR1. Example: kalChan1 151"
+echo "setSerial0                Set the PPM error to SDR0. Value from kalChan0. Example: setSerial0 -45"
+echo "setSerial1                Set the PPM error to SDR1. Value from kalChan1. Example: setSerial1 23"
+echo "raspi-config              Open Raspberry Pi settings to expand filesystem"
+
+}

init.d-stratux

@@ -1,64 +0,0 @@
-#!/bin/sh
-
-### BEGIN INIT INFO
-# Provides:		stratux
-# Required-Start:	$network
-# Required-Stop:
-# Should-Start:
-# Should-Stop:
-# Default-Start:	2
-# Default-Stop:		6
-# Short-Description:	Stratux ADS-B Receiver
-# Description:		RTL-SDR ADS-B receiver
-### END INIT INFO
-
-PATH=/sbin:/bin:/usr/sbin:/usr/bin
-DAEMON_SBIN=/usr/sbin/stratux
-DAEMON_DEFS=
-DAEMON_CONF=
-NAME=stratux
-DESC="Stratux ADS-B Receiver"
-PIDFILE=/var/run/stratux.pid
-
-[ -x "$DAEMON_SBIN" ] || exit 0
-
-DAEMON_OPTS="-B -P $PIDFILE $DAEMON_OPTS $DAEMON_CONF"
-
-. /lib/lsb/init-functions
-
-case "$1" in
-  start)
-	log_daemon_msg "Starting $DESC" "$NAME"
-	start-stop-daemon --start --oknodo --quiet --exec "$DAEMON_SBIN" \
-		--pidfile "$PIDFILE" --make-pidfile -- $DAEMON_OPTS >/dev/null
-	log_end_msg "$?"
-	;;
-  stop)
-	log_daemon_msg "Stopping $DESC" "$NAME"
-	start-stop-daemon --stop --oknodo --quiet --exec "$DAEMON_SBIN" \
-		--pidfile "$PIDFILE"
-	log_end_msg "$?"
-	;;
-  reload)
-  	log_daemon_msg "Reloading $DESC" "$NAME"
-	start-stop-daemon --stop --signal HUP --exec "$DAEMON_SBIN" \
-		--pidfile "$PIDFILE"
-	log_end_msg "$?"
-	;;
-  restart|force-reload)
-  	$0 stop
-	sleep 8
-	$0 start
-	;;
-  status)
-	status_of_proc "$DAEMON_SBIN" "$NAME"
-	exit $?
-	;;
-  *)
-	N=/etc/init.d/$NAME
-	echo "Usage: $N {start|stop|restart|force-reload|reload|status}" >&2
-	exit 1
-	;;
-esac
-
-exit 0

main/cputemp.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const invalidCpuTemp = float32(-99.0)
+
+type CpuTempUpdateFunc func(cpuTemp float32)
+
+/* cpuTempMonitor() reads the RPi board temperature every second and
+calls a callback.  This is broken out into its own function (run as
+its own goroutine) because the RPi temperature monitor code is buggy,
+and often times reading this file hangs quite some time.  */
+
+func cpuTempMonitor(updater CpuTempUpdateFunc) {
+	timer := time.NewTicker(1 * time.Second)
+	for {
+		// Update CPUTemp.
+		temp, err := ioutil.ReadFile("/sys/class/thermal/thermal_zone0/temp")
+		tempStr := strings.Trim(string(temp), "\n")
+		t := invalidCpuTemp
+		if err == nil {
+			tInt, err := strconv.Atoi(tempStr)
+			if err == nil {
+				if tInt > 1000 {
+					t = float32(tInt) / float32(1000.0)
+				} else {
+					t = float32(tInt) // case where Temp is returned as simple integer
+				}
+			}
+		}
+		if t >= invalidCpuTemp { // Only update if valid value was obtained.
+			updater(t)
+		}
+		<-timer.C
+	}
+}
+
+// Check if CPU temperature is valid. Assume <= 0 is invalid.
+func isCPUTempValid(cpuTemp float32) bool {
+	return cpuTemp > 0
+}

main/datalog.go

@@ -0,0 +1,642 @@
+/*
+	Copyright (c) 2015-2016 Christopher Young
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	datalog.go: Log stratux data as it is received. Bucket data into timestamp time slots.
+
+*/
+
+package main
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	_ "github.com/mattn/go-sqlite3"
+	"log"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	LOG_TIMESTAMP_RESOLUTION = 250 * time.Millisecond
+)
+
+type StratuxTimestamp struct {
+	id                   int64
+	Time_type_preference int // 0 = stratuxClock, 1 = gpsClock, 2 = gpsClock extrapolated via stratuxClock.
+	StratuxClock_value   time.Time
+	GPSClock_value       time.Time // The value of this is either from the GPS or extrapolated from the GPS via stratuxClock if pref is 1 or 2. It is time.Time{} if 0.
+	PreferredTime_value  time.Time
+	StartupID            int64
+}
+
+// 'startup' table creates a new entry each time the daemon is started. This keeps track of sequential starts, even if the
+//  timestamp is ambiguous (units with no GPS). This struct is just a placeholder for an empty table (other than primary key).
+type StratuxStartup struct {
+	id   int64
+	Fill string
+}
+
+var dataLogStarted bool
+var dataLogReadyToWrite bool
+
+var stratuxStartupID int64
+var dataLogTimestamps []StratuxTimestamp
+var dataLogCurTimestamp int64 // Current timestamp bucket. This is an index on dataLogTimestamps which is not necessarily the db id.
+
+/*
+	checkTimestamp().
+		Verify that our current timestamp is within the LOG_TIMESTAMP_RESOLUTION bucket.
+		 Returns false if the timestamp was changed, true if it is still valid.
+		 This is where GPS timestamps are extrapolated, if the GPS data is currently valid.
+*/
+
+func checkTimestamp() bool {
+	thisCurTimestamp := dataLogCurTimestamp
+	if stratuxClock.Since(dataLogTimestamps[thisCurTimestamp].StratuxClock_value) >= LOG_TIMESTAMP_RESOLUTION {
+		var ts StratuxTimestamp
+		ts.id = 0
+		ts.Time_type_preference = 0 // stratuxClock.
+		ts.StratuxClock_value = stratuxClock.Time
+		ts.GPSClock_value = time.Time{}
+		ts.PreferredTime_value = stratuxClock.Time
+
+		// Extrapolate from GPS timestamp, if possible.
+		if isGPSClockValid() && thisCurTimestamp > 0 {
+			// Was the last timestamp either extrapolated or GPS time?
+			last_ts := dataLogTimestamps[thisCurTimestamp]
+			if last_ts.Time_type_preference == 1 || last_ts.Time_type_preference == 2 {
+				// Extrapolate via stratuxClock.
+				timeSinceLastTS := ts.StratuxClock_value.Sub(last_ts.StratuxClock_value) // stratuxClock ticks since last timestamp.
+				extrapolatedGPSTimestamp := last_ts.PreferredTime_value.Add(timeSinceLastTS)
+
+				// Re-set the preferred timestamp type to '2' (extrapolated time).
+				ts.Time_type_preference = 2
+				ts.PreferredTime_value = extrapolatedGPSTimestamp
+				ts.GPSClock_value = extrapolatedGPSTimestamp
+			}
+		}
+
+		dataLogTimestamps = append(dataLogTimestamps, ts)
+		dataLogCurTimestamp = int64(len(dataLogTimestamps) - 1)
+		return false
+	}
+	return true
+}
+
+type SQLiteMarshal struct {
+	FieldType string
+	Marshal   func(v reflect.Value) string
+}
+
+func boolMarshal(v reflect.Value) string {
+	b := v.Bool()
+	if b {
+		return "1"
+	}
+	return "0"
+}
+
+func intMarshal(v reflect.Value) string {
+	return strconv.FormatInt(v.Int(), 10)
+}
+
+func uintMarshal(v reflect.Value) string {
+	return strconv.FormatUint(v.Uint(), 10)
+}
+
+func floatMarshal(v reflect.Value) string {
+	return strconv.FormatFloat(v.Float(), 'f', 10, 64)
+}
+
+func stringMarshal(v reflect.Value) string {
+	return v.String()
+}
+
+func notsupportedMarshal(v reflect.Value) string {
+	return ""
+}
+
+func structCanBeMarshalled(v reflect.Value) bool {
+	m := v.MethodByName("String")
+	if m.IsValid() && !m.IsNil() {
+		return true
+	}
+	return false
+}
+
+func structMarshal(v reflect.Value) string {
+	if structCanBeMarshalled(v) {
+		m := v.MethodByName("String")
+		in := make([]reflect.Value, 0)
+		ret := m.Call(in)
+		if len(ret) > 0 {
+			return ret[0].String()
+		}
+	}
+	return ""
+}
+
+var sqliteMarshalFunctions = map[string]SQLiteMarshal{
+	"bool":         {FieldType: "INTEGER", Marshal: boolMarshal},
+	"int":          {FieldType: "INTEGER", Marshal: intMarshal},
+	"uint":         {FieldType: "INTEGER", Marshal: uintMarshal},
+	"float":        {FieldType: "REAL", Marshal: floatMarshal},
+	"string":       {FieldType: "TEXT", Marshal: stringMarshal},
+	"struct":       {FieldType: "STRING", Marshal: structMarshal},
+	"notsupported": {FieldType: "notsupported", Marshal: notsupportedMarshal},
+}
+
+var sqlTypeMap = map[reflect.Kind]string{
+	reflect.Bool:          "bool",
+	reflect.Int:           "int",
+	reflect.Int8:          "int",
+	reflect.Int16:         "int",
+	reflect.Int32:         "int",
+	reflect.Int64:         "int",
+	reflect.Uint:          "uint",
+	reflect.Uint8:         "uint",
+	reflect.Uint16:        "uint",
+	reflect.Uint32:        "uint",
+	reflect.Uint64:        "uint",
+	reflect.Uintptr:       "notsupported",
+	reflect.Float32:       "float",
+	reflect.Float64:       "float",
+	reflect.Complex64:     "notsupported",
+	reflect.Complex128:    "notsupported",
+	reflect.Array:         "notsupported",
+	reflect.Chan:          "notsupported",
+	reflect.Func:          "notsupported",
+	reflect.Interface:     "notsupported",
+	reflect.Map:           "notsupported",
+	reflect.Ptr:           "notsupported",
+	reflect.Slice:         "notsupported",
+	reflect.String:        "string",
+	reflect.Struct:        "struct",
+	reflect.UnsafePointer: "notsupported",
+}
+
+func makeTable(i interface{}, tbl string, db *sql.DB) {
+	val := reflect.ValueOf(i)
+
+	fields := make([]string, 0)
+	for i := 0; i < val.NumField(); i++ {
+		kind := val.Field(i).Kind()
+		fieldName := val.Type().Field(i).Name
+		sqlTypeAlias := sqlTypeMap[kind]
+
+		// Check that if the field is a struct that it can be marshalled.
+		if sqlTypeAlias == "struct" && !structCanBeMarshalled(val.Field(i)) {
+			continue
+		}
+		if sqlTypeAlias == "notsupported" || fieldName == "id" {
+			continue
+		}
+		sqlType := sqliteMarshalFunctions[sqlTypeAlias].FieldType
+		s := fieldName + " " + sqlType
+		fields = append(fields, s)
+	}
+
+	// Add the timestamp_id field to link up with the timestamp table.
+	if tbl != "timestamp" && tbl != "startup" {
+		fields = append(fields, "timestamp_id INTEGER")
+	}
+
+	tblCreate := fmt.Sprintf("CREATE TABLE %s (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, %s)", tbl, strings.Join(fields, ", "))
+
+	_, err := db.Exec(tblCreate)
+	if err != nil {
+		fmt.Printf("ERROR: %s\n", err.Error())
+	}
+}
+
+/*
+	bulkInsert().
+		Reads insertBatch and insertBatchIfs. This is called after a group of insertData() calls.
+*/
+
+func bulkInsert(tbl string, db *sql.DB) (res sql.Result, err error) {
+	if _, ok := insertString[tbl]; !ok {
+		return nil, errors.New("no insert statement")
+	}
+
+	batchVals := insertBatchIfs[tbl]
+	numColsPerRow := len(batchVals[0])
+	maxRowBatch := int(999 / numColsPerRow) // SQLITE_MAX_VARIABLE_NUMBER = 999.
+	//	log.Printf("table %s. %d cols per row. max batch %d\n", tbl, numColsPerRow, maxRowBatch)
+	for len(batchVals) > 0 {
+		//     timeInit := time.Now()
+		i := int(0) // Variable number of rows per INSERT statement.
+
+		stmt := ""
+		vals := make([]interface{}, 0)
+		querySize := uint64(0)                                            // Size of the query in bytes.
+		for len(batchVals) > 0 && i < maxRowBatch && querySize < 750000 { // Maximum of 1,000,000 bytes per query.
+			if len(stmt) == 0 { // The first set will be covered by insertString.
+				stmt = insertString[tbl]
+				querySize += uint64(len(insertString[tbl]))
+			} else {
+				addStr := ", (" + strings.Join(strings.Split(strings.Repeat("?", len(batchVals[0])), ""), ",") + ")"
+				stmt += addStr
+				querySize += uint64(len(addStr))
+			}
+			for _, val := range batchVals[0] {
+				querySize += uint64(len(val.(string)))
+			}
+			vals = append(vals, batchVals[0]...)
+			batchVals = batchVals[1:]
+			i++
+		}
+		//		log.Printf("inserting %d rows to %s. querySize=%d\n", i, tbl, querySize)
+		res, err = db.Exec(stmt, vals...)
+		//      timeBatch := time.Since(timeInit)                                                                                                                     // debug
+		//      log.Printf("SQLite: bulkInserted %d rows to %s. Took %f msec to build and insert query. querySize=%d\n", i, tbl, 1000*timeBatch.Seconds(), querySize) // debug
+		if err != nil {
+			log.Printf("sqlite INSERT error: '%s'\n", err.Error())
+			return
+		}
+	}
+
+	// Clear the buffers.
+	delete(insertString, tbl)
+	delete(insertBatchIfs, tbl)
+
+	return
+}
+
+/*
+	insertData().
+		Inserts an arbitrary struct into an SQLite table.
+		 Inserts the timestamp first, if its 'id' is 0.
+
+*/
+
+// Cached 'VALUES' statements. Indexed by table name.
+var insertString map[string]string // INSERT INTO tbl (col1, col2, ...) VALUES(?, ?, ...). Only for one value.
+var insertBatchIfs map[string][][]interface{}
+
+func insertData(i interface{}, tbl string, db *sql.DB, ts_num int64) int64 {
+	val := reflect.ValueOf(i)
+
+	keys := make([]string, 0)
+	values := make([]string, 0)
+	for i := 0; i < val.NumField(); i++ {
+		kind := val.Field(i).Kind()
+		fieldName := val.Type().Field(i).Name
+		sqlTypeAlias := sqlTypeMap[kind]
+
+		if sqlTypeAlias == "notsupported" || fieldName == "id" {
+			continue
+		}
+
+		v := sqliteMarshalFunctions[sqlTypeAlias].Marshal(val.Field(i))
+
+		keys = append(keys, fieldName)
+		values = append(values, v)
+	}
+
+	// Add the timestamp_id field to link up with the timestamp table.
+	if tbl != "timestamp" && tbl != "startup" {
+		keys = append(keys, "timestamp_id")
+		if dataLogTimestamps[ts_num].id == 0 {
+			//FIXME: This is somewhat convoluted. When insertData() is called for a ts_num that corresponds to a timestamp with no database id,
+			// then it inserts that timestamp via the same interface and the id is updated in the structure via the below lines
+			// (dataLogTimestamps[ts_num].id = id).
+			dataLogTimestamps[ts_num].StartupID = stratuxStartupID
+			insertData(dataLogTimestamps[ts_num], "timestamp", db, ts_num) // Updates dataLogTimestamps[ts_num].id.
+		}
+		values = append(values, strconv.FormatInt(dataLogTimestamps[ts_num].id, 10))
+	}
+
+	if _, ok := insertString[tbl]; !ok {
+		// Prepare the statement.
+		tblInsert := fmt.Sprintf("INSERT INTO %s (%s) VALUES(%s)", tbl, strings.Join(keys, ","),
+			strings.Join(strings.Split(strings.Repeat("?", len(keys)), ""), ","))
+		insertString[tbl] = tblInsert
+	}
+
+	// Make the values slice into a slice of interface{}.
+	ifs := make([]interface{}, len(values))
+	for i := 0; i < len(values); i++ {
+		ifs[i] = values[i]
+	}
+
+	insertBatchIfs[tbl] = append(insertBatchIfs[tbl], ifs)
+
+	if tbl == "timestamp" || tbl == "startup" { // Immediate insert always for "timestamp" and "startup" table.
+		res, err := bulkInsert(tbl, db) // Bulk insert of 1, always.
+		if err == nil {
+			id, err := res.LastInsertId()
+			if err == nil && tbl == "timestamp" { // Special handling for timestamps. Update the timestamp ID.
+				ts := dataLogTimestamps[ts_num]
+				ts.id = id
+				dataLogTimestamps[ts_num] = ts
+			}
+			return id
+		}
+	}
+
+	return 0
+}
+
+type DataLogRow struct {
+	tbl    string
+	data   interface{}
+	ts_num int64
+}
+
+var dataLogChan chan DataLogRow
+var shutdownDataLog chan bool
+var shutdownDataLogWriter chan bool
+
+var dataLogWriteChan chan DataLogRow
+
+func dataLogWriter(db *sql.DB) {
+	dataLogWriteChan = make(chan DataLogRow, 10240)
+	shutdownDataLogWriter = make(chan bool)
+	// The write queue. As data comes in via dataLogChan, it is timestamped and stored.
+	//  When writeTicker comes up, the queue is emptied.
+	writeTicker := time.NewTicker(10 * time.Second)
+	rowsQueuedForWrite := make([]DataLogRow, 0)
+	for {
+		select {
+		case r := <-dataLogWriteChan:
+			// Accept timestamped row.
+			rowsQueuedForWrite = append(rowsQueuedForWrite, r)
+		case <-writeTicker.C:
+			//			for i := 0; i < 1000; i++ {
+			//				logSituation()
+			//			}
+			timeStart := stratuxClock.Time
+			nRows := len(rowsQueuedForWrite)
+			if globalSettings.DEBUG {
+				log.Printf("Writing %d rows\n", nRows)
+			}
+			// Write the buffered rows. This will block while it is writing.
+			// Save the names of the tables affected so that we can run bulkInsert() on after the insertData() calls.
+			tblsAffected := make(map[string]bool)
+			// Start transaction.
+			tx, err := db.Begin()
+			if err != nil {
+				log.Printf("db.Begin() error: %s\n", err.Error())
+				break // from select {}
+			}
+			for _, r := range rowsQueuedForWrite {
+				tblsAffected[r.tbl] = true
+				insertData(r.data, r.tbl, db, r.ts_num)
+			}
+			// Do the bulk inserts.
+			for tbl, _ := range tblsAffected {
+				bulkInsert(tbl, db)
+			}
+			// Close the transaction.
+			tx.Commit()
+			rowsQueuedForWrite = make([]DataLogRow, 0) // Zero the queue.
+			timeElapsed := stratuxClock.Since(timeStart)
+			if globalSettings.DEBUG {
+				rowsPerSecond := float64(nRows) / float64(timeElapsed.Seconds())
+				log.Printf("Writing finished. %d rows in %.2f seconds (%.1f rows per second).\n", nRows, float64(timeElapsed.Seconds()), rowsPerSecond)
+			}
+			if timeElapsed.Seconds() > 10.0 {
+				log.Printf("WARNING! SQLite logging is behind. Last write took %.1f seconds.\n", float64(timeElapsed.Seconds()))
+				dataLogCriticalErr := fmt.Errorf("WARNING! SQLite logging is behind. Last write took %.1f seconds.\n", float64(timeElapsed.Seconds()))
+				addSystemError(dataLogCriticalErr)
+			}
+		case <-shutdownDataLogWriter: // Received a message on the channel to initiate a graceful shutdown, and to command dataLog() to shut down
+			log.Printf("datalog.go: dataLogWriter() received shutdown message with rowsQueuedForWrite = %d\n", len(rowsQueuedForWrite))
+			shutdownDataLog <- true
+			return
+		}
+	}
+	log.Printf("datalog.go: dataLogWriter() shutting down\n")
+}
+
+func dataLog() {
+	dataLogStarted = true
+	log.Printf("datalog.go: dataLog() started\n")
+	dataLogChan = make(chan DataLogRow, 10240)
+	shutdownDataLog = make(chan bool)
+	dataLogTimestamps = make([]StratuxTimestamp, 0)
+	var ts StratuxTimestamp
+	ts.id = 0
+	ts.Time_type_preference = 0 // stratuxClock.
+	ts.StratuxClock_value = stratuxClock.Time
+	ts.GPSClock_value = time.Time{}
+	ts.PreferredTime_value = stratuxClock.Time
+	dataLogTimestamps = append(dataLogTimestamps, ts)
+	dataLogCurTimestamp = 0
+
+	// Check if we need to create a new database.
+	createDatabase := false
+
+	if _, err := os.Stat(dataLogFilef); os.IsNotExist(err) {
+		createDatabase = true
+		log.Printf("creating new database '%s'.\n", dataLogFilef)
+	}
+
+	db, err := sql.Open("sqlite3", dataLogFilef)
+	if err != nil {
+		log.Printf("sql.Open(): %s\n", err.Error())
+	}
+
+	defer func() {
+		db.Close()
+		dataLogStarted = false
+		//close(dataLogChan)
+		log.Printf("datalog.go: dataLog() has closed DB in %s\n", dataLogFilef)
+	}()
+
+	_, err = db.Exec("PRAGMA journal_mode=WAL")
+	if err != nil {
+		log.Printf("db.Exec('PRAGMA journal_mode=WAL') err: %s\n", err.Error())
+	}
+	_, err = db.Exec("PRAGMA synchronous=OFF")
+	if err != nil {
+		log.Printf("db.Exec('PRAGMA journal_mode=WAL') err: %s\n", err.Error())
+	}
+
+	//log.Printf("Starting dataLogWriter\n") // REMOVE -- DEBUG
+	go dataLogWriter(db)
+
+	// Do we need to create the database?
+	if createDatabase {
+		makeTable(StratuxTimestamp{}, "timestamp", db)
+		makeTable(mySituation, "mySituation", db)
+		makeTable(globalStatus, "status", db)
+		makeTable(globalSettings, "settings", db)
+		makeTable(TrafficInfo{}, "traffic", db)
+		makeTable(msg{}, "messages", db)
+		makeTable(esmsg{}, "es_messages", db)
+		makeTable(Dump1090TermMessage{}, "dump1090_terminal", db)
+		makeTable(gpsPerfStats{}, "gps_attitude", db)
+		makeTable(StratuxStartup{}, "startup", db)
+	}
+
+	// The first entry to be created is the "startup" entry.
+	stratuxStartupID = insertData(StratuxStartup{}, "startup", db, 0)
+
+	dataLogReadyToWrite = true
+	//log.Printf("Entering dataLog read loop\n") //REMOVE -- DEBUG
+	for {
+		select {
+		case r := <-dataLogChan:
+			// When data is input, the first step is to timestamp it.
+			// Check if our time bucket has expired or has never been entered.
+			checkTimestamp()
+			// Mark the row with the current timestamp ID, in case it gets entered later.
+			r.ts_num = dataLogCurTimestamp
+			// Queue it for the scheduled write.
+			dataLogWriteChan <- r
+		case <-shutdownDataLog: // Received a message on the channel to complete a graceful shutdown (see the 'defer func()...' statement above).
+			log.Printf("datalog.go: dataLog() received shutdown message\n")
+			return
+		}
+	}
+	log.Printf("datalog.go: dataLog() shutting down\n")
+	close(shutdownDataLog)
+}
+
+/*
+	setDataLogTimeWithGPS().
+		Create a timestamp entry using GPS time.
+*/
+
+func setDataLogTimeWithGPS(sit SituationData) {
+	if isGPSClockValid() {
+		var ts StratuxTimestamp
+		// Piggyback a GPS time update from this update.
+		ts.id = 0
+		ts.Time_type_preference = 1 // gpsClock.
+		ts.StratuxClock_value = stratuxClock.Time
+		ts.GPSClock_value = sit.GPSTime
+		ts.PreferredTime_value = sit.GPSTime
+
+		dataLogTimestamps = append(dataLogTimestamps, ts)
+		dataLogCurTimestamp = int64(len(dataLogTimestamps) - 1)
+	}
+}
+
+/*
+	logSituation(), logStatus(), ... pass messages from other functions to the logging
+		engine. These are only read into `dataLogChan` if the Replay Log is toggled on,
+		and if the log system is ready to accept writes.
+*/
+
+func isDataLogReady() bool {
+	return dataLogReadyToWrite
+}
+
+func logSituation() {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "mySituation", data: mySituation}
+	}
+}
+
+func logStatus() {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "status", data: globalStatus}
+	}
+}
+
+func logSettings() {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "settings", data: globalSettings}
+	}
+}
+
+func logTraffic(ti TrafficInfo) {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "traffic", data: ti}
+	}
+}
+
+func logMsg(m msg) {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "messages", data: m}
+	}
+}
+
+func logESMsg(m esmsg) {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "es_messages", data: m}
+	}
+}
+
+func logGPSAttitude(gpsPerf gpsPerfStats) {
+	if globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "gps_attitude", data: gpsPerf}
+	}
+}
+
+func logDump1090TermMessage(m Dump1090TermMessage) {
+	if globalSettings.DEBUG && globalSettings.ReplayLog && isDataLogReady() {
+		dataLogChan <- DataLogRow{tbl: "dump1090_terminal", data: m}
+	}
+}
+
+func initDataLog() {
+	//log.Printf("dataLogStarted = %t. dataLogReadyToWrite = %t\n", dataLogStarted, dataLogReadyToWrite) //REMOVE -- DEBUG
+	insertString = make(map[string]string)
+	insertBatchIfs = make(map[string][][]interface{})
+	go dataLogWatchdog()
+
+	//log.Printf("datalog.go: initDataLog() complete.\n") //REMOVE -- DEBUG
+}
+
+/*
+	dataLogWatchdog(): Watchdog function to control startup / shutdown of data logging subsystem.
+		Called by initDataLog as a goroutine. It iterates once per second to determine if
+		globalSettings.ReplayLog has toggled. If logging was switched from off to on, it starts
+		datalog() as a goroutine. If the log is running and we want it to stop, it calls
+		closeDataLog() to turn off the input channels, close the log, and tear down the dataLog
+		and dataLogWriter goroutines.
+*/
+
+func dataLogWatchdog() {
+	for {
+		if !dataLogStarted && globalSettings.ReplayLog { // case 1: sqlite logging isn't running, and we want to start it
+			log.Printf("datalog.go: Watchdog wants to START logging.\n")
+			go dataLog()
+		} else if dataLogStarted && !globalSettings.ReplayLog { // case 2:  sqlite logging is running, and we want to shut it down
+			log.Printf("datalog.go: Watchdog wants to STOP logging.\n")
+			closeDataLog()
+		}
+		//log.Printf("Watchdog iterated.\n") //REMOVE -- DEBUG
+		time.Sleep(1 * time.Second)
+		//log.Printf("Watchdog sleep over.\n") //REMOVE -- DEBUG
+	}
+}
+
+/*
+	closeDataLog(): Handler for graceful shutdown of data logging goroutines. It is called by
+		by dataLogWatchdog(), gracefulShutdown(), and by any other function (disk space monitor?)
+		that needs to be able to shut down sqlite logging without corrupting data or blocking
+		execution.
+
+		This function turns off log message reads into the dataLogChan receiver, and sends a
+		message to a quit channel ('shutdownDataLogWriter`) in dataLogWriter(). dataLogWriter()
+		then sends a message to a quit channel to 'shutdownDataLog` in dataLog() to close *that*
+		goroutine. That function sets dataLogStarted=false once the logfile is closed. By waiting
+		for that signal, closeDataLog() won't exit until the log is safely written. This prevents
+		data loss on shutdown.
+*/
+
+func closeDataLog() {
+	//log.Printf("closeDataLog(): dataLogStarted = %t\n", dataLogStarted) //REMOVE -- DEBUG
+	dataLogReadyToWrite = false // prevent any new messages from being sent down the channels
+	log.Printf("datalog.go: Starting data log shutdown\n")
+	shutdownDataLogWriter <- true      //
+	defer close(shutdownDataLogWriter) // ... and close the channel so subsequent accidental writes don't stall execution
+	log.Printf("datalog.go: Waiting for shutdown signal from dataLog()")
+	for dataLogStarted {
+		//log.Printf("closeDataLog(): dataLogStarted = %t\n", dataLogStarted) //REMOVE -- DEBUG
+		time.Sleep(50 * time.Millisecond)
+	}
+	log.Printf("datalog.go: Data log shutdown successful.\n")
+}

main/equations.go

@@ -0,0 +1,355 @@
+/*
+	Copyright (c) 2016 AvSquirrel (https://github.com/AvSquirrel)
+	Distributable under the terms of the "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	equations.go: Math and statistics library used to support AHRS
+         and other fuctions of Stratux package
+*/
+
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+// linReg calculates slope and intercept for a least squares linear regression of y[] vs x[]
+// Returns error if fewer than two data points in each series, or if series lengths are different
+
+func linReg(x, y []float64) (slope, intercept float64, valid bool) {
+
+	n := len(x)
+	nf := float64(n)
+
+	if n != len(y) {
+		fmt.Printf("linReg: Lengths not equal\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	if n < 2 {
+		fmt.Printf("linReg: Lengths too short\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	var Sx, Sy, Sxx, Sxy, Syy float64
+
+	for i := range x {
+		Sx += x[i]
+		Sy += y[i]
+		Sxx += x[i] * x[i]
+		Sxy += x[i] * y[i]
+		Syy += y[i] * y[i]
+	}
+
+	if nf*Sxx == Sx*Sx {
+		fmt.Printf("linReg: Infinite slope\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	// Calculate slope and intercept
+	slope = (nf*Sxy - Sx*Sy) / (nf*Sxx - Sx*Sx)
+	intercept = Sy/nf - slope*Sx/nf
+	valid = true
+	return
+}
+
+// linRegWeighted calculates slope and intercept for a weighted least squares
+// linear regression of y[] vs x[], given weights w[] for each point.
+// Returns error if fewer than two data points in each series, if series lengths are different,
+// if weights sum to zero, or if slope is infinite
+
+func linRegWeighted(x, y, w []float64) (slope, intercept float64, valid bool) {
+
+	n := len(x)
+
+	if n != len(y) || n != len(w) {
+		fmt.Printf("linRegWeighted: Lengths not equal\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	if n < 2 {
+		fmt.Printf("linRegWeighted: Lengths too short\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	//var Sx, Sy, Sxx, Sxy, Syy float64
+	var Sw, Swx, Swy, Swxx, Swxy, Swyy float64
+
+	for i := range x {
+		Sw += w[i]
+		Swxy += w[i] * x[i] * y[i]
+		Swx += w[i] * x[i]
+		Swy += w[i] * y[i]
+		Swxx += w[i] * x[i] * x[i]
+		Swyy += w[i] * y[i] * y[i]
+		/*
+			Sx += x[i]
+			Sy += y[i]
+			Sxx += x[i]*x[i]
+			Sxy += x[i]*y[i]
+			Syy += y[i]*y[i]
+		*/
+	}
+
+	if Sw == 0 {
+		fmt.Printf("linRegWeighted: Sum of weights is zero\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	if Sw*Swxx == Swx*Swx {
+		fmt.Printf("linRegWeighted: Infinite slope\n")
+		return math.NaN(), math.NaN(), false
+	}
+
+	// Calculate slope and intercept
+	slope = (Sw*Swxy - Swx*Swy) / (Sw*Swxx - Swx*Swx)
+	intercept = Swy/Sw - slope*Swx/Sw
+	valid = true
+	return
+}
+
+// triCubeWeight returns the value of the tricube weight function
+// at point x, for the given center and halfwidth.
+func triCubeWeight(center, halfwidth, x float64) float64 {
+	var weight, x_t float64
+	x_t = math.Abs((x - center) / halfwidth)
+	if x_t < 1 {
+		weight = math.Pow((1 - math.Pow(x_t, 3)), 3)
+	} else {
+		weight = 0
+	}
+	return weight
+}
+
+// arrayMin calculates the minimum value in array x
+func arrayMin(x []float64) (float64, bool) {
+	if len(x) < 1 {
+		fmt.Printf("arrayMin: Length too short\n")
+		return math.NaN(), false
+	}
+
+	min := x[0]
+	for i := range x {
+		if x[i] < min {
+			min = x[i]
+		}
+	}
+	return min, true
+}
+
+// arrayMax calculates the maximum value in array x
+func arrayMax(x []float64) (float64, bool) {
+	if len(x) < 1 {
+		fmt.Printf("arrayMax: Length too short\n")
+		return math.NaN(), false
+	}
+
+	max := x[0]
+	for i := range x {
+		if x[i] > max {
+			max = x[i]
+		}
+	}
+	return max, true
+}
+
+// arrayRange calculates the range of values in array x
+func arrayRange(x []float64) (float64, bool) {
+	max, err1 := arrayMax(x)
+	min, err2 := arrayMin(x)
+
+	if !err1 || !err2 {
+		fmt.Printf("Error calculating range\n")
+		return math.NaN(), false
+	}
+
+	return (max - min), true
+}
+
+// mean returns the arithmetic mean of array x
+func mean(x []float64) (float64, bool) {
+	if len(x) < 1 {
+		fmt.Printf("mean: Length too short\n")
+		return math.NaN(), false
+	}
+
+	sum := 0.0
+	nf := float64(len(x))
+
+	for i := range x {
+		sum += x[i]
+	}
+
+	return sum / nf, true
+}
+
+// stdev estimates the sample standard deviation of array x
+func stdev(x []float64) (float64, bool) {
+	if len(x) < 2 {
+		fmt.Printf("stdev: Length too short\n")
+		return math.NaN(), false
+	}
+
+	nf := float64(len(x))
+	xbar, xbarValid := mean(x)
+
+	if !xbarValid {
+		fmt.Printf("stdev: Error calculating xbar\n")
+		return math.NaN(), false
+	}
+
+	sumsq := 0.0
+
+	for i := range x {
+		sumsq += (x[i] - xbar) * (x[i] - xbar)
+	}
+
+	return math.Pow(sumsq/(nf-1), 0.5), true
+}
+
+// radians converts angle from degrees, and returns its value in radians
+func radians(angle float64) float64 {
+	return angle * math.Pi / 180.0
+}
+
+// degrees converts angle from radians, and returns its value in degrees
+func degrees(angle float64) float64 {
+	return angle * 180.0 / math.Pi
+}
+
+// radiansRel converts angle from degrees, and returns its value in radians in the range -Pi to + Pi
+func radiansRel(angle float64) float64 {
+	for angle > 180 {
+		angle -= 360
+	}
+	for angle < -180 {
+		angle += 360
+	}
+	return angle * math.Pi / 180.0
+}
+
+// degreesRel converts angle from radians, and returns its value in the range of -180 to +180 degrees
+func degreesRel(angle float64) float64 {
+	for angle > math.Pi {
+		angle -= 2 * math.Pi
+	}
+	for angle < -math.Pi {
+		angle += 2 * math.Pi
+	}
+	return angle * 180.0 / math.Pi
+}
+
+// degreesHdg converts angle from radians, and returns its value in the range of 0+ to 360 degrees
+func degreesHdg(angle float64) float64 {
+	for angle < 0 {
+		angle += 2 * math.Pi
+	}
+	return angle * 180.0 / math.Pi
+}
+
+// roundToInt16 cheaply rounds a float64 to an int16, rather than truncating
+func roundToInt16(in float64) (out int16) {
+	if in >= 0 {
+		out = int16(in + 0.5)
+	} else {
+		out = int16(in - 0.5)
+	}
+	return
+}
+
+/*
+Distance functions based on rectangular coordinate systems
+Simple calculations and "good enough" on small scale (± 1° of lat / lon)
+suitable for relative distance to nearby traffic
+*/
+
+// distRect returns distance and bearing to target #2 (e.g. traffic) from target #1 (e.g. ownship)
+// Inputs are lat / lon of both points in decimal degrees
+// Outputs are distance in meters and bearing in degrees (0° = north, 90° = east)
+// Secondary outputs are north and east components of distance in meters (north, east positive)
+
+func distRect(lat1, lon1, lat2, lon2 float64) (dist, bearing, distN, distE float64) {
+	radius_earth := 6371008.8 // meters; mean radius
+	dLat := radiansRel(lat2 - lat1)
+	avgLat := radiansRel((lat2 + lat1) / 2)
+	dLon := radiansRel(lon2 - lon1)
+	distN = dLat * radius_earth
+	distE = dLon * radius_earth * math.Abs(math.Cos(avgLat))
+	dist = math.Pow(distN*distN+distE*distE, 0.5)
+	bearing = math.Atan2(distE, distN)
+	bearing = degreesHdg(bearing)
+	return
+}
+
+// distRectNorth returns north-south distance from point 1 to point 2.
+// Inputs are lat in decimal degrees. Output is distance in meters (east positive)
+func distRectNorth(lat1, lat2 float64) float64 {
+	var dist float64
+	radius_earth := 6371008.8 // meters; mean radius
+	dLat := radiansRel(lat2 - lat1)
+	dist = dLat * radius_earth
+	return dist
+}
+
+// distRectEast returns east-west distance from point 1 to point 2.
+// Inputs are lat/lon in decimal degrees. Output is distance in meters (north positive)
+func distRectEast(lat1, lon1, lat2, lon2 float64) float64 {
+	var dist float64
+	radius_earth := 6371008.8 // meters; mean radius
+	//dLat := radiansRel(lat2 - lat1) // unused
+	avgLat := radiansRel((lat2 + lat1) / 2)
+	dLon := radiansRel(lon2 - lon1)
+	dist = dLon * radius_earth * math.Abs(math.Cos(avgLat))
+	return dist
+}
+
+/*
+Distance functions: Polar coordinate systems
+More accurate over longer distances
+*/
+
+// distance calculates distance between two points using the law of cosines.
+// Inputs are lat / lon of both points in decimal degrees
+// Outputs are distance in meters and bearing to the target from origin in degrees (0° = north, 90° = east)
+func distance(lat1, lon1, lat2, lon2 float64) (dist, bearing float64) {
+	radius_earth := 6371008.8 // meters; mean radius
+
+	lat1 = radians(lat1)
+	lon1 = radians(lon1)
+	lat2 = radians(lat2)
+	lon2 = radians(lon2)
+
+	dist = math.Acos(math.Sin(lat1)*math.Sin(lat2)+math.Cos(lat1)*math.Cos(lat2)*math.Cos(lon2-lon1)) * radius_earth
+
+	var x, y float64
+
+	x = math.Cos(lat1)*math.Sin(lat2) - math.Sin(lat1)*math.Cos(lat2)*math.Cos(lon2-lon1)
+	y = math.Sin(lon2-lon1) * math.Cos(lat2)
+
+	bearing = degreesHdg(math.Atan2(y, x))
+
+	return
+}
+
+// CalcAltitude determines the pressure altitude (feet) from the atmospheric pressure (hPa)
+func CalcAltitude(press float64) (altitude float64) {
+	altitude = 145366.45 * (1.0 - math.Pow(press/1013.25, 0.190284))
+	return
+}
+
+// golang only defines min/max for float64. Really.
+func iMin(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func iMax(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}

main/fancontrol.go

@@ -0,0 +1,241 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/takama/daemon"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+// #include <wiringPi.h>
+// #cgo LDFLAGS: -lwiringPi
+import "C"
+
+// Initialize Prometheus metrics.
+var (
+	currentTemp = prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "current_temp",
+		Help: "Current CPU temp.",
+	})
+
+	totalFanOnTime = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "total_fan_on_time",
+			Help: "Total fan run time.",
+		},
+		[]string{"all"},
+	)
+
+	totalUptime = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "total_uptime",
+			Help: "Total uptime.",
+		},
+		[]string{"all"},
+	)
+)
+
+const (
+	// CPU temperature target, degrees C
+	defaultTempTarget = 50.
+	hysteresis        = float32(1.)
+
+	pwmClockDivisor = 100
+
+	/* Minimum duty cycle is the point below which the fan does
+	/* not spin. This depends on both your fan and the switching
+	/* transistor used. */
+	defaultPwmDutyMin = 1
+	pwmDutyMax        = 10
+
+	// Temperature at which we give up attempting active fan speed control and set it to full speed.
+	failsafeTemp = 65
+
+	// how often to update
+	delaySeconds = 30
+
+	// GPIO-1/BCM "18"/Pin 12 on a Raspberry Pi 3
+	defaultPin = 1
+
+	// name of the service
+	name        = "fancontrol"
+	description = "cooling fan speed control based on CPU temperature"
+
+	// Address on which daemon should be listen.
+	addr = ":9977"
+)
+
+type FanControl struct {
+	TempTarget     float32
+	TempCurrent    float32
+	PWMDutyMin     int
+	PWMDutyMax     int
+	PWMDutyCurrent int
+	PWMPin         int
+}
+
+var myFanControl FanControl
+
+var stdlog, errlog *log.Logger
+
+func updateStats() {
+	updateTicker := time.NewTicker(1 * time.Second)
+	for {
+		<-updateTicker.C
+		totalUptime.With(prometheus.Labels{"all": "all"}).Inc()
+		currentTemp.Set(float64(myFanControl.TempCurrent))
+		if myFanControl.PWMDutyCurrent > 0 {
+			totalFanOnTime.With(prometheus.Labels{"all": "all"}).Inc()
+		}
+	}
+}
+
+func fanControl() {
+	prometheus.MustRegister(currentTemp)
+	prometheus.MustRegister(totalFanOnTime)
+	prometheus.MustRegister(totalUptime)
+
+	go updateStats()
+
+	cPin := C.int(myFanControl.PWMPin)
+
+	C.wiringPiSetup()
+
+	// Power on "test". Allows the user to verify that their fan is working.
+	C.pinMode(cPin, C.OUTPUT)
+	C.digitalWrite(cPin, C.HIGH)
+	time.Sleep(5 * time.Second)
+	C.digitalWrite(cPin, C.LOW)
+
+	C.pwmSetMode(C.PWM_MODE_MS)
+	C.pinMode(cPin, C.PWM_OUTPUT)
+	C.pwmSetRange(C.uint(myFanControl.PWMDutyMax))
+	C.pwmSetClock(pwmClockDivisor)
+	C.pwmWrite(cPin, C.int(myFanControl.PWMDutyMin))
+	myFanControl.TempCurrent = 0
+	go cpuTempMonitor(func(cpuTemp float32) {
+		if isCPUTempValid(cpuTemp) {
+			myFanControl.TempCurrent = cpuTemp
+		}
+	})
+
+	myFanControl.PWMDutyCurrent = 0
+
+	delay := time.NewTicker(delaySeconds * time.Second)
+
+	for {
+		if myFanControl.TempCurrent > (myFanControl.TempTarget + hysteresis) {
+			myFanControl.PWMDutyCurrent = iMax(iMin(myFanControl.PWMDutyMax, myFanControl.PWMDutyCurrent+1), myFanControl.PWMDutyMin)
+		} else if myFanControl.TempCurrent < (myFanControl.TempTarget - hysteresis) {
+			myFanControl.PWMDutyCurrent = iMax(myFanControl.PWMDutyCurrent-1, 0)
+			if myFanControl.PWMDutyCurrent < myFanControl.PWMDutyMin {
+				myFanControl.PWMDutyCurrent = 0
+			}
+		}
+		//log.Println(myFanControl.TempCurrent, " ", myFanControl.PWMDutyCurrent)
+		C.pwmWrite(cPin, C.int(myFanControl.PWMDutyCurrent))
+		<-delay.C
+		if myFanControl.PWMDutyCurrent == myFanControl.PWMDutyMax && myFanControl.TempCurrent >= failsafeTemp {
+			// Reached the maximum temperature. We stop using PWM control and set the fan to "on" permanently.
+			break
+		}
+	}
+
+	// Default to "ON".
+	C.pinMode(cPin, C.OUTPUT)
+	C.digitalWrite(cPin, C.HIGH)
+}
+
+// Service has embedded daemon
+type Service struct {
+	daemon.Daemon
+}
+
+// Manage by daemon commands or run the daemon
+func (service *Service) Manage() (string, error) {
+
+	tempTarget := flag.Float64("temp", defaultTempTarget, "Target CPU Temperature, degrees C")
+	pwmDutyMin := flag.Int("minduty", defaultPwmDutyMin, "Minimum PWM duty cycle")
+	pin := flag.Int("pin", defaultPin, "PWM pin (wiringPi numbering)")
+	flag.Parse()
+
+	usage := "Usage: " + name + " install | remove | start | stop | status"
+	// if received any kind of command, do it
+	if flag.NArg() > 0 {
+		command := os.Args[flag.NFlag()+1]
+		switch command {
+		case "install":
+			return service.Install()
+		case "remove":
+			return service.Remove()
+		case "start":
+			return service.Start()
+		case "stop":
+			return service.Stop()
+		case "status":
+			return service.Status()
+		default:
+			return usage, nil
+		}
+	}
+
+	myFanControl.TempTarget = float32(*tempTarget)
+	myFanControl.PWMDutyMin = *pwmDutyMin
+	myFanControl.PWMDutyMax = pwmDutyMax
+	myFanControl.PWMPin = *pin
+
+	go fanControl()
+
+	// Set up channel on which to send signal notifications.
+	// We must use a buffered channel or risk missing the signal
+	// if we're not ready to receive when the signal is sent.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)
+
+	http.HandleFunc("/", handleStatusRequest)
+	http.Handle("/metrics", promhttp.Handler())
+	http.ListenAndServe(addr, nil)
+
+	// interrupt by system signal
+	for {
+		killSignal := <-interrupt
+		stdlog.Println("Got signal:", killSignal)
+		if killSignal == os.Interrupt {
+			return "Daemon was interrupted by system signal", nil
+		}
+		return "Daemon was killed", nil
+	}
+}
+
+func handleStatusRequest(w http.ResponseWriter, r *http.Request) {
+	statusJSON, _ := json.Marshal(&myFanControl)
+	w.Write(statusJSON)
+}
+
+func init() {
+	stdlog = log.New(os.Stdout, "", 0)
+	errlog = log.New(os.Stderr, "", 0)
+}
+
+func main() {
+	srv, err := daemon.New(name, description, []string{}...)
+	if err != nil {
+		errlog.Println("Error: ", err)
+		os.Exit(1)
+	}
+	service := &Service{srv}
+	status, err := service.Manage()
+	if err != nil {
+		errlog.Println(status, "\nError: ", err)
+		os.Exit(1)
+	}
+	fmt.Println(status)
+}

main/lowpower_uat.go

@@ -0,0 +1,155 @@
+package main
+
+import (
+	"encoding/hex"
+	"fmt"
+	"github.com/stratux/serial"
+	"log"
+	"os"
+	"time"
+	"unsafe"
+)
+
+/*
+
+#cgo LDFLAGS: -ldump978 -lm
+
+#include <stdint.h>
+#include "../dump978/fec.h"
+
+*/
+import "C"
+
+var radioSerialConfig *serial.Config
+var radioSerialPort *serial.Port
+
+func initUATRadioSerial() error {
+	// Init for FEC routines.
+	C.init_fec()
+	go func() {
+		watchTicker := time.NewTicker(1 * time.Second)
+		for {
+			<-watchTicker.C
+			// Watch for the radio or change in settings.
+			if !globalSettings.UAT_Enabled || globalStatus.UATRadio_connected {
+				// UAT not enabled or radio already set up. Continue.
+				continue
+			}
+			if _, err := os.Stat("/dev/uatradio"); err != nil {
+				// Device not connected.
+				continue
+			}
+			log.Printf("===== UAT Device Name  : UATRadio v1.0 =====\n")
+
+			// Initialize port at 2Mbaud.
+			radioSerialConfig = &serial.Config{Name: "/dev/uatradio", Baud: 2000000}
+			p, err := serial.OpenPort(radioSerialConfig)
+			if err != nil {
+				log.Printf("\tUAT Open Failed: %s\n", err.Error())
+				continue
+			}
+
+			log.Printf("\tUATRadio init success.\n")
+
+			radioSerialPort = p
+			globalStatus.UATRadio_connected = true
+
+			// Start a goroutine to watch the serial port.
+			go radioSerialPortReader(radioSerialPort)
+		}
+	}()
+	return nil
+}
+
+/*
+	radioSerialPortReader().
+	 Loop to read data from the radio serial port.
+*/
+var radioMagic = []byte{0x0a, 0xb0, 0xcd, 0xe0}
+
+func radioSerialPortReader(serialPort *serial.Port) {
+	defer func() {
+		globalStatus.UATRadio_connected = false
+		serialPort.Close()
+	}()
+	tmpBuf := make([]byte, 1024) // Read buffer.
+	var buf []byte               // Message buffer.
+	for {
+		n, err := serialPort.Read(tmpBuf)
+		if err != nil {
+			log.Printf("serial port err, shutting down radio: %s\n", err.Error())
+			return
+		}
+		buf = append(buf, tmpBuf[:n]...)
+		bufLen := len(buf)
+		var finBuf []byte   // Truncated buffer, with processed messages extracted.
+		var numMessages int // Number of messages extracted.
+		// Search for a suitable message to extract.
+		for i := 0; i < bufLen-6; i++ {
+			if (buf[i] == radioMagic[0]) && (buf[i+1] == radioMagic[1]) && (buf[i+2] == radioMagic[2]) && (buf[i+3] == radioMagic[3]) {
+				// Found the magic sequence. Get the length.
+				msgLen := int(uint16(buf[i+4])+(uint16(buf[i+5])<<8)) + 5 // 5 bytes for RSSI and TS.
+				// Check if we've read enough to finish this message.
+				if bufLen < i+6+msgLen {
+					break // Wait for more of the message to come in.
+				}
+				// Message is long enough.
+				processRadioMessage(buf[i+6 : i+6+msgLen])
+				// Remove everything in the buffer before this message.
+				finBuf = buf[i+6+msgLen:]
+				numMessages++
+			}
+		}
+		if numMessages > 0 {
+			buf = finBuf
+		}
+	}
+}
+
+/*
+	processRadioMessage().
+	 Processes a single message from the radio. De-interleaves (when necessary), checks Reed-Solomon, passes to main process.
+*/
+
+func processRadioMessage(msg []byte) {
+	// RSSI and message timestamp are prepended to the actual packet.
+
+	// RSSI
+	rssiRaw := int8(msg[0])
+	//rssiAdjusted := int16(rssiRaw) - 132 // -132 dBm, calculated minimum RSSI.
+	//rssiDump978 := int16(1000 * (10 ^ (float64(rssiAdjusted) / 20)))
+	rssiDump978 := rssiRaw
+
+	//_ := uint32(msg[1]) + (uint32(msg[2]) << 8) + (uint32(msg[3]) << 16) + (uint32(msg[4]) << 24) // Timestamp. Currently unused.
+
+	msg = msg[5:]
+
+	var toRelay string
+	var rs_errors int
+	switch len(msg) {
+	case 552:
+		to := make([]byte, 552)
+		C.correct_uplink_frame((*C.uint8_t)(unsafe.Pointer(&msg[0])), (*C.uint8_t)(unsafe.Pointer(&to[0])), (*C.int)(unsafe.Pointer(&rs_errors)))
+		toRelay = fmt.Sprintf("+%s;ss=%d;", hex.EncodeToString(to[:432]), rssiDump978)
+	case 48:
+		to := make([]byte, 48)
+		copy(to, msg)
+		i := int(C.correct_adsb_frame((*C.uint8_t)(unsafe.Pointer(&to[0])), (*C.int)(unsafe.Pointer(&rs_errors))))
+		if i == 1 {
+			// Short ADS-B frame.
+			toRelay = fmt.Sprintf("-%s;ss=%d;", hex.EncodeToString(to[:18]), rssiDump978)
+		} else if i == 2 {
+			// Long ADS-B frame.
+			toRelay = fmt.Sprintf("-%s;ss=%d;", hex.EncodeToString(to[:34]), rssiDump978)
+		}
+	default:
+		log.Printf("processRadioMessage(): unhandled message size %d\n", len(msg))
+	}
+
+	if len(toRelay) > 0 && rs_errors != 9999 {
+		o, msgtype := parseInput(toRelay)
+		if o != nil && msgtype != 0 {
+			relayMessage(msgtype, o)
+		}
+	}
+}

main/managementinterface.go

@@ -1,11 +1,32 @@
+/*
+	Copyright (c) 2015-2016 Christopher Young
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	managementinterface.go: Web interfaces (JSON and websocket), web server for web interface HTML.
+*/
+
 package main
 
 import (
+	"archive/zip"
+	"encoding/hex"
 	"encoding/json"
+	"fmt"
+	humanize "github.com/dustin/go-humanize"
 	"golang.org/x/net/websocket"
 	"io"
+	"io/ioutil"
 	"log"
 	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"syscall"
+	"text/template"
 	"time"
 )
 
@@ -14,68 +35,832 @@ type SettingMessage struct {
 	Value   bool   `json:"state"`
 }
 
-type InfoMessage struct {
-	*status
-	*settings
+// Weather updates channel.
+var weatherUpdate *uibroadcaster
+var trafficUpdate *uibroadcaster
+var gdl90Update *uibroadcaster
+
+func handleGDL90WS(conn *websocket.Conn) {
+	// Subscribe the socket to receive updates.
+	gdl90Update.AddSocket(conn)
+
+	// Connection closes when function returns. Since uibroadcast is writing and we don't need to read anything (for now), just keep it busy.
+	for {
+		buf := make([]byte, 1024)
+		_, err := conn.Read(buf)
+		if err != nil {
+			break
+		}
+		if buf[0] != 0 { // Dummy.
+			continue
+		}
+		time.Sleep(1 * time.Second)
+	}
 }
 
-func statusSender(conn *websocket.Conn) {
+// Situation updates channel.
+var situationUpdate *uibroadcaster
+
+// Raw weather (UATFrame packet stream) update channel.
+var weatherRawUpdate *uibroadcaster
+
+/*
+	The /weather websocket starts off by sending the current buffer of weather messages, then sends updates as they are received.
+*/
+func handleWeatherWS(conn *websocket.Conn) {
+	// Subscribe the socket to receive updates.
+	weatherUpdate.AddSocket(conn)
+
+	// Connection closes when function returns. Since uibroadcast is writing and we don't need to read anything (for now), just keep it busy.
+	for {
+		buf := make([]byte, 1024)
+		_, err := conn.Read(buf)
+		if err != nil {
+			break
+		}
+		if buf[0] != 0 { // Dummy.
+			continue
+		}
+		time.Sleep(1 * time.Second)
+	}
+}
+
+func handleJsonIo(conn *websocket.Conn) {
+	trafficMutex.Lock()
+	for _, traf := range traffic {
+		if !traf.Position_valid { // Don't send unless a valid position exists.
+			continue
+		}
+		trafficJSON, _ := json.Marshal(&traf)
+		conn.Write(trafficJSON)
+	}
+	// Subscribe the socket to receive updates.
+	trafficUpdate.AddSocket(conn)
+	weatherRawUpdate.AddSocket(conn)
+	situationUpdate.AddSocket(conn)
+
+	trafficMutex.Unlock()
+
+	// Connection closes when function returns. Since uibroadcast is writing and we don't need to read anything (for now), just keep it busy.
+	for {
+		buf := make([]byte, 1024)
+		_, err := conn.Read(buf)
+		if err != nil {
+			break
+		}
+		if buf[0] != 0 { // Dummy.
+			continue
+		}
+		time.Sleep(1 * time.Second)
+	}
+}
+
+// Works just as weather updates do.
+
+func handleTrafficWS(conn *websocket.Conn) {
+	trafficMutex.Lock()
+	for _, traf := range traffic {
+		if !traf.Position_valid { // Don't send unless a valid position exists.
+			continue
+		}
+		trafficJSON, _ := json.Marshal(&traf)
+		conn.Write(trafficJSON)
+	}
+	// Subscribe the socket to receive updates.
+	trafficUpdate.AddSocket(conn)
+	trafficMutex.Unlock()
+
+	// Connection closes when function returns. Since uibroadcast is writing and we don't need to read anything (for now), just keep it busy.
+	for {
+		buf := make([]byte, 1024)
+		_, err := conn.Read(buf)
+		if err != nil {
+			break
+		}
+		if buf[0] != 0 { // Dummy.
+			continue
+		}
+		time.Sleep(1 * time.Second)
+	}
+}
+
+func handleStatusWS(conn *websocket.Conn) {
+	//	log.Printf("Web client connected.\n")
+
 	timer := time.NewTicker(1 * time.Second)
 	for {
-		<-timer.C
+		// The below is not used, but should be if something needs to be streamed from the web client ever in the future.
+		/*		var msg SettingMessage
+				err := websocket.JSON.Receive(conn, &msg)
+				if err == io.EOF {
+					break
+				} else if err != nil {
+					log.Printf("handleStatusWS: %s\n", err.Error())
+				} else {
+					// Use 'msg'.
+				}
+		*/
 
-		update, _ := json.Marshal(InfoMessage{status:&globalStatus, settings:&globalSettings})
+		// Send status.
+		update, _ := json.Marshal(&globalStatus)
 		_, err := conn.Write(update)
 
 		if err != nil {
-//			log.Printf("Web client disconnected.\n")
+			//			log.Printf("Web client disconnected.\n")
 			break
 		}
+		<-timer.C
+	}
+}
+
+func handleSituationWS(conn *websocket.Conn) {
+	timer := time.NewTicker(100 * time.Millisecond)
+	for {
+		situationJSON, _ := json.Marshal(&mySituation)
+		_, err := conn.Write(situationJSON)
+
+		if err != nil {
+			break
+		}
+		<-timer.C
+
+	}
+
+}
+
+// AJAX call - /getStatus. Responds with current global status
+// a webservice call for the same data available on the websocket but when only a single update is needed
+func handleStatusRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	statusJSON, _ := json.Marshal(&globalStatus)
+	fmt.Fprintf(w, "%s\n", statusJSON)
+}
+
+// AJAX call - /getSituation. Responds with current situation (lat/lon/gdspeed/track/pitch/roll/heading/etc.)
+func handleSituationRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	situationJSON, _ := json.Marshal(&mySituation)
+	fmt.Fprintf(w, "%s\n", situationJSON)
+}
+
+// AJAX call - /getTowers. Responds with all ADS-B ground towers that have sent messages that we were able to parse, along with its stats.
+func handleTowersRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+
+	ADSBTowerMutex.Lock()
+	towersJSON, err := json.Marshal(&ADSBTowers)
+	if err != nil {
+		log.Printf("Error sending tower JSON data: %s\n", err.Error())
+	}
+	// for testing purposes, we can return a fixed reply
+	// towersJSON = []byte(`{"(38.490880,-76.135554)":{"Lat":38.49087953567505,"Lng":-76.13555431365967,"Signal_strength_last_minute":100,"Signal_strength_max":67,"Messages_last_minute":1,"Messages_total":1059},"(38.978698,-76.309276)":{"Lat":38.97869825363159,"Lng":-76.30927562713623,"Signal_strength_last_minute":495,"Signal_strength_max":32,"Messages_last_minute":45,"Messages_total":83},"(39.179285,-76.668413)":{"Lat":39.17928457260132,"Lng":-76.66841268539429,"Signal_strength_last_minute":50,"Signal_strength_max":24,"Messages_last_minute":1,"Messages_total":16},"(39.666309,-74.315300)":{"Lat":39.66630935668945,"Lng":-74.31529998779297,"Signal_strength_last_minute":9884,"Signal_strength_max":35,"Messages_last_minute":4,"Messages_total":134}}`)
+	fmt.Fprintf(w, "%s\n", towersJSON)
+	ADSBTowerMutex.Unlock()
+}
+
+// AJAX call - /getSatellites. Responds with all GNSS satellites that are being tracked, along with status information.
+func handleSatellitesRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	mySituation.muSatellite.Lock()
+	satellitesJSON, err := json.Marshal(&Satellites)
+	if err != nil {
+		log.Printf("Error sending GNSS satellite JSON data: %s\n", err.Error())
+	}
+	fmt.Fprintf(w, "%s\n", satellitesJSON)
+	mySituation.muSatellite.Unlock()
+}
+
+// AJAX call - /getSettings. Responds with all stratux.conf data.
+func handleSettingsGetRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	readWiFiUserSettings()
+	settingsJSON, _ := json.Marshal(&globalSettings)
+	fmt.Fprintf(w, "%s\n", settingsJSON)
+}
+
+// AJAX call - /setSettings. receives via POST command, any/all stratux.conf data.
+func handleSettingsSetRequest(w http.ResponseWriter, r *http.Request) {
+	// define header in support of cross-domain AJAX
+	setNoCache(w)
+	setJSONHeaders(w)
+	w.Header().Set("Access-Control-Allow-Method", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+	// for an OPTION method request, we return header without processing.
+	// this insures we are recognized as supporting cross-domain AJAX REST calls
+	if r.Method == "POST" {
+		// raw, _ := httputil.DumpRequest(r, true)
+		// log.Printf("handleSettingsSetRequest:raw: %s\n", raw)
+
+		var resetWiFi bool
+		decoder := json.NewDecoder(r.Body)
+		for {
+			var msg map[string]interface{} // support arbitrary JSON
+
+			err := decoder.Decode(&msg)
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				log.Printf("handleSettingsSetRequest:error: %s\n", err.Error())
+			} else {
+				for key, val := range msg {
+					// log.Printf("handleSettingsSetRequest:json: testing for key:%s of type %s\n", key, reflect.TypeOf(val))
+					switch key {
+					case "DarkMode":
+						globalSettings.DarkMode = val.(bool)
+					case "UAT_Enabled":
+						globalSettings.UAT_Enabled = val.(bool)
+					case "ES_Enabled":
+						globalSettings.ES_Enabled = val.(bool)
+					case "Ping_Enabled":
+						globalSettings.Ping_Enabled = val.(bool)
+					case "GPS_Enabled":
+						globalSettings.GPS_Enabled = val.(bool)
+					case "IMU_Sensor_Enabled":
+						globalSettings.IMU_Sensor_Enabled = val.(bool)
+						if !globalSettings.IMU_Sensor_Enabled && globalStatus.IMUConnected {
+							myIMUReader.Close()
+							globalStatus.IMUConnected = false
+						}
+					case "BMP_Sensor_Enabled":
+						globalSettings.BMP_Sensor_Enabled = val.(bool)
+						if !globalSettings.BMP_Sensor_Enabled && globalStatus.BMPConnected {
+							myPressureReader.Close()
+							globalStatus.BMPConnected = false
+						}
+					case "DEBUG":
+						globalSettings.DEBUG = val.(bool)
+					case "DisplayTrafficSource":
+						globalSettings.DisplayTrafficSource = val.(bool)
+					case "ReplayLog":
+						v := val.(bool)
+						if v != globalSettings.ReplayLog { // Don't mark the files unless there is a change.
+							globalSettings.ReplayLog = v
+						}
+					case "AHRSLog":
+						globalSettings.AHRSLog = val.(bool)
+					case "IMUMapping":
+						if globalSettings.IMUMapping != val.([2]int) {
+							globalSettings.IMUMapping = val.([2]int)
+							myIMUReader.Close()
+							globalStatus.IMUConnected = false // Force a restart of the IMU reader
+						}
+					case "PPM":
+						globalSettings.PPM = int(val.(float64))
+					case "Baud":
+						if serialOut, ok := globalSettings.SerialOutputs["/dev/serialout0"]; ok { //FIXME: Only one device for now.
+							newBaud := int(val.(float64))
+							if newBaud == serialOut.Baud { // Same baud rate. No change.
+								continue
+							}
+							log.Printf("changing /dev/serialout0 baud rate from %d to %d.\n", serialOut.Baud, newBaud)
+							serialOut.Baud = newBaud
+							// Close the port if it is open.
+							if serialOut.serialPort != nil {
+								log.Printf("closing /dev/serialout0 for baud rate change.\n")
+								serialOut.serialPort.Close()
+								serialOut.serialPort = nil
+							}
+							globalSettings.SerialOutputs["/dev/serialout0"] = serialOut
+						}
+					case "WatchList":
+						globalSettings.WatchList = val.(string)
+					case "GLimits":
+						globalSettings.GLimits = val.(string)
+					case "OwnshipModeS":
+						// Expecting a hex string less than 6 characters (24 bits) long.
+						if len(val.(string)) > 6 { // Too long.
+							continue
+						}
+						// Pad string, must be 6 characters long.
+						vals := strings.ToUpper(val.(string))
+						for len(vals) < 6 {
+							vals = "0" + vals
+						}
+						hexn, err := hex.DecodeString(vals)
+						if err != nil { // Number not valid.
+							log.Printf("handleSettingsSetRequest:OwnshipModeS: %s\n", err.Error())
+							continue
+						}
+						globalSettings.OwnshipModeS = fmt.Sprintf("%02X%02X%02X", hexn[0], hexn[1], hexn[2])
+					case "StaticIps":
+						ipsStr := val.(string)
+						ips := strings.Split(ipsStr, " ")
+						if ipsStr == "" {
+							ips = make([]string, 0)
+						}
+
+						re, _ := regexp.Compile(`^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$`)
+						err := ""
+						for _, ip := range ips {
+							// Verify IP format
+							if !re.MatchString(ip) {
+								err = err + "Invalid IP: " + ip + ". "
+							}
+						}
+						if err != "" {
+							log.Printf("handleSettingsSetRequest:StaticIps: %s\n", err)
+							continue
+						}
+						globalSettings.StaticIps = ips
+					case "WiFiSSID":
+						globalSettings.WiFiSSID = val.(string)
+						resetWiFi = true
+					case "WiFiChannel":
+						globalSettings.WiFiChannel = int(val.(float64))
+						resetWiFi = true
+					case "WiFiSecurityEnabled":
+						globalSettings.WiFiSecurityEnabled = val.(bool)
+						resetWiFi = true
+					case "WiFiPassphrase":
+						globalSettings.WiFiPassphrase = val.(string)
+						resetWiFi = true
+					case "WiFiSmartEnabled":
+						globalSettings.WiFiSmartEnabled = val.(bool)
+						resetWiFi = true
+					default:
+						log.Printf("handleSettingsSetRequest:json: unrecognized key:%s\n", key)
+					}
+				}
+				saveSettings()
+				if resetWiFi {
+					saveWiFiUserSettings()
+					go func() {
+						time.Sleep(time.Second)
+						cmd := exec.Command("ifdown", "wlan0")
+						if err := cmd.Start(); err != nil {
+							log.Printf("Error shutting down WiFi: %s\n", err.Error())
+						}
+						if err = cmd.Wait(); err != nil {
+							log.Printf("Error shutting down WiFi: %s\n", err.Error())
+						}
+						cmd = exec.Command("ifup", "wlan0")
+						if err := cmd.Start(); err != nil {
+							log.Printf("Error starting WiFi: %s\n", err.Error())
+						}
+						if err = cmd.Wait(); err != nil {
+							log.Printf("Error starting WiFi: %s\n", err.Error())
+						}
+					}()
+				}
+			}
+		}
+
+		// while it may be redundant, we return the latest settings
+		settingsJSON, _ := json.Marshal(&globalSettings)
+		fmt.Fprintf(w, "%s\n", settingsJSON)
+	}
+}
+
+func handleShutdownRequest(w http.ResponseWriter, r *http.Request) {
+	syscall.Sync()
+	gracefulShutdown()
+	syscall.Reboot(syscall.LINUX_REBOOT_CMD_POWER_OFF)
+}
+
+func doReboot() {
+	syscall.Sync()
+	gracefulShutdown()
+	syscall.Reboot(syscall.LINUX_REBOOT_CMD_RESTART)
+}
+
+func handleDeleteLogFile(w http.ResponseWriter, r *http.Request) {
+	log.Println("handleDeleteLogFile called!!!")
+	clearDebugLogFile()
+}
+
+func handleDeleteAHRSLogFiles(w http.ResponseWriter, r *http.Request) {
+	files, err := ioutil.ReadDir("/var/log")
+	if err != nil {
+		http.Error(w, fmt.Sprintf("error deleting AHRS logs: %s", err), http.StatusNotFound)
+		return
+	}
+
+	var fn string
+	for _, f := range files {
+		fn = f.Name()
+		if v, _ := filepath.Match("sensors_*.csv", fn); v {
+			os.Remove("/var/log/" + fn)
+			log.Printf("Deleting AHRS log file %s\n", fn)
+		}
+		analysisLogger = nil
+	}
+}
+
+func handleDevelModeToggle(w http.ResponseWriter, r *http.Request) {
+	log.Printf("handleDevelModeToggle called!!!\n")
+	globalSettings.DeveloperMode = true
+	saveSettings()
+}
+
+func handleRestartRequest(w http.ResponseWriter, r *http.Request) {
+	log.Printf("handleRestartRequest called\n")
+	go doRestartApp()
+}
+
+func handleRebootRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	w.Header().Set("Access-Control-Allow-Method", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+	go delayReboot()
+}
+
+func handleOrientAHRS(w http.ResponseWriter, r *http.Request) {
+	// define header in support of cross-domain AJAX
+	setNoCache(w)
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Method", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+	// For an OPTION method request, we return header without processing.
+	// This ensures we are recognized as supporting cross-domain AJAX REST calls.
+	if r.Method == "POST" {
+		var (
+			action []byte = make([]byte, 1)
+			err    error
+		)
+
+		if _, err = r.Body.Read(action); err != nil {
+			log.Println("AHRS Error: handleOrientAHRS received invalid request")
+			http.Error(w, "orientation received invalid request", http.StatusBadRequest)
+		}
+
+		switch action[0] {
+		case 'f': // Set sensor "forward" direction (toward nose of airplane).
+			f, err := getMinAccelDirection()
+			if err != nil {
+				log.Printf("AHRS Error: sensor orientation: couldn't read accelerometer: %s\n", err)
+				http.Error(w, fmt.Sprintf("couldn't read accelerometer: %s\n", err), http.StatusBadRequest)
+				return
+			}
+			log.Printf("AHRS Info: sensor orientation success! forward axis is %d\n", f)
+			globalSettings.IMUMapping = [2]int{f, 0}
+		case 'd': // Set sensor "up" direction (toward top of airplane).
+			globalSettings.SensorQuaternion = [4]float64{0, 0, 0, 0}
+			saveSettings()
+			myIMUReader.Close()
+			globalStatus.IMUConnected = false // restart the processes depending on the orientation
+			ResetAHRSGLoad()
+			time.Sleep(2000 * time.Millisecond)
+		}
 	}
 }
 
-func handleManagementConnection(conn *websocket.Conn) {
-//	log.Printf("Web client connected.\n")
-	go statusSender(conn)
+func handleCageAHRS(w http.ResponseWriter, r *http.Request) {
+	// define header in support of cross-domain AJAX
+	setNoCache(w)
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Method", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
 
-	for {
-		var msg SettingMessage
-		err := websocket.JSON.Receive(conn, &msg)
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			log.Printf("handleManagementConnection: %s\n", err.Error())
-		} else {
-			if msg.Setting == "UAT_Enabled" {
-				globalSettings.UAT_Enabled = msg.Value
-			}
-			if msg.Setting == "ES_Enabled" {
-				globalSettings.ES_Enabled = msg.Value
-			}
-			if msg.Setting == "GPS_Enabled" {
-				globalSettings.GPS_Enabled = msg.Value
-			}
-			if msg.Setting == "AHRS_Enabled" {
-				globalSettings.AHRS_Enabled = msg.Value
-			}
-			if msg.Setting == "DEBUG" {
-				globalSettings.DEBUG = msg.Value
-			}
+	// For an OPTION method request, we return header without processing.
+	// This ensures we are recognized as supporting cross-domain AJAX REST calls.
+	if r.Method == "POST" {
+		CageAHRS()
+	}
+}
 
-			saveSettings()
+func handleCalibrateAHRS(w http.ResponseWriter, r *http.Request) {
+	// define header in support of cross-domain AJAX
+	setNoCache(w)
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Method", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+	// For an OPTION method request, we return header without processing.
+	// This ensures we are recognized as supporting cross-domain AJAX REST calls.
+	if r.Method == "POST" {
+		CalibrateAHRS()
+	}
+}
+
+func handleResetGMeter(w http.ResponseWriter, r *http.Request) {
+	// define header in support of cross-domain AJAX
+	setNoCache(w)
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Method", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+	// For an OPTION method request, we return header without processing.
+	// This ensures we are recognized as supporting cross-domain AJAX REST calls.
+	if r.Method == "POST" {
+		ResetAHRSGLoad()
+	}
+}
+
+func doRestartApp() {
+	time.Sleep(1)
+	syscall.Sync()
+	out, err := exec.Command("/bin/systemctl", "restart", "stratux").Output()
+	if err != nil {
+		log.Printf("restart error: %s\n%s", err.Error(), out)
+	} else {
+		log.Printf("restart: %s\n", out)
+	}
+}
+
+// AJAX call - /getClients. Responds with all connected clients.
+func handleClientsGetRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	netMutex.Lock()
+	clientsJSON, _ := json.Marshal(&outSockets)
+	netMutex.Unlock()
+	fmt.Fprintf(w, "%s\n", clientsJSON)
+}
+
+func delayReboot() {
+	time.Sleep(1 * time.Second)
+	doReboot()
+}
+
+func handleDownloadLogRequest(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/zip")
+	w.Header().Set("Content-Disposition", "attachment; filename='stratux.log'")
+	http.ServeFile(w, r, "/var/log/stratux.log")
+}
+
+func handleDownloadAHRSLogsRequest(w http.ResponseWriter, r *http.Request) {
+	// Common error handler
+	httpErr := func(w http.ResponseWriter, e error) {
+		http.Error(w, fmt.Sprintf("error zipping AHRS logs: %s", e), http.StatusNotFound)
+	}
+
+	files, err := ioutil.ReadDir("/var/log")
+	if err != nil {
+		httpErr(w, err)
+		return
+	}
+
+	z := zip.NewWriter(w)
+	defer z.Close()
+
+	for _, f := range files {
+		fn := f.Name()
+		v1, _ := filepath.Match("sensors_*.csv", fn)
+		v2, _ := filepath.Match("stratux.log", fn)
+		if !(v1 || v2) {
+			continue
+		}
+
+		unzippedFile, err := os.Open("/var/log/" + fn)
+		if err != nil {
+			httpErr(w, err)
+			return
+		}
+
+		fh, err := zip.FileInfoHeader(f)
+		if err != nil {
+			httpErr(w, err)
+			return
+		}
+		zippedFile, err := z.CreateHeader(fh)
+		if err != nil {
+			httpErr(w, err)
+			return
+		}
+
+		_, err = io.Copy(zippedFile, unzippedFile)
+		if err != nil {
+			httpErr(w, err)
+			return
 		}
 	}
+	w.Header().Set("Content-Type", "application/zip")
+	w.Header().Set("Content-Disposition", "attachment; filename=\"ahrs_logs.zip\"")
+}
+
+func handleDownloadDBRequest(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/zip")
+	w.Header().Set("Content-Disposition", "attachment; filename='stratux.sqlite'")
+	http.ServeFile(w, r, "/var/log/stratux.sqlite")
+}
+
+// Upload an update file.
+func handleUpdatePostRequest(w http.ResponseWriter, r *http.Request) {
+	setNoCache(w)
+	setJSONHeaders(w)
+	r.ParseMultipartForm(1024 * 1024 * 32) // ~32MB update.
+	file, handler, err := r.FormFile("update_file")
+	if err != nil {
+		log.Printf("Update failed from %s (%s).\n", r.RemoteAddr, err.Error())
+		return
+	}
+	defer file.Close()
+	// Special hardware builds. Don't allow an update unless the filename contains the hardware build name.
+	if (len(globalStatus.HardwareBuild) > 0) && !strings.Contains(strings.ToLower(handler.Filename), strings.ToLower(globalStatus.HardwareBuild)) {
+		w.WriteHeader(404)
+		return
+	}
+	updateFile := fmt.Sprintf("/root/update-stratux-v.sh")
+	f, err := os.OpenFile(updateFile, os.O_WRONLY|os.O_CREATE, 0666)
+	if err != nil {
+		log.Printf("Update failed from %s (%s).\n", r.RemoteAddr, err.Error())
+		return
+	}
+	defer f.Close()
+	io.Copy(f, file)
+	log.Printf("%s uploaded %s for update.\n", r.RemoteAddr, updateFile)
+	// Successful update upload. Now reboot.
+	go delayReboot()
+}
+
+func setNoCache(w http.ResponseWriter) {
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
+}
+
+func setJSONHeaders(w http.ResponseWriter) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Content-Type", "application/json")
+}
+
+func defaultServer(w http.ResponseWriter, r *http.Request) {
+	//	setNoCache(w)
+
+	http.FileServer(http.Dir("/var/www")).ServeHTTP(w, r)
+}
+
+func handleroPartitionRebuild(w http.ResponseWriter, r *http.Request) {
+	out, err := exec.Command("/usr/sbin/rebuild_ro_part.sh").Output()
+
+	if err != nil {
+		addSingleSystemErrorf("partition-rebuild", "Rebuild RO Partition error: %s", err.Error())
+	} else {
+		addSingleSystemErrorf("partition-rebuild", "Rebuild RO Partition success: %s", out)
+	}
+
+}
+
+// https://gist.github.com/alexisrobert/982674.
+// Copyright (c) 2010-2014 Alexis ROBERT <alexis.robert@gmail.com>.
+const dirlisting_tpl = `<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<!-- Modified from lighttpd directory listing -->
+<head>
+<title>Index of {{.Name}}</title>
+<style type="text/css">
+a, a:active {text-decoration: none; color: blue;}
+a:visited {color: #48468F;}
+a:hover, a:focus {text-decoration: underline; color: red;}
+body {background-color: #F5F5F5;}
+h2 {margin-bottom: 12px;}
+table {margin-left: 12px;}
+th, td { font: 90% monospace; text-align: left;}
+th { font-weight: bold; padding-right: 14px; padding-bottom: 3px;}
+td {padding-right: 14px;}
+td.s, th.s {text-align: right;}
+div.list { background-color: white; border-top: 1px solid #646464; border-bottom: 1px solid #646464; padding-top: 10px; padding-bottom: 14px;}
+div.foot { font: 90% monospace; color: #787878; padding-top: 4px;}
+</style>
+</head>
+<body>
+<h2>Index of {{.Name}}</h2>
+<div class="list">
+<table summary="Directory Listing" cellpadding="0" cellspacing="0">
+<thead><tr><th class="n">Name</th><th>Last Modified</th><th>Size (bytes)</th><th class="dl">Options</th></tr></thead>
+<tbody>
+{{range .Children_files}}
+<tr><td class="n"><a href="/logs/stratux/{{.Name}}">{{.Name}}</a></td><td>{{.Mtime}}</td><td>{{.Size}}</td><td class="dl"><a href="/logs/stratux/{{.Name}}">Download</a></td></tr>
+{{end}}
+</tbody>
+</table>
+</div>
+<div class="foot">{{.ServerUA}}</div>
+</body>
+</html>`
+
+type fileInfo struct {
+	Name  string
+	Mtime string
+	Size  string
+}
+
+// Manages directory listings
+type dirlisting struct {
+	Name           string
+	Children_files []fileInfo
+	ServerUA       string
+}
+
+//FIXME: This needs to be switched to show a "sessions log" from the sqlite database.
+func viewLogs(w http.ResponseWriter, r *http.Request) {
+
+	names, err := ioutil.ReadDir("/var/log/stratux/")
+	if err != nil {
+		return
+	}
+
+	fi := make([]fileInfo, 0)
+	for _, val := range names {
+		if val.Name()[0] == '.' {
+			continue
+		} // Remove hidden files from listing
+
+		if !val.IsDir() {
+			mtime := val.ModTime().Format("2006-Jan-02 15:04:05")
+			sz := humanize.Comma(val.Size())
+			fi = append(fi, fileInfo{Name: val.Name(), Mtime: mtime, Size: sz})
+		}
+	}
+
+	tpl, err := template.New("tpl").Parse(dirlisting_tpl)
+	if err != nil {
+		return
+	}
+	data := dirlisting{Name: r.URL.Path, ServerUA: "Stratux " + stratuxVersion + "/" + stratuxBuild,
+		Children_files: fi}
+
+	err = tpl.Execute(w, data)
+	if err != nil {
+		log.Printf("viewLogs() error: %s\n", err.Error())
+	}
+
 }
 
 func managementInterface() {
-	http.Handle("/", http.FileServer(http.Dir("/var/www")))
+	weatherUpdate = NewUIBroadcaster()
+	trafficUpdate = NewUIBroadcaster()
+	situationUpdate = NewUIBroadcaster()
+	weatherRawUpdate = NewUIBroadcaster()
+	gdl90Update = NewUIBroadcaster()
+
+	http.HandleFunc("/", defaultServer)
 	http.Handle("/logs/", http.StripPrefix("/logs/", http.FileServer(http.Dir("/var/log"))))
-	http.HandleFunc("/control",
+	http.HandleFunc("/view_logs/", viewLogs)
+
+	http.HandleFunc("/gdl90",
 		func(w http.ResponseWriter, req *http.Request) {
 			s := websocket.Server{
-				Handler: websocket.Handler(handleManagementConnection)}
+				Handler: websocket.Handler(handleGDL90WS)}
 			s.ServeHTTP(w, req)
 		})
+	http.HandleFunc("/status",
+		func(w http.ResponseWriter, req *http.Request) {
+			s := websocket.Server{
+				Handler: websocket.Handler(handleStatusWS)}
+			s.ServeHTTP(w, req)
+		})
+	http.HandleFunc("/situation",
+		func(w http.ResponseWriter, req *http.Request) {
+			s := websocket.Server{
+				Handler: websocket.Handler(handleSituationWS)}
+			s.ServeHTTP(w, req)
+		})
+	http.HandleFunc("/weather",
+		func(w http.ResponseWriter, req *http.Request) {
+			s := websocket.Server{
+				Handler: websocket.Handler(handleWeatherWS)}
+			s.ServeHTTP(w, req)
+		})
+	http.HandleFunc("/traffic",
+		func(w http.ResponseWriter, req *http.Request) {
+			s := websocket.Server{
+				Handler: websocket.Handler(handleTrafficWS)}
+			s.ServeHTTP(w, req)
+		})
+
+	http.HandleFunc("/jsonio",
+		func(w http.ResponseWriter, req *http.Request) {
+			s := websocket.Server{
+				Handler: websocket.Handler(handleJsonIo)}
+			s.ServeHTTP(w, req)
+		})
+
+	http.HandleFunc("/getStatus", handleStatusRequest)
+	http.HandleFunc("/getSituation", handleSituationRequest)
+	http.HandleFunc("/getTowers", handleTowersRequest)
+	http.HandleFunc("/getSatellites", handleSatellitesRequest)
+	http.HandleFunc("/getSettings", handleSettingsGetRequest)
+	http.HandleFunc("/setSettings", handleSettingsSetRequest)
+	http.HandleFunc("/restart", handleRestartRequest)
+	http.HandleFunc("/shutdown", handleShutdownRequest)
+	http.HandleFunc("/reboot", handleRebootRequest)
+	http.HandleFunc("/getClients", handleClientsGetRequest)
+	http.HandleFunc("/updateUpload", handleUpdatePostRequest)
+	http.HandleFunc("/roPartitionRebuild", handleroPartitionRebuild)
+	http.HandleFunc("/develmodetoggle", handleDevelModeToggle)
+	http.HandleFunc("/orientAHRS", handleOrientAHRS)
+	http.HandleFunc("/calibrateAHRS", handleCalibrateAHRS)
+	http.HandleFunc("/cageAHRS", handleCageAHRS)
+	http.HandleFunc("/resetGMeter", handleResetGMeter)
+	http.HandleFunc("/deletelogfile", handleDeleteLogFile)
+	http.HandleFunc("/downloadlog", handleDownloadLogRequest)
+	http.HandleFunc("/deleteahrslogfiles", handleDeleteAHRSLogFiles)
+	http.HandleFunc("/downloadahrslogs", handleDownloadAHRSLogsRequest)
+	http.HandleFunc("/downloaddb", handleDownloadDBRequest)
 
 	err := http.ListenAndServe(managementAddr, nil)
 

main/monotonic.go

@@ -0,0 +1,66 @@
+/*
+	Copyright (c) 2015-2016 Christopher Young
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	Modifications (c) 2016 AvSquirrel (https://github.com/AvSquirrel)
+	monotonic.go: Create monotonic clock using time.Timer - necessary because of real time clock changes on RPi.
+*/
+
+package main
+
+import (
+	humanize "github.com/dustin/go-humanize"
+	"time"
+)
+
+// Timer (since start).
+
+type monotonic struct {
+	Milliseconds uint64
+	Time         time.Time
+	ticker       *time.Ticker
+	realTimeSet  bool
+	RealTime     time.Time
+}
+
+func (m *monotonic) Watcher() {
+	for {
+		<-m.ticker.C
+		m.Milliseconds += 10
+		m.Time = m.Time.Add(10 * time.Millisecond)
+		if m.realTimeSet {
+			m.RealTime = m.RealTime.Add(10 * time.Millisecond)
+		}
+	}
+}
+
+func (m *monotonic) Since(t time.Time) time.Duration {
+	return m.Time.Sub(t)
+}
+
+func (m *monotonic) HumanizeTime(t time.Time) string {
+	return humanize.RelTime(t, m.Time, "ago", "from now")
+}
+
+func (m *monotonic) Unix() int64 {
+	return int64(m.Since(time.Time{}).Seconds())
+}
+
+func (m *monotonic) HasRealTimeReference() bool {
+	return m.realTimeSet
+}
+
+func (m *monotonic) SetRealTimeReference(t time.Time) {
+	if !m.realTimeSet { // Only allow the real clock to be set once.
+		m.RealTime = t
+		m.realTimeSet = true
+	}
+}
+
+func NewMonotonic() *monotonic {
+	t := &monotonic{Milliseconds: 0, Time: time.Time{}, ticker: time.NewTicker(10 * time.Millisecond)}
+	go t.Watcher()
+	return t
+}

main/network.go

@@ -1,11 +1,21 @@
+/*
+	Copyright (c) 2015-2016 Christopher Young
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	network.go: Client networking routines, DHCP lease monitoring, queue management, ICMP monitoring.
+*/
+
 package main
 
 import (
+	"github.com/tarm/serial"
 	"golang.org/x/net/icmp"
-	"golang.org/x/net/internal/iana"
 	"golang.org/x/net/ipv4"
 	"io/ioutil"
 	"log"
+	"math"
 	"math/rand"
 	"net"
 	"os"
@@ -23,35 +33,60 @@ type networkMessage struct {
 }
 
 type networkConnection struct {
-	Conn         *net.UDPConn
-	Ip           string
-	Port         uint32
-	Capability   uint8
-	messageQueue [][]byte // Device message queue.
+	Conn            *net.UDPConn
+	Ip              string
+	Port            uint32
+	Capability      uint8
+	messageQueue    [][]byte // Device message queue.
+	MessageQueueLen int      // Length of the message queue. For debugging.
 	/*
 		Sleep mode/throttle variables. "sleep mode" is actually now just a very reduced packet rate, since we don't know positively
 		 when a client is ready to accept packets - we just assume so if we don't receive ICMP Unreachable packets in 5 secs.
 	*/
-	lastUnreachable time.Time // Last time the device sent an ICMP Unreachable packet.
+	LastUnreachable time.Time // Last time the device sent an ICMP Unreachable packet.
 	nextMessageTime time.Time // The next time that the device is "able" to receive a message.
+	numOverflows    uint32    // Number of times the queue has overflowed - for calculating the amount to chop off from the queue.
+	SleepFlag       bool      // Whether or not this client has been marked as sleeping - only used for debugging (relies on messages being sent to update this flag in sendToAllConnectedClients()).
+	FFCrippled      bool
+}
+
+type serialConnection struct {
+	DeviceString string
+	Baud         int
+	serialPort   *serial.Port
 }
 
 var messageQueue chan networkMessage
+
 var outSockets map[string]networkConnection
 var dhcpLeases map[string]string
-var netMutex *sync.Mutex
-
 var pingResponse map[string]time.Time // Last time an IP responded to an "echo" response.
+var netMutex *sync.Mutex              // netMutex needs to be locked before accessing dhcpLeases, pingResponse, and outSockets and calling isSleeping() and isThrottled().
+
+var totalNetworkMessagesSent uint32
 
 const (
 	NETWORK_GDL90_STANDARD = 1
 	NETWORK_AHRS_FFSIM     = 2
 	NETWORK_AHRS_GDL90     = 4
 	dhcp_lease_file        = "/var/lib/dhcp/dhcpd.leases"
+	dhcp_lease_dir         = "/var/lib/dhcp"
+	extra_hosts_file       = "/etc/stratux-static-hosts.conf"
 )
 
+var dhcpLeaseDirectoryLastTest time.Time // Last time fsWriteTest() was run on the DHCP lease directory.
+
 // Read the "dhcpd.leases" file and parse out IP/hostname.
 func getDHCPLeases() (map[string]string, error) {
+	// Do a write test. Even if we are able to read the file, it may be out of date because there's a fs write issue.
+	// Only perform the test once every 5 minutes to minimize writes.
+	if stratuxClock.Since(dhcpLeaseDirectoryLastTest) >= 5*time.Minute {
+		err := fsWriteTest(dhcp_lease_dir)
+		if err != nil {
+			addSingleSystemErrorf("fs-write", "Write error on '%s', your EFB may have issues receiving weather and traffic.", dhcp_lease_dir)
+		}
+		dhcpLeaseDirectoryLastTest = stratuxClock.Time
+	}
 	dat, err := ioutil.ReadFile(dhcp_lease_file)
 	ret := make(map[string]string)
 	if err != nil {
@@ -74,58 +109,218 @@ func getDHCPLeases() (map[string]string, error) {
 			ret[block_ip] = ""
 		}
 	}
+
+	// Add IP's set through the settings page
+	if globalSettings.StaticIps != nil {
+		for _, ip := range globalSettings.StaticIps {
+			ret[ip] = ""
+		}
+	}
+
+	// Added the ability to have static IP hosts stored in /etc/stratux-static-hosts.conf
+
+	dat2, err := ioutil.ReadFile(extra_hosts_file)
+	if err != nil {
+		return ret, nil
+	}
+
+	iplines := strings.Split(string(dat2), "\n")
+	block_ip2 := ""
+	for _, ipline := range iplines {
+		spacedip := strings.Split(ipline, " ")
+		if len(spacedip) == 2 {
+			// The ip is in block_ip2
+			block_ip2 = spacedip[0]
+			// the hostname is here
+			ret[block_ip2] = spacedip[1]
+		}
+	}
+
 	return ret, nil
 }
 
+/*
+	isSleeping().
+	 Check if a client identifier 'ip:port' is in either a sleep or active state.
+	 ***WARNING***: netMutex must be locked before calling this function.
+*/
 func isSleeping(k string) bool {
+	if globalSettings.NoSleep == true {
+		return false
+	}
 	ipAndPort := strings.Split(k, ":")
-	lastPing, ok := pingResponse[ipAndPort[0]]
 	// No ping response. Assume disconnected/sleeping device.
-	if !ok || time.Since(lastPing) > (10*time.Second) {
+	if lastPing, ok := pingResponse[ipAndPort[0]]; !ok || stratuxClock.Since(lastPing) > (10*time.Second) {
 		return true
 	}
-	if time.Since(outSockets[k].lastUnreachable) < (5 * time.Second) {
+	if stratuxClock.Since(outSockets[k].LastUnreachable) < (5 * time.Second) {
 		return true
 	}
 	return false
 }
 
-// Throttle mode for testing port open and giving some start-up time to the app.
-// Throttling is 0.1% data rate for first 15 seconds.
+/*
+	isThrottled().
+	 Checks if a client identifier 'ip:port' is throttled.
+	 Throttle mode is for testing port open and giving some start-up time to the app.
+	 Throttling is 0.1% data rate for first 15 seconds.
+	 ***WARNING***: netMutex must be locked before calling this function.
+*/
 func isThrottled(k string) bool {
-	return (rand.Int()%1000 != 0) && time.Since(outSockets[k].lastUnreachable) < (15*time.Second)
+	return (rand.Int()%1000 != 0) && stratuxClock.Since(outSockets[k].LastUnreachable) < (15*time.Second)
 }
 
 func sendToAllConnectedClients(msg networkMessage) {
+	if (msg.msgType & NETWORK_GDL90_STANDARD) != 0 {
+		// It's a GDL90 message. Send to serial output channel (which may or may not cause something to happen).
+		serialOutputChan <- msg.msg
+		networkGDL90Chan <- msg.msg
+	}
+
 	netMutex.Lock()
 	defer netMutex.Unlock()
 	for k, netconn := range outSockets {
+		sleepFlag := isSleeping(k)
+
+		netconn.SleepFlag = sleepFlag
+		outSockets[k] = netconn
+
 		// Check if this port is able to accept the type of message we're sending.
 		if (netconn.Capability & msg.msgType) == 0 {
 			continue
 		}
 		// Send non-queueable messages immediately, or discard if the client is in sleep mode.
+
+		if !sleepFlag {
+			netconn.numOverflows = 0 // Reset the overflow counter whenever the client is not sleeping so that we're not penalizing future sleepmodes.
+		}
+
 		if !msg.queueable {
-			if !isSleeping(k) {
-				netconn.Conn.Write(msg.msg) // Write immediately.
+			if sleepFlag {
+				continue
 			}
+			netconn.Conn.Write(msg.msg) // Write immediately.
+			totalNetworkMessagesSent++
+			globalStatus.NetworkDataMessagesSent++
+			globalStatus.NetworkDataMessagesSentNonqueueable++
+			globalStatus.NetworkDataBytesSent += uint64(len(msg.msg))
+			globalStatus.NetworkDataBytesSentNonqueueable += uint64(len(msg.msg))
 		} else {
 			// Queue the message if the message is "queueable".
 			if len(netconn.messageQueue) >= maxUserMsgQueueSize { // Too many messages queued? Drop the oldest.
 				log.Printf("%s:%d - message queue overflow.\n", netconn.Ip, netconn.Port)
-				netconn.messageQueue = netconn.messageQueue[1 : maxUserMsgQueueSize-1]
+				netconn.numOverflows++
+				s := 2 * netconn.numOverflows // Double the amount we chop off on each overflow.
+				if int(s) >= len(netconn.messageQueue) {
+					netconn.messageQueue = make([][]byte, 0)
+				} else {
+					netconn.messageQueue = netconn.messageQueue[s:]
+				}
 			}
-			netconn.messageQueue = append(netconn.messageQueue, msg.msg)
+			netconn.messageQueue = append(netconn.messageQueue, msg.msg) // each netconn.messageQueue is therefore an array (well, a slice) of formatted GDL90 messages
 			outSockets[k] = netconn
 		}
 	}
 }
 
-// Just returns the number of DHCP leases for now.
-func getNetworkStats() uint {
-	ret := uint(len(dhcpLeases))
-	globalStatus.Connected_Users = ret
-	return ret
+var serialOutputChan chan []byte
+var networkGDL90Chan chan []byte
+
+func networkOutWatcher() {
+	for {
+		ch := <-networkGDL90Chan
+		gdl90Update.SendJSON(ch)
+	}
+}
+
+// Monitor serial output channel, send to serial port.
+func serialOutWatcher() {
+	// Check every 30 seconds for a serial output device.
+	serialTicker := time.NewTicker(30 * time.Second)
+
+	serialDev := "/dev/serialout0" //FIXME: This is temporary. Only one serial output device for now.
+
+	for {
+		select {
+		case <-serialTicker.C:
+			if _, err := os.Stat(serialDev); !os.IsNotExist(err) { // Check if the device file exists.
+				var thisSerialConn serialConnection
+				// Check if we need to start handling a new device.
+				if val, ok := globalSettings.SerialOutputs[serialDev]; !ok {
+					newSerialOut := serialConnection{DeviceString: serialDev, Baud: 38400}
+					log.Printf("detected new serial output, setting up now: %s. Default baudrate 38400.\n", serialDev)
+					if globalSettings.SerialOutputs == nil {
+						globalSettings.SerialOutputs = make(map[string]serialConnection)
+					}
+					globalSettings.SerialOutputs[serialDev] = newSerialOut
+					saveSettings()
+					thisSerialConn = newSerialOut
+				} else {
+					thisSerialConn = val
+				}
+				// Check if we need to open the connection now.
+				if thisSerialConn.serialPort == nil {
+					cfg := &serial.Config{Name: thisSerialConn.DeviceString, Baud: thisSerialConn.Baud}
+					p, err := serial.OpenPort(cfg)
+					if err != nil {
+						log.Printf("serialout port (%s) err: %s\n", thisSerialConn.DeviceString, err.Error())
+						break // We'll attempt again in 30 seconds.
+					} else {
+						log.Printf("opened serialout: Name: %s, Baud: %d\n", thisSerialConn.DeviceString, thisSerialConn.Baud)
+					}
+					// Save the serial port connection.
+					thisSerialConn.serialPort = p
+					globalSettings.SerialOutputs[serialDev] = thisSerialConn
+				}
+			}
+
+		case b := <-serialOutputChan:
+			if val, ok := globalSettings.SerialOutputs[serialDev]; ok {
+				if val.serialPort != nil {
+					_, err := val.serialPort.Write(b)
+					if err != nil { // Encountered an error in writing to the serial port. Close it and set Serial_out_enabled.
+						log.Printf("serialout (%s) port err: %s. Closing port.\n", val.DeviceString, err.Error())
+						val.serialPort.Close()
+						val.serialPort = nil
+						globalSettings.SerialOutputs[serialDev] = val
+					}
+				}
+			}
+		}
+	}
+}
+
+// Returns the number of DHCP leases and prints queue lengths.
+func getNetworkStats() {
+
+	netMutex.Lock()
+	defer netMutex.Unlock()
+
+	var numNonSleepingClients uint
+
+	for k, netconn := range outSockets {
+		queueBytes := 0
+		for _, msg := range netconn.messageQueue {
+			queueBytes += len(msg)
+		}
+		if globalSettings.DEBUG {
+			log.Printf("On  %s:%d,  Queue length = %d messages / %d bytes\n", netconn.Ip, netconn.Port, len(netconn.messageQueue), queueBytes)
+		}
+		ipAndPort := strings.Split(k, ":")
+		if len(ipAndPort) != 2 {
+			continue
+		}
+		ip := ipAndPort[0]
+		if pingRespTime, ok := pingResponse[ip]; ok {
+			// Don't count the ping time if it is the same as stratuxClock epoch.
+			// If the client has responded to a ping in the last 15 minutes, count it as "connected" or "recent".
+			if !pingRespTime.Equal(time.Time{}) && stratuxClock.Since(pingRespTime) < 15*time.Minute {
+				numNonSleepingClients++
+			}
+		}
+	}
+
+	globalStatus.Connected_Users = numNonSleepingClients
 }
 
 // See who has a DHCP lease and make a UDP connection to each of them.
@@ -172,21 +367,86 @@ func refreshConnectedClients() {
 }
 
 func messageQueueSender() {
-	secondTimer := time.NewTicker(5 * time.Second)
-	queueTimer := time.NewTicker(400 * time.Microsecond) // 2500 msg/sec
+	secondTimer := time.NewTicker(15 * time.Second) // getNetworkStats().
+	queueTimer := time.NewTicker(100 * time.Millisecond)
+
+	var lastQueueTimeChange time.Time // Reevaluate	send frequency every 5 seconds.
 	for {
 		select {
 		case msg := <-messageQueue:
 			sendToAllConnectedClients(msg)
 		case <-queueTimer.C:
 			netMutex.Lock()
+
+			averageSendableQueueSize := float64(0.0)
 			for k, netconn := range outSockets {
 				if len(netconn.messageQueue) > 0 && !isSleeping(k) && !isThrottled(k) {
-					tmpConn := netconn
-					tmpConn.Conn.Write(tmpConn.messageQueue[0])
-					tmpConn.messageQueue = tmpConn.messageQueue[1:]
-					outSockets[k] = tmpConn
+					averageSendableQueueSize += float64(len(netconn.messageQueue)) // Add num sendable messages.
+
+					var queuedMsg []byte
+
+					// Combine the first 256 entries in netconn.messageQueue to avoid flooding wlan0 with too many IOPS.
+					// Need to play nice with non-queued messages, so this limits the number of entries to combine.
+					// UAT uplink block is 432 bytes, so transmit block size shouldn't be larger than 108 KiB. 10 Mbps per device would therefore be needed to send within a 100 ms window.
+
+					mqDepth := len(netconn.messageQueue)
+					if mqDepth > 256 {
+						mqDepth = 256
+					}
+
+					for j := 0; j < mqDepth; j++ {
+						queuedMsg = append(queuedMsg, netconn.messageQueue[j]...)
+					}
+
+					/*
+						for j, _ := range netconn.messageQueue {
+							queuedMsg = append(queuedMsg, netconn.messageQueue[j]...)
+						}
+					*/
+
+					netconn.Conn.Write(queuedMsg)
+					totalNetworkMessagesSent++
+					globalStatus.NetworkDataMessagesSent++
+					globalStatus.NetworkDataBytesSent += uint64(len(queuedMsg))
+
+					//netconn.messageQueue = [][]byte{}
+					if mqDepth < len(netconn.messageQueue) {
+						netconn.messageQueue = netconn.messageQueue[mqDepth:]
+					} else {
+						netconn.messageQueue = [][]byte{}
+					}
+					outSockets[k] = netconn
+
+					/*
+						tmpConn := netconn
+						tmpConn.Conn.Write(tmpConn.messageQueue[0])
+						totalNetworkMessagesSent++
+						globalStatus.NetworkDataMessagesSent++
+						globalStatus.NetworkDataBytesSent += uint64(len(tmpConn.messageQueue[0]))
+						tmpConn.messageQueue = tmpConn.messageQueue[1:]
+						outSockets[k] = tmpConn
+					*/
 				}
+				netconn.MessageQueueLen = len(netconn.messageQueue)
+				outSockets[k] = netconn
+			}
+
+			if stratuxClock.Since(lastQueueTimeChange) >= 5*time.Second {
+				var pd float64
+				if averageSendableQueueSize > 0.0 && len(outSockets) > 0 {
+					averageSendableQueueSize = averageSendableQueueSize / float64(len(outSockets)) // It's a total, not an average, up until this point.
+					pd = math.Max(float64(1.0/750.0), float64(1.0/(4.0*averageSendableQueueSize))) // Say 250ms is enough to get through the whole queue.
+				} else {
+					pd = float64(0.1) // 100ms.
+				}
+
+				if globalSettings.DEBUG {
+					log.Printf("Average sendable queue is %v messages. Changing queue timer to %f seconds\n", averageSendableQueueSize, pd)
+				}
+
+				queueTimer.Stop()
+				queueTimer = time.NewTicker(time.Duration(pd*1000000000.0) * time.Nanosecond)
+				lastQueueTimeChange = stratuxClock.Time
 			}
 			netMutex.Unlock()
 		case <-secondTimer.C:
@@ -196,7 +456,7 @@ func messageQueueSender() {
 }
 
 func sendMsg(msg []byte, msgType uint8, queueable bool) {
-	messageQueue <- networkMessage{msg: msg, msgType: msgType, queueable: queueable, ts: time.Now()}
+	messageQueue <- networkMessage{msg: msg, msgType: msgType, queueable: queueable, ts: stratuxClock.Time}
 }
 
 func sendGDL90(msg []byte, queueable bool) {
@@ -204,7 +464,6 @@ func sendGDL90(msg []byte, queueable bool) {
 }
 
 func monitorDHCPLeases() {
-	//TODO: inotify or dhcp event hook.
 	timer := time.NewTicker(30 * time.Second)
 	for {
 		select {
@@ -218,6 +477,7 @@ func icmpEchoSender(c *icmp.PacketConn) {
 	timer := time.NewTicker(5 * time.Second)
 	for {
 		<-timer.C
+		netMutex.Lock()
 		// Collect IPs.
 		ips := make(map[string]bool)
 		for k, _ := range outSockets {
@@ -242,7 +502,9 @@ func icmpEchoSender(c *icmp.PacketConn) {
 				log.Printf("couldn't send ICMP Echo: %s\n", err.Error())
 				continue
 			}
+			totalNetworkMessagesSent++
 		}
+		netMutex.Unlock()
 	}
 }
 
@@ -262,7 +524,7 @@ func sleepMonitor() {
 			log.Printf("%s\n", err.Error())
 			continue
 		}
-		msg, err := icmp.ParseMessage(iana.ProtocolICMP, buf[:n])
+		msg, err := icmp.ParseMessage(1, buf[:n])
 		if err != nil {
 			continue
 		}
@@ -271,7 +533,9 @@ func sleepMonitor() {
 
 		// Look for echo replies, mark it as received.
 		if msg.Type == ipv4.ICMPTypeEchoReply {
-			pingResponse[ip] = time.Now()
+			netMutex.Lock()
+			pingResponse[ip] = stratuxClock.Time
+			netMutex.Unlock()
 			continue // No further processing needed.
 		}
 
@@ -280,7 +544,7 @@ func sleepMonitor() {
 			continue
 		}
 		// Packet parsing.
-		mb, err := msg.Body.Marshal(iana.ProtocolICMP)
+		mb, err := msg.Body.Marshal(1)
 		if err != nil {
 			continue
 		}
@@ -299,14 +563,87 @@ func sleepMonitor() {
 			netMutex.Unlock()
 			continue
 		}
-		p.lastUnreachable = time.Now()
+		p.LastUnreachable = stratuxClock.Time
 		outSockets[ipAndPort] = p
 		netMutex.Unlock()
 	}
 }
 
+func networkStatsCounter() {
+	timer := time.NewTicker(1 * time.Second)
+	var previousNetworkMessagesSent, previousNetworkBytesSent, previousNetworkMessagesSentNonqueueable, previousNetworkBytesSentNonqueueable uint64
+
+	for {
+		<-timer.C
+		globalStatus.NetworkDataMessagesSentLastSec = globalStatus.NetworkDataMessagesSent - previousNetworkMessagesSent
+		globalStatus.NetworkDataBytesSentLastSec = globalStatus.NetworkDataBytesSent - previousNetworkBytesSent
+		globalStatus.NetworkDataMessagesSentNonqueueableLastSec = globalStatus.NetworkDataMessagesSentNonqueueable - previousNetworkMessagesSentNonqueueable
+		globalStatus.NetworkDataBytesSentNonqueueableLastSec = globalStatus.NetworkDataBytesSentNonqueueable - previousNetworkBytesSentNonqueueable
+
+		// debug option. Uncomment to log per-second network statistics. Useful for debugging WiFi instability.
+		//log.Printf("Network data messages sent: %d total, %d last second.  Network data bytes sent: %d total, %d last second.\n", globalStatus.NetworkDataMessagesSent, globalStatus.NetworkDataMessagesSentLastSec, globalStatus.NetworkDataBytesSent, globalStatus.NetworkDataBytesSentLastSec)
+
+		previousNetworkMessagesSent = globalStatus.NetworkDataMessagesSent
+		previousNetworkBytesSent = globalStatus.NetworkDataBytesSent
+		previousNetworkMessagesSentNonqueueable = globalStatus.NetworkDataMessagesSentNonqueueable
+		previousNetworkBytesSentNonqueueable = globalStatus.NetworkDataBytesSentNonqueueable
+
+	}
+
+}
+
+/*
+	ffMonitor().
+		Watches for "i-want-to-play-ffm-udp", "i-can-play-ffm-udp", and "i-cannot-play-ffm-udp" UDP messages broadcasted on
+		 port 50113. Tags the client, issues a warning, and disables AHRS GDL90 output.
+
+*/
+
+func ffMonitor() {
+	addr := net.UDPAddr{Port: 50113, IP: net.ParseIP("0.0.0.0")}
+	conn, err := net.ListenUDP("udp", &addr)
+	if err != nil {
+		log.Printf("ffMonitor(): error listening on port 50113: %s\n", err.Error())
+		return
+	}
+	defer conn.Close()
+	for {
+		buf := make([]byte, 1024)
+		n, addr, err := conn.ReadFrom(buf)
+		ipAndPort := strings.Split(addr.String(), ":")
+		ip := ipAndPort[0]
+		if err != nil {
+			log.Printf("err: %s\n", err.Error())
+			return
+		}
+		// Got message, check if it's in the correct format.
+		if n < 3 || buf[0] != 0xFF || buf[1] != 0xFE {
+			continue
+		}
+		s := string(buf[2:n])
+		s = strings.Replace(s, "\x00", "", -1)
+		ffIpAndPort := ip + ":4000"
+		netMutex.Lock()
+		p, ok := outSockets[ffIpAndPort]
+		if !ok {
+			// Can't do anything, the client isn't even technically connected.
+			netMutex.Unlock()
+			continue
+		}
+		if strings.HasPrefix(s, "i-want-to-play-ffm-udp") || strings.HasPrefix(s, "i-can-play-ffm-udp") || strings.HasPrefix(s, "i-cannot-play-ffm-udp") {
+			p.FFCrippled = true
+			//FIXME: AHRS output doesn't need to be disabled globally, just on the ForeFlight client IPs.
+			addSingleSystemErrorf("ff-warn", "Stratux is not supported by your EFB app. Your EFB app is known to regularly make changes that cause compatibility issues with Stratux. See the README for a list of apps that officially support Stratux.")
+		}
+		outSockets[ffIpAndPort] = p
+		netMutex.Unlock()
+	}
+}
+
 func initNetwork() {
 	messageQueue = make(chan networkMessage, 1024) // Buffered channel, 1024 messages.
+	serialOutputChan = make(chan []byte, 1024)     // Buffered channel, 1024 GDL90 messages.
+	networkGDL90Chan = make(chan []byte, 1024)
 	outSockets = make(map[string]networkConnection)
 	pingResponse = make(map[string]time.Time)
 	netMutex = &sync.Mutex{}
@@ -314,4 +651,7 @@ func initNetwork() {
 	go monitorDHCPLeases()
 	go messageQueueSender()
 	go sleepMonitor()
+	go networkStatsCounter()
+	go serialOutWatcher()
+	go networkOutWatcher()
 }

main/ping.go

@@ -0,0 +1,271 @@
+/*
+	Copyright (c) 2016 uAvionix
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	ping.go: uAvionix Ping ADS-B monitoring and management.
+*/
+
+package main
+
+import (
+	"bufio"
+	//"fmt"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	//"sync/atomic"
+	"net"
+	"os/exec"
+	"time"
+
+	// Using forked version of tarm/serial to force Linux
+	// instead of posix code, allowing for higher baud rates
+	"github.com/uavionix/serial"
+)
+
+// Ping device data
+var pingSerialConfig *serial.Config
+var pingSerialPort *serial.Port
+var pingWG *sync.WaitGroup
+var closeCh chan int
+
+func initPingSerial() bool {
+	var device string
+	baudrate := int(2000000)
+
+	log.Printf("Configuring Ping ADS-B\n")
+
+	if _, err := os.Stat("/dev/ping"); err == nil {
+		device = "/dev/ping"
+	} else if _, err := os.Stat("/dev/softrf"); err == nil {
+		device = "/dev/softrf"
+		baudrate = int(38400)
+	} else {
+		log.Printf("No suitable Ping device found.\n")
+		return false
+	}
+	log.Printf("Using %s for Ping\n", device)
+
+	// Open port
+	// No timeout specified as Ping does not heartbeat
+	pingSerialConfig = &serial.Config{Name: device, Baud: baudrate}
+	p, err := serial.OpenPort(pingSerialConfig)
+	if err != nil {
+		log.Printf("Error opening serial port: %s\n", err.Error())
+		return false
+	}
+	log.Printf("Ping opened serial port")
+
+	// No device configuration is needed, we should be ready
+
+	pingSerialPort = p
+	return true
+}
+
+func pingNetworkRepeater() {
+	defer pingWG.Done()
+	log.Println("Entered Ping network repeater ...")
+	cmd := exec.Command("/usr/bin/dump1090", "--net-only")
+	stdout, _ := cmd.StdoutPipe()
+	stderr, _ := cmd.StderrPipe()
+
+	err := cmd.Start()
+	if err != nil {
+		log.Printf("Error executing /usr/bin/dump1090: %s\n", err)
+		// don't return immediately, use the proper shutdown procedure
+		shutdownPing = true
+		for {
+			select {
+			case <-closeCh:
+				return
+			default:
+				time.Sleep(1 * time.Second)
+			}
+		}
+	}
+
+	log.Println("Executed /usr/bin/dump1090 successfully...")
+
+	scanStdout := bufio.NewScanner(stdout)
+	scanStderr := bufio.NewScanner(stderr)
+
+	for {
+		select {
+		case <-closeCh:
+			log.Println("Ping network repeater: shutdown msg received, calling cmd.Process.Kill() ...")
+			err := cmd.Process.Kill()
+			if err != nil {
+				log.Printf("\t couldn't kill dump1090: %s\n", err)
+			} else {
+				cmd.Wait()
+				log.Println("\t kill successful...")
+			}
+			return
+		default:
+			for scanStdout.Scan() {
+				m := Dump1090TermMessage{Text: scanStdout.Text(), Source: "stdout"}
+				logDump1090TermMessage(m)
+			}
+			if err := scanStdout.Err(); err != nil {
+				log.Printf("scanStdout error: %s\n", err)
+			}
+
+			for scanStderr.Scan() {
+				m := Dump1090TermMessage{Text: scanStderr.Text(), Source: "stderr"}
+				logDump1090TermMessage(m)
+				if shutdownES != true {
+					shutdownES = true
+				}
+			}
+			if err := scanStderr.Err(); err != nil {
+				log.Printf("scanStderr error: %s\n", err)
+			}
+
+			time.Sleep(1 * time.Second)
+		}
+	}
+}
+
+var dump1090Connection net.Conn = nil
+var connectionError error
+
+func pingNetworkConnection() {
+	// Send to dump1090 on port 30001
+	dump1090Addr := "127.0.0.1:30001"
+	dump1090Connection, connectionError = net.Dial("tcp", dump1090Addr)
+	// RCB monitor for connection failure and redial
+}
+
+func pingSerialReader() {
+	//defer pingWG.Done()
+	defer pingSerialPort.Close()
+	// RCB TODO channel control for terminate
+
+	log.Printf("Starting Ping serial reader")
+
+	scanner := bufio.NewScanner(pingSerialPort)
+	for scanner.Scan() && globalStatus.Ping_connected && globalSettings.Ping_Enabled {
+		s := scanner.Text()
+		// Trimspace removes newlines as well as whitespace
+		s = strings.TrimSpace(s)
+		//logString := fmt.Sprintf("Ping received: %s", s)
+		//log.Println(logString)
+		if s[0] == '*' {
+			// 1090ES report
+			// Ping appends a signal strength at the end of the message
+			// e.g. *8DC01C2860C37797E9732E555B23;ss=049D;
+			// Remove this before forwarding to dump1090
+			// We currently aren't doing anything with this information
+			// and need to develop a scaling equation - we're using a
+			// log detector for power so it should have a logarithmic
+			// relationship. In one example, at -25dBm input (upper limit
+			// of RX) we saw ~0x500. At -95dBm input (lower limit of RX)
+			// we saw 0x370
+			report := strings.Split(s, ";")
+			//replayLog(s, MSGCLASS_DUMP1090);
+			if dump1090Connection == nil {
+				log.Println("Starting dump1090 network connection")
+				pingNetworkConnection()
+			}
+			if len(report[0]) != 0 && dump1090Connection != nil {
+				dump1090Connection.Write([]byte(report[0] + ";\r\n"))
+				//log.Println("Relaying 1090ES message")
+				//logString := fmt.Sprintf("Relaying 1090ES: %s;", report[0]);
+				//log.Println(logString)
+			}
+		} else if s[0] == '+' || s[0] == '-' {
+			// UAT report
+			// Ping appends a signal strength and RS bit errors corrected
+			// at the end of the message
+			// e.g. -08A5DFDF3907E982585F029B00040080105C3AB4BC5C240700A206000000000000003A13C82F96C80A63191F05FCB231;rs=1;ss=A2;
+			// We need to rescale the signal strength for interpretation by dump978,
+			// which expects a 0-1000 base 10 (linear?) scale
+			// RSSI is in hex and represents an int8 with -128 (0x80) representing an
+			// errored measurement. There will be some offset from actual due to loss
+			// in the path. In one example we measured 0x93 (-98) when injecting a
+			// -102dBm signal
+			o, msgtype := parseInput(s)
+			if o != nil && msgtype != 0 {
+				//logString = fmt.Sprintf("Relaying message, type=%d", msgtype)
+				//log.Println(logString)
+				relayMessage(msgtype, o)
+			} else if o == nil {
+				//log.Println("Not relaying message, o == nil")
+			} else {
+				//log.Println("Not relaying message, msgtype == 0")
+			}
+		}
+	}
+	globalStatus.Ping_connected = false
+	log.Printf("Exiting Ping serial reader")
+	return
+}
+
+func pingShutdown() {
+	log.Println("Entered Ping shutdown() ...")
+	//close(closeCh)
+	//log.Println("Ping shutdown(): calling pingWG.Wait() ...")
+	//pingWG.Wait() // Wait for the goroutine to shutdown
+	//log.Println("Ping shutdown(): pingWG.Wait() returned...")
+	// RCB TODO FINISH
+	globalStatus.Ping_connected = false
+}
+
+func pingKill() {
+	// Send signal to shutdown to pingWatcher().
+	shutdownPing = true
+	// Spin until device has been de-initialized.
+	for globalStatus.Ping_connected != false {
+		time.Sleep(1 * time.Second)
+	}
+}
+
+// to keep our sync primitives synchronized, only exit a read
+// method's goroutine via the close flag channel check, to
+// include catastrophic dongle failures
+var shutdownPing bool
+
+// Watch for config/device changes.
+func pingWatcher() {
+	prevPingEnabled := false
+
+	for {
+		time.Sleep(1 * time.Second)
+
+		// true when a serial call fails
+		if shutdownPing {
+			pingShutdown()
+			shutdownPing = false
+		}
+
+		if prevPingEnabled == globalSettings.Ping_Enabled {
+			continue
+		}
+
+		// Global settings have changed, reconfig
+		if globalSettings.Ping_Enabled && !globalStatus.Ping_connected {
+			globalStatus.Ping_connected = initPingSerial()
+			//count := 0
+			if globalStatus.Ping_connected {
+				//pingWG.Add(1)
+				go pingNetworkRepeater()
+				//pingNetworkConnection()
+				go pingSerialReader()
+				// Emulate SDR count
+				//count = 2
+			}
+			//atomic.StoreUint32(&globalStatus.Devices, uint32(count))
+		} else if !globalSettings.Ping_Enabled {
+			pingShutdown()
+		}
+
+		prevPingEnabled = globalSettings.Ping_Enabled
+	}
+}
+
+func pingInit() {
+	go pingWatcher()
+}

main/plugin.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"time"
+)
+
+type StratuxPlugin struct {
+	InitFunc     func() bool
+	ShutdownFunc func() bool
+	Name         string
+	Clock        time.Time
+	Input        chan string
+}

main/ry835ai.go

@@ -1,410 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"bufio"
-	"github.com/kidoman/embd"
-	_ "github.com/kidoman/embd/host/all"
-	"github.com/kidoman/embd/sensor/bmp180"
-	"github.com/tarm/serial"
-
-	"../mpu6050"
-	"os"
-)
-
-type SituationData struct {
-	mu_GPS *sync.Mutex
-
-	// From GPS.
-	lastFixSinceMidnightUTC uint32
-	lat                     float32
-	lng                     float32
-	quality                 uint8
-	satellites              uint16
-	accuracy                float32 // Meters.
-	alt                     float32 // Feet.
-	alt_accuracy            float32
-	lastFixLocalTime        time.Time
-	trueCourse              uint16
-	groundSpeed             uint16
-	lastGroundTrackTime     time.Time
-
-	mu_Attitude *sync.Mutex
-
-	// From BMP180 pressure sensor.
-	temp              float64
-	pressure_alt      float64
-	lastTempPressTime time.Time
-
-	// From MPU6050 accel/gyro.
-	pitch            float64
-	roll             float64
-	gyro_heading     float64
-	lastAttitudeTime time.Time
-}
-
-var serialConfig *serial.Config
-var serialPort *serial.Port
-
-func initGPSSerial() bool {
-	var device string
-	if _, err := os.Stat("/dev/ttyACM0"); err == nil {
-		device = "/dev/ttyACM0"
-	} else {
-		device = "/dev/ttyAMA0"
-	}
-	log.Printf("Using %s for GPS\n", device)
-	serialConfig = &serial.Config{Name: device, Baud: 9600}
-	p, err := serial.OpenPort(serialConfig)
-	if err != nil {
-		log.Printf("serial port err: %s\n", err.Error())
-		return false
-	}
-	serialPort = p
-	return true
-}
-
-func processNMEALine(l string) bool {
-	x := strings.Split(l, ",")
-	if x[0] == "$GNVTG" { // Ground track information.
-		mySituation.mu_GPS.Lock()
-		defer mySituation.mu_GPS.Unlock()
-		if len(x) < 10 {
-			return false
-		}
-		trueCourse := uint16(0)
-		if len(x[1]) > 0 {
-			tc, err := strconv.ParseFloat(x[1], 32)
-			if err != nil {
-				return false
-			}
-			trueCourse = uint16(tc)
-			//FIXME: Experimental. Set heading to true heading on the MPU6050 reader.
-			if myMPU6050 != nil && globalStatus.RY835AI_connected && globalSettings.AHRS_Enabled {
-				myMPU6050.ResetHeading(float64(tc))
-			}
-		} else {
-			// No movement.
-			mySituation.trueCourse = 0
-			mySituation.groundSpeed = 0
-			mySituation.lastGroundTrackTime = time.Time{}
-			return true
-		}
-		groundSpeed, err := strconv.ParseFloat(x[5], 32) // Knots.
-		if err != nil {
-			return false
-		}
-
-		mySituation.trueCourse = uint16(trueCourse)
-		mySituation.groundSpeed = uint16(groundSpeed)
-		mySituation.lastGroundTrackTime = time.Now()
-
-	} else if x[0] == "$GNGGA" { // GPS fix.
-		if len(x) < 15 {
-			return false
-		}
-		mySituation.mu_GPS.Lock()
-		defer mySituation.mu_GPS.Unlock()
-		// Timestamp.
-		if len(x[1]) < 9 {
-			return false
-		}
-		hr, err1 := strconv.Atoi(x[1][0:2])
-		min, err2 := strconv.Atoi(x[1][2:4])
-		sec, err3 := strconv.Atoi(x[1][4:6])
-		if err1 != nil || err2 != nil || err3 != nil {
-			return false
-		}
-
-		mySituation.lastFixSinceMidnightUTC = uint32((hr * 60 * 60) + (min * 60) + sec)
-
-		// Latitude.
-		if len(x[2]) < 10 {
-			return false
-		}
-		hr, err1 = strconv.Atoi(x[2][0:2])
-		minf, err2 := strconv.ParseFloat(x[2][2:10], 32)
-		if err1 != nil || err2 != nil {
-			return false
-		}
-
-		mySituation.lat = float32(hr) + float32(minf/60.0)
-		if x[3] == "S" { // South = negative.
-			mySituation.lat = -mySituation.lat
-		}
-
-		// Longitude.
-		if len(x[4]) < 11 {
-			return false
-		}
-		hr, err1 = strconv.Atoi(x[4][0:3])
-		minf, err2 = strconv.ParseFloat(x[4][3:11], 32)
-		if err1 != nil || err2 != nil {
-			return false
-		}
-
-		mySituation.lng = float32(hr) + float32(minf/60.0)
-		if x[5] == "W" { // West = negative.
-			mySituation.lng = -mySituation.lng
-		}
-
-		// Quality indicator.
-		q, err1 := strconv.Atoi(x[6])
-		if err1 != nil {
-			return false
-		}
-		mySituation.quality = uint8(q)
-
-		// Satellites.
-		sat, err1 := strconv.Atoi(x[7])
-		if err1 != nil {
-			return false
-		}
-		mySituation.satellites = uint16(sat)
-
-		// Accuracy.
-		hdop, err1 := strconv.ParseFloat(x[8], 32)
-		if err1 != nil {
-			return false
-		}
-		mySituation.accuracy = float32(hdop * 5.0) //FIXME: 5 meters ~ 1.0 HDOP?
-
-		// Altitude.
-		alt, err1 := strconv.ParseFloat(x[9], 32)
-		if err1 != nil {
-			return false
-		}
-		mySituation.alt = float32(alt * 3.28084) // Covnert to feet.
-
-		//TODO: Altitude accuracy.
-		mySituation.alt_accuracy = 0
-
-		// Timestamp.
-		mySituation.lastFixLocalTime = time.Now()
-
-	}
-	return true
-}
-
-func gpsSerialReader() {
-	defer serialPort.Close()
-	for globalSettings.GPS_Enabled && globalStatus.GPS_connected {
-
-		scanner := bufio.NewScanner(serialPort)
-		for scanner.Scan() {
-			s := scanner.Text()
-			// log.Printf("Output: %s\n", s)
-			processNMEALine(s)
-		}
-		if err := scanner.Err(); err != nil {
-			log.Printf("reading standard input: %s\n", err.Error())
-		}
-	}
-	globalStatus.GPS_connected = false
-}
-
-var i2cbus embd.I2CBus
-var myBMP180 *bmp180.BMP180
-var myMPU6050 *mpu6050.MPU6050
-
-func readBMP180() (float64, float64, error) { // ºCelsius, Meters
-	temp, err := myBMP180.Temperature()
-	if err != nil {
-		return temp, 0.0, err
-	}
-	altitude, err := myBMP180.Altitude()
-	altitude = float64(1/0.3048) * altitude // Convert meters to feet.
-	if err != nil {
-		return temp, altitude, err
-	}
-	return temp, altitude, nil
-}
-
-func readMPU6050() (float64, float64, error) { //TODO: error checking.
-	pitch, roll := myMPU6050.PitchAndRoll()
-	return pitch, roll, nil
-}
-
-func initBMP180() error {
-	myBMP180 = bmp180.New(i2cbus) //TODO: error checking.
-	return nil
-}
-
-func initMPU6050() error {
-	myMPU6050 = mpu6050.New(i2cbus) //TODO: error checking.
-	return nil
-}
-
-func initI2C() error {
-	i2cbus = embd.NewI2CBus(1) //TODO: error checking.
-	return nil
-}
-
-// Unused at the moment. 5 second update, since read functions in bmp180 are slow.
-func tempAndPressureReader() {
-	timer := time.NewTicker(5 * time.Second)
-	for globalStatus.RY835AI_connected && globalSettings.AHRS_Enabled {
-		<-timer.C
-		// Read temperature and pressure altitude.
-		temp, alt, err_bmp180 := readBMP180()
-		// Process.
-		if err_bmp180 != nil {
-			log.Printf("readBMP180(): %s\n", err_bmp180.Error())
-			globalStatus.RY835AI_connected = false
-		} else {
-			mySituation.temp = temp
-			mySituation.pressure_alt = alt
-			mySituation.lastTempPressTime = time.Now()
-		}
-	}
-	globalStatus.RY835AI_connected = false
-}
-
-func makeFFAHRSSimReport() {
-	s := fmt.Sprintf("XATTStratux,%f,%f,%f", mySituation.gyro_heading, mySituation.pitch, mySituation.roll)
-
-	sendMsg([]byte(s), NETWORK_AHRS_FFSIM, false)
-}
-
-func makeAHRSGDL90Report() {
-	msg := make([]byte, 16)
-	msg[0] = 0x4c
-	msg[1] = 0x45
-	msg[2] = 0x01
-	msg[3] = 0x00
-
-	pitch := int16(float64(mySituation.pitch) * float64(10.0))
-	roll := int16(float64(mySituation.roll) * float64(10.0))
-	hdg := uint16(float64(mySituation.gyro_heading) * float64(10.0)) //TODO.
-	slip_skid := int16(float64(0) * float64(10.0))                   //TODO.
-	yaw_rate := int16(float64(0) * float64(10.0))                    //TODO.
-	g := int16(float64(1.0) * float64(10.0))                         //TODO.
-
-	// Roll.
-	msg[4] = byte((roll >> 8) & 0xFF)
-	msg[5] = byte(roll & 0xFF)
-
-	// Pitch.
-	msg[6] = byte((pitch >> 8) & 0xFF)
-	msg[7] = byte(pitch & 0xFF)
-
-	// Heading.
-	msg[8] = byte((hdg >> 8) & 0xFF)
-	msg[9] = byte(hdg & 0xFF)
-
-	// Slip/skid.
-	msg[10] = byte((slip_skid >> 8) & 0xFF)
-	msg[11] = byte(slip_skid & 0xFF)
-
-	// Yaw rate.
-	msg[12] = byte((yaw_rate >> 8) & 0xFF)
-	msg[13] = byte(yaw_rate & 0xFF)
-
-	// "G".
-	msg[14] = byte((g >> 8) & 0xFF)
-	msg[15] = byte(g & 0xFF)
-
-	sendMsg(prepareMessage(msg), NETWORK_AHRS_GDL90, false)
-}
-
-func attitudeReaderSender() {
-	timer := time.NewTicker(100 * time.Millisecond) // ~10Hz update.
-	for globalStatus.RY835AI_connected && globalSettings.AHRS_Enabled {
-		<-timer.C
-		// Read pitch and roll.
-		pitch, roll, err_mpu6050 := readMPU6050()
-
-		mySituation.mu_Attitude.Lock()
-
-		if err_mpu6050 != nil {
-			log.Printf("readMPU6050(): %s\n", err_mpu6050.Error())
-			globalStatus.RY835AI_connected = false
-			break
-		} else {
-			mySituation.pitch = pitch
-			mySituation.roll = roll
-			mySituation.gyro_heading = myMPU6050.Heading() //FIXME. Experimental.
-			mySituation.lastAttitudeTime = time.Now()
-		}
-
-		// Send, if valid.
-		//		if isGPSGroundTrackValid(), etc.
-
-		makeFFAHRSSimReport()
-		makeAHRSGDL90Report()
-
-		mySituation.mu_Attitude.Unlock()
-	}
-	globalStatus.RY835AI_connected = false
-}
-
-func isGPSValid() bool {
-	return time.Since(mySituation.lastFixLocalTime).Seconds() < 15
-}
-
-func isGPSGroundTrackValid() bool {
-	return time.Since(mySituation.lastGroundTrackTime).Seconds() < 15
-}
-
-func isAHRSValid() bool {
-	return time.Since(mySituation.lastAttitudeTime).Seconds() < 1 // If attitude information gets to be over 1 second old, declare invalid.
-}
-
-func isTempPressValid() bool {
-	return time.Since(mySituation.lastTempPressTime).Seconds() < 15
-}
-
-func initAHRS() error {
-	if err := initI2C(); err != nil { // I2C bus.
-		return err
-	}
-	if err := initBMP180(); err != nil { // I2C temperature and pressure altitude.
-		i2cbus.Close()
-		return err
-	}
-	if err := initMPU6050(); err != nil { // I2C accel/gyro.
-		i2cbus.Close()
-		myBMP180.Close()
-		return err
-	}
-	globalStatus.RY835AI_connected = true
-	go attitudeReaderSender()
-	go tempAndPressureReader()
-
-	return nil
-}
-
-func pollRY835AI() {
-	timer := time.NewTicker(10 * time.Second)
-	for {
-		<-timer.C
-		// GPS enabled, was not connected previously?
-		if globalSettings.GPS_Enabled && !globalStatus.GPS_connected {
-			globalStatus.GPS_connected = initGPSSerial() // via USB for now.
-			if globalStatus.GPS_connected {
-				go gpsSerialReader()
-			}
-		}
-		// RY835AI I2C enabled, was not connected previously?
-		if globalSettings.AHRS_Enabled && !globalStatus.RY835AI_connected {
-			err := initAHRS()
-			if err != nil {
-				log.Printf("initAHRS(): %s\ndisabling AHRS sensors.\n", err.Error())
-				globalStatus.RY835AI_connected = false
-			}
-		}
-	}
-}
-
-func initRY835AI() {
-	mySituation.mu_GPS = &sync.Mutex{}
-	mySituation.mu_Attitude = &sync.Mutex{}
-
-	go pollRY835AI()
-}

main/sdr.go

@@ -1,131 +1,313 @@
+/*
+	Copyright (c) 2015-2016 Christopher Young
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	sdr.go: SDR monitoring, SDR management, data input from UAT/1090ES channels.
+*/
+
 package main
 
 import (
+	"log"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"time"
+
 	"../godump978"
 	rtl "github.com/jpoirier/gortlsdr"
-	"log"
-	"time"
 )
 
-var uatSDR int // Index.
-var esSDR int  // Index.
+// Device holds per dongle values and attributes
+type Device struct {
+	dev     *rtl.Context
+	wg      *sync.WaitGroup
+	closeCh chan int
+	indexID int
+	ppm     int
+	serial  string
+	idSet   bool
+}
 
-// Read 978MHz from SDR.
-func sdrReader() {
-	var err error
-	var dev *rtl.Context
+// UAT is a 978 MHz device
+type UAT Device
 
-	log.Printf("===== UAT Device name: %s =====\n", rtl.GetDeviceName(uatSDR))
-	if dev, err = rtl.Open(uatSDR); err != nil {
-		log.Printf("\tOpen Failed, exiting\n")
-		uatSDR = -1
-		return
-	}
-	defer dev.Close()
-	m, p, s, err := dev.GetUsbStrings()
+// ES is a 1090 MHz device
+type ES Device
+
+// UATDev holds a 978 MHz dongle object
+var UATDev *UAT
+
+// ESDev holds a 1090 MHz dongle object
+var ESDev *ES
+
+type Dump1090TermMessage struct {
+	Text   string
+	Source string
+}
+
+func (e *ES) read() {
+	defer e.wg.Done()
+	log.Println("Entered ES read() ...")
+	cmd := exec.Command("/usr/bin/dump1090", "--oversample", "--net", "--device-index", strconv.Itoa(e.indexID), "--ppm", strconv.Itoa(e.ppm))
+	stdout, _ := cmd.StdoutPipe()
+	stderr, _ := cmd.StderrPipe()
+
+	err := cmd.Start()
 	if err != nil {
-		log.Printf("\tGetUsbStrings Failed - error: %s\n", err)
-	} else {
-		log.Printf("\tGetUsbStrings - %s %s %s\n", m, p, s)
-	}
-	log.Printf("\tGetTunerType: %s\n", dev.GetTunerType())
-
-	//---------- Set Tuner Gain ----------
-	tgain := 480
-
-	err = dev.SetTunerGainMode(true)
-	if err != nil {
-		log.Printf("\tSetTunerGainMode Failed - error: %s\n", err)
-	} else {
-		log.Printf("\tSetTunerGainMode Successful\n")
+		log.Printf("Error executing /usr/bin/dump1090: %s\n", err)
+		// don't return immediately, use the proper shutdown procedure
+		shutdownES = true
+		for {
+			select {
+			case <-e.closeCh:
+				return
+			default:
+				time.Sleep(1 * time.Second)
+			}
+		}
 	}
 
-	err = dev.SetTunerGain(tgain)
-	if err != nil {
-		log.Printf("\tSetTunerGain Failed - error: %s\n", err)
-	} else {
-		log.Printf("\tSetTunerGain Successful\n")
-	}
+	log.Println("Executed /usr/bin/dump1090 successfully...")
 
-	//---------- Get/Set Sample Rate ----------
-	samplerate := 2083334
-	err = dev.SetSampleRate(samplerate)
-	if err != nil {
-		log.Printf("\tSetSampleRate Failed - error: %s\n", err)
-	} else {
-		log.Printf("\tSetSampleRate - rate: %d\n", samplerate)
-	}
-	log.Printf("\tGetSampleRate: %d\n", dev.GetSampleRate())
+	done := make(chan bool)
 
-	//---------- Get/Set Xtal Freq ----------
-	rtlFreq, tunerFreq, err := dev.GetXtalFreq()
-	if err != nil {
-		log.Printf("\tGetXtalFreq Failed - error: %s\n", err)
-	} else {
-		log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq)
-	}
+	go func() {
+		for {
+			select {
+			case <-done:
+				return
+			case <-e.closeCh:
+				log.Println("ES read(): shutdown msg received, calling cmd.Process.Kill() ...")
+				err := cmd.Process.Kill()
+				if err == nil {
+					log.Println("\t kill successful...")
+				}
+				return
+			default:
+				time.Sleep(1 * time.Second)
+			}
+		}
+	}()
 
-	newRTLFreq := 28800000
-	newTunerFreq := 28800000
-	err = dev.SetXtalFreq(newRTLFreq, newTunerFreq)
-	if err != nil {
-		log.Printf("\tSetXtalFreq Failed - error: %s\n", err)
-	} else {
-		log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n",
-			newRTLFreq, newTunerFreq)
-	}
+	stdoutBuf := make([]byte, 1024)
+	stderrBuf := make([]byte, 1024)
+	go func() {
+		for {
+			select {
+			case <-done:
+				return
+			default:
+				n, err := stdout.Read(stdoutBuf)
+				if err == nil && n > 0 {
+					m := Dump1090TermMessage{Text: string(stdoutBuf[:n]), Source: "stdout"}
+					logDump1090TermMessage(m)
+				}
+			}
+		}
+	}()
 
-	//---------- Get/Set Center Freq ----------
-	err = dev.SetCenterFreq(978000000)
-	if err != nil {
-		log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err)
-	} else {
-		log.Printf("\tSetCenterFreq 978MHz Successful\n")
-	}
+	go func() {
+		for {
+			select {
+			case <-done:
+				return
+			default:
+				n, err := stderr.Read(stderrBuf)
+				if err == nil && n > 0 {
+					m := Dump1090TermMessage{Text: string(stderrBuf[:n]), Source: "stderr"}
+					logDump1090TermMessage(m)
+				}
+			}
+		}
+	}()
 
-	log.Printf("\tGetCenterFreq: %d\n", dev.GetCenterFreq())
+	cmd.Wait()
 
-	//---------- Set Bandwidth ----------
-	bw := 1000000
-	log.Printf("\tSetting Bandwidth: %d\n", bw)
-	if err = dev.SetTunerBw(bw); err != nil {
-		log.Printf("\tSetTunerBw %d Failed, error: %s\n", bw, err)
-	} else {
-		log.Printf("\tSetTunerBw %d Successful\n", bw)
-	}
+	// we get here if A) the dump1090 process died
+	// on its own or B) cmd.Process.Kill() was called
+	// from within the goroutine, either way close
+	// the "done" channel, which ensures we don't leak
+	// goroutines...
+	close(done)
+}
 
-	if err = dev.ResetBuffer(); err == nil {
-		log.Printf("\tResetBuffer Successful\n")
-	} else {
-		log.Printf("\tResetBuffer Failed - error: %s\n", err)
-	}
-	//---------- Get/Set Freq Correction ----------
-	freqCorr := dev.GetFreqCorrection()
-	log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
-	err = dev.SetFreqCorrection(int(globalSettings.PPM))
-	if err != nil {
-		log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err)
-	} else {
-		log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM)
-	}
+func (u *UAT) read() {
+	defer u.wg.Done()
+	log.Println("Entered UAT read() ...")
+	var buffer = make([]uint8, rtl.DefaultBufLength)
 
-	for uatSDR != -1 {
-		var buffer = make([]uint8, rtl.DefaultBufLength)
-		nRead, err := dev.ReadSync(buffer, rtl.DefaultBufLength)
-		if err != nil {
-			log.Printf("\tReadSync Failed - error: %s\n", err)
-			uatSDR = -1
-			break
-		} else {
-			//			log.Printf("\tReadSync %d\n", nRead)
-			buf := buffer[:nRead]
-			godump978.InChan <- buf
+	for {
+		select {
+		default:
+			nRead, err := u.dev.ReadSync(buffer, rtl.DefaultBufLength)
+			if err != nil {
+				if globalSettings.DEBUG {
+					log.Printf("\tReadSync Failed - error: %s\n", err)
+				}
+				if shutdownUAT != true {
+					shutdownUAT = true
+				}
+				break
+			}
+
+			if nRead > 0 {
+				buf := buffer[:nRead]
+				godump978.InChan <- buf
+			}
+		case <-u.closeCh:
+			log.Println("UAT read(): shutdown msg received...")
+			return
 		}
 	}
 }
 
+func getPPM(serial string) int {
+	r, err := regexp.Compile("str?a?t?u?x:\\d+:?(-?\\d*)")
+	if err != nil {
+		return globalSettings.PPM
+	}
+
+	arr := r.FindStringSubmatch(serial)
+	if arr == nil {
+		return globalSettings.PPM
+	}
+
+	ppm, err := strconv.Atoi(arr[1])
+	if err != nil {
+		return globalSettings.PPM
+	}
+
+	return ppm
+}
+
+func (e *ES) sdrConfig() (err error) {
+	e.ppm = getPPM(e.serial)
+	log.Printf("===== ES Device Serial: %s PPM %d =====\n", e.serial, e.ppm)
+	return
+}
+
+// 978 UAT configuration settings
+const (
+	TunerGain    = 480
+	SampleRate   = 2083334
+	NewRTLFreq   = 28800000
+	NewTunerFreq = 28800000
+	CenterFreq   = 978000000
+	Bandwidth    = 1000000
+)
+
+func (u *UAT) sdrConfig() (err error) {
+	log.Printf("===== UAT Device Name  : %s =====\n", rtl.GetDeviceName(u.indexID))
+	log.Printf("===== UAT Device Serial: %s=====\n", u.serial)
+
+	if u.dev, err = rtl.Open(u.indexID); err != nil {
+		log.Printf("\tUAT Open Failed...\n")
+		return
+	}
+	log.Printf("\tGetTunerType: %s\n", u.dev.GetTunerType())
+
+	//---------- Set Tuner Gain ----------
+	err = u.dev.SetTunerGainMode(true)
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tSetTunerGainMode Failed - error: %s\n", err)
+		return
+	}
+	log.Printf("\tSetTunerGainMode Successful\n")
+
+	err = u.dev.SetTunerGain(TunerGain)
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tSetTunerGain Failed - error: %s\n", err)
+		return
+	}
+	log.Printf("\tSetTunerGain Successful\n")
+
+	tgain := u.dev.GetTunerGain()
+	log.Printf("\tGetTunerGain: %d\n", tgain)
+
+	//---------- Get/Set Sample Rate ----------
+	err = u.dev.SetSampleRate(SampleRate)
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tSetSampleRate Failed - error: %s\n", err)
+		return
+	}
+	log.Printf("\tSetSampleRate - rate: %d\n", SampleRate)
+
+	log.Printf("\tGetSampleRate: %d\n", u.dev.GetSampleRate())
+
+	//---------- Get/Set Xtal Freq ----------
+	rtlFreq, tunerFreq, err := u.dev.GetXtalFreq()
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tGetXtalFreq Failed - error: %s\n", err)
+		return
+	}
+	log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq)
+
+	err = u.dev.SetXtalFreq(NewRTLFreq, NewTunerFreq)
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tSetXtalFreq Failed - error: %s\n", err)
+		return
+	}
+	log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n",
+		NewRTLFreq, NewTunerFreq)
+
+	//---------- Get/Set Center Freq ----------
+	err = u.dev.SetCenterFreq(CenterFreq)
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err)
+		return
+	}
+	log.Printf("\tSetCenterFreq 978MHz Successful\n")
+
+	log.Printf("\tGetCenterFreq: %d\n", u.dev.GetCenterFreq())
+
+	//---------- Set Bandwidth ----------
+	log.Printf("\tSetting Bandwidth: %d\n", Bandwidth)
+	if err = u.dev.SetTunerBw(Bandwidth); err != nil {
+		u.dev.Close()
+		log.Printf("\tSetTunerBw %d Failed, error: %s\n", Bandwidth, err)
+		return
+	}
+	log.Printf("\tSetTunerBw %d Successful\n", Bandwidth)
+
+	if err = u.dev.ResetBuffer(); err != nil {
+		u.dev.Close()
+		log.Printf("\tResetBuffer Failed - error: %s\n", err)
+		return
+	}
+	log.Printf("\tResetBuffer Successful\n")
+
+	//---------- Get/Set Freq Correction ----------
+	freqCorr := u.dev.GetFreqCorrection()
+	log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
+
+	u.ppm = getPPM(u.serial)
+	err = u.dev.SetFreqCorrection(u.ppm)
+	if err != nil {
+		u.dev.Close()
+		log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", u.ppm, err)
+		return
+	}
+	log.Printf("\tSetFreqCorrection %d Successful\n", u.ppm)
+
+	return
+}
+
 // Read from the godump978 channel - on or off.
 func uatReader() {
+	log.Println("Entered uatReader() ...")
 	for {
 		uat := <-godump978.OutChan
 		o, msgtype := parseInput(uat)
@@ -135,36 +317,245 @@ func uatReader() {
 	}
 }
 
-// Watch for config/device changes.
-func sdrWatcher() {
-	timer := time.NewTicker(1 * time.Second)
-	for {
-		<-timer.C
-		// Update device count.
-		globalStatus.Devices = uint(rtl.GetDeviceCount())
+func (u *UAT) writeID() error {
+	info, err := u.dev.GetHwInfo()
+	if err != nil {
+		return err
+	}
+	info.Serial = "stratux:978"
+	return u.dev.SetHwInfo(info)
+}
 
-		if uatSDR == -1 && globalSettings.UAT_Enabled {
-			if globalStatus.Devices == 0 {
-				log.Printf("No RTL-SDR devices.\n")
-				continue
+func (e *ES) writeID() error {
+	info, err := e.dev.GetHwInfo()
+	if err != nil {
+		return err
+	}
+	info.Serial = "stratux:1090"
+	return e.dev.SetHwInfo(info)
+}
+
+func (u *UAT) shutdown() {
+	log.Println("Entered UAT shutdown() ...")
+	close(u.closeCh) // signal to shutdown
+	log.Println("UAT shutdown(): calling u.wg.Wait() ...")
+	u.wg.Wait() // Wait for the goroutine to shutdown
+	log.Println("UAT shutdown(): u.wg.Wait() returned...")
+	log.Println("UAT shutdown(): closing device ...")
+	u.dev.Close() // preempt the blocking ReadSync call
+	log.Println("UAT shutdown() complete ...")
+}
+
+func (e *ES) shutdown() {
+	log.Println("Entered ES shutdown() ...")
+	close(e.closeCh) // signal to shutdown
+	log.Println("ES shutdown(): calling e.wg.Wait() ...")
+	e.wg.Wait() // Wait for the goroutine to shutdown
+	log.Println("ES shutdown() complete ...")
+}
+
+var sdrShutdown bool
+
+func sdrKill() {
+	// Send signal to shutdown to sdrWatcher().
+	sdrShutdown = true
+	// Spin until all devices have been de-initialized.
+	for UATDev != nil || ESDev != nil {
+		time.Sleep(1 * time.Second)
+	}
+}
+
+func reCompile(s string) *regexp.Regexp {
+	// note , compile returns a nil pointer on error
+	r, _ := regexp.Compile(s)
+	return r
+}
+
+type regexUAT regexp.Regexp
+type regexES regexp.Regexp
+
+var rUAT = (*regexUAT)(reCompile("str?a?t?u?x:978"))
+var rES = (*regexES)(reCompile("str?a?t?u?x:1090"))
+
+func (r *regexUAT) hasID(serial string) bool {
+	if r == nil {
+		return strings.HasPrefix(serial, "stratux:978")
+	}
+	return (*regexp.Regexp)(r).MatchString(serial)
+}
+
+func (r *regexES) hasID(serial string) bool {
+	if r == nil {
+		return strings.HasPrefix(serial, "stratux:1090")
+	}
+	return (*regexp.Regexp)(r).MatchString(serial)
+}
+
+func createUATDev(id int, serial string, idSet bool) error {
+	UATDev = &UAT{indexID: id, serial: serial}
+	if err := UATDev.sdrConfig(); err != nil {
+		log.Printf("UATDev.sdrConfig() failed: %s\n", err)
+		UATDev = nil
+		return err
+	}
+	UATDev.wg = &sync.WaitGroup{}
+	UATDev.idSet = idSet
+	UATDev.closeCh = make(chan int)
+	UATDev.wg.Add(1)
+	go UATDev.read()
+	return nil
+}
+
+func createESDev(id int, serial string, idSet bool) error {
+	ESDev = &ES{indexID: id, serial: serial}
+	if err := ESDev.sdrConfig(); err != nil {
+		log.Printf("ESDev.sdrConfig() failed: %s\n", err)
+		ESDev = nil
+		return err
+	}
+	ESDev.wg = &sync.WaitGroup{}
+	ESDev.idSet = idSet
+	ESDev.closeCh = make(chan int)
+	ESDev.wg.Add(1)
+	go ESDev.read()
+	return nil
+}
+
+func configDevices(count int, esEnabled, uatEnabled bool) {
+	// once the tagged dongles have been assigned, explicitly range over
+	// the remaining IDs and assign them to any anonymous dongles
+	unusedIDs := make(map[int]string)
+
+	// loop 1: assign tagged dongles
+	for i := 0; i < count; i++ {
+		_, _, s, err := rtl.GetDeviceUsbStrings(i)
+		if err == nil {
+			//FIXME: Trim NULL from the serial. Best done in gortlsdr, but putting this here for now.
+			s = strings.Trim(s, "\x00")
+			// no need to check if createXDev returned an error; if it
+			// failed to config the error is logged and we can ignore
+			// it here so it doesn't get queued up again
+			if uatEnabled && UATDev == nil && rUAT.hasID(s) {
+				createUATDev(i, s, true)
+			} else if esEnabled && ESDev == nil && rES.hasID(s) {
+				createESDev(i, s, true)
+			} else {
+				unusedIDs[i] = s
 			}
-			uatSDR = 0
-			go sdrReader()
+		} else {
+			log.Printf("rtl.GetDeviceUsbStrings id %d: %s\n", i, err)
 		}
-		if esSDR == -1 && globalSettings.ES_Enabled {
-			if globalStatus.Devices == 0 || (globalStatus.Devices == 1 && globalSettings.UAT_Enabled) {
-				log.Printf("Not enough RTL-SDR devices.\n")
-			}
-			esSDR = 1
+	}
+
+	// loop 2: assign anonymous dongles but sanity check the serial ids
+	// so we don't cross config for dual assigned dongles. e.g. when two
+	// dongles are set to the same stratux id and the unconsumed,
+	// non-anonymous, dongle makes it to this loop.
+	for i, s := range unusedIDs {
+		if uatEnabled && !globalStatus.UATRadio_connected && UATDev == nil && !rES.hasID(s) {
+			createUATDev(i, s, false)
+		} else if esEnabled && ESDev == nil && !rUAT.hasID(s) {
+			createESDev(i, s, false)
 		}
 	}
 }
 
+// to keep our sync primitives synchronized, only exit a read
+// method's goroutine via the close flag channel check, to
+// include catastrophic dongle failures
+var shutdownES bool
+var shutdownUAT bool
+
+// Watch for config/device changes.
+func sdrWatcher() {
+	prevCount := 0
+	prevUATEnabled := false
+	prevESEnabled := false
+
+	// Get the system (RPi) uptime.
+	info := syscall.Sysinfo_t{}
+	err := syscall.Sysinfo(&info)
+	if err == nil {
+		// Got system uptime. Delay if and only if the system uptime is less than 120 seconds. This should be plenty of time
+		//  for the RPi to come up and start Stratux. Keeps the delay from happening if the daemon is auto-restarted from systemd.
+		if info.Uptime < 120 {
+			time.Sleep(90 * time.Second)
+		} else if globalSettings.DeveloperMode {
+			// Throw a "critical error" if developer mode is enabled. Alerts the developer that the daemon was restarted (possibly)
+			//  unexpectedly.
+			addSingleSystemErrorf("restart-warn", "System uptime %d seconds. Daemon was restarted.\n", info.Uptime)
+		}
+	}
+
+	for {
+		time.Sleep(1 * time.Second)
+		if sdrShutdown {
+			if UATDev != nil {
+				UATDev.shutdown()
+				UATDev = nil
+			}
+			if ESDev != nil {
+				ESDev.shutdown()
+				ESDev = nil
+			}
+			return
+		}
+
+		// true when a ReadSync call fails
+		if shutdownUAT {
+			if UATDev != nil {
+				UATDev.shutdown()
+				UATDev = nil
+			}
+			shutdownUAT = false
+		}
+		// true when we get stderr output
+		if shutdownES {
+			if ESDev != nil {
+				ESDev.shutdown()
+				ESDev = nil
+			}
+			shutdownES = false
+		}
+
+		// capture current state
+		esEnabled := globalSettings.ES_Enabled
+		uatEnabled := globalSettings.UAT_Enabled
+		count := rtl.GetDeviceCount()
+		interfaceCount := count
+		if globalStatus.UATRadio_connected {
+			interfaceCount++
+		}
+		atomic.StoreUint32(&globalStatus.Devices, uint32(interfaceCount))
+
+		// support up to two dongles
+		if count > 2 {
+			count = 2
+		}
+
+		if count == prevCount && prevESEnabled == esEnabled && prevUATEnabled == uatEnabled {
+			continue
+		}
+
+		// the device count or the global settings have changed, reconfig
+		if UATDev != nil {
+			UATDev.shutdown()
+			UATDev = nil
+		}
+		if ESDev != nil {
+			ESDev.shutdown()
+			ESDev = nil
+		}
+		configDevices(count, esEnabled, uatEnabled)
+
+		prevCount = count
+		prevUATEnabled = uatEnabled
+		prevESEnabled = esEnabled
+	}
+}
+
 func sdrInit() {
-	uatSDR = -1
-	esSDR = -1
 	go sdrWatcher()
 	go uatReader()
-	godump978.Dump978Init()
 	go godump978.ProcessDataFromChannel()
 }

main/sensors.go

@@ -0,0 +1,494 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"../goflying/ahrs"
+	"../goflying/ahrsweb"
+	"../sensors"
+	"github.com/kidoman/embd"
+	_ "github.com/kidoman/embd/host/all"
+)
+
+const (
+	numRetries uint8 = 5
+	calCLimit        = 0.15
+	calDLimit        = 10.0
+
+	// WHO_AM_I values to differentiate between the different IMUs.
+	MPUREG_WHO_AM_I     = 0x75
+	MPUREG_WHO_AM_I_VAL = 0x71 // Expected value.
+	ICMREG_WHO_AM_I     = 0x00
+	ICMREG_WHO_AM_I_VAL = 0xEA // Expected value.
+)
+
+var (
+	i2cbus           embd.I2CBus
+	myPressureReader sensors.PressureReader
+	myIMUReader      sensors.IMUReader
+	cal              chan (string)
+	analysisLogger   *ahrs.AHRSLogger
+	ahrsCalibrating  bool
+	logMap           map[string]interface{}
+)
+
+func initI2CSensors() {
+	i2cbus = embd.NewI2CBus(1)
+
+	go pollSensors()
+	go sensorAttitudeSender()
+	go updateAHRSStatus()
+}
+
+func pollSensors() {
+	timer := time.NewTicker(4 * time.Second)
+	for {
+		<-timer.C
+
+		// If it's not currently connected, try connecting to pressure sensor
+		if globalSettings.BMP_Sensor_Enabled && !globalStatus.BMPConnected {
+			globalStatus.BMPConnected = initPressureSensor() // I2C temperature and pressure altitude.
+			go tempAndPressureSender()
+		}
+
+		// If it's not currently connected, try connecting to IMU
+		if globalSettings.IMU_Sensor_Enabled && !globalStatus.IMUConnected {
+			globalStatus.IMUConnected = initIMU() // I2C accel/gyro/mag.
+		}
+	}
+}
+
+func initPressureSensor() (ok bool) {
+	bmp, err := sensors.NewBMP280(&i2cbus, 100*time.Millisecond)
+	if err == nil {
+		myPressureReader = bmp
+		return true
+	}
+
+	//TODO westphae: make bmp180.go to fit bmp interface
+
+	return false
+}
+
+func tempAndPressureSender() {
+	var (
+		temp     float64
+		press    float64
+		altLast  = -9999.9
+		altitude float64
+		err      error
+		dt       = 0.1
+		failNum  uint8
+	)
+
+	// Initialize variables for rate of climb calc
+	u := 5 / (5 + float32(dt)) // Use 5 sec decay time for rate of climb, slightly faster than typical VSI
+
+	timer := time.NewTicker(time.Duration(1000*dt) * time.Millisecond)
+	for globalSettings.BMP_Sensor_Enabled && globalStatus.BMPConnected {
+		<-timer.C
+
+		// Read temperature and pressure altitude.
+		temp, err = myPressureReader.Temperature()
+		if err != nil {
+			addSingleSystemErrorf("pressure-sensor-temp-read", "AHRS Error: Couldn't read temperature from sensor: %s", err)
+		}
+		press, err = myPressureReader.Pressure()
+		if err != nil {
+			addSingleSystemErrorf("pressure-sensor-pressure-read", "AHRS Error: Couldn't read pressure from sensor: %s", err)
+			failNum++
+			if failNum > numRetries {
+				//				log.Printf("AHRS Error: Couldn't read pressure from sensor %d times, closing BMP: %s", failNum, err)
+				myPressureReader.Close()
+				globalStatus.BMPConnected = false // Try reconnecting a little later
+				break
+			}
+		}
+
+		// Update the Situation data.
+		mySituation.muBaro.Lock()
+		mySituation.BaroLastMeasurementTime = stratuxClock.Time
+		mySituation.BaroTemperature = float32(temp)
+		altitude = CalcAltitude(press)
+		mySituation.BaroPressureAltitude = float32(altitude)
+		if altLast < -2000 {
+			altLast = altitude // Initialize
+		}
+		// Assuming timer is reasonably accurate, use a regular ewma
+		mySituation.BaroVerticalSpeed = u*mySituation.BaroVerticalSpeed + (1-u)*float32(altitude-altLast)/(float32(dt)/60)
+		mySituation.muBaro.Unlock()
+		altLast = altitude
+	}
+	mySituation.BaroPressureAltitude = 99999
+	mySituation.BaroVerticalSpeed = 99999
+}
+
+func initIMU() (ok bool) {
+	// Check if the chip is the ICM-20948 or MPU-9250.
+	v, err := i2cbus.ReadByteFromReg(0x68, ICMREG_WHO_AM_I)
+	if err != nil {
+		log.Printf("Error identifying IMU: %s\n", err.Error())
+		return false
+	}
+	v2, err := i2cbus.ReadByteFromReg(0x68, MPUREG_WHO_AM_I)
+	if err != nil {
+		log.Printf("Error identifying IMU: %s\n", err.Error())
+		return false
+	}
+
+	if v == ICMREG_WHO_AM_I_VAL {
+		log.Println("ICM-20948 detected.")
+		imu, err := sensors.NewICM20948(&i2cbus)
+		if err == nil {
+			myIMUReader = imu
+			return true
+		}
+	} else if v2 == MPUREG_WHO_AM_I_VAL {
+		log.Println("MPU-9250 detected.")
+		imu, err := sensors.NewMPU9250(&i2cbus)
+		if err == nil {
+			myIMUReader = imu
+			return true
+		}
+	} else {
+		log.Printf("Could not identify MPU. v=%02x, v2=%02x.\n", v, v2)
+		return false
+	}
+
+	return false
+}
+
+//FIXME: Shoud be moved to managementinterface.go and standardized on management interface port.
+
+func sensorAttitudeSender() {
+	var (
+		t                    time.Time
+		roll, pitch, heading float64
+		mpuError, magError   error
+		failNum              uint8
+	)
+
+	s := ahrs.NewSimpleAHRS()
+	m := ahrs.NewMeasurement()
+	cal = make(chan (string), 1)
+
+	// Set up loggers for analysis
+	ahrswebListener, err := ahrsweb.NewKalmanListener()
+	if err != nil {
+		// addSingleSystemErrorf("ahrs-web-start", "AHRS Info: couldn't start ahrswebListener: %s\n", err.Error())
+	} else {
+		defer ahrswebListener.Close()
+	}
+
+	// Need a sampling freq faster than 10Hz
+	timer := time.NewTicker(50 * time.Millisecond) // ~20Hz update.
+	for {
+		// Set sensor gyro calibrations
+		if c, d := &globalSettings.C, &globalSettings.D; d[0]*d[0]+d[1]*d[1]+d[2]*d[2] > 0 {
+			s.SetCalibrations(c, d)
+			log.Printf("AHRS Info: IMU Calibrations read from settings: accel %6f %6f %6f; gyro %6f %6f %6f\n",
+				c[0], c[1], c[2], d[0], d[1], d[2])
+		} else {
+			// Do an initial calibration
+			select { // Don't block if cal isn't receiving: only need one calibration in the queue at a time.
+			case cal <- "cal":
+			default:
+			}
+		}
+
+		// Set sensor quaternion
+		if f := &globalSettings.SensorQuaternion; f[0]*f[0]+f[1]*f[1]+f[2]*f[2]+f[3]*f[3] > 0 {
+			s.SetSensorQuaternion(f)
+		} else {
+			select { // Don't block if cal isn't receiving: only need one calibration in the queue at a time.
+			case cal <- "level":
+			default:
+			}
+		}
+
+		failNum = 0
+		<-timer.C
+		time.Sleep(950 * time.Millisecond)
+		for globalSettings.IMU_Sensor_Enabled && globalStatus.IMUConnected {
+			<-timer.C
+
+			// Process calibration and level requests
+			select {
+			case action := <-cal:
+				log.Printf("AHRS Info: cal received action %s\n", action)
+				ahrsCalibrating = true
+				myIMUReader.Read() // Clear out the averages
+				var (
+					nTries uint8
+					cc, dd float64
+				)
+				for (math.Abs(cc-1) > calCLimit || dd > calDLimit) && nTries < numRetries {
+					time.Sleep(1 * time.Second)
+					_, d1, d2, d3, c1, c2, c3, _, _, _, mpuError, _ := myIMUReader.Read()
+					cc = math.Sqrt(c1*c1 + c2*c2 + c3*c3)
+					dd = math.Sqrt(d1*d1 + d2*d2 + d3*d3)
+					nTries++
+					log.Printf("AHRS Info: IMU calibration attempt #%d\n", nTries)
+					if mpuError != nil {
+						log.Printf("AHRS Info: Error reading IMU while calibrating: %s\n", mpuError)
+					} else {
+						if strings.Contains(action, "cal") { // Calibrate gyros
+							globalSettings.D = [3]float64{d1, d2, d3}
+							s.SetCalibrations(nil, &globalSettings.D)
+							log.Printf("AHRS Info: IMU gyro calibration: %3f %3f %3f\n", d1, d2, d3)
+						}
+						if strings.Contains(action, "level") { // Calibrate accel / level
+							globalSettings.C = [3]float64{c1, c2, c3}
+							s.SetCalibrations(&globalSettings.C, nil)
+							globalSettings.SensorQuaternion = *makeOrientationQuaternion(globalSettings.C)
+							s.SetSensorQuaternion(&globalSettings.SensorQuaternion)
+							s.Reset()
+							log.Printf("AHRS Info: IMU accel calibration: %3f %3f %3f\n", c1, c2, c3)
+							log.Printf("AHRS Info: Caged to quaternion %v\n", globalSettings.SensorQuaternion)
+						}
+						saveSettings()
+					}
+				}
+				ahrsCalibrating = false
+				<-timer.C // Make sure we get data for the actual algorithm
+			default:
+			}
+
+			// Make the IMU sensor measurements.
+			t = stratuxClock.Time
+			m.T = float64(t.UnixNano()/1000) / 1e6
+			_, m.B1, m.B2, m.B3, m.A1, m.A2, m.A3, m.M1, m.M2, m.M3, mpuError, magError = myIMUReader.Read()
+			m.SValid = mpuError == nil
+			m.MValid = magError == nil
+			if mpuError != nil {
+				log.Printf("AHRS Gyro/Accel Error: %s\n", mpuError)
+				failNum++
+				if failNum > numRetries {
+					log.Printf("AHRS Gyro/Accel Error: failed to read %d times, restarting: %s\n",
+						failNum-1, mpuError)
+					myIMUReader.Close()
+					globalStatus.IMUConnected = false
+				}
+				continue
+			}
+			failNum = 0
+			if magError != nil {
+				if globalSettings.DEBUG {
+					log.Printf("AHRS Magnetometer Error, not using for this run: %s\n", magError)
+				}
+				m.MValid = false
+			}
+
+			// Make the GPS measurements.
+			m.TW = float64(mySituation.GPSLastGroundTrackTime.UnixNano()/1000) / 1e6
+			m.WValid = isGPSGroundTrackValid()
+			if m.WValid {
+				m.W1 = mySituation.GPSGroundSpeed * math.Sin(float64(mySituation.GPSTrueCourse)*ahrs.Deg)
+				m.W2 = mySituation.GPSGroundSpeed * math.Cos(float64(mySituation.GPSTrueCourse)*ahrs.Deg)
+				if globalSettings.BMP_Sensor_Enabled && globalStatus.BMPConnected {
+					m.W3 = float64(mySituation.BaroVerticalSpeed * 60 / 6076.12)
+				} else {
+					m.W3 = float64(mySituation.GPSVerticalSpeed) * 3600 / 6076.12
+				}
+			}
+
+			// Run the AHRS calculations.
+			s.Compute(m)
+
+			// If we have valid AHRS info, then update mySituation.
+			mySituation.muAttitude.Lock()
+			if s.Valid() {
+				roll, pitch, heading = s.RollPitchHeading()
+				mySituation.AHRSRoll = roll / ahrs.Deg
+				mySituation.AHRSPitch = pitch / ahrs.Deg
+				mySituation.AHRSGyroHeading = heading
+				if !isAHRSInvalidValue(heading) {
+					mySituation.AHRSGyroHeading /= ahrs.Deg
+				}
+
+				//TODO westphae: until magnetometer calibration is performed, no mag heading
+				mySituation.AHRSMagHeading = ahrs.Invalid
+				mySituation.AHRSSlipSkid = s.SlipSkid()
+				mySituation.AHRSTurnRate = s.RateOfTurn()
+				mySituation.AHRSGLoad = s.GLoad()
+				if mySituation.AHRSGLoad < mySituation.AHRSGLoadMin || mySituation.AHRSGLoadMin == 0 {
+					mySituation.AHRSGLoadMin = mySituation.AHRSGLoad
+				}
+				if mySituation.AHRSGLoad > mySituation.AHRSGLoadMax {
+					mySituation.AHRSGLoadMax = mySituation.AHRSGLoad
+				}
+
+				mySituation.AHRSLastAttitudeTime = t
+			} else {
+				mySituation.AHRSRoll = ahrs.Invalid
+				mySituation.AHRSPitch = ahrs.Invalid
+				mySituation.AHRSGyroHeading = ahrs.Invalid
+				mySituation.AHRSMagHeading = ahrs.Invalid
+				mySituation.AHRSSlipSkid = ahrs.Invalid
+				mySituation.AHRSTurnRate = ahrs.Invalid
+				mySituation.AHRSGLoad = ahrs.Invalid
+				mySituation.AHRSGLoadMin = ahrs.Invalid
+				mySituation.AHRSGLoadMax = 0
+				mySituation.AHRSLastAttitudeTime = time.Time{}
+				s.Reset()
+			}
+			mySituation.muAttitude.Unlock()
+
+			makeAHRSGDL90Report() // Send whether or not valid - the function will invalidate the values as appropriate
+
+			// Send to AHRS debugging server.
+			if ahrswebListener != nil {
+				if err = ahrswebListener.Send(s.GetState(), m); err != nil {
+					log.Printf("AHRS Error: couldn't write to ahrsweb: %s\n", err)
+					ahrswebListener = nil
+				}
+			}
+
+			// Log it to csv for later analysis.
+			if globalSettings.AHRSLog && usage.Usage() < 0.95 {
+				if analysisLogger == nil {
+					analysisFilename := fmt.Sprintf("sensors_%s.csv", time.Now().Format("20060102_150405"))
+					logMap = s.GetLogMap()
+					updateExtraLogging()
+					analysisLogger = ahrs.NewAHRSLogger(filepath.Join(logDirf, analysisFilename), logMap)
+				}
+
+				if analysisLogger != nil {
+					updateExtraLogging()
+					analysisLogger.Log()
+				}
+			} else {
+				analysisLogger = nil
+			}
+		}
+	}
+}
+
+func updateExtraLogging() {
+	logMap["GPSNACp"] = float64(mySituation.GPSNACp)
+	logMap["GPSTrueCourse"] = mySituation.GPSTrueCourse
+	logMap["GPSVerticalAccuracy"] = mySituation.GPSVerticalAccuracy
+	logMap["GPSHorizontalAccuracy"] = mySituation.GPSHorizontalAccuracy
+	logMap["GPSAltitudeMSL"] = mySituation.GPSAltitudeMSL
+	logMap["GPSFixQuality"] = float64(mySituation.GPSFixQuality)
+	logMap["BaroPressureAltitude"] = float64(mySituation.BaroPressureAltitude)
+	logMap["BaroVerticalSpeed"] = float64(mySituation.BaroVerticalSpeed)
+}
+
+func makeOrientationQuaternion(g [3]float64) (f *[4]float64) {
+	if globalSettings.IMUMapping[0] == 0 { // if unset, default to some standard orientation
+		globalSettings.IMUMapping[0] = -1 // +2 for RY836AI
+	}
+
+	// This is the "forward direction" chosen during the orientation process.
+	var x *[3]float64 = new([3]float64)
+	if globalSettings.IMUMapping[0] < 0 {
+		x[-globalSettings.IMUMapping[0]-1] = -1
+	} else {
+		x[+globalSettings.IMUMapping[0]-1] = +1
+	}
+
+	// Normalize the gravity vector to be 1 G.
+	z, _ := ahrs.MakeUnitVector(g)
+
+	rotmat, _ := ahrs.MakeHardSoftRotationMatrix(*z, *x, [3]float64{0, 0, 1}, [3]float64{1, 0, 0})
+	f = new([4]float64)
+	f[0], f[1], f[2], f[3] = ahrs.RotationMatrixToQuaternion(*rotmat)
+	return
+}
+
+// This is used in the orientation process where the user specifies the forward and up directions.
+func getMinAccelDirection() (i int, err error) {
+	_, _, _, _, a1, a2, a3, _, _, _, err, _ := myIMUReader.ReadOne()
+	if err != nil {
+		return
+	}
+	log.Printf("AHRS Info: sensor orientation accels %1.3f %1.3f %1.3f\n", a1, a2, a3)
+	switch {
+	case math.Abs(a1) > math.Abs(a2) && math.Abs(a1) > math.Abs(a3):
+		if a1 > 0 {
+			i = 1
+		} else {
+			i = -1
+		}
+	case math.Abs(a2) > math.Abs(a3) && math.Abs(a2) > math.Abs(a1):
+		if a2 > 0 {
+			i = 2
+		} else {
+			i = -2
+		}
+	case math.Abs(a3) > math.Abs(a1) && math.Abs(a3) > math.Abs(a2):
+		if a3 > 0 {
+			i = 3
+		} else {
+			i = -3
+		}
+	default:
+		err = fmt.Errorf("couldn't determine biggest accel from %1.3f %1.3f %1.3f", a1, a2, a3)
+	}
+
+	return
+}
+
+// CageAHRS sends a signal to the AHRSProvider that it should recalibrate and reset its level orientation.
+func CageAHRS() {
+	cal <- "level"
+}
+
+// CageAHRS sends a signal to the AHRSProvider that it should recalibrate and reset its level orientation.
+func CalibrateAHRS() {
+	cal <- "cal"
+}
+
+// ResetAHRSGLoad resets the min and max to the current G load value.
+func ResetAHRSGLoad() {
+	mySituation.AHRSGLoadMax = mySituation.AHRSGLoad
+	mySituation.AHRSGLoadMin = mySituation.AHRSGLoad
+}
+
+func updateAHRSStatus() {
+	var (
+		msg    uint8
+		imu    bool
+		ticker *time.Ticker
+	)
+
+	ticker = time.NewTicker(250 * time.Millisecond)
+
+	for {
+		<-ticker.C
+		msg = 0
+
+		// GPS ground track valid?
+		if isGPSGroundTrackValid() {
+			msg++
+		}
+		// IMU is being used
+		imu = globalSettings.IMU_Sensor_Enabled && globalStatus.IMUConnected
+		if imu {
+			msg += 1 << 1
+		}
+		// BMP is being used
+		if globalSettings.BMP_Sensor_Enabled && globalStatus.BMPConnected {
+			msg += 1 << 2
+		}
+		// IMU is doing a calibration
+		if ahrsCalibrating {
+			msg += 1 << 3
+		}
+		// Logging to csv
+		if imu && analysisLogger != nil {
+			msg += 1 << 4
+		}
+		mySituation.AHRSStatus = msg
+	}
+}
+
+func isAHRSInvalidValue(val float64) bool {
+	return math.Abs(val-ahrs.Invalid) < 0.01
+}

main/uibroadcast.go

@@ -0,0 +1,67 @@
+/*
+	Copyright (c) 2015-2016 Christopher Young
+	Distributable under the terms of The "BSD New" License
+	that can be found in the LICENSE file, herein included
+	as part of this header.
+
+	uibroadcast.go: Helper functions for managementinterface - notification channels for update "subscriptions"
+	 (used for weather and traffic websockets).
+*/
+
+package main
+
+import (
+	"encoding/json"
+	"golang.org/x/net/websocket"
+	"sync"
+	"time"
+)
+
+type uibroadcaster struct {
+	sockets    []*websocket.Conn
+	sockets_mu *sync.Mutex
+	messages   chan []byte
+}
+
+func NewUIBroadcaster() *uibroadcaster {
+	ret := &uibroadcaster{
+		sockets:    make([]*websocket.Conn, 0),
+		sockets_mu: &sync.Mutex{},
+		messages:   make(chan []byte, 1024),
+	}
+	go ret.writer()
+	return ret
+}
+
+func (u *uibroadcaster) Send(msg []byte) {
+	u.messages <- msg
+}
+
+func (u *uibroadcaster) SendJSON(i interface{}) {
+	j, _ := json.Marshal(&i)
+	u.Send(j)
+}
+
+func (u *uibroadcaster) AddSocket(sock *websocket.Conn) {
+	u.sockets_mu.Lock()
+	u.sockets = append(u.sockets, sock)
+	u.sockets_mu.Unlock()
+}
+
+func (u *uibroadcaster) writer() {
+	for {
+		msg := <-u.messages
+		// Send to all.
+		p := make([]*websocket.Conn, 0) // Keep a list of the writeable sockets.
+		u.sockets_mu.Lock()
+		for _, sock := range u.sockets {
+			err := sock.SetWriteDeadline(time.Now().Add(time.Second))
+			_, err2 := sock.Write(msg)
+			if err == nil && err2 == nil {
+				p = append(p, sock)
+			}
+		}
+		u.sockets = p // Save the list of writeable sockets.
+		u.sockets_mu.Unlock()
+	}
+}

mpu6050/mpu6050.go

@@ -1,273 +0,0 @@
-// Package mpu6050 allows interfacing with InvenSense mpu6050 barometric pressure sensor. This sensor
-// has the ability to provided compensated temperature and pressure readings.
-package mpu6050
-
-import (
-	"math"
-	"time"
-	//	"github.com/golang/glog"
-	"github.com/kidoman/embd"
-	"log"
-)
-
-//https://www.olimex.com/Products/Modules/Sensors/MOD-MPU6050/resources/RM-MPU-60xxA_rev_4.pdf
-const (
-	address = 0x68
-
-	GYRO_XOUT_H = 0x43
-	GYRO_YOUT_H = 0x45
-	GYRO_ZOUT_H = 0x47
-
-	ACCEL_XOUT_H = 0x3B
-	ACCEL_YOUT_H = 0x3D
-	ACCEL_ZOUT_H = 0x3F
-
-	PWR_MGMT_1 = 0x6B
-
-	GYRO_CONFIG = 0x1B
-	ACCEL_CONFIG = 0x1C
-
-	ACCEL_SCALE = 16384.0 // Assume AFS_SEL = 0.
-	GYRO_SCALE  = 131.0   // Assume FS_SEL = 0.
-
-	pollDelay = 500 * time.Microsecond // 2000Hz
-)
-
-type XYZ struct {
-	x float32
-	y float32
-	z float32
-}
-
-// MPU6050 represents a InvenSense MPU6050 sensor.
-type MPU6050 struct {
-	Bus  embd.I2CBus
-	Poll time.Duration
-
-	started bool
-
-	//TODO
-	gyro_reading  XYZ // "Integrated".
-	accel_reading XYZ // Directly from sensor.
-
-	pitch_history []float64
-	roll_history  []float64
-
-	pitch_resting float64
-	roll_resting  float64
-
-	pitch   float64
-	roll    float64
-	heading float64
-	//	gyro		chan XYZ
-	//	accel		chan XYZ
-
-	quit chan struct{}
-}
-
-// New returns a handle to a MPU6050 sensor.
-func New(bus embd.I2CBus) *MPU6050 {
-	n := &MPU6050{Bus: bus, Poll: pollDelay}
-	n.StartUp()
-	return n
-}
-
-//TODO
-func (d *MPU6050) StartUp() error {
-	d.Bus.WriteByteToReg(address, PWR_MGMT_1, 0) // Wake device up.
-
-	d.Bus.WriteByteToReg(address, GYRO_CONFIG, 0) // FS_SEL = 0
-	d.Bus.WriteByteToReg(address, ACCEL_CONFIG, 0) // AFS_SEL = 0
-
-	d.pitch_history = make([]float64, 0)
-	d.roll_history = make([]float64, 0)
-
-	d.started = true
-	d.Run()
-
-	return nil
-}
-
-func (d *MPU6050) calibrate() {
-	//TODO: Error checking to make sure that the histories are extensive enough to be significant.
-	//TODO: Error checking to do continuous calibrations.
-	pitch_adjust := float64(0)
-	for _, v := range d.pitch_history {
-		pitch_adjust = pitch_adjust + v
-	}
-	pitch_adjust = pitch_adjust / float64(len(d.pitch_history))
-	d.pitch_resting = pitch_adjust
-
-	roll_adjust := float64(0)
-	for _, v := range d.roll_history {
-		roll_adjust = roll_adjust + v
-	}
-	roll_adjust = roll_adjust / float64(len(d.roll_history))
-	d.roll_resting = roll_adjust
-	log.Printf("calibrate: pitch %f, roll %f\n", pitch_adjust, roll_adjust)
-}
-
-func (d *MPU6050) readGyro() (XYZ, error) {
-	var ret XYZ
-
-	x, err := d.Bus.ReadWordFromReg(address, GYRO_XOUT_H)
-	if err != nil {
-		return ret, err
-	}
-	y, err := d.Bus.ReadWordFromReg(address, GYRO_YOUT_H)
-	if err != nil {
-		return ret, err
-	}
-	z, err := d.Bus.ReadWordFromReg(address, GYRO_ZOUT_H)
-	if err != nil {
-		return ret, err
-	}
-
-	ret.x = float32(int16(x)) / GYRO_SCALE // º/sec
-	ret.y = float32(int16(y)) / GYRO_SCALE // º/sec
-	ret.z = float32(int16(z)) / GYRO_SCALE // º/sec
-
-	return ret, nil
-}
-
-func (d *MPU6050) readAccel() (XYZ, error) {
-	var ret XYZ
-
-	x, err := d.Bus.ReadWordFromReg(address, ACCEL_XOUT_H)
-	if err != nil {
-		return ret, err
-	}
-	y, err := d.Bus.ReadWordFromReg(address, ACCEL_YOUT_H)
-	if err != nil {
-		return ret, err
-	}
-	z, err := d.Bus.ReadWordFromReg(address, ACCEL_ZOUT_H)
-	if err != nil {
-		return ret, err
-	}
-
-	ret.x = float32(int16(x)) / ACCEL_SCALE
-	ret.y = float32(int16(y)) / ACCEL_SCALE
-	ret.z = float32(int16(z)) / ACCEL_SCALE
-
-	return ret, nil
-}
-
-func (d *MPU6050) calculatePitchAndRoll() {
-	accel := d.accel_reading
-	//	log.Printf("accel: %f, %f, %f\n", accel.x, accel.y, accel.z)
-
-	// Accel.
-
-	p1 := math.Atan2(float64(accel.y), dist(accel.x, accel.z))
-	p1_deg := p1 * (180.0 / math.Pi)
-
-	r1 := math.Atan2(float64(accel.x), dist(accel.y, accel.z))
-	r1_deg := -r1 * (180.0 / math.Pi)
-
-	// Gyro.
-
-	p2 := float64(d.gyro_reading.x)
-	r2 := float64(d.gyro_reading.y) // Backwards?
-
-	// "Noise filter".
-	ft := float64(0.98)
-	sample_period := float64(1 / 2000.0)
-	d.pitch = float64(ft*(sample_period*p2+d.pitch) + (1-ft)*p1_deg)
-	d.roll = float64((ft*(sample_period*r2+d.roll) + (1-ft)*r1_deg))
-
-	d.pitch_history = append(d.pitch_history, d.pitch)
-	d.roll_history = append(d.roll_history, d.roll)
-
-	//FIXME: Experimental (heading).
-
-
-
-	f := math.Atan2(float64(d.gyro_reading.z), dist(float32(d.pitch), float32(d.roll)))
-	h1_deg := -float64(3.42857142857)*f * (180.0 / math.Pi)
-	//	d.heading = float64((float64(3.42857142857)*sample_period * float64(-d.gyro_reading.z)) + d.heading)
-	d.heading = float64((sample_period * h1_deg) + d.heading)
-	if d.heading > 360.0 {
-		d.heading = d.heading - float64(360.0)
-	} else if d.heading < 0.0 {
-		d.heading = d.heading + float64(360.0)
-	}
-}
-
-func (d *MPU6050) measureGyro() error {
-	XYZ_gyro, err := d.readGyro()
-	if err != nil {
-		return err
-	}
-	d.gyro_reading = XYZ_gyro
-	return nil
-}
-
-func (d *MPU6050) measureAccel() error {
-	XYZ_accel, err := d.readAccel()
-	if err != nil {
-		return err
-	}
-	d.accel_reading = XYZ_accel
-	return nil
-}
-
-func (d *MPU6050) measure() error {
-	if err := d.measureGyro(); err != nil {
-		return err
-	}
-	if err := d.measureAccel(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func dist(a, b float32) float64 {
-	a64 := float64(a)
-	b64 := float64(b)
-	return math.Sqrt((a64 * a64) + (b64 * b64))
-}
-
-// Temperature returns the current temperature reading.
-func (d *MPU6050) PitchAndRoll() (float64, float64) {
-	return (d.pitch - d.pitch_resting), (d.roll - d.roll_resting)
-}
-
-func (d *MPU6050) Heading() float64 {
-	return d.heading
-}
-
-func (d *MPU6050) Run() {
-	go func() {
-		d.quit = make(chan struct{})
-		timer := time.NewTicker(d.Poll)
-		calibrateTimer := time.NewTicker(1 * time.Minute)
-		for {
-			select {
-			case <-timer.C:
-				d.measureGyro()
-				d.measureAccel()
-				d.calculatePitchAndRoll()
-			case <-calibrateTimer.C:
-				d.calibrate()
-				calibrateTimer.Stop()
-			case <-d.quit:
-				return
-			}
-		}
-	}()
-	return
-}
-
-// Set heading from a known value (usually GPS true heading).
-func (d *MPU6050) ResetHeading(heading float64) {
-	log.Printf("reset true heading: %f\n", heading)
-	d.heading = heading
-}
-
-// Close.
-func (d *MPU6050) Close() {
-	if d.quit != nil {
-		d.quit <- struct{}{}
-	}
-}

notes/app-vendor-integration.md

@@ -0,0 +1,285 @@
+# app side integration
+
+### Protocol & network information
+
+Stratux uses GDL90 protocol over port 4000 UDP. All messages are sent as **unicast** messages. When a device is connected to the stratux Wi-Fi
+network and a DHCP lease is issued to the device, the IP of the DHCP lease is added to the list of clients receiving GDL90 messages.
+
+
+The GDL90 is "standard" with the exception of three non-standard GDL90-style messages: `0xCC` (stratux heartbeat), `0x5358` (another stratux heartbeat), and `0x4C` (AHRS report).
+
+### How to recognize stratux
+
+In order of preference:
+
+1. Look for `0xCC` (or `0x5358`) GDL90 heartbeat message. This is sent at the same time as the GDL90 heartbeat (0x00) message.
+2. Look for Wi-Fi network that **starts with** "stratux".
+3. Detect 192.168.10.0/24 Wi-Fi connection, verify stratux status with JSON response from ws://192.168.10.1/status.
+4. Use the the second [stratux status](http://hiltonsoftware.com/stratux/StratuxStatusMessage-V104.pdf) message.
+
+See main/gen_gdl90.go:makeStratuxHeartbeat() for heartbeat (#1) format.
+
+### Sleep mode
+
+Stratux makes use of of ICMP Echo/Echo Reply and ICMP Destination Unreachable packets to determine the state of the application receiving GDL90 messages.
+
+*Queueable messages* includes all UAT uplink messages, and in general: any messages whose value will not degrade for having been delayed for
+the typical "sleep mode" period, whose content remains accurate despite said delay, and whose content is sufficiently redundant such
+that if the typical delay period is exceeded then it can be discarded.
+
+When a client enters sleep mode, queueable messages are entered into a FIFO queue of fixed size which should be sufficient to hold 10-25 minutes of data per client. Non-queueable messages that are directed
+towards a client while in sleep mode are discarded. When in sleep mode, therefore, no GDL90 messages are received by the client.
+
+There are three cases that are used to determine the state of a client:
+
+1. Responding to ICMP Echo AND no ICMP Destination Unreachable received for destination port => not sleeping.
+2. Not responding to ICMP Echo => sleeping.
+3. Responding to ICMP Echo AND ICMP Destination Unreachable received for destination port => sleeping.
+
+The sleep mode detection routine has two parts:
+
+1. ICMP Echo packets are sent every 5 seconds. If a response is not received in the last 10 seconds, the client is in sleep mode.
+2. If an ICMP Destination Unreachable is received in the last 5 seconds, the client is in sleep mode.
+3. If an ICMP Destination Unreachable has been received in the last 15 seconds, but not in the last 5 seconds, the client is in *throttle mode*. In throttle mode, messages are sent at 0.1% of the normal rate. This gives the client a chance to recover or to respond that the port is closed.
+
+
+__Note__: NEXRAD frames, METARs, and Winds Aloft, and other weather data may be delayed in reception to
+the receiving application. The timestamp in the GDL90 message should always be used to for the observation
+time, and **not the time the message was received**.
+
+### Traffic handling
+
+Stratux receives traffic updates from UAT downlink messages and/or 1090ES messages.
+
+Traffic information roughly follows this path:
+
+1. Traffic update is received (from any source). An entry for the target is created, indexed by the ICAO address of the target.
+2. Any position/information updates received from any source for this ICAO address updates the entry created in #1.
+3. If no updates are received from any source over 60 seconds, the target entry is deleted.
+4. A GDL90 traffic report is sent for every target entry (having valid lat/lng) every 1 second.
+
+When traffic information is being received both from UAT and 1090ES sources, it is not uncommon to see a flip/flop in tail numbers on targets.
+Some 1090ES transponders will send the actual registration number of the aircraft, which then becomes a TIS-B target whose tail number may be
+a squawk code.
+
+
+### Additional data/control available to EFBs
+
+Stratux makes available a webserver to retrieve statistics which may be useful to EFBs:
+
+* `http://192.168.10.1/getTowers` - a list of ADS-B towers received with attached message receipt and signal level statistics. Example output:
+
+```json
+{
+  "(28.845592,-96.920400)": {
+    "Lat": 28.845591545105,
+    "Lng": -96.920399665833,
+    "Signal_strength_last_minute": 55,
+    "Signal_strength_max": 69,
+    "Messages_last_minute": 97,
+    "Messages_total": 196
+  },
+  "(29.266505,-98.309097)": {
+    "Lat": 29.266505241394,
+    "Lng": -98.309097290039,
+    "Signal_strength_last_minute": 78,
+    "Signal_strength_max": 78,
+    "Messages_last_minute": 1,
+    "Messages_total": 3
+  },
+  "(29.702547,-96.900787)": {
+    "Lat": 29.702546596527,
+    "Lng": -96.900787353516,
+    "Signal_strength_last_minute": 87,
+    "Signal_strength_max": 119,
+    "Messages_last_minute": 94,
+    "Messages_total": 203
+  }
+}
+```
+
+* `http://192.168.10.1/getStatus` - device status and statistics. Example output (commented JSON):
+
+```javascript
+{
+  "Version": "v1.4r2",
+  "Build": "ebd6b9bf5049aa5bb31c345c1eaa39648bc219a2",
+  "HardwareBuild": "",
+  "Devices": 1,
+  "Connected_Users": 0,
+  "DiskBytesFree": 60625375232,
+  "UAT_messages_last_minute": 0,
+  "UAT_messages_max": 0,
+  "ES_messages_last_minute": 0,
+  "ES_messages_max": 0,
+  "UAT_traffic_targets_tracking": 0,
+  "ES_traffic_targets_tracking": 0,
+  "Ping_connected": false,
+  "GPS_satellites_locked": 5,
+  "GPS_satellites_seen": 7,
+  "GPS_satellites_tracked": 9,
+  "GPS_position_accuracy": 10.2,
+  "GPS_connected": true,
+  "GPS_solution": "GPS + SBAS (WAAS)",
+  "GPS_detected_type": 55,
+  "Uptime": 323020,
+  "UptimeClock": "0001-01-01T00:05:23.02Z",
+  "CPUTemp": 47.774,
+  "NetworkDataMessagesSent": 0,
+  "NetworkDataMessagesSentNonqueueable": 0,
+  "NetworkDataBytesSent": 0,
+  "NetworkDataBytesSentNonqueueable": 0,
+  "NetworkDataMessagesSentLastSec": 0,
+  "NetworkDataMessagesSentNonqueueableLastSec": 0,
+  "NetworkDataBytesSentLastSec": 0,
+  "NetworkDataBytesSentNonqueueableLastSec": 0,
+  "UAT_METAR_total": 0,
+  "UAT_TAF_total": 0,
+  "UAT_NEXRAD_total": 0,
+  "UAT_SIGMET_total": 0,
+  "UAT_PIREP_total": 0,
+  "UAT_NOTAM_total": 0,
+  "UAT_OTHER_total": 0,
+  "Errors": [
+    
+  ],
+  "Logfile_Size": 34487043,
+  "AHRS_LogFiles_Size": 0,
+  "BMPConnected": true,
+  "IMUConnected": true
+}
+```
+
+* `http://192.168.10.1/getSettings` - get device settings. Example output:
+
+```json
+{
+  "UAT_Enabled": true,
+  "ES_Enabled": false,
+  "Ping_Enabled": false,
+  "GPS_Enabled": true,
+  "BMP_Sensor_Enabled": true,
+  "IMU_Sensor_Enabled": true,
+  "NetworkOutputs": [
+    {
+      "Conn": null,
+      "Ip": "",
+      "Port": 4000,
+      "Capability": 5,
+      "MessageQueueLen": 0,
+      "LastUnreachable": "0001-01-01T00:00:00Z",
+      "SleepFlag": false,
+      "FFCrippled": false
+    }
+  ],
+  "SerialOutputs": null,
+  "DisplayTrafficSource": false,
+  "DEBUG": false,
+  "ReplayLog": false,
+  "AHRSLog": false,
+  "IMUMapping": [
+    -1,
+    0
+  ],
+  "SensorQuaternion": [
+    0.0068582877312501,
+    0.0067230280142738,
+    0.7140806859355,
+    -0.69999752767998
+  ],
+  "C": [
+    -0.019065523239845,
+    -0.99225684377575,
+    -0.019766228217414
+  ],
+  "D": [
+    -2.7707754753258,
+    5.544145023957,
+    -1.890621662038
+  ],
+  "PPM": 0,
+  "OwnshipModeS": "F00000",
+  "WatchList": "",
+  "DeveloperMode": false,
+  "GLimits": "",
+  "StaticIps": [
+    
+  ]
+}
+```
+* `http://192.168.10.1/setSettings` - set device settings. Use an HTTP POST of JSON content in the format given above - posting only the fields containing the settings to be modified.
+
+* `http://192.168.10.1/getSituation` - get GPS/AHRS information. Example output:
+
+```json
+{
+  "GPSLastFixSinceMidnightUTC": 67337.6,
+  "GPSLatitude": 39.108533,
+  "GPSLongitude": -76.770862,
+  "GPSFixQuality": 2,
+  "GPSHeightAboveEllipsoid": 115.51,
+  "GPSGeoidSep": -17.523,
+  "GPSSatellites": 5,
+  "GPSSatellitesTracked": 11,
+  "GPSSatellitesSeen": 8,
+  "GPSHorizontalAccuracy": 10.2,
+  "GPSNACp": 9,
+  "GPSAltitudeMSL": 170.10767,
+  "GPSVerticalAccuracy": 8,
+  "GPSVerticalSpeed": -0.6135171,
+  "GPSLastFixLocalTime": "0001-01-01T00:06:44.24Z",
+  "GPSTrueCourse": 0,
+  "GPSTurnRate": 0,
+  "GPSGroundSpeed": 0.77598433056951,
+  "GPSLastGroundTrackTime": "0001-01-01T00:06:44.24Z",
+  "GPSTime": "2017-09-26T18:42:17Z",
+  "GPSLastGPSTimeStratuxTime": "0001-01-01T00:06:43.65Z",
+  "GPSLastValidNMEAMessageTime": "0001-01-01T00:06:44.24Z",
+  "GPSLastValidNMEAMessage": "$PUBX,04,184426.00,260917,240266.00,1968,18,-177618,-952.368,21*1A",
+  "GPSPositionSampleRate": 0,
+  "BaroTemperature": 37.02,
+  "BaroPressureAltitude": 153.32,
+  "BaroVerticalSpeed": 1.3123479,
+  "BaroLastMeasurementTime": "0001-01-01T00:06:44.23Z",
+  "AHRSPitch": -0.97934145732801,                     // Degrees. 3276.7 = Invalid.
+  "AHRSRoll": -2.2013729217108,                       // Degrees. 3276.7 = Invalid.
+  "AHRSGyroHeading": 187741.08073052,                 // Degrees. Process mod 360. 3276.7 = Invalid.
+  "AHRSMagHeading": 3276.7,                           // Degrees. Process mod 360. 3276.7 = Invalid.
+  "AHRSSlipSkid": 0.52267604604907,                   // Degrees. 3276.7 = Invalid.
+  "AHRSTurnRate": 3276.7,                             // Degrees per second. 3276.7 = Invalid.
+  "AHRSGLoad": 0.99847599584255,                      // Current G load, in G's. Reads 1 G at rest.
+  "AHRSGLoadMin": 0.99815989027411,                   // Minimum recorded G load, in G's.
+  "AHRSGLoadMax": 1.0043409597397,                    // Maximum recorded G load, in G's.
+  "AHRSLastAttitudeTime": "0001-01-01T00:06:44.28Z",  // Stratux clock ticks since last attitude update. Reference against /getStatus -> UptimeClock.
+  "AHRSStatus": 7                                     // Status bitmask. See main/sensors.go -> updateAHRSStatus().
+}
+```
+
+
+* `ws://192.168.10.1/traffic` - traffic stream. On initial connect, all currently tracked traffic targets are dumped. Updates are streamed as they are received. Example output:
+
+Initial connect:
+
+```json
+{"Icao_addr":2837120,"OnGround":false,"Lat":42.19293,"Lng":-83.92148,"Position_valid":true,"Alt":3400,"Track":9,"Speed":92,"Speed_valid":true,"Vvel":0,"Tail":"","Last_seen":"2015-12-22T21:29:22.241048727Z","Last_source":2}
+{"Icao_addr":2836155,"OnGround":false,"Lat":42.122932,"Lng":-84.17615,"Position_valid":true,"Alt":2800,"Track":158,"Speed":105,"Speed_valid":true,"Vvel":0,"Tail":"","Last_seen":"2015-12-22T21:29:22.241543881Z","Last_source":2}
+```
+
+Subsequent update (2837120 = 2B4A80 reports a newer position, altitude increased from 2,800' to 3,400'):
+
+```json
+{"Icao_addr":2837120,"OnGround":false,"Lat":42.193336,"Lng":-83.92136,"Position_valid":true,"Alt":3400,"Track":9,"Speed":92,"Speed_valid":true,"Vvel":0,"Tail":"","Last_seen":"2015-12-22T21:29:22.252914555Z","Last_source":2}
+```
+
+* `http://192.168.10.1/calibrateAHRS` - run AHRS sensor calibration routine. Submit a blank POST to this URL.
+
+* `http://192.168.10.1/cageAHRS` - "level" attitude display. Submit a blank POST to this URL.
+
+* `http://192.168.10.1/resetGMeter` - reset G-meter to zero. Submit a blank POST to this URL.
+
+* `http://192.168.10.1/restart` - restart Stratux application.
+
+* `http://192.168.10.1/reboot` - reboot the system.
+
+* `http://192.168.10.1/shutdown` - shutdown the system.
+

selfupdate/makeupdate.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+#apt-get install -y dh-make
+
+stratuxVersion=`git describe --tags --abbrev=0`
+stratuxBuild=`git log -n 1 --pretty=%H`
+
+echo
+echo
+echo "Packaging ${stratuxVersion} (${stratuxBuild})."
+echo
+echo
+
+cd ..
+make
+rm -rf work
+mkdir -p work/bin
+cp gen_gdl90 work/bin/
+cp fancontrol work/bin/
+cp libdump978.so work/bin/
+cp __lib__systemd__system__stratux.service work/bin/
+cp __root__stratux-pre-start.sh work/bin/
+cp dump1090/dump1090 work/bin/
+cp -r web work/bin/
+cp image/hostapd.conf work/bin/
+cp image/hostapd-edimax.conf work/bin/
+cp image/config.txt work/bin/
+cp image/rtl-sdr-blacklist.conf work/bin/
+cp image/bashrc.txt work/bin/
+cp image/modules.txt work/bin/
+cp image/stxAliases.txt work/bin/
+cp image/hostapd_manager.sh work/bin/
+cp image/sdr-tool.sh work/bin/
+cp image/10-stratux.rules work/bin/
+cp image/99-uavionix.rules work/bin/
+cp image/motd work/bin/
+cp image/stratux-wifi.sh work/bin/
+cp image/rc.local work/bin/
+cp image/dhcpd-not_smart.conf work/bin/
+cp image/dhcpd-smart.conf work/bin/
+cp image/interfaces work/bin/
+cp image/logrotate.conf work/bin/
+cp image/logrotate_d_stratux work/bin/
+cp image/rsyslog_d_stratux work/bin/
+
+cp test-data/ahrs/ahrs_table.log work/bin/
+cp ahrs_approx work/bin/
+
+#TODO: librtlsdr.
+cd work/
+cat ../selfupdate/update_header.sh >update.sh
+
+echo "stratuxVersion=${stratuxVersion}" >>update.sh
+echo "stratuxBuild=${stratuxBuild}" >>update.sh
+
+
+find bin/ -type d | sed -e 's/^bin\///' | grep -v '^$' | while read dn; do
+	echo "mkdir -p $dn" >>update.sh
+done
+find bin/ -type f | while read fn; do
+	echo -n "packaging $fn... "
+	UPFN=`echo $fn | sed -e 's/^bin\///'`
+	echo "cat >${UPFN}.b64 <<__EOF__" >>update.sh
+	gzip -c $fn | base64 >>update.sh
+	echo "__EOF__" >>update.sh
+	echo "base64 -d ${UPFN}.b64 | gzip -d -c >${UPFN}" >>update.sh
+	echo "rm -f ${UPFN}.b64" >>update.sh
+	echo "done"
+done
+cat ../selfupdate/update_footer.sh >>update.sh
+
+chmod +x update.sh
+
+OUTF="update-stratux-${stratuxVersion}-${stratuxBuild:0:10}.sh"
+mv update.sh $OUTF
+
+
+echo
+echo
+echo "$OUTF ready."
+echo
+echo

selfupdate/process_builds.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+ssh -i ~/.ssh/id_rsa.updates stratux-updates@updates.stratux.me 'ls -1 queue/' | while read git_hash ; do
+	echo "***** Building $git_hash. *****"
+	git clone https://github.com/cyoung/stratux --recursive $git_hash
+	cd $git_hash
+	git reset --hard $git_hash
+	cd selfupdate
+	./makeupdate.sh
+	cd ..
+	for fl in `ls -1 work/update*.sh | cut -d/ -f2`
+	do
+		scp -i ~/.ssh/id_rsa.updates work/${fl} stratux-updates@updates.stratux.me:uploading/
+		ssh -i ~/.ssh/id_rsa.updates stratux-updates@updates.stratux.me "mv uploading/${fl} finished/"
+	done
+	cd ..
+	ssh -i ~/.ssh/id_rsa.updates stratux-updates@updates.stratux.me "rm -f queue/${git_hash}"
+done

selfupdate/update_footer.sh

@@ -0,0 +1,105 @@
+cp -f gen_gdl90 /usr/bin/gen_gdl90
+chmod 755 /usr/bin/gen_gdl90
+cp -f libdump978.so /usr/lib/libdump978.so
+chmod 655 /usr/bin/gen_gdl90
+
+# Startup script.
+RASPBIAN_VERSION=`cat /etc/debian_version`
+if test "$RASPBIAN_VERSION" = "8.0" ; then
+	# Install the systemd startup scripts in any case, even if they won't be used. If this is being run, then the old init.d script
+	#  is still intact and we just leave it. If running Wheezy, then remove the old init.d script.
+	rm -f /etc/init.d/stratux
+	rm -f /etc/rc2.d/S01stratux
+	rm -f /etc/rc6.d/K01stratux
+fi
+
+cp -f __lib__systemd__system__stratux.service /lib/systemd/system/stratux.service
+cp -f __root__stratux-pre-start.sh /root/stratux-pre-start.sh
+chmod 644 /lib/systemd/system/stratux.service
+chmod 744 /root/stratux-pre-start.sh
+ln -fs /lib/systemd/system/stratux.service /etc/systemd/system/multi-user.target.wants/stratux.service
+
+#wifi config
+cp -f hostapd.conf /etc/hostapd/hostapd.conf
+cp -f hostapd-edimax.conf /etc/hostapd/hostapd-edimax.conf
+
+#rsyslog config
+cp -f rsyslog_d_stratux /etc/rsyslog.d/stratux.conf
+
+#logrotate config
+cp -f logrotate.conf /etc/logrotate.conf
+cp -f logrotate_d_stratux /etc/logrotate.d/stratux
+
+#WiFi Hostapd ver test and hostapd.conf builder script
+cp -f stratux-wifi.sh /usr/sbin/
+chmod 755 /usr/sbin/stratux-wifi.sh
+
+#WiFi Config Manager
+cp -f hostapd_manager.sh /usr/sbin/
+chmod 755 /usr/sbin/hostapd_manager.sh
+
+#SDR Serial Script
+cp -f sdr-tool.sh /usr/sbin/
+chmod 755 /usr/sbin/sdr-tool.sh
+
+#boot config
+cp -f config.txt /boot/config.txt
+
+#rc.local
+cp -f rc.local /etc/
+
+#disable serial console
+sed -i /boot/cmdline.txt -e "s/console=ttyAMA0,[0-9]\+ //"
+
+#modprobe.d blacklist
+cp -f rtl-sdr-blacklist.conf /etc/modprobe.d/
+
+#udev config
+cp -f 10-stratux.rules /etc/udev/rules.d
+cp -f 99-uavionix.rules /etc/udev/rules.d
+
+#go setup
+cp -f bashrc.txt /root/.bashrc
+cp -f stxAliases.txt /root/.stxAliases
+
+# /etc/modules
+cp -f modules.txt /etc/modules
+
+#motd
+cp -f motd /etc/motd
+
+#fan control utility
+#remove old script
+rm -f /usr/bin/fancontrol.py
+#install new program
+/usr/bin/fancontrol stop
+/usr/bin/fancontrol remove
+cp -f fancontrol /usr/bin/
+chmod 755 /usr/bin/fancontrol
+/usr/bin/fancontrol install
+
+cp -f dump1090 /usr/bin/
+chmod 755 /usr/bin/dump1090
+
+# AHRS approx data.
+cp -f ahrs_table.log /root/
+cp -f ahrs_approx /usr/bin/
+chmod 755 /usr/bin/ahrs_approx
+
+# DHCPD Config.
+cp -f dhcpd-not_smart.conf /etc/dhcp/
+cp -f dhcpd-smart.conf /etc/dhcp/
+ln -s /etc/dhcp/dhcpd-not_smart.conf /etc/dhcp/dhcpd.conf
+
+# Interfaces file.
+cp -f interfaces /etc/network/interfaces
+
+# Web files install.
+cd web/ && make stratuxBuild=${stratuxBuild}
+
+# Remove old Wi-Fi watcher script.
+rm -f /usr/sbin/wifi_watch.sh
+sed -i "/\bwifi_watch\b/d" /etc/rc.local
+
+cd /
+rm -rf /root/stratux-update

selfupdate/update_header.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+rm -rf /root/stratux-update
+mkdir -p /root/stratux-update
+cd /root/stratux-update
+rm -f /var/log/stratux*

sensors/bmp280.go

@@ -0,0 +1,81 @@
+// Package sensors provides a stratux interface to sensors used for AHRS calculations.
+package sensors
+
+import (
+	"errors"
+	"time"
+
+	"../goflying/bmp280"
+	"github.com/kidoman/embd"
+)
+
+const (
+	bmp280PowerMode   = bmp280.NormalMode
+	bmp280Standby     = bmp280.StandbyTime63ms
+	bmp280FilterCoeff = bmp280.FilterCoeff16
+	bmp280TempRes     = bmp280.Oversamp16x
+	bmp280PressRes    = bmp280.Oversamp16x
+)
+
+// BMP280 represents a BMP280 sensor and implements the PressureSensor interface.
+type BMP280 struct {
+	sensor  *bmp280.BMP280
+	data    *bmp280.BMPData
+	running bool
+}
+
+var errBMP = errors.New("BMP280 Error: BMP280 is not running")
+
+// NewBMP280 looks for a BMP280 connected on the I2C bus having one of the valid addresses and begins reading it.
+func NewBMP280(i2cbus *embd.I2CBus, freq time.Duration) (*BMP280, error) {
+	var (
+		bmp    *bmp280.BMP280
+		errbmp error
+	)
+
+	bmp, errbmp = bmp280.NewBMP280(i2cbus, bmp280.Address1,
+		bmp280PowerMode, bmp280Standby, bmp280FilterCoeff, bmp280TempRes, bmp280PressRes)
+	if errbmp != nil { // Maybe the BMP280 isn't at Address1, try Address2
+		bmp, errbmp = bmp280.NewBMP280(i2cbus, bmp280.Address2,
+			bmp280PowerMode, bmp280Standby, bmp280FilterCoeff, bmp280TempRes, bmp280PressRes)
+	}
+	if errbmp != nil {
+		return nil, errbmp
+	}
+
+	newbmp := BMP280{sensor: bmp, data: new(bmp280.BMPData)}
+	go newbmp.run()
+
+	return &newbmp, nil
+}
+
+func (bmp *BMP280) run() {
+	bmp.running = true
+	clock := time.NewTicker(100 * time.Millisecond)
+	for bmp.running {
+		<-clock.C
+		bmp.data = <-bmp.sensor.C
+	}
+}
+
+// Temperature returns the current temperature in degrees C measured by the BMP280
+func (bmp *BMP280) Temperature() (float64, error) {
+	if !bmp.running {
+		return 0, errBMP
+	}
+	return bmp.data.Temperature, nil
+}
+
+// Pressure returns the current pressure in mbar measured by the BMP280
+func (bmp *BMP280) Pressure() (float64, error) {
+	if !bmp.running {
+		return 0, errBMP
+	}
+	return bmp.data.Pressure, nil
+}
+
+// Close stops the measurements of the BMP280
+func (bmp *BMP280) Close() {
+	bmp.running = false
+	bmp.sensor.Close()
+}

sensors/icm20948.go

@@ -0,0 +1,98 @@
+// Package sensors provides a stratux interface to sensors used for AHRS calculations.
+package sensors
+
+import (
+	"../goflying/icm20948"
+	"github.com/kidoman/embd"
+)
+
+const (
+	gyroRange  = 250 // gyroRange is the default range to use for the Gyro.
+	accelRange = 4   // accelRange is the default range to use for the Accel.
+	updateFreq = 50  // updateFreq is the rate at which to update the sensor values.
+)
+
+// ICM20948 represents an InvenSense ICM-20948 attached to the I2C bus and satisfies
+// the IMUReader interface.
+type ICM20948 struct {
+	mpu *icm20948.ICM20948
+}
+
+// NewICM20948 returns an instance of the ICM-20948 IMUReader, connected to an
+// ICM-20948 attached on the I2C bus with either valid address.
+func NewICM20948(i2cbus *embd.I2CBus) (*ICM20948, error) {
+	var (
+		m   ICM20948
+		mpu *icm20948.ICM20948
+		err error
+	)
+
+	mpu, err = icm20948.NewICM20948(i2cbus, gyroRange, accelRange, updateFreq, true, false)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set Gyro (Accel) LPFs to 25 Hz to filter out prop/glareshield vibrations above 1200 (1260) RPM
+	mpu.SetGyroLPF(25)
+	mpu.SetAccelLPF(25)
+
+	m.mpu = mpu
+	return &m, nil
+}
+
+// Read returns the average (since last reading) time, Gyro X-Y-Z, Accel X-Y-Z, Mag X-Y-Z,
+// error reading Gyro/Accel, and error reading Mag.
+func (m *ICM20948) Read() (T int64, G1, G2, G3, A1, A2, A3, M1, M2, M3 float64, GAError, MAGError error) {
+	var (
+		data *icm20948.MPUData
+		i    int8
+	)
+	data = new(icm20948.MPUData)
+
+	for data.N == 0 && i < 5 {
+		data = <-m.mpu.CAvg
+		T = data.T.UnixNano()
+		G1 = data.G1
+		G2 = data.G2
+		G3 = data.G3
+		A1 = data.A1
+		A2 = data.A2
+		A3 = data.A3
+		M1 = data.M1
+		M2 = data.M2
+		M3 = data.M3
+		GAError = data.GAError
+		MAGError = data.MagError
+		i++
+	}
+	return
+}
+
+// ReadOne returns the most recent time, Gyro X-Y-Z, Accel X-Y-Z, Mag X-Y-Z,
+// error reading Gyro/Accel, and error reading Mag.
+func (m *ICM20948) ReadOne() (T int64, G1, G2, G3, A1, A2, A3, M1, M2, M3 float64, GAError, MAGError error) {
+	var (
+		data *icm20948.MPUData
+	)
+	data = new(icm20948.MPUData)
+
+	data = <-m.mpu.C
+	T = data.T.UnixNano()
+	G1 = data.G1
+	G2 = data.G2
+	G3 = data.G3
+	A1 = data.A1
+	A2 = data.A2
+	A3 = data.A3
+	M1 = data.M1
+	M2 = data.M2
+	M3 = data.M3
+	GAError = data.GAError
+	MAGError = data.MagError
+	return
+}
+
+// Close stops reading the MPU.
+func (m *ICM20948) Close() {
+	m.mpu.CloseMPU()
+}

sensors/imu.go

@@ -0,0 +1,17 @@
+// Package sensors provides a stratux interface to sensors used for AHRS calculations.
+package sensors
+
+// IMUReader provides an interface to various Inertial Measurement Unit sensors,
+// such as the InvenSense MPU9150 or MPU9250.  It is a light abstraction on top
+// of the current github.com/westphae/goflying MPU9250 driver so that it can accommodate other types
+// of drivers.
+type IMUReader interface {
+	// Read returns the average (since last reading) time, Gyro X-Y-Z, Accel X-Y-Z, Mag X-Y-Z,
+	// error reading Gyro/Accel, and error reading Mag.
+	Read() (T int64, G1, G2, G3, A1, A2, A3, M1, M2, M3 float64, GAError, MagError error)
+	// ReadOne returns the most recent time, Gyro X-Y-Z, Accel X-Y-Z, Mag X-Y-Z,
+	// error reading Gyro/Accel, and error reading Mag.
+	ReadOne() (T int64, G1, G2, G3, A1, A2, A3, M1, M2, M3 float64, GAError, MagError error)
+	// Close stops reading the MPU.
+	Close()
+}

sensors/mpu9250.go

@@ -0,0 +1,98 @@
+// Package sensors provides a stratux interface to sensors used for AHRS calculations.
+package sensors
+
+import (
+	"../goflying/mpu9250"
+	"github.com/kidoman/embd"
+)
+
+const (
+	mpu9250GyroRange  = 250 // mpu9250GyroRange is the default range to use for the Gyro.
+	mpu9250AccelRange = 4   // mpu9250AccelRange is the default range to use for the Accel.
+	mpu9250UpdateFreq = 50  // mpu9250UpdateFreq is the rate at which to update the sensor values.
+)
+
+// MPU9250 represents an InvenSense MPU9250 attached to the I2C bus and satisfies
+// the IMUReader interface.
+type MPU9250 struct {
+	mpu *mpu9250.MPU9250
+}
+
+// NewMPU9250 returns an instance of the MPU9250 IMUReader, connected to an
+// MPU9250 attached on the I2C bus with either valid address.
+func NewMPU9250(i2cbus *embd.I2CBus) (*MPU9250, error) {
+	var (
+		m   MPU9250
+		mpu *mpu9250.MPU9250
+		err error
+	)
+
+	mpu, err = mpu9250.NewMPU9250(i2cbus, mpu9250GyroRange, mpu9250AccelRange, mpu9250UpdateFreq, true, false)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set Gyro (Accel) LPFs to 20 (21) Hz to filter out prop/glareshield vibrations above 1200 (1260) RPM
+	mpu.SetGyroLPF(21)
+	mpu.SetAccelLPF(21)
+
+	m.mpu = mpu
+	return &m, nil
+}
+
+// Read returns the average (since last reading) time, Gyro X-Y-Z, Accel X-Y-Z, Mag X-Y-Z,
+// error reading Gyro/Accel, and error reading Mag.
+func (m *MPU9250) Read() (T int64, G1, G2, G3, A1, A2, A3, M1, M2, M3 float64, GAError, MAGError error) {
+	var (
+		data *mpu9250.MPUData
+		i    int8
+	)
+	data = new(mpu9250.MPUData)
+
+	for data.N == 0 && i < 5 {
+		data = <-m.mpu.CAvg
+		T = data.T.UnixNano()
+		G1 = data.G1
+		G2 = data.G2
+		G3 = data.G3
+		A1 = data.A1
+		A2 = data.A2
+		A3 = data.A3
+		M1 = data.M1
+		M2 = data.M2
+		M3 = data.M3
+		GAError = data.GAError
+		MAGError = data.MagError
+		i++
+	}
+	return
+}
+
+// ReadOne returns the most recent time, Gyro X-Y-Z, Accel X-Y-Z, Mag X-Y-Z,
+// error reading Gyro/Accel, and error reading Mag.
+func (m *MPU9250) ReadOne() (T int64, G1, G2, G3, A1, A2, A3, M1, M2, M3 float64, GAError, MAGError error) {
+	var (
+		data *mpu9250.MPUData
+	)
+	data = new(mpu9250.MPUData)
+
+	data = <-m.mpu.C
+	T = data.T.UnixNano()
+	G1 = data.G1
+	G2 = data.G2
+	G3 = data.G3
+	A1 = data.A1
+	A2 = data.A2
+	A3 = data.A3
+	M1 = data.M1
+	M2 = data.M2
+	M3 = data.M3
+	GAError = data.GAError
+	MAGError = data.MagError
+	return
+}
+
+// Close stops reading the MPU.
+func (m *MPU9250) Close() {
+	m.mpu.CloseMPU()
+}

sensors/pressure.go

@@ -0,0 +1,10 @@
+// Package sensors provides a stratux interface to sensors used for AHRS calculations.
+package sensors
+
+// PressureReader provides an interface to a sensor reading pressure and maybe
+// temperature or humidity, like the BMP180 or BMP280.
+type PressureReader interface {
+	Temperature() (temp float64, tempError error) // Temperature returns the temperature in degrees C.
+	Pressure() (press float64, pressError error) // Pressure returns the atmospheric pressure in mBar.
+	Close() // Close stops reading from the sensor.
+}

start_stratux.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-screen -S stratux -d -m /usr/bin/start_uat
-screen -S dump1090 -d -m /usr/bin/dump1090 --net --device-index 1

start_uat.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-/usr/bin/gen_gdl90
-

test/Makefile

@@ -0,0 +1,14 @@
+ifeq "$(CIRCLECI)" "true"
+	#
+else
+$(if $(GOROOT),,$(error GOROOT is not set!))
+endif
+
+SRCS = $(wildcard *.go)
+DEST = $(patsubst %.go,%,$(SRCS))
+
+all: $(DEST)
+
+%: %.go
+	go build $<
+	

test/bmp180_read.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"fmt"
+	"github.com/kidoman/embd"
+	_ "github.com/kidoman/embd/host/all"
+	"github.com/kidoman/embd/sensor/bmp180"
+)
+
+var i2cbus embd.I2CBus
+var myBMP180 *bmp180.BMP180
+
+func readBMP180() (float64, float64, error) { // ºCelsius, Meters
+	temp, err := myBMP180.Temperature()
+	if err != nil {
+		return temp, 0.0, err
+	}
+	altitude, err := myBMP180.Altitude()
+	altitude = float64(1/0.3048) * altitude // Convert meters to feet.
+	if err != nil {
+		return temp, altitude, err
+	}
+	return temp, altitude, nil
+}
+
+func initBMP180() error {
+	myBMP180 = bmp180.New(i2cbus) //TODO: error checking.
+	return nil
+}
+
+func initI2C() error {
+	i2cbus = embd.NewI2CBus(1) //TODO: error checking.
+	return nil
+}
+
+// Unused at the moment. 5 second update, since read functions in bmp180 are slow.
+func tempAndPressureReader() {
+	// Read temperature and pressure altitude.
+	temp, alt, err_bmp180 := readBMP180()
+	// Process.
+	if err_bmp180 != nil {
+		fmt.Printf("readBMP180(): %s\n", err_bmp180.Error())
+	} else {
+		fmt.Printf("Temp %f Alt %f\n", temp, alt)
+	}
+}
+
+func initAHRS() error {
+	if err := initI2C(); err != nil { // I2C bus.
+		return err
+	}
+	if err := initBMP180(); err != nil { // I2C temperature and pressure altitude.
+		i2cbus.Close()
+		return err
+	}
+	go tempAndPressureReader()
+
+	return nil
+}
+
+func main() {
+	fmt.Printf("Hello world!\n")
+	initAHRS()
+	for {
+		tempAndPressureReader()
+	}
+}

test/es_dump_csv.go

@@ -0,0 +1,134 @@
+package main
+
+import (
+	"database/sql"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	_ "github.com/mattn/go-sqlite3"
+	"os"
+	"time"
+)
+
+type dump1090Data struct {
+	Icao_addr           uint32
+	DF                  int     // Mode S downlink format.
+	CA                  int     // Lowest 3 bits of first byte of Mode S message (DF11 and DF17 capability; DF18 control field, zero for all other DF types)
+	TypeCode            int     // Mode S type code
+	SubtypeCode         int     // Mode S subtype code
+	SBS_MsgType         int     // type of SBS message (used in "old" 1090 parsing)
+	SignalLevel         float64 // Decimal RSSI (0-1 nominal) as reported by dump1090-mutability. Convert to dB RSSI before setting in TrafficInfo.
+	Tail                *string
+	Squawk              *int // 12-bit squawk code in octal format
+	Emitter_category    *int
+	OnGround            *bool
+	Lat                 *float32
+	Lng                 *float32
+	Position_valid      bool
+	NACp                *int
+	Alt                 *int
+	AltIsGNSS           bool   //
+	GnssDiffFromBaroAlt *int16 // GNSS height above baro altitude in feet; valid range is -3125 to 3125. +/- 3138 indicates larger difference.
+	Vvel                *int16
+	Speed_valid         bool
+	Speed               *uint16
+	Track               *uint16
+	Timestamp           time.Time // time traffic last seen, UTC
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Printf("es_dump_csv <sqlite file>\n")
+		return
+	}
+	db, err := sql.Open("sqlite3", os.Args[1])
+	if err != nil {
+		fmt.Printf("sql.Open(): %s\n", err.Error())
+		return
+	}
+	defer db.Close()
+	rows, err := db.Query("SELECT Data FROM es_messages")
+	if err != nil {
+		fmt.Printf("db.Exec(): %s\n", err.Error())
+		return
+	}
+	defer rows.Close()
+
+	csvOut := make([][]string, 0)
+
+	for rows.Next() {
+		var Data string
+		if err := rows.Scan(&Data); err != nil {
+			fmt.Printf("rows.Scan(): %s\n", err.Error())
+			continue
+		}
+		var d dump1090Data
+		err := json.Unmarshal([]byte(Data), &d)
+		if err != nil {
+			fmt.Printf("json.Unmarshal(): %s\n", err.Error())
+			continue
+		}
+
+		r := make([]string, 23)
+		r[0] = fmt.Sprintf("%06x", d.Icao_addr)
+		r[1] = fmt.Sprintf("%d", d.DF)
+		r[2] = fmt.Sprintf("%d", d.CA)
+		r[3] = fmt.Sprintf("%d", d.TypeCode)
+		r[4] = fmt.Sprintf("%d", d.SubtypeCode)
+		r[5] = fmt.Sprintf("%d", d.SBS_MsgType)
+
+		r[6] = fmt.Sprintf("%f", d.SignalLevel)
+		if d.Tail != nil {
+			r[7] = fmt.Sprintf("%s", *d.Tail)
+		}
+		if d.Squawk != nil {
+			r[8] = fmt.Sprintf("%d", *d.Squawk)
+		}
+		if d.Emitter_category != nil {
+			r[9] = fmt.Sprintf("%d", *d.Emitter_category)
+		}
+		if d.OnGround != nil {
+			r[10] = fmt.Sprintf("%t", *d.OnGround)
+		}
+		if d.Lat != nil {
+			r[11] = fmt.Sprintf("%f", *d.Lat)
+		}
+		if d.Lng != nil {
+			r[12] = fmt.Sprintf("%f", *d.Lng)
+		}
+
+		r[13] = fmt.Sprintf("%t", d.Position_valid)
+		if d.NACp != nil {
+			r[14] = fmt.Sprintf("%d", *d.NACp)
+		}
+		if d.Alt != nil {
+			r[15] = fmt.Sprintf("%d", *d.Alt)
+		}
+
+		r[16] = fmt.Sprintf("%t", d.AltIsGNSS)
+		if d.GnssDiffFromBaroAlt != nil {
+			r[17] = fmt.Sprintf("%d", *d.GnssDiffFromBaroAlt)
+		}
+		if d.Vvel != nil {
+			r[18] = fmt.Sprintf("%d", *d.Vvel)
+		}
+		r[19] = fmt.Sprintf("%t", d.Speed_valid)
+		if d.Speed != nil {
+			r[20] = fmt.Sprintf("%d", *d.Speed)
+		}
+		if d.Track != nil {
+			r[21] = fmt.Sprintf("%d", *d.Track)
+		}
+		r[22] = fmt.Sprintf("%s", d.Timestamp)
+
+		csvOut = append(csvOut, r)
+	}
+
+	w := csv.NewWriter(os.Stdout)
+	w.WriteAll(csvOut)
+
+	if err := rows.Err(); err != nil {
+		fmt.Printf("rows.Scan(): %s\n", err.Error())
+		return
+	}
+}

test/extract_gps.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+
+cat $1 | grep -a -v ^START | grep -a -v ^PAUSE | grep -a -v ^UNPAUSE | grep -a PUBX,00 | cut -d, -f1,5,6,7,8,9

test/extract_metar.go

@@ -33,7 +33,7 @@ var logger *log.Logger
 var buf bytes.Buffer
 
 func dlac_decode(data []byte, data_len uint32) string {
-	fmt.Printf("dlac on %s\n", hex.Dump(data))
+	//	fmt.Printf("dlac on %s\n", hex.Dump(data))
 	step := 0
 	tab := false
 	ret := ""
@@ -78,7 +78,7 @@ func decodeInfoFrame(frame []byte, frame_start int, frame_len uint32, frame_type
 
 	t_opt := ((uint32(data[1]) & 0x01) << 1) | (uint32(data[2]) >> 7)
 	product_id := ((uint32(data[0]) & 0x1f) << 6) | (uint32(data[1]) >> 2)
-	fmt.Printf("%d %d\n", data[0], data[1])
+	//	fmt.Printf("%d %d\n", data[0], data[1])
 	if product_id != 413 { // FIXME.
 		return
 	}
@@ -184,7 +184,10 @@ func main() {
 	logger = log.New(&buf, "logger: ", log.Lshortfile)
 	reader := bufio.NewReader(os.Stdin)
 	for {
-		buf, _ := reader.ReadString('\n')
+		buf, err := reader.ReadString('\n')
+		if err != nil { // All done.
+			break
+		}
 		parseInput(buf)
 	}
 }

test/getairmet.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+	"../uatparse"
+	"bufio"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"github.com/gansidui/geohash"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type UATFrame struct {
+	FISB_month   uint32
+	FISB_day     uint32
+	FISB_hours   uint32
+	FISB_minutes uint32
+	FISB_seconds uint32
+
+	Product_id uint32
+	// Text data, if applicable.
+	Text_data []string
+
+	// For AIRMET/NOTAM.
+	//FIXME: Temporary.
+	Points             map[string][]uatparse.GeoPoint
+	ReportNumber       uint16
+	ReportYear         uint16
+	LocationIdentifier string
+	RecordFormat       uint8
+	ReportStart        string
+	ReportEnd          string
+}
+
+var reports map[string]UATFrame
+
+func groupPoints(f *uatparse.UATFrame) map[string][]uatparse.GeoPoint {
+	// Index all of the points by GeoHash. Group points together.
+	res := make(map[string][]uatparse.GeoPoint)
+	precision := 5 // 6 maybe, 0.000687.
+	for _, p := range f.Points {
+		hash, _ := geohash.Encode(p.Lat, p.Lon, precision)
+		if r, ok := res[hash]; ok {
+			r = append(r, p)
+			res[hash] = r
+		} else {
+			res[hash] = []uatparse.GeoPoint{p}
+		}
+	}
+	return res
+}
+
+func updateReport(f *uatparse.UATFrame) {
+	if f.ReportNumber == 0 || f.ReportYear == 0 || f.RecordFormat == 0 {
+		return
+	}
+	s := strconv.Itoa(int(f.ReportNumber)) + "-" + strconv.Itoa(int(f.ReportYear))
+	f.LocationIdentifier = strings.Replace(f.LocationIdentifier, "\x03", "", -1)
+	if len(f.Points) == 0 && len(f.Text_data) == 0 {
+		return
+	}
+	if p, ok := reports[s]; ok {
+		if len(f.Points) > 0 {
+			p.Points = groupPoints(f)
+			reports[s] = p
+		}
+		if len(f.Text_data) > 0 {
+			p.Text_data = f.Text_data
+			reports[s] = p
+		}
+	} else {
+		var z UATFrame
+		z.FISB_month = f.FISB_month
+		z.FISB_day = f.FISB_day
+		z.FISB_hours = f.FISB_hours
+		z.FISB_minutes = f.FISB_minutes
+		z.FISB_seconds = f.FISB_seconds
+		z.Product_id = f.Product_id
+		z.Points = groupPoints(f)
+		z.ReportNumber = f.ReportNumber
+		z.ReportYear = f.ReportYear
+		z.LocationIdentifier = f.LocationIdentifier
+		z.RecordFormat = f.RecordFormat
+		z.ReportStart = f.ReportStart
+		z.ReportEnd = f.ReportEnd
+
+		reports[s] = z
+	}
+}
+
+func main() {
+	reports = make(map[string]UATFrame)
+	s := "+3cc0978aa66ca3a02100002d3f29688210000000ff0dc45e1e00000000efd305071c142d071d0300bef1e3f1900abdf823bc440abe9ee394a80ac088439a980abfefa3e45c0abef1e3f1900a248000353f6a002210000000ff003e51987c4d5060cb9cb1c30833df2c78cf87f2d74c307d77cf7c10893053857f1d70df2e72c70c1fc75c37cb9cb2cf07f3c707f3c707c17d97df7df780260000353f6a002210000000ff004146247c4d5060cb9cb1c30833df2cf3df07f2d35c307d77cf7d7b71e3881420f3417f1d70df2e72c70c1fc75c37cf0c35d797f0c307f2d707c17d97df7df780648000213c66b022102c45170000bec0487c38f50136d1202c4517bb0defcf0da0c77c79cb26a0844517830defcf0da01145e05176605f1b205f3b205f4b205f6b205176605e00943a0497660e52bf2dcc8013848145d9817c6c8145d980a80250e8145d98178013848125d98334afcb132c8145d981680250e8145d981780138480140322014e120497660cb74ac8145d981780250e8145d9810d2004e1205176605f68033131203075048013848020524890c1105120c75c37c77c79cb2b71d71c31df0cf0c054d47800;rs=31;"
+	//	s := "+3c2643887cdca4802100002d3f29688210000000ff0dc45e1e00000000efd305071c142d071d0300bef1e3f1900abdf823bc440abe9ee394a80ac088439a980abfefa3e45c0abef1e3f1900a248000353f6a002210000000ff003e51987c4d5060cb9cb1c30833df2c78cf87f2d74c307d77cf7c10893053857f1d70df2e72c70c1fc75c37cb9cb2cf07f3c707f3c707c17d97df7df7806c80002d3f29682210000000ff00ce11787c04948d15480b0c8260cb8cb0d358032094e05c1832e32c34d5e04948d1548132454920605501148348063d280919281604c24481539424c832e70cf0c1e04948d154809192baeb8d3a024180d3e05c980931e1923cd833c138050558143e0cb039780430c8143e0d304d31600841a050f833c0538580948b8143e0d703858044cd7943e0cf04e014155e0c91e008c5e0c31c2f5894e008c5e0cd336040340ebc24ae8033ce11380458c407830c2dc336ae8033ce1138033ce507782644830cda814212560c3969e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;rs=17;"
+
+	//	s := "+3bb40f8953d8b1b0360000353f54002210000000ff006185947c4d5060cb9c70c30833df0d78d707f2e72d5f5df49fcf4c3105fc75c37cb9c70c307f1d70df3c30df0c1fc30c1fcb2c1f05f65f7f3d30c417d2cf4c3105f0545054825526604854c549616018f48315381448e1e0052141b2024e78006c80002d3f29682210000000ff00ce11787c04948d15480b0c8260cb8cb0d358032094e05c1832e32c34d5e04948d1548132454920605501148348063d280919281604c24481539424c832e70cf0c1e04948d154809192baeb8d3a024180d3e05c980931e1923cd833c138050558143e0cb039780430c8143e0d304d31600841a050f833c0538580948b8143e0d703858044cd7943e0cf04e014155e0c91e008c5e0c31c2f5894e008c5e0cd336040340ebc24ae8033ce11380458c407830c2dc336ae8033ce1138033ce507782644830cda814212560c3969e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;rs=29;"
+
+	//	s := "+3c2643887cdcb780480000213e955822102cc5c1000085bb887c38f50136d1202cc5c1bb0defc30ca0cb6c70d336a084c5c1830defc30ca03170603c24d48143d715280c1d48280534a0c72c34e30ca9834cb2c33c2ec303b0e36c38d38bb1c17828d2ee4e360160317069831c31d6ec46520a33cf1bb01948011cca603d55203c68131525890c5831d70df2db1c34cedc75c38c70c70d3378005700002d3f29688210000000ff28c4631e00000000efd317071c142d071d0300ce1a242695a4ce03a3e63da4cc01039cbda4ca5f633345a4c93ca31db1a4c899034aa1a4c8328379fda4c73fe39e15a4c75fa3d24da4cac703fe89a4ccf3840731a4ce1a242695a4ce1a24269540ce03a3e63d40cc01039cbd40ca5f63334540c93ca31db140c899034aa140c8328379fd40c73fe39e1540c75fa3d24d40cac703fe8940ccf384073140ce1a24269540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;"
+
+	replayUATFilename := flag.Bool("stdin", false, "Read from stdin")
+
+	flag.Parse()
+
+	if *replayUATFilename == true {
+		reader := bufio.NewReader(os.Stdin)
+		for {
+			text, err := reader.ReadString('\n')
+			if err != nil {
+				break
+			}
+			msg, err := uatparse.New(text)
+			if err != nil {
+				//				fmt.Printf("err: %s\n", err.Error())
+				//				return
+				continue
+			}
+			msg.DecodeUplink()
+			for _, frame := range msg.Frames {
+				updateReport(frame)
+			}
+		}
+	} else {
+
+		msg, err := uatparse.New(s)
+
+		if err != nil {
+			fmt.Printf("err: %s\n", err.Error())
+			return
+		}
+
+		msg.DecodeUplink()
+
+		for _, frame := range msg.Frames {
+			updateReport(frame)
+		}
+	}
+
+	r := make([]UATFrame, 0)
+	for _, p := range reports {
+		if len(p.Points) > 0 && len(p.Text_data) > 0 {
+			r = append(r, p)
+		}
+	}
+
+	j, _ := json.Marshal(&r)
+	fmt.Printf("%s\n", j)
+
+}