smokephil/ems
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

CANFilter arbeitet jetzt als Thread

Browse source 
CANFilter wurde vollständig zu einem Thread umgebaut.
swich wurde angefangen umzubauen (nicht funktionsfähig)
.gitignore wurde zum Repository hinzugefügt
This commit is contained in:
Philipp Rauch 2013-11-19 17:11:25 +01:00
parent 4a1ef13bc9
commit 704e02385f
3 changed files with 138 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

43
.gitignore vendored Normal file
View file

@ -0,0 +1,43 @@
# Ignore-Datei selbst ausschließen
.gitignore
.gitmodules
Thumbs.db
# Bestimmte Dateien ausschließen
cache.dat
# Es können Wildcards (*,?) verwendet werden:
*.exe
*.dll
*.dsbackup
*.avrsln
*.avrsuo
*.avrgccproj
*.aps
*.atsln
*.atsuo
*.cproj
*.aws
*.xml
*.xslt
*.aux
*.dvi
*.lof
*.log
*.lot
*.out
*.synctex.gz
*.toc
.project
.pydevproject
tmp?.dat
# Auch Verzeichnisse kann man ausschießen:
*default/
*Debug/
*bin/
*ADC/
*CAN/
*UART/
.*/
CANLibrary/

118
scr/CANFilter.py
View file

@ -10,80 +10,88 @@ from CanSignal import CanSignal
from PCan import PcanAdapter from PCan import PcanAdapter
import datetime import datetime
import time import time
import threading
#import MySQLdb #import MySQLdb
debug = False debug = False
pcan = PcanAdapter(PcanAdapter.Baudrate['250k']) class CANFilter(threading.Thread):
pcan.initialize()
dc_battery = CanMessage(0x3A4, 8, 50, 'dc_battery') battery_current, battery_voltage, battery_capacity, battery_timestamp, test = [], [], [], [], []
dc_grid = CanMessage(0x3A5, 8, 50, 'dc_grid')
dc_pv = CanMessage(0x3A6, 8, 50, 'dc_pv')
dc_charging = CanMessage(0x3A7, 8, 50, 'dc_charging')
pcan.addMessage(dc_battery) def __init__(self):
pcan.addMessage(dc_grid) print "INIT"
pcan.addMessage(dc_pv) threading.Thread.__init__(self)
pcan.addMessage(dc_charging)
current = CanSignal(0, 16, 0, 0.001, 0, 'current') self.pcan = PcanAdapter(PcanAdapter.Baudrate['250k'])
voltage = CanSignal(16, 16, 0, 0.01, 0, 'voltage') self.pcan.initialize()
capacity = CanSignal(32, 11, 0, 0.05, 0, 'capacity')
isMaster = CanSignal(56, 1, 0, 1, 0, 'isMaster')
isFeed = CanSignal(57, 1, 0, 1, 0, 'isFeed')
isCharging = CanSignal(57, 1, 0, 1, 0, 'isCharging')
isOn = CanSignal(58, 1, 0, 1, 0, 'isOn')
pcan.Messages['dc_battery'].addSignal( current ) dc_battery = CanMessage(0x3A4, 8, 50, 'dc_battery')
pcan.Messages['dc_battery'].addSignal( voltage ) dc_grid = CanMessage(0x3A5, 8, 50, 'dc_grid')
pcan.Messages['dc_battery'].addSignal( capacity ) dc_pv = CanMessage(0x3A6, 8, 50, 'dc_pv')
pcan.Messages['dc_battery'].addSignal( isMaster ) dc_charging = CanMessage(0x3A7, 8, 50, 'dc_charging')
pcan.Messages['dc_battery'].addSignal( isCharging )
pcan.Messages['dc_grid'].addSignal( current ) self.pcan.addMessage(dc_battery)
pcan.Messages['dc_grid'].addSignal( voltage ) self.pcan.addMessage(dc_grid)
pcan.Messages['dc_grid'].addSignal( isMaster ) self.pcan.addMessage(dc_pv)
pcan.Messages['dc_grid'].addSignal( isFeed ) self.pcan.addMessage(dc_charging)
pcan.Messages['dc_grid'].addSignal( isOn )
pcan.Messages['dc_pv'].addSignal( current ) current = CanSignal(0, 16, 0, 0.001, 0, 'current')
pcan.Messages['dc_pv'].addSignal( voltage ) voltage = CanSignal(16, 16, 0, 0.01, 0, 'voltage')
capacity = CanSignal(32, 11, 0, 0.05, 0, 'capacity')
isMaster = CanSignal(56, 1, 0, 1, 0, 'isMaster')
isFeed = CanSignal(57, 1, 0, 1, 0, 'isFeed')
isCharging = CanSignal(57, 1, 0, 1, 0, 'isCharging')
isOn = CanSignal(58, 1, 0, 1, 0, 'isOn')
pcan.Messages['dc_charging'].addSignal( current ) self.pcan.Messages['dc_battery'].addSignal( current )
pcan.Messages['dc_charging'].addSignal( voltage ) self.pcan.Messages['dc_battery'].addSignal( voltage )
self.pcan.Messages['dc_battery'].addSignal( capacity )
self.pcan.Messages['dc_battery'].addSignal( isMaster )
self.pcan.Messages['dc_battery'].addSignal( isCharging )
battery_current, battery_voltage, battery_capacity, battery_timestamp = [], [], [], [] self.pcan.Messages['dc_grid'].addSignal( current )
self.pcan.Messages['dc_grid'].addSignal( voltage )
self.pcan.Messages['dc_grid'].addSignal( isMaster )
self.pcan.Messages['dc_grid'].addSignal( isFeed )
self.pcan.Messages['dc_grid'].addSignal( isOn )
self.pcan.Messages['dc_pv'].addSignal( current )
self.pcan.Messages['dc_pv'].addSignal( voltage )
self.pcan.Messages['dc_charging'].addSignal( current )
self.pcan.Messages['dc_charging'].addSignal( voltage )
#connection = MySQLdb.connect("url", "user", "passwort", "datenbankname") #connection = MySQLdb.connect("url", "user", "passwort", "datenbankname")
#cursor = connection.cursor() #cursor = connection.cursor()
def mean(l): def mean(self, l):
return float(sum(l))/len(l) if len(l) > 0 else 0 return float(sum(l))/len(l) if len(l) > 0 else 0
while True: def run(self):
receiveMessageId = pcan.receiveMessage() while True:
if receiveMessageId == pcan.Messages['dc_battery'].Id: receiveMessageId = self.pcan.receiveMessage()
if receiveMessageId == self.pcan.Messages['dc_battery'].Id:
battery_current.append(pcan.Messages['dc_battery'].Signals['current'].GetData()) self.battery_current.append(self.pcan.Messages['dc_battery'].Signals['current'].GetData())
battery_voltage.append(pcan.Messages['dc_battery'].Signals['voltage'].GetData()) self.battery_voltage.append(self.pcan.Messages['dc_battery'].Signals['voltage'].GetData())
battery_capacity.append(pcan.Messages['dc_battery'].Signals['capacity'].GetData()) self.battery_capacity.append(self.pcan.Messages['dc_battery'].Signals['capacity'].GetData())
battery_timestamp.append(str(datetime.datetime.now())) self.battery_timestamp.append(datetime.datetime.now())
if len(battery_timestamp) == 1000: if len(self.battery_timestamp) == 100:
if debug: if debug:
print 'current: ', mean(battery_current) print 'current: ', self.mean(self.battery_current)
print 'voltage: ', mean(battery_voltage) print 'voltage: ', self.mean(self.battery_voltage)
print 'SoC: ', mean(battery_capacity) print 'SoC: ', self.mean(self.battery_capacity)
print 'time: ', mean(battery_timestamp) print 'time: ', self.mean(self.battery_timestamp)
tabelle = 'EMS-TEST' tabelle = 'EMS-TEST'
daten = [(tabelle, str(battery_timestamp[i]), str(battery_current[i]), str(battery_voltage[i]), str(battery_capacity[i])) for i in range(1000)] daten = [(tabelle, str(self.battery_timestamp[i]), str(self.battery_current[i]), str(self.battery_voltage[i]), str(self.battery_capacity[i])) for i in range(100)]
sql = 'INSERT INTO %s VALUES(%s, %s, %s, %s)' sql = 'INSERT INTO %s VALUES(%s, %s, %s, %s)'
for i in daten: for i in daten:
print sql % i print sql % i
# cursor.executemany(sql, daten) # cursor.executemany(sql, daten)
del battery_current[:], battery_voltage[:], battery_capacity[:], battery_timestamp[:] del self.battery_current[:], self.battery_voltage[:], self.battery_capacity[:], self.battery_timestamp[:]
time.sleep(0.01) time.sleep(0.01)

