Fotometer Marke Eigenbau

# Configuration file for wxLightSensor application
#
# Lines starting with a # and empty lines are ignored
#
# Each line starts with the name of the preset, followed by as many
# key value pairs as you need to provide.  Every key is in Lux
# and the value is whatever you are measuring in the preset.

Tetra NO3;-323 0;-418 6;-448 13;-493 18;-517 25;-568 50;-597 100
JBL Phosphat/100;0 0;-12 3;-20 5;-28 10;-44 21;-80 42;-145 83;-250 167;-400 334;-530 669;-575 1338
JBL Fe/1000;0 0;-17 19;-22 38;-34 63;-61 125;-100 250;-185 500;-325 1000;-490 2000
Kalium K;-29 0;-130 1;-388 3;-508 9;-589 12;-606 13;-618 14;-652 16;-675 17
Magnesium 150;-270 0;-285 6;-305 12;-355 22;-405 38;-477 75;-542 150
Magnesium 20;-263 0;-433 6;-490 9;-510 11;-542 18
JBL NO3;-140 0;-280 6;-340 3;-370 18;-408 25;-429 50;-463 10

#!/usr/bin/env python
#
#   wxLightSensor is a simple wxPython based light sensor display.
#   Copyright (C) 2012 
#
#   This program 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.
#
#   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
#

import os
import sys
import time
import wx


# TODO: Put these in the config file
HOST = "localhost"
PORT = 4223
UID = "7es" # Change to your UID

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ambient_light import AmbientLight


def interpolate_middle(k, values):
    keys = sorted(values.keys())
    k1 = [x for x in keys if x < k][-1]
    k2 = [x for x in keys if x > k][0]
    v = (values[k1] + values[k2]) / 2.0
    return v


def interpolate_linear(k, values):
    keys = sorted(values.keys())
    k1 = [x for x in keys if x < k][-1]
    k2 = [x for x in keys if x > k][0]
    v1 = values[k1]
    v2 = values[k2]
    v = v1 + ((v2 - v1) / (k2 - k1)) * (k - k1)
    return v


# TODO: Create sensible preset class for different measurements
class wxLightSensorPreset:
    """This class represents presets the user can choose."""

    def __init__(self, name='', values=None):
        self.name = name
	if values is None:
	    self.values = {}
	else:
	    self.values = values

    def getDisplayName(self):
        return "%s" % self.name

    def __str__(self):
        return self.getDisplayName()


