Building a FlightAware UAT Feeder_

#!/usr/bin/env python3
''' collectd-skyaware978.py (c) 2019 Matthew Ernisse <matt@going-flying.com>
 All Rights Reserved.

Collect statistics from skyaware978 and send to collectd.  Uses the collectd
Exec plugin.  This uses the same counter names as the dump1090-fa version
so you can share the same dashboard across both 978 and 1090 feeder systems.

The receiver stats aren't presently collected by dump978 it seems.

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.

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.
'''
import json
import os
import socket
import time

def print_aircraft(stats):
    ''' Parse and emit information from the aircraft.json file. '''
    aircraft = len(stats.get('aircraft', []))
    messages = stats.get('messages')
    if not messages:
        raise ValueError('JSON stats undefined')

    m = "PUTVAL \"{}/dump1090/counter-messages\" interval={} N:{}".format(
        hostname,
        interval,
        messages
    )
    print(m)

    m = "PUTVAL \"{}/dump1090/gauge-aircraft\" interval={} N:{}".format(
        hostname,
        interval,
        aircraft
    )
    print(m)


def print_stats(stats):
    ''' Parse and emit information from the stats.json file. '''
    # These come from stats['total']
    counters = [
        'samples_processed',
        'samples_dropped',
    ]

    # These come from stats['last1min']
    gauges = [
        'signal',
        'noise'
    ]
    total = stats.get('total')
    latest = stats.get('last1min')

    total_values = total.get('local')
    latest_values = latest.get('local')
    if not total_values or not type(total_values) == dict:
        return

    if not latest_values or not type(latest_values) == dict:
        return

    for k in counters:
        value = total_values.get(k)
        if not value:
            value = 'U'

        m = "PUTVAL \"{}/dump1090/counter-{}\" interval={} N:{}".format(
            hostname,
            k,
            interval,
            value
        )
        print(m)

    for k in gauges:
        value = latest_values.get(k)
        if not value:
            value = 'U'

        m = "PUTVAL \"{}/dump1090/gauge-{}\" interval={} N:{}".format(
            hostname,
            k,
            interval,
            value
        )
        print(m)


if __name__ == '__main__':
    interval = float(os.environ.get('COLLECTD_INTERVAL', 10))
    hostname = os.environ.get('COLLECTD_HOSTNAME', socket.getfqdn())

    while True:
#       with open('/var/run/dump1090-fa/stats.json') as fd:
#           stats = json.load(fd)
#
#       print_stats(stats)

        with open('/var/run/skyaware978/aircraft.json') as fd:
            stats = json.load(fd)

        print_aircraft(stats)
        time.sleep(interval)

#!/usr/bin/env python3
'''bmp280.py (c) 2019 Matthew J Ernisse <matt@going-flying.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.

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.
'''
import struct
import smbus
import time


