pyP2SerialMon.py

#!/usr/bin/python
# -*- coding: utf-8 -*-#

# Copyright 2013, 2014 Weber Yann, Weber Laurent
#
# This file is part of pyP2Monitor.
#
#        pyP2Monitor is free software: you can redistribute it and/or modify
#        it under the terms of the GNU General Public License as published by
#        the Free Software Foundation, either version 3 of the License, or
#        (at your option) any later version.
#
#        pyP2Monitor is distributed in the hope that it will be useful,
#        but WITHOUT ANY WARRANTY; without even the implied warranty of
#        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#        GNU General Public License for more details.
#
#        You should have received a copy of the GNU General Public License
#        along with pyP2Monitor.  If not, see <http://www.gnu.org/licenses/>.
#

##@page serialmon Howto use the monitoring programm
#
# @section smdesc Description
# The monitoring programm is used to retrieve and store datas from the furnace using the serial port.
# This is done by running the pyP2_monitor executable.
# 
# @section smopt Programm options
# There is few important options :
# - -p That define the serial port to communicate on ( on GNU/Linux system usually something like /dev/ttyS0 )
# - -d That define the name of the sqlite database to store datas in
# - -B That tell the programm to fork in background
#
# To have more informations on possible options run "pyP2_monitor -h"

#Python libs import
import serial, signal, time, sys, os, traceback
import time

#pyP2Monitor import
import p2com 
from p2com import *
import p2proto
from p2proto import *
import p2msg
from p2msg import *
import utils

com = None
pidfile= ""

##Gentle exit to manage sigint
def gentle_exit(signal, frame):
        logger.critical("signal caught, exiting")
        #Serial port closing
        com.stop()
        os.unlink(pidfile)
        sys.exit(0)

##"Fork" into background
def start_daemon(pidfile):
        arg = []
        for e in sys.argv:
                if e != '-B' and e != '--background':   #Deleting background option
                        arg.append(e)
        logger.debug("Starting background process...")
        pid = os.spawnv(os.P_NOWAIT,arg[0], arg)
        fdpid = open(pidfile,"w+")
        fdpid.write(str(pid))
        fdpid.close()
        
        logger.debug("Background process started. Pid = "+str(pid))
        
        return pid


signal.signal(signal.SIGINT, gentle_exit)
signal.signal(10, gentle_exit)

#Argument parse
args = utils.argParse('monitor')

#Init output (logging and verbosity)
utils.initLogging(args['verbosity'], args['log_file'], args['log_level'], args['log_num'], args['log_size'])

logger = utils.getLogger()

#start background process to start a daemon
pidfile = args['pidfile']
if args['background']:
        exit(start_daemon(pidfile))
elif args['stop']: #or kill an existing daemon
        try:
                pidfd = open(pidfile,"r")
                pid = int(pidfd.read())
                os.kill(pid, 10)
                logger.debug("Sig 10 send to process",pid)
        except:
                exit(0)
        exit(1)
        

#Store all the data's storage method
storage = []
if args['database'] != None:
        for c in args['database']:
                storage.append(('sqlite',c))
if args['last_data'] != None:
  #Testing if this file is openable
  lfile=open(args['last_data'], "w+")
  lfile.close()
  #adding the file to the storage list
  storage.append(('lastdata',args['last_data']))
if args['file'] != None:
        for c in args['file']:
                storage.append(('file',c))
if args['csv'] != None:
        for c in args['csv']:
                storage.append(('csv',c))

#Serial port opening
com = P2Furn(args['port'])

#Running wanted stages
for stage in args['stage']:
        maxretry = 3
        
        infinite = False
        
        stages = 0      

        if stage == 'all':
                stages = 7
                infinite = True
        elif stage == 'auth':
                stages = 1
        elif stage == 'init':
                stages = 2
        elif stage == 'data':
                stages = 3
        
        while True:
                try:
                        
                        #Run auth stage
                        if stages&1:
                                again = 0
                                while again<maxretry:
                                        try:
                                                com.runAuth(P2Furn.userId(args['user']))
                                                again = maxretry+1
                                        except p2com.P2ComError as e:
                                                if again < maxretry:
                                                        logger.error("Authentication stage failed : "+str(e))
                                                        again+=1
                                                        time.sleep(10*again)
                                                else:
                                                        logger.critical("Authentication stage failed again after "+str(maxretry)+" attempts")
                                                        raise e
                        
                        #Run initialisation stage
                        if stages&2:
                                again = 0
                                while again<maxretry:
                                        try:
                                                com.runInit()
                                                again = maxretry+1
                                        except p2com.P2ComError as e:
                                                if again < maxretry:
                                                        logger.error("Initialisation stage failed : "+str(e))
                                                        again+=1
                                                        time.sleep(10*again)
                                                else:
                                                        logger.critical("Initialisation stage failed again after "+str(maxretry)+" attempts")
                                                        raise e
                        
                        #Run data exchange stage
                        if stages&3:
                                again = 0
                                while again<maxretry:
                                        try:
                                                com.readData(float(args['data_wait']),storage)
                                                again = maxretry+1
                                        except p2com.P2ComError as e:
                                                if again < maxretry:
                                                        logger.error("DataReading stage failed : "+str(e))
                                                        again+=1
                                                        time.sleep(10*again)
                                                else:  
                                                        logger.critical("DataReading stage failed again after "+str(maxretry)+" attempts")
                                                        raise e
                                                
                except p2com.P2ComError as e: #Catch exception raised by stage failed after maxretry
                        if infinite:
                                        logger.error("Running stages failed, closing serial port, waiting 60 seconds and trying again...")
                                        com.stop()
                                        time.sleep(60)
                                        logger.info("Opening serial port again and trying again")
                                        com = P2Furn(args['port'])
                        else:
                                        raise e
                except SystemExit:
                        raise
                except:
                                logger.critical(traceback.format_exc())
                                com.stop()
                                exit(1)

#Serial port closing
com.stop()