51
scr/swich.py
View file

@ -8,38 +8,51 @@ Created on 15.11.2013
import MySQLdb import MySQLdb
import threading import threading
import Queue import Queue
from CANFilter import CANFilter
MYSQL = 0 MYSQL = 0
CSV = 1 CSV = 1
XML = 2 XML = 2
JSON = 3 JSON = 3
class Swich(object): class Swich(threading.Thread):
def __init__(self, source):
def __init__(self, source = MYSQL):
threading.Thread.__init__(self)
self.source = source self.source = source
def start(self): def __del__(self):
if self.source == MYSQL: if self.source == MYSQL:
# @TODO CANFilter starten self.CAN.join()
self.connection = MySQLdb.connect("url", "user", "passwort", "datenbankname")
def initialisiere(self):
if self.source == MYSQL:
self.CAN = CANFilter()
self.CAN.start()
self.connection = MySQLdb.connect("url", "user", "password", "database_name")
self.cursor = self.connection.cursor() self.cursor = self.connection.cursor()
self.queue = self.__createQueue__() self.queue = Queue.Queue()
return self.queue return self.queue, self.CAN
elif self.source ==CSV:
elif self.source == CSV:
pass pass
elif self.source == XML: elif self.source == XML:
pass pass
elif self.source == JSON: elif self.source == JSON:
pass pass
else: else:
return return
def __createQueue__(self):
return def run(self):
while True:
def setQueue(self): sql = 'SELECT * FROM %s ORDER BY timestamp DESC LIMIT 1'
pass item = Swich.queue.get(block = True) #item is a string which names the table that will be returned (newest values)
def getQueue(self): print self.cursor.execute(sql % item)
pass
def setQueue(self, item):
self.queue.put(item)