class BMP280(object):
    ''' Read the data from a BMP 280 Temperature/Pressure
    sensor.  This operates in a single shot mode, so once the
    class is instansiated the values are available as
    temperature, pressure and humidity properties on the
    instance.
    '''
    # Home altitude is 147m, 482ft ASL
    altitude = 147
    registers = {
        'TMP_XLSB': 0xFC,
        'TMP_LSB': 0xFB,
        'TMP_MSB': 0xFA,
        'PRESS_XLSB': 0xF9,
        'PRESS_LSB': 0xF8,
        'PRESS_MSB': 0xF7,
        'CONFIG': 0xF5,
        'CTRL_MEAS': 0xF4,
        'STATUS': 0xF3,
        'RESET': 0xE0,
        'ID': 0xD0,
        'CAL00': 0x88,
    }

    def __init__(self, devAddr, busId=1):
        self.busId = busId
        self.calTable = {
            'dig_T1': 0x00,
            'dig_T2': 0x00,
            'dig_T3': 0x00,

            'dig_P1': 0x00,
            'dig_P2': 0x00,
            'dig_P3': 0x00,
            'dig_P4': 0x00,
            'dig_P5': 0x00,
            'dig_P6': 0x00,
            'dig_P7': 0x00,
            'dig_P8': 0x00,
            'dig_P9': 0x00,
        }
        self.calTableKeys = [
            'dig_T1',
            'dig_T2',
            'dig_T3',

            'dig_P1',
            'dig_P2',
            'dig_P3',
            'dig_P4',
            'dig_P5',
            'dig_P6',
            'dig_P7',
            'dig_P8',
            'dig_P9',
        ]

        self.devAddr = devAddr
        self.devId = None

        self.bus = smbus.SMBus(self.busId)
        self.reset()
        self.devId = self.bus.read_byte_data(
            self.devAddr,
            self.registers['ID']
        )


        # Setting up monitor modes as suggested in 3.5.1
        # forced mode, 1 sample / minute, oversampling x1, no filter.
        # See 5.4.3
        ctrl_reg = 0x4A # osrs_t 001, osrs_p 001, mode 010
        self.bus.write_byte_data(
            self.devAddr,
            self.registers['CTRL_MEAS'],
            ctrl_reg
        )

        # Load the factory calibration values from the onboard EEPROM.
        # There is 1 block of memory from 0x88 to 0xA1.  Page 21 of
        # the datasheet explains how they are layed out.
        cals = self.bus.read_i2c_block_data(
            self.devAddr,
            self.registers['CAL00'],
            24
        )

        calTable = struct.unpack(
            '<HhhHhhhhhhhh',
            bytes(cals)
        )

        for i, val in enumerate(calTable):
            key = self.calTableKeys[i]
            self.calTable[key] = val

        time.sleep(0.2)

        measurements = self.bus.read_i2c_block_data(
            self.devAddr,
            self.registers['PRESS_MSB'],
            6
        )

        press = self._unpacker(measurements[0:3])
        temp = self._unpacker(measurements[3:6])

        (t_fine, self.temp) = self._compensate_temp(temp)
        self.press = self._compensate_press(press, t_fine)

    def __str__(self):
        return "<BME280 bus={:X}, addr=0x{:X}, id=0x{:X}>".format(
            self.busId,
            self.devAddr,
            self.devId,
        )

    # Compensation functions adapted from Appendix Section 8.1
    def _compensate_temp(self, val):
        ''' Return the compensated temperature measurement
        along with the fine adjustment value in a tuple of
        (t_fine, degrees C) as t_fine is used by the other
        compensation functions.
        '''
        var1 = (val / 16384.0 - self.calTable['dig_T1'] / 1024.0) \
            * self.calTable['dig_T2']
        var2 = (val / 131072.0 - self.calTable['dig_T1'] / 8192.0) * \
            (val / 131072.0 - self.calTable['dig_T1'] / 8192.0) * \
            self.calTable['dig_T3']

        t_fine = var1 + var2
        return (t_fine, t_fine / 5120.0)

    def _compensate_press(self, measurement, t_fine):
        ''' Return the compensated pressure measurement in
        hectopascals (hPa).
        '''
        var1 = (t_fine / 2.0) - 64000.0
        var2 = var1 * var1 * self.calTable['dig_P6'] / 32768.0
        var2 = var2 + var1 * self.calTable['dig_P5'] * 2
        var2 = (var2 / 4.0) + self.calTable['dig_P4'] * 65530.0
        var1 = (self.calTable['dig_P3'] * var1 * var1 / 524288.0 + \
            self.calTable['dig_P2'] * var1) / 524288.0
        var1 = (1.0 + var1 / 32768.0) * self.calTable['dig_P1']

        if var1 == 0:
            return 0.0

        pressure = 1048576.0 - measurement
        pressure = (pressure - (var2 / 4096.0)) * 6250.0 / var1

        var1 = self.calTable['dig_P9'] * pressure * pressure / \
            2147483648.0
        var2 = pressure * self.calTable['dig_P8'] / 32768.0
        pressure = pressure + \
            (var1 + var2 + self.calTable['dig_P7']) / 16.0

        # Convert Pascals to hPa
        return float(pressure / 100.0)

    def _unpacker(self, vals):
        ''' Take the 3 bytes from the device in XLSB, LSB, MSB and
        convert to a Python int.

        Section 4.3.7 describes the formats.
        '''

        return (vals[0] << 12) | (vals[1] << 4) | (vals[2] >> 4)

    def reset(self):
        ''' Soft reset the sensor. '''
        # 5.4.2
        self.bus.write_byte_data(
            self.devAddr,
            self.registers['RESET'],
            0xB6
        )
        time.sleep(0.05)

    @property
    def baroStr(self):
        ''' Return a string for the barometric pressure. '''
        if self.press < 985:
            return 'Stormy'
        elif self.press < 1005:
            return 'Rain'
        elif self.press < 1025:
            return 'Fair'
        else:
            return 'Very Dry'

    @property
    def mmhg(self):
        ''' Returns the current barometric pressure in mmHg instead of
        hPa.
        '''
        return self.press * 0.02953

    @property
    def qnh(self):
        ''' Given a local altitude determine the current QNH at the
        sensor location.
        '''
        diff = self.altitude / 30
        return self.press + diff

    @property
    def qnhhg(self):
        ''' Given a local altitude determine the current QNH at the
        sensor location.
        '''
        diff = self.altitude / 30
        return (self.press + diff) * 0.02953

if __name__=="__main__":
    sensor = BMP280(0x76, 1)
    print('{:.02f}°C, QFE {:.02f} inHg ({}), QNH {:.02f} inHg'.format(
        sensor.temp,
        sensor.mmhg,
        sensor.baroStr,
        sensor.qnhhg
    ))

#!/usr/bin/env python3
'''collectd-bmp280.py (c) 2019 Matthew J Ernisse <matt@going-flying.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.

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.
'''
import bmp280
import os
import socket
import time


def read_sensor():
    sensor = bmp280.BMP280(0x76, 1)
    return (sensor.temp, 0.0)


if __name__ == '__main__':
    interval = float(os.environ.get('COLLECTD_INTERVAL', 10))
    hostname = os.environ.get('COLLECTD_HOSTNAME', socket.getfqdn())

    while True:
        retval = read_sensor()
        print("PUTVAL \"{}/hih6130/gauge-temperature\" interval={} N:{:.2f}".format(
            hostname,
            interval,
            retval[0]
        ))

        print("PUTVAL \"{}/hih6130/gauge-humidity\" interval={} N:{:.2f}".format(
            hostname,
            interval,
            retval[1]
        ))

        time.sleep(interval)