#!/usr/bin/python

from array import *
import os
import math
import time
import datetime
import ADS1256
import redis
import FTL.FTLog
import numpy as np

FTL.FTLog.Write(" FTSampler started")

#configurazione per lavorare su server redis locale
REDIS_PORT = 6379
REDIS_HOST = '127.0.0.1'
redSrv0 = redis.Redis(
    host=REDIS_HOST,
    port=REDIS_PORT,
    db=0)

#funzione per leggere e decodificare da redis
def getRedisVal(redisKey):
   if redSrv0.get(redisKey) is None:
      return redSrv0.get(redisKey)
   else:
      return redSrv0.get(redisKey).decode('utf-8')

#definizioni variabili
redSamPer='SETTINGS:LOG:EXETIME'
redSampleFreq = 'SETTINGS:LOG:FREQ'

#se non c'è un valore nei campi di redis, popolo il db
redSrv0.set('SETTINGS:LOG:STATUS',0)
redSrv0.set('SETTINGS:POWER:OFF',0)
if redSrv0.get('SETTINGS:WARNING:EXETIME') is None:
    redSrv0.set('SETTINGS:WARNING:EXETIME',0)
if redSrv0.get('SETTINGS:LOG:FREQ') is None:
    redSrv0.set('SETTINGS:LOG:FREQ', 100)
if redSrv0.get('SETTINGS:DECIMALS:COUNT') is None:
    redSrv0.set('SETTINGS:DECIMALS:COUNT',1)
if redSrv0.get('RTDATA:VALUE:K1CONST') is None:
    redSrv0.set('RTDATA:VALUE:K1CONST', 0)
if redSrv0.get('RTDATA:VALUE:K2CONST') is None:
    redSrv0.set('RTDATA:VALUE:K2CONST', 1)
if redSrv0.get('RTDATA:VALUE:OFFSET') is None:
    redSrv0.set('RTDATA:VALUE:OFFSET', 0)
if redSrv0.get('SETTINGS:POWER:UPTIME') is None:
    redSrv0.set('SETTINGS:POWER:UPTIME', 300)
if redSrv0.get('SETTINGS:POWER:CH') is None:
    redSrv0.set('SETTINGS:POWER:CH', 10)
if redSrv0.get('RTDATA:VALUE:UMEASURE') is None:
    redSrv0.set('RTDATA:VALUE:UMEASURE', "kOhm")
if redSrv0.get('SETTINGS:LOG:EXETIME') is None:
    redSrv0.set('SETTINGS:LOG:EXETIME', 1)
if redSrv0.get('RTDATA:VALUE:SMOOTHED') is None:
    redSrv0.set('RTDATA:VALUE:SMOOTHED', 1)
if redSrv0.get('RTDATA:VALUE:RAW') is None:
    redSrv0.set('RTDATA:VALUE:RAW', 1)
if redSrv0.get('RTDATA:VALUE:REAL') is None:
    redSrv0.set('RTDATA:VALUE:REAL', 1)
if redSrv0.get('RTDATA:VALUE:SMRAW') is None:
    redSrv0.set('RTDATA:VALUE:SMRAW', 1)
if redSrv0.get('SETTINGS:POWER:THRESH') is None:
    redSrv0.set('SETTINGS:POWER:THRESH', 0)
if redSrv0.get('SETTINGS:SMOOTHING:FUNCTION') is None:
    redSrv0.set('SETTINGS:SMOOTHING:FUNCTION', 0)
if redSrv0.get('SETTINGS:SMOOTHING:FACTOR') is None:
    redSrv0.set('SETTINGS:SMOOTHING:FACTOR', 10)
if redSrv0.get('SETTINGS:PASSWORD:CURRENT') is None:
    redSrv0.set('SETTINGS:PASSWORD:CURRENT',"-")
if redSrv0.get('SETTINGS:FOLDER:CURRENT') is None:
    redSrv0.set('SETTINGS:FOLDER:CURRENT', "")
if redSrv0.get('SETTINGS:SELECTED_CH') is None:
    redSrv0.set('SETTINGS:SELECTED_CH',0)
if redSrv0.get('SETTINGS:CHANNEL:A') is None:
    redSrv0.set('SETTINGS:CHANNEL:A',2)
if redSrv0.get('SETTINGS:CHANNEL:B') is None:
    redSrv0.set('SETTINGS:CHANNEL:B',3)
if redSrv0.get('RTDATA:SESSION:NAME') is None:
    redSrv0.set('RTDATA:SESSION:NAME',"")