class wxLightSensorFrame(wx.Frame):

    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, "wxLightSensor")
        self.__initVariables()
        self.__createGUI()
        self.__loadPresets()

    def __initVariables(self):
        self.__absoluteValue = 0
        self.__taraValue = 0
        self.__measurementValue = 0
        self.__isMeasurementRunning = False
        self.__timeStep = 1000 # milliseconds
        progDir = os.path.abspath(os.path.dirname(sys.argv[0]))
        homeDir = os.path.expanduser('~')
        self.__globalPresetsFile = os.path.join(progDir, '.wxlightsensorrc')
        self.__selectedPreset = None

    def __createGUI(self):
        self.__createControls()
        self.__layoutControls()
        self.__updateGUI()

    def __createControls(self):
        self.__mainPanel = wx.Panel(self, wx.ID_ANY)

        self.__txtValue = wx.StaticText(self.__mainPanel, wx.ID_ANY, "00:00:00")
        self.__txtValue.SetFont(wx.Font(36, wx.DEFAULT, wx.NORMAL, wx.BOLD,
            0, ""))

        self.__btnStartStop = wx.Button(self.__mainPanel, wx.NewId(),
            "START/STOP")
        self.Bind(wx.EVT_BUTTON, self.__OnBtnStartStop, self.__btnStartStop)
        self.__btnReset = wx.Button(self.__mainPanel, wx.NewId(), "Reset")
        self.Bind(wx.EVT_BUTTON, self.__OnBtnReset, self.__btnReset)

        self.__txtPresets = wx.StaticText(self.__mainPanel, wx.ID_ANY,
            "Presets:")
        self.__choicePresets = wx.Choice(self.__mainPanel, wx.NewId())
        self.Bind(wx.EVT_CHOICE, self.__OnPresetSelected, self.__choicePresets)

    def __layoutControls(self):
        topSizer = wx.BoxSizer(wx.VERTICAL)
        vBox = wx.BoxSizer(wx.VERTICAL)
        hBox = wx.BoxSizer(wx.HORIZONTAL)
        hBoxPresets = wx.BoxSizer(wx.HORIZONTAL)


        self.SetSizer(topSizer)
        self.__mainPanel.SetSizer(vBox)

        hBox.Add(self.__btnStartStop, True,  wx.CENTER)
        hBox.Add(self.__btnReset, True,  wx.CENTER)

        hBoxPresets.Add(self.__txtPresets, False, wx.CENTER)
        hBoxPresets.Add(self.__choicePresets, True, wx.CENTER)

        vBox.Add(self.__txtValue, 0,  wx.CENTER)
        vBox.Add(hBox, True,  wx.EXPAND | wx.CENTER)
        vBox.Add(hBoxPresets, True, wx.EXPAND | wx.CENTER)
        topSizer.Add(self.__mainPanel, 1, wx.EXPAND)

        topSizer.Fit(self)

    def __loadPresets(self):
        self.__presets = []
        self.__loadPresetsFromFile(self.__globalPresetsFile)
        for p in self.__presets:
            self.__choicePresets.Append(p.getDisplayName())

    def __loadPresetsFromFile(self, fname):
        if fname is None: return
        if not os.path.exists(fname): return
        if not os.path.isfile(fname):
            sys.stderr.write('Not a file: fname\n')
            return
        try:
            f = open(fname, 'r')
            contents = f.read()
            f.close()
        except IOError, e:
            sys.stderr.write(e)
            return
        self.__parsePresetsFile(contents)

    def __parsePresetsFile(self, contents):
        for i, line in enumerate([x.strip() for x in contents.splitlines()]):
            # skip empty lines and comments
            if line == '': continue
            if line.startswith('#'): continue
            fields = line.split(';')
            if len(fields) < 2:
                sys.stderr.write('Line %d: Wrong number of fields\n' % (i + 1))
                continue
            preset = wxLightSensorPreset()
            preset.name = fields[0]
	    for f in fields[1:]:
            	try:
                    k, v = f.split(' ')
                    preset.values[int(k)] = float(v)
                except Exception, e:
                    sys.stderr.write('Invalid data field: %s\n' % f)
                    continue
            self.__presets.append(preset)

    def __OnBtnReset(self, event):
	self.__taraValue = self.__absoluteValue
	self.__updateGUI()

    def __OnBtnStartStop(self, event):
        if self.__isMeasurementRunning:
            self.__cancelMeasurement()
        else:
            self.__startMeasurement()

    def __OnPresetSelected(self, event):
        sel = self.__choicePresets.GetSelection()
        self.__selectedPreset = self.__presets[sel]
        self.__measurementValue = 0
        self.__updateGUI()

    def __updateGUI(self):
        self.__updateValue()
        self.__updateButtons()

    def __updateValue(self):
	txt = self.__getValueForDisplay()
        self.__txtValue.SetLabel(txt)

    def __getValueForDisplay(self):
	if not self.__isMeasurementRunning:
	    return 'off'
	p = self.__selectedPreset
	if p is None: return 'No preset selected'
	print "measured (abs/rel):", self.__absoluteValue, "/", self.__measurementValue
        k = int(self.__measurementValue)
	if p.values.has_key(k):
	    v = p.values[k]
	else:
	    keys = p.values.keys()
	    keys.sort()
	    if k > keys[-1]:
		return 'too high'
            elif k < keys[0]:
		return 'too low'
	    else:
		#v = interpolate_middle(k, p.values)
		v = interpolate_linear(k, p.values)
        txt = '%.2f Lux / %.2f' % (self.__measurementValue, v)
        return txt

    def __updateButtons(self):
        #self.__btnReset.Enable(not self.__isMeasurementRunning)
        self.__btnReset.Enable(True)
        self.__btnStartStop.Enable(True)

    def __cancelMeasurement(self):
        self.__isMeasurementRunning = False
	self.__ipcon.destroy()
        self.__absoluteValue = 0
        self.__taraValue = 0
        self.__measurementValue = 0
        self.__updateGUI()

    def __startMeasurement(self):
        self.__isMeasurementRunning = True
        self.__ipcon = IPConnection(HOST, PORT) # Create ip connection to brickd

        al = AmbientLight(UID) # Create device object
        self.__ipcon.add_device(al) # Add device to ip connection
        # Don't use device before it is added to a connection

        # Set Period for illuminance callback to 1s (1000ms)
        # Note: The illuminance callback is only called every second if the 
        #       illuminance has changed since the last call!
        al.set_illuminance_callback_period(self.__timeStep)

        # closure
        # Callback function for illuminance callback (parameter has unit Lux/10)
        def cb_illuminance(illuminance):
	    self.__absoluteValue = illuminance/10.0
	    self.__measurementValue = self.__absoluteValue - self.__taraValue
            self.__updateGUI()

        # Register illuminance callback to function cb_illuminance
        al.register_callback(al.CALLBACK_ILLUMINANCE, cb_illuminance)

        self.__updateGUI()


if __name__ == '__main__':
    app = wx.App(False)
    frame = wxLightSensorFrame()
    frame.Show(True)
    app.MainLoop()