{-# LANGUAGE RecordWildCards, RankNTypes #-}
{- Example (on OS X):
	./thermometer /dev/tty.serial-0001 4.0 \
		| while read T ; do osascript -e 'say "'$T'"' ; done
-}

module Main where

import Prelude
import Control.Concurrent
import Control.Monad
import Control.Monad.Error
import Control.Exception (bracket)
import Data.IORef
import Data.Time
import qualified System.Environment as Env
import qualified System.Cmd as Cmd
import qualified System.IO as IO
import Text.Printf

import System.Hardware.Acquisition
import qualified System.Hardware.Acquisition.Connection.Serial as S
import qualified System.Hardware.Acquisition.Protocol.QM1537 as Q
import qualified System.Hardware.Acquisition.Adaptor.Filter as Filter
import qualified System.Hardware.Acquisition.Adaptor.Continuous as Continuous
import qualified System.Hardware.Acquisition.Adaptor.RateLimit as RateLimit
import qualified System.Hardware.Acquisition.Adaptor.PID as PID

{- main :: IO () -}
{- main = Env.getArgs >>= parseArgs -}

serialConfig = S.Config
	{ S.baud = S.B2400
	, S.bits = 8
	, S.parity = S.NoParity
	, S.stop = S.One
	, S.flow = S.NoFlowControl
	}

pid :: MonadIO m => IORef Sample -> IORef PID.Parameters -> Adaptor m
pid setPoint params = foldr (=>>=) return
	[ Filter.exponentialAverage 0.5
	, Continuous.adaptor
	, RateLimit.adaptor 1.0
	, PID.adaptor (ioChannel (readIORef setPoint)) params
	]

parseArgs :: [String] -> IO ()
parseArgs [devpath] = parseArgs [devpath, "1.0"]
parseArgs [devpath, delay] = bracket (before devpath) (after . fst) (body . snd)
parseArgs _ = return ()

before devpath = do
	S.open serialConfig devpath
	conn <- S.open serialConfig devpath
	let proto = Q.protocol conn
	c : _ <- initialise proto
	setPoint <- newIORef 300
	params <- newIORef (PID.Parameters (1/10) (1/0) 0)
	output <- pid setPoint params c
	return ((conn, proto, c), (output, setPoint, params))

after (conn, proto, c) = do
	close c
	destroy proto
	disconnect conn

body output = do
	forever $ do
		Sample {..} <- getSample output
		let clamped = (-1.0) `max` value `min` 1.0
		let w = 80
		let n = round (clamped * fromIntegral w)
		let (neg, pos) = case compare n 0 of
			LT -> (replicate (w + n) ' ' ++ replicate (-n) '=', replicate w ' ')
			EQ -> (replicate w ' ', replicate w ' ')
			GT -> (replicate w ' ', replicate n '=' ++ replicate (w - n) ' ')
		printf "[%s|%s] " neg pos
		IO.hFlush IO.stdout

