#!/usr/bin/env python

# pfh 6/15/09
# Starting from http://itamarst.org/writings/etech04/twisted_internet-22.html
# Goal: Listen to arduino, save data in engineering units, to CSV, also present
# in twisted.web or similar. Socket server?
#
# Design: For now, have arduino send raw ADC counts over and we'll do the
# calibration - seems smarter. I can then use config file parser to move
# all the constants into a config file.
#
# I really want something like rrdtool-based graphs with different timescales.
# Maybe graphite?
# http://somic.org/2009/05/21/graphite-rabbitmq-integration/
# Or even AMQP for fun?
# Serial code from http://twistedmatrix.com/projects/core/documentation/examples/gpsfix.py

from twisted.internet import win32eventreactor
win32eventreactor.install()

from twisted.protocols.basic import LineReceiver

from twisted.internet import reactor
from twisted.internet.serialport import SerialPort
from twisted.web import server, resource, client
from twisted.web.server import Site
from twisted.web.static import File

from twisted.python import usage
from twisted.python import log
import sys
import time

## import stuff from Autobahn
##
from autobahn.websocket import listenWS
from autobahn.wamp import WampServerFactory, WampServerProtocol, exportRpc

print "using Twisted reactor", reactor.__class__
print


lastTemp = 0.0
lastRH = 0.0
lastTimestamp = 0

class THOptions(usage.Options):
    optParameters = [
        ['baudrate', 'b', 9600, 'Serial baudrate'],
        ['port', 'p', 3, 'Serial port to use'],
        ]

class indexPage(resource.Resource):
    isLeaf = True

    def render_GET(self, request):
        ccStr = ' Temp:%f Humidity:%f\n' % (lastTemp, lastRH)
        return ccStr


## MCU protocol
##
class McuProtocol(LineReceiver):

    ## need a reference to our WS-MCU gateway factory to dispatch PubSub events
    ##
    def __init__(self, wsMcuFactory):
        self.wsMcuFactory = wsMcuFactory

    @exportRpc("control-led")
    def controlLed(self, status):
        ## use self.transport.write to send control to MCU via serial
        ##
        if status:
            print "turn on LED"
        else:
            print "turn off LED"

    def processData(self, data):
        """Convert raw ADC counts into SI units as per datasheets"""
        # Skip bad reads
        if len(data) != 2:
            return

        global lastTemp, lastRH, lastTimestamp

        tempCts = int(data[0])
        rhCts = int(data[1])

        rhVolts = rhCts * 0.0048828125
        # 10mV/degree, 1024 count/5V
        temp = tempCts * 0.48828125
        # RH temp correction is -0.7% per deg C
        rhcf = (-0.7 * (temp - 25.0)) / 100.0

        # Uncorrected humidity
        humidity = (rhVolts * 45.25) - 42.76

        # Add correction factor
        humidity = humidity + (rhcf * humidity)


        lastTemp = tempCts
        lastRH = rhCts
        #lastTemp = temp
        #lastRH = humidity
        # Update screen now and then
        if (time.time() - lastTimestamp) > 20.0:

            ## dispatch Temp/Humidity as a PubSub event to all clients subscribed to
            ## topic http://example.com/mcu#measure1
            ##
            self.wsMcuFactory._dispatchEvent("http://example.com/mcu#measure1", (temp, humidity))

            log.msg('Temp: %f C Relative humidity: %f %%' % (temp, humidity))
            log.msg('Temp: %f counts: %d RH: %f counts: %d volts: %f' % (temp, tempCts, humidity, rhCts, rhVolts))
            lastTimestamp = time.time()

        return temp, humidity

    def connectionMade(self):
        log.msg('Serial connection made!')

    def lineReceived(self, line):
        try:
            data = line.split()
            log.msg(data)
            self.processData(data)
        except ValueError:
            log.err('Unable to parse data %s' % line)
            return


## WS-MCU protocol
##
class WsMcuProtocol(WampServerProtocol):

    def onSessionOpen(self):
        ## register topic under which we will publish MCU measurements
        ##
        self.registerForPubSub("http://example.com/mcu#", True)

        ## register methods for RPC
        ##
        self.registerForRpc(self.factory.mcuProtocol, "http://example.com/mcu-control#")


## WS-MCU factory
##
class WsMcuFactory(WampServerFactory):

    protocol = WsMcuProtocol

    def __init__(self, url):
        WampServerFactory.__init__(self, url)
        self.mcuProtocol = McuProtocol(self)

    def pubKeepAlive(self):
        self.keepAlive += 1
        self._dispatchEvent("http://example.com/mcu#keepalive", self.keepAlive)
        reactor.callLater(1, self.pubKeepAlive)

    def startFactory(self):
        WampServerFactory.startFactory(self)
        self.keepAlive = 0
        self.pubKeepAlive()


if __name__ == '__main__':

    log.startLogging(sys.stdout)

    ## create MCU-WS gateway factory/protocol
    ##
    wsMcuFactory = WsMcuFactory("ws://localhost:9000")
    listenWS(wsMcuFactory)

    o = THOptions()
    try:
        o.parseOptions()
    except usage.UsageError, errortext:
        log.err('%s %s' % (sys.argv[0], errortext))
        log.msg('Try %s --help for usage details' % sys.argv[0])
        raise SystemExit, 1

    if o.opts['baudrate']:
        baudrate = int(o.opts['baudrate'])

    port = o.opts['port']

    log.msg('About to open port %s' % port)
    s = SerialPort(wsMcuFactory.mcuProtocol, port, reactor, baudrate=baudrate)

    ## embedded web server for static files
    ##
    webdir = File(".")
    web = Site(webdir)
    reactor.listenTCP(2000, web)

    reactor.run()