Aggiunta vers legacy 1.8
This commit is contained in:
@@ -0,0 +1,23 @@
|
||||
[id]
|
||||
idxMacchina = 1005
|
||||
|
||||
[web]
|
||||
URLBASE = http://10.74.82.219/MPIO/inputIOB.aspx?idxMacchina=
|
||||
URLALIVE = http://10.74.82.219/MPIO/Alive.aspx
|
||||
URLENABLED = http://10.74.82.219/MPIO/Enabled.aspx?idxMacchina=
|
||||
URLADV1 = &valore=
|
||||
URLREBO = http://10.74.82.219/MPIO/sendReboot.aspx?idxMacchina=
|
||||
|
||||
[time]
|
||||
SAMPLETIME = 0.20
|
||||
TIMEOUTSHORT = 0.30
|
||||
TIMEOUTLONG = 50
|
||||
SENDURLTIME = 0.50
|
||||
|
||||
[log]
|
||||
LOGLEVEL = 10
|
||||
LOGFILE = logfile.txt
|
||||
LOGREBO = logReboot.txt
|
||||
|
||||
[comm]
|
||||
port = /dev/ttyAMA0
|
||||
@@ -0,0 +1,23 @@
|
||||
[id]
|
||||
idxMacchina = 1002
|
||||
|
||||
[web]
|
||||
URLBASE = http://192.168.51.71/MPIO/inputIOB.aspx?idxMacchina=
|
||||
URLALIVE = http://192.168.51.71/MPIO/Alive.aspx
|
||||
URLENABLED = http://192.168.51.71/MPIO/Enabled.aspx?idxMacchina=
|
||||
URLADV1 = &valore=
|
||||
URLREBO = http://192.168.51.71/MPIO/sendReboot.aspx?idxMacchina=
|
||||
|
||||
[time]
|
||||
SAMPLETIME = 0.25
|
||||
TIMEOUTSHORT = 2
|
||||
TIMEOUTLONG = 50
|
||||
SENDURLTIME = 0.2
|
||||
|
||||
[log]
|
||||
LOGLEVEL = 10
|
||||
LOGFILE = logfile.txt
|
||||
LOGREBO = /var/log/logReboot.txt
|
||||
|
||||
[comm]
|
||||
port = /dev/ttyAMA0
|
||||
@@ -0,0 +1,23 @@
|
||||
[id]
|
||||
idxMacchina = 1005
|
||||
|
||||
[web]
|
||||
URLBASE = http://10.74.82.219/MPIO/inputIOB.aspx?idxMacchina=
|
||||
URLALIVE = http://10.74.82.219/MPIO/Alive.aspx
|
||||
URLENABLED = http://10.74.82.219/MPIO/Enabled.aspx?idxMacchina=
|
||||
URLADV1 = &valore=
|
||||
URLREBO = http://10.74.82.219/MPIO/sendReboot.aspx?idxMacchina=
|
||||
|
||||
[time]
|
||||
SAMPLETIME = 0.20
|
||||
TIMEOUTSHORT = 0.30
|
||||
TIMEOUTLONG = 50
|
||||
SENDURLTIME = 0.50
|
||||
|
||||
[log]
|
||||
LOGLEVEL = 10
|
||||
LOGFILE = logfile.txt
|
||||
LOGREBO = logReboot.txt
|
||||
|
||||
[comm]
|
||||
port = /dev/ttyAMA0
|
||||
@@ -0,0 +1,41 @@
|
||||
### BEGIN INIT INFO
|
||||
# Provides: MapoIOB: script Steamware per avvio driver IOB
|
||||
# Required-Start: $remote_fs $syslog ramlog
|
||||
# Required-Stop: $remote_fs $syslog ramlog
|
||||
# Default-Start: 2 3 4 5
|
||||
# Default-Stop: 0 1 6
|
||||
# Short-Description: Steamware's MapoIOB driver
|
||||
# Description: Steamware's MapoIOB driver, versione lettura porta parallela
|
||||
### END INIT INFO
|
||||
|
||||
#! /bin/sh
|
||||
# /etc/init.d/MapoIOB
|
||||
|
||||
export HOME
|
||||
case "$1" in
|
||||
start)
|
||||
echo "Starting readParallela"
|
||||
cd /home/pi/steamware
|
||||
/usr/bin/python ./readParallela.py 2>&1 &
|
||||
;;
|
||||
stop)
|
||||
echo "Stopping readParallela"
|
||||
RS_PID=`ps auxwww | grep readParallela.py | head -1 | awk '{print $2}'`
|
||||
kill -9 $RS_PID
|
||||
cd /home/pi/steamware
|
||||
rm .lockfile
|
||||
;;
|
||||
restart)
|
||||
## Stop the service and regardless of whether it was
|
||||
## running or not, start it again.
|
||||
$0 stop
|
||||
killall python
|
||||
$0 start
|
||||
;;
|
||||
*)
|
||||
echo "Usage: /etc/init.d/MapoIOB {start|stop|restart}"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
exit 0
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
#!/bin/bash
|
||||
|
||||
# controlla se il logfile è correntemente scritto (quindi MapoIOB è alive) altrimenti riavvia!
|
||||
|
||||
DATE=`date +%Y-%m-%d`
|
||||
cd /var/log
|
||||
if [ -f MapoIOB ]
|
||||
then
|
||||
# controllo SE sia stato acceduto da meno di 2 minuti (=alive da log...)
|
||||
trovato=`find . -name 'MapoIOB*' -cmin -1`
|
||||
if [[ $trovato != './MapoIOB' ]]
|
||||
then
|
||||
/etc/init.d/MapoIOB restart
|
||||
echo $date + "riavvio!"
|
||||
fi
|
||||
else
|
||||
# in questo caso AVVIO il processo MapoIOB
|
||||
/etc/init.d/MapoIOB start
|
||||
echo $date + "file non trovato, avvio!"
|
||||
fi
|
||||
@@ -0,0 +1,14 @@
|
||||
#!/bin/bash
|
||||
|
||||
DATE=`date +%Y-%m-%d_%T`
|
||||
# log inizio pulizia
|
||||
echo $DATE " - INIZIO pulizia processi python" >> clean.log
|
||||
# effettua pulizia processi: killa tutti i processi python
|
||||
killall python
|
||||
|
||||
# avvia MapoIob
|
||||
/etc/init.d/MapoIOB start
|
||||
|
||||
# log fatto!
|
||||
DATE=`date +%Y-%m-%d_%T`
|
||||
echo $DATE " - FINE pulizia processi python + riavvio MapoIOB" >> clean.log
|
||||
@@ -0,0 +1 @@
|
||||
* * * * * /bin/bash /home/pi/steamware/checkAlive.sh >> /home/pi/stdout 2>> /home/pi/stderr
|
||||
@@ -0,0 +1,47 @@
|
||||
#|/bin/bash
|
||||
|
||||
#installa il necessario per RPI-3-IOB partendo dal contenuto della folder /home/pi/steamware
|
||||
|
||||
#step 1: creo file di log nuovi
|
||||
rm /var/log/log*.txt
|
||||
rm /var/log/MapoIOB
|
||||
rm /home/pi/steamware/log*.txt
|
||||
|
||||
touch /var/log/logReboot.txt
|
||||
touch /var/log/logTemp.txt
|
||||
touch /var/log/MapoIOB
|
||||
|
||||
ln -sf /var/log/logReboot.txt /home/pi/steamware/logReboot.txt
|
||||
ln -sf /var/log/logTemp.txt /home/pi/steamware/logTemp.txt
|
||||
ln -sf /var/log/MapoIOB /home/pi/steamware/logfile.txt
|
||||
|
||||
chown pi:pi /home/pi -R
|
||||
chmod 666 /var/log/log*.txt
|
||||
chmod 666 /var/log/MapoIOB
|
||||
|
||||
#step 2: copio files in /usr/local/bin
|
||||
cd /home/pi/steamware
|
||||
chmod +x *.sh
|
||||
cp *.sh /usr/local/bin/
|
||||
|
||||
# step 3: copio target systemd in avvio...
|
||||
cp -f sendRebootIOB /etc/init.d/sendRebootIOB
|
||||
cp -f sendRebootIOB.service /etc/systemd/system/sendRebootIOB.service
|
||||
echo ""
|
||||
echo "-----------------------------------------------"
|
||||
echo "Completare registrazione servizio avvio: digitare i seguenti comandi"
|
||||
echo "systemctl enable sendRebootIOB"
|
||||
echo "systemctl daemon-reload"
|
||||
echo "systemctl status sendRebootIOB"
|
||||
echo "-----------------------------------------------"
|
||||
echo ""
|
||||
echo ""
|
||||
echo ""
|
||||
echo "-----------------------------------------------"
|
||||
echo "Infine creare voce crontab che salvi temperatura CPU/GPU ogni 20 minuti..."
|
||||
echo "crontab -e"
|
||||
echo "*/20 * * * * /usr/local/bin/saveTemp.sh"
|
||||
echo "-----------------------------------------------"
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
#!/bin/bash
|
||||
/usr/bin/python /home/pi/steamware/readParallela.py
|
||||
@@ -0,0 +1,2 @@
|
||||
#!/bin/bash
|
||||
/usr/bin/python /home/steamware/readSeriale.py
|
||||
@@ -0,0 +1,530 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# readParallela v. 1.8
|
||||
# versione estetica di Carlo + single instance timer
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# levare locking
|
||||
# timer semplificata
|
||||
# GPIO global
|
||||
|
||||
|
||||
import time
|
||||
import sys
|
||||
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
import urllib
|
||||
import ConfigParser
|
||||
import os, sys
|
||||
|
||||
import logging
|
||||
import logging.handlers
|
||||
import threading
|
||||
import Queue
|
||||
#--------------------------------------------------------------
|
||||
|
||||
# COSTANTI
|
||||
MSGLEN = 9
|
||||
TIMEOUTSERIALE = 10
|
||||
MAXRETRY = 3
|
||||
|
||||
PROGRAM_NAME ="ReadPar IOB-pi v.1.8"
|
||||
|
||||
# DA FILE CONF
|
||||
idxMacchina = "1001"
|
||||
SAMPLETIME = 0.1
|
||||
TIMEOUTSHORT = (SAMPLETIME*20)
|
||||
TIMEOUTLONG = (SAMPLETIME*600)
|
||||
SENDURLTIME = 0.08
|
||||
|
||||
# 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
|
||||
|
||||
# contatore: serve x match tra accoda ed invia x possibile controllo a posteriori... ogni volta che accodo incremento di 1, va da 0 a 999
|
||||
cont = '0'
|
||||
|
||||
# variabile stato online/offline della macchina
|
||||
onLine = '1'
|
||||
|
||||
# variabile stato seinding/waiting x la parte invio URL
|
||||
sending = '0'
|
||||
|
||||
# variabile stato timer thread busy
|
||||
timer_busy = False
|
||||
|
||||
#--------------------------------------------------------------
|
||||
# Gestione coda (condivisa) x registrazione eventi ed invio URL
|
||||
#print "Creazione coda 1000 elementi"
|
||||
|
||||
Coda = Queue.Queue(0)
|
||||
|
||||
#queueLock = threading.Lock()
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# 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
|
||||
|
||||
except:
|
||||
pass
|
||||
|
||||
return current
|
||||
|
||||
|
||||
#--------------------------------------------------------------
|
||||
# MARCO: cambiare: chiama URL NON deve chiamare url MA METTERE IN CODA (riempiCoda!!!)
|
||||
# la parte URL vera va messa in svuotaCoda, PARAMETRICA
|
||||
|
||||
#---------------------------------------------------------------
|
||||
#Funzione di scrittura su coda con try-except
|
||||
|
||||
def accoda():
|
||||
|
||||
try:
|
||||
# url = URLBASE + idxMacchina + URLADV1 + value
|
||||
# urllib.urlopen ( url )
|
||||
#dtEve = time.strftime("%y%m%d%H%M%S")+"000"
|
||||
dtEve = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')[:-3]
|
||||
#logPro.debug( "Nuovo valore inserito in coda: " + dtEve + "#" + value + '#' + cont)
|
||||
#print(dtEve)
|
||||
#queueLock.acquire()
|
||||
Coda.put(dtEve + '#' + value + '#' + cont)
|
||||
#queueLock.release()
|
||||
#print "Nuovo valore inserito in coda: " + dtEve + "#", value
|
||||
|
||||
except Queue.Full:
|
||||
logPro.error( "Quque full" + dtEve + '#' + value + '#' + cont )
|
||||
except:
|
||||
logPro.error( "NETWORK:Errore http-no com rete-timeout" + url )
|
||||
# print "Url aforte" , url
|
||||
|
||||
|
||||
#--------------------------------------------------------------
|
||||
# MARCO: scrivere svuotaCoda come thread etc...
|
||||
def svuota_coda():
|
||||
|
||||
global onLine
|
||||
global sending
|
||||
global timer_busy
|
||||
|
||||
#print "start timer "
|
||||
|
||||
if ( timer_busy == False ):
|
||||
timer_busy = True
|
||||
#print "start timer ok "
|
||||
|
||||
try:
|
||||
if not Coda.empty():
|
||||
#print "coda da svuotare!"
|
||||
response = urllib.urlopen(URLALIVE)
|
||||
answ = response.read()
|
||||
if answ == 'OK':
|
||||
#print "OK alive"
|
||||
response2 = urllib.urlopen(URLENABLED + idxMacchina)
|
||||
answ2 = response2.read()
|
||||
if answ2 == 'OK':
|
||||
# aggiorno stato ad online
|
||||
if onLine == '0':
|
||||
logPro.info("IOB ONLINE!")
|
||||
#print("IOB ONLINE")
|
||||
|
||||
onLine = '1' # imposto comunque online
|
||||
else:
|
||||
if onLine == '1':
|
||||
logPro.error("IOB offline")
|
||||
#print("IOB offline")
|
||||
|
||||
onLine = '0'
|
||||
else:
|
||||
if onLine == '1':
|
||||
logPro.error("Server offline")
|
||||
#print("Server offline")
|
||||
|
||||
onLine = '0'
|
||||
|
||||
# ora verifico SE si possa inviare (ovvero sia online server e NON ci siano altri send attivi...)
|
||||
if onLine == '1':
|
||||
if sending == '0':
|
||||
#segnalo che sono in sending!
|
||||
sending = '1'
|
||||
|
||||
# formatto dataOra corrente
|
||||
#dtCurr = time.strftime("%y%m%d%H%M%S")+"000"
|
||||
dtCurr = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')[:-3]
|
||||
# prendo 1 valore dalla coda...
|
||||
#queueLock.acquire()
|
||||
resp = Coda.get()
|
||||
# RILASCIO SUBITO la coda x nuovi insert...
|
||||
#queueLock.release()
|
||||
|
||||
|
||||
# recupero valori da coda!
|
||||
dtEve = resp.split("#")[0]
|
||||
value = resp.split("#")[1]
|
||||
cnt = resp.split("#")[2]
|
||||
url = URLBASE + idxMacchina + URLADV1 + value
|
||||
url = url + '&dtCurr=' + dtCurr + '&dtEve=' + dtEve + '&cnt=' + cnt
|
||||
# CHIAMO URL
|
||||
response3 = urllib.urlopen ( url )
|
||||
answ3 = response3.read()
|
||||
#print(url)
|
||||
#logPro.debug(url)
|
||||
|
||||
|
||||
# log valore inviato!
|
||||
logSnd.info( value + ' ['+ cnt +']' + ' R:' + answ3 )
|
||||
#print "Valore smaltito dalla coda"
|
||||
|
||||
# completato invio, riporto sending a zero!
|
||||
sending = '0'
|
||||
else:
|
||||
logPro.info("WAIT active send to complete")
|
||||
|
||||
else:
|
||||
pass
|
||||
|
||||
else:
|
||||
pass
|
||||
|
||||
except:
|
||||
if onLine == '1':
|
||||
logPro.error("Server Non raggiungibile")
|
||||
#print "Non raggiungibile"
|
||||
|
||||
onLine = '0'
|
||||
|
||||
# in ogni caso
|
||||
|
||||
timer_busy = False
|
||||
#print "end timer ok"
|
||||
|
||||
|
||||
#print "end timer "
|
||||
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# funzione timer thread
|
||||
#---------------------------------------------------------------
|
||||
def do_every (interval, worker_func, iterations = 0):
|
||||
if iterations != 1:
|
||||
threading.Timer (
|
||||
interval,
|
||||
do_every, [interval, worker_func, 0 if iterations == 0 else iterations-1]
|
||||
).start ();
|
||||
|
||||
worker_func ();
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# gestione contatore
|
||||
#---------------------------------------------------------------
|
||||
def contatore():
|
||||
|
||||
try:
|
||||
global cont
|
||||
ctr = int(cont)
|
||||
ctr +=1
|
||||
ctr = ctr % 1000 # round robin 1000 eventi x track
|
||||
cont = str(ctr)
|
||||
except:
|
||||
print("errore incremento contatore")
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# avvia porta parallela
|
||||
#---------------------------------------------------------------
|
||||
def avviaParallela():
|
||||
|
||||
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
|
||||
|
||||
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' )
|
||||
SENDURLTIME = config.getfloat ( 'time' , 'SENDURLTIME' )
|
||||
|
||||
idxMacchina = config.get ( 'id' , 'idxMacchina' )
|
||||
|
||||
|
||||
URLBASE = config.get ( 'web' , 'URLBASE' )
|
||||
URLENABLED = config.get('web' , 'URLENABLED')
|
||||
URLALIVE = config.get ('web' , 'URLALIVE')
|
||||
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:
|
||||
logging.basicConfig(level=logging.DEBUG,
|
||||
format='%(asctime)s %(name)-8s %(levelname)-8s %(message)s',
|
||||
datefmt='%Y-%m-%d %H:%M:%S',
|
||||
filename=LOGFILE,
|
||||
filemode='a'
|
||||
)
|
||||
|
||||
# aggiungo 2 logger specifici x queue e send...
|
||||
logQue = logging.getLogger('queue')
|
||||
logSnd = logging.getLogger('sendUrl')
|
||||
logPro = logging.getLogger('program')
|
||||
|
||||
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:
|
||||
logPro.info("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
|
||||
|
||||
logPro.info( "Start " + PROGRAM_NAME )
|
||||
|
||||
|
||||
# lettura file configurazione
|
||||
|
||||
# [id]
|
||||
# idxMacchina = 2001
|
||||
# [time]
|
||||
# SAMPLETIME = 0.1
|
||||
# TIMEOUTSHORT = 200
|
||||
# TIMEOUTLONG = 6000
|
||||
|
||||
|
||||
print ( ' idxMacchina = %s' % ( idxMacchina ) )
|
||||
print ( ' SAMPLETIME = %4.2f' % ( SAMPLETIME ) )
|
||||
print ( ' TIMEOUTSHORT = %4.2f' % ( TIMEOUTSHORT ) )
|
||||
print ( ' TIMEOUTLONG = %4.2f' % ( TIMEOUTLONG ) )
|
||||
print ( ' SENDURLTIME = %4.2f' % ( SENDURLTIME ) )
|
||||
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()
|
||||
|
||||
|
||||
#--------------------------------------------------------------
|
||||
# MARCO: qui inserire avvio thread di "svuotaCoda"
|
||||
|
||||
# avviaSvuotaCoda
|
||||
#print "Avvia svuota coda"
|
||||
|
||||
do_every ( SENDURLTIME , svuota_coda );
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# ciclo forever and ever
|
||||
|
||||
old = ''
|
||||
|
||||
#print "Avvio ciclo"
|
||||
logPro.info("Avvio loop principale")
|
||||
while 1:
|
||||
|
||||
try:
|
||||
time.sleep (SAMPLETIME)
|
||||
except:
|
||||
logPro.info("First_SLEEP: errore attesa sampletime")
|
||||
|
||||
# lettura dati da IOB
|
||||
value = readParallela()
|
||||
|
||||
if ( value != '' ) :
|
||||
if value != old :
|
||||
#loggo e invio dati
|
||||
try:
|
||||
logQue.info( value + ' ['+ cont +']')
|
||||
errormsglen = 0
|
||||
accoda()
|
||||
contatore()
|
||||
except:
|
||||
logPro.error("URLBROWSER: errore registrazione valore e accoda")
|
||||
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:
|
||||
logQue.info( '>' + value + ' ['+ cont +']')
|
||||
errormsglen = 0
|
||||
accoda()
|
||||
contatore()
|
||||
except:
|
||||
logPro.error("URLBROWSER: errore registrazione valore e accoda TO_short")
|
||||
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:
|
||||
logQue.info( '>>' + value + ' ['+ cont +']')
|
||||
errormsglen = 0
|
||||
accoda()
|
||||
contatore()
|
||||
except:
|
||||
logPro.error("URLBROWSER: errore registrazione valore e accoda TO_long")
|
||||
pass
|
||||
to_long = TIMEOUTLONG
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,363 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
import serial
|
||||
import time
|
||||
import sys
|
||||
import datetime
|
||||
import urllib
|
||||
import ConfigParser
|
||||
import os, sys
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
# COSTANTI
|
||||
MSGLEN = 9
|
||||
TIMEOUTSERIALE = 10
|
||||
MAXRETRY = 3
|
||||
|
||||
# DA FILE CONF
|
||||
idxMacchina = "2001"
|
||||
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
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# 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 buffer seriale e pulizia caratteri non stampabili
|
||||
# ritorna '' se non c'è un messaggio buono o il messaggio pulito ( due bytes hex )
|
||||
# il messaggio ha il formato xx<ACK>i00 00<CR><LF>xxx
|
||||
|
||||
def readSeriale():
|
||||
|
||||
global to_serial
|
||||
global to_retry
|
||||
global errormsglen
|
||||
|
||||
ret = ''
|
||||
current = ''
|
||||
i = 0
|
||||
|
||||
# ritorna '' se non ci sono abbastanza caratteri
|
||||
try:
|
||||
if ser.inWaiting() < MSGLEN :
|
||||
#
|
||||
# to_serial = to_serial - 1 # se non mi risponde, faccio un ' altra richiesta....
|
||||
# if to_serial <= 0:
|
||||
# try:
|
||||
# requestData ()
|
||||
# except:
|
||||
# logga("SERIALE: errore su requestData")
|
||||
# sys.exit(1)
|
||||
# to_serial = TIMEOUTSERIALE # ripristino timer
|
||||
# to_retry = to_retry - 1 # contatore retry
|
||||
# if to_retry <= 0:
|
||||
# logga ( 'IOB not responding' )
|
||||
# return ret
|
||||
logga("SERIALE: errore msglen < 9 char - Errore no. " + str(errormsglen))
|
||||
errormsglen = errormsglen +1
|
||||
avviaSeriale()
|
||||
time.sleep(.2)
|
||||
if errormsglen > 30:
|
||||
sys.exit(1)
|
||||
except:
|
||||
if startstatus == 0:
|
||||
logga ("Porta SERIALE non disponibile - ser.inWaiting error - exit... - Errore no. " + str(errormsglen))
|
||||
errormsglen = errormsglen +1
|
||||
avviaSeriale()
|
||||
time.sleep(.2)
|
||||
if errormsglen > 30:
|
||||
sys.exit(1)
|
||||
|
||||
# finchè c'è robba .. leggi e tieni i buoni
|
||||
to_serial = TIMEOUTSERIALE
|
||||
to_retry = MAXRETRY
|
||||
try:
|
||||
while ser.inWaiting() > 0 :
|
||||
try:
|
||||
c = ser.read(1)
|
||||
except:
|
||||
logga("SERIALE: errore su try ser.read")
|
||||
sys.exit(1)
|
||||
# filtra caratteri non stampabili
|
||||
if c > ' ' :
|
||||
current += c
|
||||
#sys.stdout.write(current + '<<<<\n')
|
||||
# ora il messaggio ha il formato xxxxxi00 00xxx : cerco la 'i' iniziale
|
||||
try:
|
||||
while i < len(current) and current[i] != 'i':
|
||||
i = i + 1
|
||||
except:
|
||||
logga("SERIALE: errore su ricerca i iniziale")
|
||||
sys.exit(1)
|
||||
# se non ho trovato la 'i' restituisco ''
|
||||
if i == len(current)-1:
|
||||
return ret
|
||||
else:
|
||||
current = current[i+1:i+3]
|
||||
# richiesta dati ad IOB
|
||||
requestData()
|
||||
#sys.stdout.write ( current + '\n')
|
||||
except:
|
||||
if startstatus == 0:
|
||||
logga ('Porta SERIALE non disponibile - ser.inWaiting e filtraggio error...exit')
|
||||
sys.exit(1)
|
||||
return current
|
||||
#---------------------------------------------------------------
|
||||
# richiesta dati ad IOB : scrittura su seriale
|
||||
|
||||
def requestData ():
|
||||
try :
|
||||
ser.write ("$i" + '\r\n')
|
||||
ser.flush()
|
||||
except :
|
||||
if startstatus == 0:
|
||||
logga ( "SERIAL: Errore di scrittura/flush")
|
||||
|
||||
|
||||
#---------------------------------------------------------------
|
||||
#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 )
|
||||
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# Funzione che verifica possibilità di creare log e include testo corrente
|
||||
|
||||
def logga(message) :
|
||||
try:
|
||||
log(message)
|
||||
except :
|
||||
pass
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
|
||||
def avviaSeriale():
|
||||
global ser
|
||||
|
||||
try:
|
||||
ser = serial.Serial(
|
||||
port = comm_port ,
|
||||
baudrate = 9600 ,
|
||||
parity = serial.PARITY_NONE ,
|
||||
stopbits = serial.STOPBITS_ONE ,
|
||||
bytesize = serial.EIGHTBITS
|
||||
)
|
||||
startstatus = 0
|
||||
except serial.serialutil.SerialException , e :
|
||||
try:
|
||||
if startstatus == 0:
|
||||
logga ( "SERIAL:Errore apertura seriale - " + comm_port)
|
||||
except:
|
||||
pass
|
||||
sys.stdout.write ( '\nErrore apertura seriale\n\n%s\n\n' % e )
|
||||
if errormsglen > 30:
|
||||
sys.exit (1)
|
||||
|
||||
#---------------------------------------------------------------
|
||||
#---------------------------------------------------------------
|
||||
# MAIN
|
||||
|
||||
try:
|
||||
config = ConfigParser.RawConfigParser()
|
||||
config.read ( 'readSeriale.cfg' )
|
||||
|
||||
SAMPLETIME = config.getfloat ( 'time' , 'SAMPLETIME' )
|
||||
TIMEOUTSHORT = config.getfloat ( 'time' , 'TIMEOUTSHORT' )
|
||||
TIMEOUTLONG = config.getfloat ( 'time' , 'TIMEOUTLONG' )
|
||||
|
||||
idxMacchina = config.get ( 'id' , 'idxMacchina' )
|
||||
comm_port = config.get ( 'comm' , 'port' )
|
||||
|
||||
URLBASE = config.get ( 'web' , 'URLBASE' )
|
||||
URLADV1 = config.get ( 'web' , 'URLADV1' )
|
||||
|
||||
LOGFILE = config.get ( 'log' , 'LOGFILE' )
|
||||
LOGLEVEL = config.get ( 'log' , 'LOGLEVEL' )
|
||||
except:
|
||||
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 Read seriale IOB v.0.2 !!!!\n'
|
||||
|
||||
global startstatus
|
||||
startstatus = 1
|
||||
|
||||
if startstatus == 1:
|
||||
logga("Avvio Programma")
|
||||
|
||||
# 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 Read seriale IOB v.0.2")
|
||||
|
||||
|
||||
# lettura file configurazione
|
||||
|
||||
# [comm]
|
||||
# port = /dev/ttyS0
|
||||
# [id]
|
||||
# idxMacchina = 2001
|
||||
# [time]
|
||||
# SAMPLETIME = 0.1
|
||||
# TIMEOUTSHORT = 200
|
||||
# TIMEOUTLONG = 6000
|
||||
|
||||
print ( ' comm_port = %s' % ( comm_port ) )
|
||||
print ( ' idxMacchina = %s' % ( idxMacchina ) )
|
||||
print ( ' SAMPLETIME = %4.2f' % ( SAMPLETIME ) )
|
||||
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 seriale
|
||||
|
||||
avviaSeriale()
|
||||
|
||||
#try:
|
||||
# ser = serial.Serial(
|
||||
# port = comm_port ,
|
||||
# baudrate = 9600 ,
|
||||
# parity = serial.PARITY_NONE ,
|
||||
# stopbits = serial.STOPBITS_ONE ,
|
||||
# bytesize = serial.EIGHTBITS
|
||||
# )
|
||||
# print "Initialized!"
|
||||
#except serial.serialutil.SerialException , e :
|
||||
# try:
|
||||
# logga ( "SERIAL:Errore apertura seriale - " + comm_port)
|
||||
# except:
|
||||
# pass
|
||||
# sys.stdout.write ( '\nErrore apertura seriale\n\n%s\n\n' % e )
|
||||
# sys.exit (1)
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# ciclo forever and ever
|
||||
|
||||
old = ''
|
||||
|
||||
# richiesta dati ad IOB
|
||||
try:
|
||||
requestData()
|
||||
except:
|
||||
logga("SERIALE: errore sul try di requestData")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
while 1:
|
||||
try:
|
||||
time.sleep (SAMPLETIME)
|
||||
except:
|
||||
logga("SERIALE_SLEEP: errore attesa sampletime")
|
||||
# lettura dati da IOB
|
||||
try:
|
||||
value = readSeriale()
|
||||
except:
|
||||
if startstatus == 0:
|
||||
logga("errore PRIMA LETTURA SERIALE")
|
||||
sys.exit(1)
|
||||
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
|
||||
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
#!/bin/bash
|
||||
|
||||
#salva la temperatura CPU e GPU su chiamata...
|
||||
|
||||
# imposto logfile...
|
||||
logFile="/var/log/logTemp.txt"
|
||||
|
||||
cpuTemp0=$(cat /sys/class/thermal/thermal_zone0/temp)
|
||||
cpuTemp1=$(($cpuTemp0/1000))
|
||||
cpuTemp2=$(($cpuTemp0/100))
|
||||
cpuTempM=$(($cpuTemp2 % $cpuTemp1))
|
||||
|
||||
gpuTemp=`vcgencmd measure_temp`
|
||||
|
||||
loadAvg=`cat /proc/loadavg`
|
||||
|
||||
echo "$(date) | CPU: temp=$cpuTemp1.$cpuTempM ºC | GPU: $gpuTemp | LoadAvg: $loadAvg" >> $logFile
|
||||
@@ -0,0 +1,130 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# sendReboot v. 1.8
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
|
||||
import time
|
||||
import sys
|
||||
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
import urllib
|
||||
import ConfigParser
|
||||
import os, sys
|
||||
|
||||
import logging
|
||||
|
||||
import time
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
# COSTANTI
|
||||
PROGRAM_NAME = "SendReboot IOB-pi v.1.8"
|
||||
|
||||
# DA FILE CONF
|
||||
idxMacchina = "99"
|
||||
|
||||
# registro se ho fatto chiamata
|
||||
global numTry
|
||||
numTry = 1
|
||||
|
||||
|
||||
#---------------------------------------------------------------
|
||||
#Funzione di scrittura su url con try-except
|
||||
#---------------------------------------------------------------
|
||||
|
||||
def chiamaUrl(numTry):
|
||||
|
||||
try:
|
||||
urllib.urlopen ( url )
|
||||
numTry = numTry + 10
|
||||
except Exception, e:
|
||||
print e
|
||||
logging.info ( e )
|
||||
print "Url aforte" , url
|
||||
return numTry
|
||||
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# Funzione di recupero mac address per poterlo inviare a MPIO
|
||||
#---------------------------------------------------------------
|
||||
def getMAC(interface):
|
||||
# Return the MAC address of interface
|
||||
try:
|
||||
str = open('/sys/class/net/' + interface + '/address').read()
|
||||
except:
|
||||
str = "00:00:00:00:00:00"
|
||||
return str[0:17]
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# MAIN
|
||||
#---------------------------------------------------------------
|
||||
|
||||
try:
|
||||
config = ConfigParser.RawConfigParser()
|
||||
config.read ( 'IOB.cfg' )
|
||||
|
||||
idxMacchina = config.get ( 'id' , 'idxMacchina' )
|
||||
|
||||
|
||||
URLREBO = config.get ( 'web' , 'URLREBO' )
|
||||
|
||||
LOGFILE = config.get ( 'log' , 'LOGREBO' )
|
||||
except:
|
||||
print "\n\n" + PROGRAM_NAME + ' - Error 4 - in config file ' 'IOB.cfg'
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
#--------------------------------------------
|
||||
# oggetto Logger
|
||||
#--------------------------------------------
|
||||
try:
|
||||
# log = Logger(LOGFILE)
|
||||
logging.basicConfig(level=logging.DEBUG,
|
||||
format='%(asctime)s %(name)-8s %(levelname)-8s %(message)s',
|
||||
datefmt='%Y-%m-%d %H:%M:%S',
|
||||
filename=LOGFILE,
|
||||
filemode='a')
|
||||
|
||||
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:
|
||||
logging.info("Avvio Programma " + PROGRAM_NAME)
|
||||
|
||||
|
||||
# lettura file configurazione
|
||||
print ( ' idxMacchina = %s' % ( idxMacchina ) )
|
||||
print ( ' URLREBO = %s' % ( URLREBO ) )
|
||||
print ( ' LOGFILE = %s' % ( LOGFILE ) )
|
||||
|
||||
# lettura mac address
|
||||
myMac = getMAC('eth0')
|
||||
print ( ' MAC Address = %s' % ( myMac ) )
|
||||
|
||||
# configuro URL da inviare
|
||||
url = URLREBO + idxMacchina + "&mac=" + myMac
|
||||
|
||||
# modifica: cerco se ho inviato segnale altrimenti ritento invio...
|
||||
while (numTry < 11):
|
||||
logging.info("Tentativo invio URL: " + `numTry` )
|
||||
numTry = chiamaUrl(numTry)
|
||||
time.sleep(3)
|
||||
numTry = numTry + 1
|
||||
|
||||
|
||||
# registro che ho inviato!
|
||||
logging.info("Inviato segnale di reboot!: " + url )
|
||||
@@ -0,0 +1,33 @@
|
||||
#!/bin/sh -
|
||||
#
|
||||
### BEGIN INIT INFO
|
||||
# Provides: sendReboot
|
||||
# Required-Start: $network $remote_fs $syslog
|
||||
# Required-Stop: $remote_fs $syslog
|
||||
# Default-Start: 2 3 4 5
|
||||
# Default-Stop: 0 1 6
|
||||
# Short-Description: Steamware's IOB reboot signal
|
||||
# Description: Steamware's sendReboot segnalazione reboot dispositivo
|
||||
### END INIT INFO
|
||||
|
||||
#! /bin/sh
|
||||
# /etc/init.d/sendReboot
|
||||
|
||||
|
||||
|
||||
export HOME
|
||||
case "$1" in
|
||||
start)
|
||||
cd /home/pi/steamware
|
||||
echo "Starting sendReboot"
|
||||
/usr/bin/python ./sendReboot.py 2>&1 &
|
||||
echo "Verifica Rete e file IOB"
|
||||
/usr/local/bin/setIobConf.sh
|
||||
;;
|
||||
*)
|
||||
echo "Usage: /etc/init.d/sendReboot {start}"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
exit 0
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
[Unit]
|
||||
SourcePath=/etc/init.d/sendRebootIOB
|
||||
Description=LSB: Steamware's IOB reboot signal
|
||||
Before=runlevel2.target runlevel3.target runlevel4.target runlevel5.target shutdown.target
|
||||
Wants=network-online.target
|
||||
After=network.target network-online.target auditd.service
|
||||
Conflicts=shutdown.target
|
||||
|
||||
[Service]
|
||||
Type=forking
|
||||
Restart=no
|
||||
TimeoutSec=5min
|
||||
IgnoreSIGPIPE=no
|
||||
KillMode=process
|
||||
GuessMainPID=no
|
||||
RemainAfterExit=yes
|
||||
SysVStartPriority=2
|
||||
ExecStart=/etc/init.d/sendRebootIOB start
|
||||
ExecStop=/etc/init.d/sendRebootIOB stop
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash
|
||||
|
||||
# verifico se sia rete donati o rete steamware o offline...
|
||||
netStatus=`cat /sys/class/net/eth0/operstate`
|
||||
iaddr=`ifconfig eth0 | grep "inet addr" | cut -d ':' -f 2 | cut -d ' ' -f 1`
|
||||
|
||||
cd /home/pi/steamware
|
||||
|
||||
if [[ $netStatus != "up" ]]
|
||||
then
|
||||
echo "Siamo Offline, pagina demo!"
|
||||
elif [[ $iaddr == "10.74.82"* ]]
|
||||
then
|
||||
cp IOB.cfg.steamware IOB.cfg -f
|
||||
echo "Siamo in Steamware!"
|
||||
elif [[ $iaddr == "192.168.51"* ]]
|
||||
then
|
||||
cp IOB.cfg.donati IOB.cfg -f
|
||||
echo "Siamo a Passirano!"
|
||||
else
|
||||
echo "Siamo altrove, pagina demo!"
|
||||
fi
|
||||
|
||||
echo "$iaddr"
|
||||
|
||||
chown pi:pi *
|
||||
@@ -0,0 +1,31 @@
|
||||
import logging
|
||||
|
||||
# set up logging to file - see previous section for more details
|
||||
logging.basicConfig(level=logging.DEBUG,
|
||||
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
|
||||
datefmt='%m-%d %H:%M',
|
||||
filename='test.log',
|
||||
filemode='w')
|
||||
# define a Handler which writes INFO messages or higher to the sys.stderr
|
||||
console = logging.StreamHandler()
|
||||
console.setLevel(logging.INFO)
|
||||
# set a format which is simpler for console use
|
||||
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
|
||||
# tell the handler to use this format
|
||||
console.setFormatter(formatter)
|
||||
# add the handler to the root logger
|
||||
logging.getLogger('').addHandler(console)
|
||||
|
||||
# Now, we can log to the root logger, or any other logger. First the root...
|
||||
logging.info('Jackdaws love my big sphinx of quartz.')
|
||||
|
||||
# Now, define a couple of other loggers which might represent areas in your
|
||||
# application:
|
||||
|
||||
logger1 = logging.getLogger('myapp.area1')
|
||||
logger2 = logging.getLogger('myapp.area2')
|
||||
|
||||
logger1.debug('Quick zephyrs blow, vexing daft Jim.')
|
||||
logger1.info('How quickly daft jumping zebras vex.')
|
||||
logger2.warning('Jail zesty vixen who grabbed pay from quack.')
|
||||
logger2.error('The five boxing wizards jump quickly.')
|
||||
@@ -0,0 +1,31 @@
|
||||
import fcntl
|
||||
import os
|
||||
import logging
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# meccanismo di file lock per evitare multiple instances
|
||||
# The function will try to lock the file specified , if it success, return True, else return False.
|
||||
# The nice thing is that the lock will be dropped when the program terminates.
|
||||
# >>>Use :
|
||||
# if not lockFile(".lock.pod"):
|
||||
# sys.exit(0)
|
||||
|
||||
def lockFile ( lockfile ) :
|
||||
|
||||
fd = os.open ( lockfile , os.O_CREAT | os.O_TRUNC | os.O_WRONLY )
|
||||
try:
|
||||
# Request exclusive (EX) non-blocking (NB) advisory lock.
|
||||
fcntl.lockf ( fd , fcntl.LOCK_EX | fcntl.LOCK_NB )
|
||||
except IOError:
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
if not lockFile ( ".lockfile" ) :
|
||||
print '\n noi non siamo soli ...\n'
|
||||
logging.error( "LOCK: Piu istanze aperte")
|
||||
#sys.exit ( 0 )
|
||||
|
||||
#- print '\n running alone ...\n'
|
||||
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,32 @@
|
||||
import win32api
|
||||
print " Running on WINDOWS\n"
|
||||
import os
|
||||
#---------------------------------------------------------------
|
||||
# meccanismo di file lock per evitare multiple instances
|
||||
# The function will try to lock the file specified , if it success, return True, else return False.
|
||||
# The nice thing is that the lock will be dropped when the program terminates.
|
||||
# >>>Use :
|
||||
# if not lockFile(".lock.pod"):
|
||||
# sys.exit(0)
|
||||
|
||||
def lockFile ( lockfile ) :
|
||||
try:
|
||||
fd = os.open ( lockfile , os.O_CREAT | os.O_TRUNC | os.O_WRONLY )
|
||||
except:
|
||||
logga("Errore nel file WIN.PY per FD")
|
||||
try:
|
||||
# Request exclusive (EX) non-blocking (NB) advisory lock.
|
||||
#fcntl.lockf ( fd , fcntl.LOCK_EX | fcntl.LOCK_NB )
|
||||
print " Dummy Method! Completa Lockfile\n"
|
||||
except IOError:
|
||||
return False
|
||||
|
||||
return True
|
||||
try:
|
||||
if not lockFile ( ".lockfile" ) :
|
||||
print '\n noi non siamo soli ...\n'
|
||||
logga ( "LOCK: Piu istanze aperte")
|
||||
sys.exit ( 0 )
|
||||
except:
|
||||
logga("if not lockfile NON RIUSCITO in file WIN.PY")
|
||||
sys.exit(1)
|
||||
Binary file not shown.
Reference in New Issue
Block a user