Samuele E. Locatelli
338 lines
6.8 KiB
Python
338 lines
6.8 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# readParallela v. 1.1
|
|
|
|
#---------------------------------------------------------------
|
|
|
|
|
|
import time
|
|
import sys
|
|
|
|
|
|
from datetime import datetime
|
|
|
|
import urllib
|
|
import ConfigParser
|
|
import os, sys
|
|
|
|
#---------------------------------------------------------------
|
|
|
|
# COSTANTI
|
|
MSGLEN = 9
|
|
TIMEOUTSERIALE = 10
|
|
MAXRETRY = 3
|
|
|
|
PROGRAM_NAME ="ReadPar IOB-pi v.1.1"
|
|
|
|
# DA FILE CONF
|
|
idxMacchina = "1001"
|
|
SAMPLETIME = 0.1
|
|
TIMEOUTSHORT = (SAMPLETIME*20)
|
|
TIMEOUTLONG = (SAMPLETIME*600)
|
|
|
|
# VAR
|
|
to_enable = False
|
|
to_short = TIMEOUTSHORT
|
|
to_long = TIMEOUTLONG
|
|
to_serial = TIMEOUTSERIALE
|
|
to_retry = MAXRETRY
|
|
errormsglen = 0
|
|
|
|
# VAR
|
|
|
|
out_0 = 24
|
|
out_1 = 26
|
|
|
|
in_0 = 11
|
|
in_1 = 12
|
|
in_2 = 13
|
|
in_3 = 15
|
|
in_4 = 16
|
|
in_5 = 18
|
|
in_6 = 22
|
|
in_7 = 7
|
|
|
|
#---------------------------------------------------------------
|
|
# classe logger
|
|
|
|
class Logger:
|
|
def __init__(self, filename):
|
|
try:
|
|
self.filename = filename
|
|
except:
|
|
logga("LOGGER: errore try su self.filename")
|
|
sys.exit(1)
|
|
def __call__(self, string):
|
|
try:
|
|
file = open(self.filename, 'a')
|
|
file.write('[' + time.strftime("%Y-%m-%d %H:%M:%S") + '] ')
|
|
file.write(string + '\n')
|
|
file.close()
|
|
except:
|
|
logga("LOGGER: errore try su scrittura")
|
|
sys.exit(1)
|
|
|
|
#---------------------------------------------------------------
|
|
# lettura parallela
|
|
# ritorna il byte letto pulito ( due char hex )
|
|
|
|
def readParallela():
|
|
|
|
global in_0
|
|
global in_1
|
|
global in_2
|
|
global in_3
|
|
global in_4
|
|
global in_5
|
|
global in_6
|
|
global in_7
|
|
|
|
global GPIO
|
|
|
|
current = ''
|
|
|
|
# print "input : "
|
|
|
|
# ritorna '' se non ci sono abbastanza caratteri
|
|
try:
|
|
num_value = 255
|
|
|
|
# print "num_value : " , num_value , in_0
|
|
|
|
if GPIO.input(in_0):
|
|
num_value = num_value - 1
|
|
|
|
if GPIO.input(in_1):
|
|
num_value = num_value - 2
|
|
|
|
if GPIO.input(in_2):
|
|
num_value = num_value - 4
|
|
|
|
if GPIO.input(in_3):
|
|
num_value = num_value - 8
|
|
|
|
if GPIO.input(in_4):
|
|
num_value = num_value - 16
|
|
|
|
if GPIO.input(in_5):
|
|
num_value = num_value - 32
|
|
|
|
if GPIO.input(in_6):
|
|
num_value = num_value - 64
|
|
|
|
if GPIO.input(in_7):
|
|
num_value = num_value - 128
|
|
|
|
current = hex( num_value ).replace ( "0x" , "" ).upper()
|
|
|
|
# print "\n\n\n\n\n" , num_value , current
|
|
|
|
##### convertire in HEX !!!!
|
|
|
|
except:
|
|
pass
|
|
|
|
return current
|
|
|
|
|
|
|
|
#---------------------------------------------------------------
|
|
#Funzione di scrittura su url con try-except
|
|
|
|
def chiamaUrl():
|
|
|
|
try:
|
|
url = URLBASE + idxMacchina + URLADV1 + value
|
|
urllib.urlopen ( url )
|
|
except:
|
|
logga ( "NETWORK:Errore http-no com rete-timeout" + url )
|
|
print "Url aforte" , url
|
|
|
|
#---------------------------------------------------------------
|
|
# Funzione che verifica possibilità di creare log e include testo corrente
|
|
|
|
def logga(message) :
|
|
try:
|
|
log(message)
|
|
except :
|
|
pass
|
|
|
|
#---------------------------------------------------------------
|
|
def avviaParallela():
|
|
|
|
try:
|
|
|
|
GPIO.setmode(GPIO.BOARD)
|
|
|
|
GPIO.setwarnings(False)
|
|
|
|
#GPIO.setup(out_0, GPIO.OUT) # output 0
|
|
#GPIO.setup(out_1, GPIO.OUT) # output 1
|
|
|
|
GPIO.setup(in_0, GPIO.IN) # input 0
|
|
GPIO.setup(in_1, GPIO.IN) # input 1
|
|
GPIO.setup(in_2, GPIO.IN) # input 2
|
|
GPIO.setup(in_3, GPIO.IN) # input 3
|
|
GPIO.setup(in_4, GPIO.IN) # input 4
|
|
GPIO.setup(in_5, GPIO.IN) # input 5
|
|
GPIO.setup(in_6, GPIO.IN) # input 6
|
|
GPIO.setup(in_7, GPIO.IN) # input 7
|
|
|
|
except:
|
|
print( "\n\n" + PROGRAM_NAME + " - Error 3 on RPi.GPIO ! \n\n")
|
|
sys.exit(1)
|
|
|
|
|
|
print( "\n\n" + PROGRAM_NAME + " - init ok \n\n")
|
|
|
|
|
|
#---------------------------------------------------------------
|
|
#---------------------------------------------------------------
|
|
# MAIN
|
|
|
|
try:
|
|
config = ConfigParser.RawConfigParser()
|
|
config.read ( 'IOB.cfg' )
|
|
|
|
SAMPLETIME = config.getfloat ( 'time' , 'SAMPLETIME' )
|
|
TIMEOUTSHORT = config.getfloat ( 'time' , 'TIMEOUTSHORT' )
|
|
TIMEOUTLONG = config.getfloat ( 'time' , 'TIMEOUTLONG' )
|
|
|
|
idxMacchina = config.get ( 'id' , 'idxMacchina' )
|
|
|
|
|
|
URLBASE = config.get ( 'web' , 'URLBASE' )
|
|
URLADV1 = config.get ( 'web' , 'URLADV1' )
|
|
|
|
LOGFILE = config.get ( 'log' , 'LOGFILE' )
|
|
LOGLEVEL = config.get ( 'log' , 'LOGLEVEL' )
|
|
except:
|
|
print "\n\n" + PROGRAM_NAME + ' - Error 4 - in config file ' 'IOB.cfg'
|
|
sys.exit(1)
|
|
|
|
# oggetto Logger
|
|
try:
|
|
log = Logger(LOGFILE)
|
|
except:
|
|
# manda mail o simili - FARE!!!
|
|
print "LOG: Impossibile creare file log con nome "
|
|
print (LOGFILE)
|
|
|
|
print "\n\n" + PROGRAM_NAME + "\n\n"
|
|
|
|
global startstatus
|
|
startstatus = 1
|
|
|
|
if startstatus == 1:
|
|
logga("Avvio Programma" + PROGRAM_NAME)
|
|
|
|
## Verifica l'OS e di conseguenza carica il file relativo con metodo di lockfile appropriato + check singola istanza
|
|
if os.name == 'posix':
|
|
import unix
|
|
else:
|
|
import win
|
|
|
|
logga ( "Start " + PROGRAM_NAME )
|
|
|
|
|
|
# lettura file configurazione
|
|
|
|
# [id]
|
|
# idxMacchina = 2001
|
|
# [time]
|
|
# SAMPLETIME = 0.1
|
|
# TIMEOUTSHORT = 200
|
|
# TIMEOUTLONG = 6000
|
|
|
|
|
|
print ( ' idxMacchina = %s' % ( idxMacchina ) )
|
|
print ( ' TIMEOUTSHORT = %4.2f' % ( TIMEOUTSHORT ) )
|
|
print ( ' TIMEOUTLONG = %4.2f' % ( TIMEOUTLONG ) )
|
|
print ( ' URLBASE = %s' % ( URLBASE ) )
|
|
print ( ' URLADV1 = %s' % ( URLADV1 ) )
|
|
print ( ' LOGFILE = %s' % ( LOGFILE ) )
|
|
print ( ' LOGLEVEL = %s' % ( LOGLEVEL ) )
|
|
|
|
# -sys.stdout.write ( 'idxMacchina ?' + idxMacchina + '\n')
|
|
|
|
to_short = TIMEOUTSHORT
|
|
to_long = TIMEOUTLONG
|
|
|
|
|
|
#--------------------------------------------------------------
|
|
# apertura parallela
|
|
|
|
try:
|
|
import RPi.GPIO as GPIO
|
|
except RuntimeError:
|
|
print( "\n\n" + PROGRAM_NAME + " - Error 1 - you need superuser privileges")
|
|
except:
|
|
print( "\n\n" + PROGRAM_NAME + " - Error 2 - you need superuser privileges. USE 'sudo' to run your script\n\n")
|
|
sys.exit(1)
|
|
|
|
|
|
avviaParallela()
|
|
|
|
#---------------------------------------------------------------
|
|
# ciclo forever and ever
|
|
|
|
old = ''
|
|
|
|
while 1:
|
|
|
|
try:
|
|
time.sleep (SAMPLETIME)
|
|
except:
|
|
logga("First_SLEEP: errore attesa sampletime")
|
|
|
|
# lettura dati da IOB
|
|
value = readParallela()
|
|
|
|
if ( value != '' ) :
|
|
if value != old :
|
|
#loggo e invio dati
|
|
try:
|
|
logga ( value )
|
|
errormsglen = 0
|
|
chiamaUrl()
|
|
except:
|
|
logga("URLBROWSER: errore registrazione valore e chiamaUrl")
|
|
pass
|
|
#enable e reset timer
|
|
to_enable = True
|
|
to_short = TIMEOUTSHORT
|
|
to_long = TIMEOUTLONG
|
|
|
|
old = value
|
|
|
|
|
|
# gestione timeout breve
|
|
if ( to_enable ) :
|
|
to_short = to_short - SAMPLETIME
|
|
if to_short <= 0:
|
|
#loggo e invio dati
|
|
try:
|
|
logga ( '>' + value )
|
|
errormsglen = 0
|
|
chiamaUrl()
|
|
except:
|
|
pass
|
|
to_short = TIMEOUTSHORT
|
|
to_enable = False # dopo un colpo il timer breve viene disabilitato
|
|
to_long = TIMEOUTLONG
|
|
|
|
# gestione timeout lungo
|
|
to_long = to_long - SAMPLETIME
|
|
if to_long <= 0:
|
|
#loggo e invio dati
|
|
try:
|
|
logga ( '>>' + value )
|
|
errormsglen = 0
|
|
chiamaUrl()
|
|
except:
|
|
pass
|
|
to_long = TIMEOUTLONG
|
|
|
|
|