for numCh in range(0,8,+1):
    if redSrv0.get('SETTINGS:IN:MAX:'+str(numCh)) is None:
        redSrv0.set('SETTINGS:IN:MAX:'+str(numCh),100)
    if redSrv0.get('SETTINGS:IN:MIN:'+str(numCh)) is None:
        redSrv0.set('SETTINGS:IN:MIN:'+str(numCh),0)
    if redSrv0.get('SETTINGS:OUT:MAX:'+str(numCh)) is None:
        redSrv0.set('SETTINGS:OUT:MAX:'+str(numCh),100)
    if redSrv0.get('SETTINGS:OUT:MIN:'+str(numCh)) is None:
        redSrv0.set('SETTINGS:OUT:MIN:'+str(numCh),0)
    if redSrv0.get('SETTINGS:UNIT:MEASURE:'+str(numCh)) is None:
        redSrv0.set('SETTINGS:UNIT:MEASURE:'+str(numCh),"V")
    if redSrv0.get('RTDATA:CH:'+str(numCh)) is None:
        redSrv0.set('RTDATA:CH:'+str(numCh),1)
    if redSrv0.get('RTDATA:OUT:'+str(numCh)) is None:
        redSrv0.set('RTDATA:OUT:'+str(numCh),1)

# calcola la media (colonna x colonna) dei valori ricevuti
def calcMean(dataArray):
    outValues = [0.0] * 8
    smoothFunction= int(getRedisVal('SETTINGS:SMOOTHING:FUNCTION'))
    smoothFact= int(getRedisVal('SETTINGS:SMOOTHING:FACTOR'))
    # verifico il TIPO di Smoothing richiesto: 0 none, 1 media semplice, 2 RMS
    if (smoothFunction == 1):
        # effettuo calcolo media mobile
        outValues = np.sum(dataArray, axis=0) / smoothFact
    elif (smoothFunction == 2):
        # calcolo i quadrati
        outValues = np.sqrt(np.sum(np.square(dataArray), axis=0) / smoothFact)
    else:
        # nessuno smooting, passa il primo dei sample acquisiti
        outValues = dataArray[0]
    # restituisco valori calcolati
    return outValues

#funzione salva time+data di log e otto valori su redis
def redisSave(CHvalues):
    decimalsCount = int(getRedisVal('SETTINGS:DECIMALS:COUNT'))
    redLastLog = 'RTDATA:TIME:LOG'
    dateFormat ="%d/%m/%Y %H:%M:%S"
    rawLastLog = datetime.datetime.now()
    lastLog = rawLastLog.strftime(dateFormat)
    redSrv0.set(redLastLog,str(lastLog))
    for chIndex in range(0,8,+1):
        redAreaIn = 'RTDATA:CH:'+str(chIndex)
        redAreaOut = 'RTDATA:OUT:'+str(chIndex)
        strValIn = float("%.4f" % (CHvalues[chIndex]))
        #salvo valore IN filtrato
        redSrv0.set(redAreaIn,round(strValIn,decimalsCount))
        # salvo i valori scalati in OUT
        roundedOut = round(scaleVal(CHvalues[chIndex], chIndex), decimalsCount)
        redSrv0.set(redAreaOut,roundedOut)

#funzione di refresh valori scalati
def scaleVal(inValue, chIndex):
    #rileggo da redis i valori min/max secondo chIndex
    chInMin = float(0)
    if  (redSrv0.get('SETTINGS:IN:MIN:'+str(chIndex)) != 0):
        chInMin = float(redSrv0.get('SETTINGS:IN:MIN:'+str(chIndex)))
    chInMax = float(3.3)
    if  (redSrv0.get('SETTINGS:IN:MAX:'+str(chIndex)) != 100):
        chInMax = float(redSrv0.get('SETTINGS:IN:MAX:'+str(chIndex)))
    chOutMin = float(0)
    if  (redSrv0.get('SETTINGS:OUT:MIN:'+str(chIndex)) != 0):
        chOutMin = float(redSrv0.get('SETTINGS:OUT:MIN:'+str(chIndex)))
    chOutMax = float(1000)
    if  (redSrv0.get('SETTINGS:OUT:MAX:'+str(chIndex)) != 100):
        chOutMax = float(redSrv0.get('SETTINGS:OUT:MAX:'+str(chIndex)))
    # check denom zero
    deltaOut = (chOutMax - chOutMin)
    deltaIn = (chInMax - chInMin)
    if(deltaIn==0):
        deltaIn = 1
    # calcolo scalato
    outVal = chOutMin + ((inValue-chInMin) * (deltaOut / deltaIn))
    return outVal

def checkPowerOff():
    powerChannel = getRedisVal('SETTINGS:POWER:CH')
    if(int(powerChannel) < 10):
        #controllo che non ci sia già una richiesta di spegnimento
        if(getRedisVal('SETTINGS:POWER:OFF')=="0"):
            limitVal = float(getRedisVal('SETTINGS:POWER:THRESH'))
            actVal = float(getRedisVal('RTDATA:CH:' + str(powerChannel)))
            #controllo che il valore letto sia inferiore al valore impostato di soglia
            if(actVal < limitVal):
                #controllo che il sistema abbia superato l'uptime minimo impostato su redis
                UptimePower = getRedisVal('SETTINGS:POWER:UPTIME')
                sysUptime = os.popen("awk '{print $1}' /proc/uptime").readline()
                if float(sysUptime) > float(UptimePower):
                    # chiedo spegnimento
                    redSrv0.set('SETTINGS:POWER:OFF',1)

def calculateValue():
    # funzione per calcolare valore risultante (B/A-B)
    decimalsCount = int(getRedisVal('SETTINGS:DECIMALS:COUNT'))
    ch1 = getRedisVal('SETTINGS:CHANNEL:A')
    ch2 = getRedisVal('SETTINGS:CHANNEL:B')
    v1 = getRedisVal('RTDATA:OUT:' + ch1)
    v2 = getRedisVal('RTDATA:OUT:' + ch2)
    k1 = getRedisVal('RTDATA:VALUE:K1CONST')
    k2 = getRedisVal('RTDATA:VALUE:K2CONST')
    offset = getRedisVal('RTDATA:VALUE:OFFSET')
    den = abs(float(v1)-float(v2))
    if(den < 0.01):
        den = 0.01
    # calcolo il valore risultante pulito (senza correzioni)
    XVal = (float(v2)/float(den))
    redSrv0.set('RTDATA:VALUE:RAW',round(XVal,decimalsCount))

    # Smoothing EWMA valori "grezzi""
    strValInRaw = XVal
    # EWMAx RAW RILEGGO DA REDIS vecchio valore
    oldValRaw = float(redSrv0.get('RTDATA:VALUE:SMRAW'))
    if(oldValRaw == 0):
        oldValRaw = 0.01
    # se variazione < 50% smooth, altrimenti usa il valore nuovo
    if((abs(XVal - oldValRaw) / oldValRaw) < 0.5):
        # effettuo smoothing valore
        eFact = 3
        strValInRaw = (XVal/eFact) + (oldValRaw * (eFact-1) / eFact)
    redSrv0.set('RTDATA:VALUE:SMRAW',round(strValInRaw,decimalsCount))

    # applicazione correzioni (costanti k1*x^2, k2*x e offset)
    newValue = (float(k1)*float(XVal)*float(XVal))+(float(k2)*float(XVal))+float(offset)
    redSrv0.set('RTDATA:VALUE:REAL',round(newValue,decimalsCount))

    # Smoothing EWMA valori corretti (fattori k1 k2)
    strValIn = newValue
    # EWMA: RILEGGO DA REDIS vecchio valore
    oldVal = float(redSrv0.get('RTDATA:VALUE:SMOOTHED'))
    if(oldVal == 0):
        oldVal = 0.01
    # se variazione < 50% smooth, altrimenti usa il valore nuovo
    if((abs(newValue - oldVal) / oldVal) < 0.5):
        # effettuo smoothing valore
        eFact = 3
        strValIn = (newValue/eFact) + (oldVal * (eFact-1) / eFact)
    redSrv0.set('RTDATA:VALUE:SMOOTHED',round(strValIn,decimalsCount))


# init array
smoothFact= int(getRedisVal('SETTINGS:SMOOTHING:FACTOR'))
initArray = [0.0] * 8
meanValues = [0.0] * 8
dataBox = np.array([initArray] * smoothFact)
redisTime = 'RTDATA:TIME:SRV'

# init oggetto lettura Digital Analog
try:
    CH = ADS1256.ADS1256()
    CH.ADS1256_init()

#ciclo principale
    while(1):
        # update freq campionamento da redis
        sampleFreq = getRedisVal(redSampleFreq)
        smoothFact= int(getRedisVal('SETTINGS:SMOOTHING:FACTOR'))
        dataBox = np.array([initArray] * smoothFact)
        now = datetime.datetime.now()
        dateFormat ="%d/%m/%Y %H:%M:%S"
        lastLog = now.strftime(dateFormat)
        redSrv0.set(redisTime,str(lastLog))
        for counter in range(0,smoothFact,+1):
            # leggo gli 8 valori
            CHvalue = CH.ADS1256_GetAll()
            floatArray = np.array(CHvalue, dtype=float)
            dataBox[counter] = floatArray*float(5.0/0x7fffff)
            # calcolo e scrittura ogni NUM PERIOD cicli
            if counter == (smoothFact-1):
                # faccio gli smoothing colonna x colonna
                meanValues = calcMean(dataBox)
                #salvo valori
                redisSave(meanValues)
                # controllo soglia spegnimento
                checkPowerOff()
                # calcolo il valore k*[V2/(V1-V2)] + offset
                calculateValue()
        # riporto ultima esecuzione ad adesso
        endExec = datetime.datetime.now()
        # calcolo il delta time dovuto alle esecuzioni
        delta = endExec - now
        # attesa viene fatta sempre
        waitTime = (int(sampleFreq)*smoothFact)/1000 - delta.microseconds/1000000
        if(waitTime < 0.0):
            redSrv0.set('SETTINGS:WARNING:EXETIME',1)
        else:
            redSrv0.set('SETTINGS:WARNING:EXETIME',0)
        if(waitTime < 0.001):
            waitTime = 0.001
        # vera attesa
        time.sleep(waitTime)

#eccezione da ctrl+c in terminale e chiusura
except KeyboardInterrupt:
    FTL.FTLog.Write(" FTSampler stopped by Ctrl+C")
    exit()

#eccezione da errore e chiusura
except Exception as errorMessage:
    FTL.FTLog.Write(str(" FTSampler stopped: " + errorMessage))
    exit()