I use two TL-3TSN, one TSN-50E (long range) and one TSN-EXT44 (external), all values seem to be correct with this script.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
try:
    import usb.core
except:
    raise Exception("You need pyusb-1 to run this script!")
 
import array, time
 
class SimpleLogger:
    def __init__(self, rawFileName):
        self.rawFile = open(rawFileName, "a")
        self.sensorFiles = {}
 
    def log(self, data):
        print "\t".join([str(i) for i in data])
        s = data[1]
        if not s in self.sensorFiles:
            self.sensorFiles[s] = open(s+".log", "a")
        self.sensorFiles[s].write("%s\t%s\t%s\t%s\n" % \
            (time.time(), data[3], data[0], data[2]))
        self.sensorFiles[s].flush()
 
    def logRaw(self, rawData):
        self.rawFile.write("%15f" % time.time())
        for d in rawData:
            self.rawFile.write(" %02X" % d)
        self.rawFile.write("\n")
        self.rawFile.flush()
 
class TL500:
    def __init__(self, sensors={}, action=None, rawAction=None):
        self.sensors = sensors
        self.dev = None
        self.action = action
        self.rawAction = rawAction
        self._buffer = array.array('B', [0]*64)
 
    def connect(self):
        self.dev = usb.core.find(idVendor=0x0451, idProduct=0x3211)
        if not self.dev:
            raise Exception("Arexx TL-500 not found!")
 
    def loopCollect(self):
        if not self.dev:
            self.connect()
        self._buffer[0] = 4
        self.dev.write(0x1, self._buffer, 0, 1000)
        self._buffer[0] = 3
        while True:
            self.dev.write(0x1, self._buffer, 0, 1000)
            rawData = self.dev.read(0x81, 64, 0, 1000)
            if rawData[1] != 0:
                if self.rawAction:
                    self.rawAction(rawData)
                if self.action:
                    self.action(self.processData(rawData))
            time.sleep(10)
 
    def processData(self, rawData):
        sensor   = rawData[3]*256 + rawData[2]
        valueRaw = rawData[4]*256 + rawData[5]
        clock    = rawData[9]*16777216 + rawData[8]*65536 + \
            rawData[7]*256 + rawData[6]
        # FIXME: this should changed for other sensor types
        value    = 0.0078 * valueRaw
        return clock, self.sensors.get(sensor, sensor), valueRaw, value
 
if __name__ == "__main__":
    logger = SimpleLogger("raw.txt")
    # these are the names of my sensors
    sensors = {11492: "325_in", 11772: "325_out", \
        8857: "325_srv", 8480: "323_in"}
    tl500 = TL500(sensors=sensors, action=logger.log, rawAction=logger.logRaw)
    errors = 0
    while errors <= 1000:
        try:
            tl500.loopCollect()
        except Exception, e:
            print e
            errors += 1
 

Fortunately you can disable the plugin and the old passwords are still there. So if you want to switch to this plugin you should use the following procedure:

1. install the Password Exporter plugin
2. export your passwords to a text file using the plugin
3. install the kwallet plugin
4. import your password file using the Password Exporter plugin
5. check the entries in the section Firefox of your kwallet using the kwalletmanager
6. don't forget to delete the exported file

This worked for me.

http://www.algorithm-forge.com/techblog/2010/01/linux-usb-driver-for-the-arexx-tl-500-–-part-ii/

There's even a small logger hardware (ARM-based) using this device:

http://rndhax.blogspot.com/2010/03/friendlyarm-mini2440-arexx-tl-500.html

As a python fan I couldn't resist porting this to python to get a small and flexible script. It can be easily extended to save the data, create charts (maybe using matplotlib) or present a web interface.

By looking at the raw data I noticed that bytes 6 and 7 (maybe more?) contain a time value. Maybe it counts the seconds since the initialization of the device?

The first version of my script is mainly a port of the C program. The script uses pyusb 1.0, a python wrapper for libusb 1.0. You may have to install it manually, most linux distributions come with older versions.

#!/usr/bin/env python
import usb.core, array, time
 
def getData(rawData):
        sensor = rawData[3] * 256 + rawData[2]
        tempRaw = rawData[4] * 256 + rawData[5]
        clock = rawData[7] * 256 + rawData[6]
        temp = 0.0078 * tempRaw
        return clock, sensor, tempRaw, temp
 
def collect(dev):
        dataDown = array.array('B', [0]*64)
        dataDown[0] = 4
        dev.write(0x1, dataDown, 0)
        dataDown[0] = 3
        while True:
                dev.write(0x1, dataDown, 0)
                rd = dev.read(0x81, 64, 0)
                if rd[1] != 0:
                        d = getData(rd)
                        print d
                        logData(d, rd)
                time.sleep(10)
 
def logData(d, rd):
        tmp = "\t".join([str(i) for i in rd])
        logfile.write("%s\t%d\t%d\t%d\t%g\t%s\n" % (time.time(),
                d[0], d[1], d[2], d[3], tmp))
 
if __name__ == "__main__":
        dev = usb.core.find(idVendor=0x0451, idProduct=0x3211)
        logfile = open("temp.txt", "a")
        collect(dev)
 

I plan to extend this to a python package using OO, cleaner interfaces, better error handling and more.

Genetic or evolutionary approaches are used to solve a wide range of problems with the computer. Many algorithms try to reproduce the mechanism of natural evolution as close as possible. They produce generations of slightly mutated information (DNA), combine the attributes of individuals, select the fittest and produce new generations.

This approach may solve many complex problems. But to get it working you have to do some serious programming and to tune a lot of parameters. In many cases a much simpler approach may be sufficient.

The next examples show a "poor man's evolution" to optimize a configuration. It just starts with a random configuration. One small change is made (random). If the result is better than before, the new configuration is used. If not, the change will be revoked. This process will continue in a loop. Thats all!

In the following example we want to place some elements on a plane. The only condition is that no overlapping happens and an additional distance between the element borders will be maintained. It starts with a random configuration (with overlapping). In every step one (randomly chosen) element is moved to a new random position. If the overall sum of overlapping is smaller than before, the new configuration is used. When a configuration is found that satisfies the condition, the background turns from blue to green and the search is turned off. Press "ALT-H" to toggle the visbility of the controls. By using the controls yout may start again and/or change the parameters.

Source: http://download.j-raedler.de/Processing/EvoCircle

You will see that the algorithm finds a solution with the default parameters within some seconds. But the result doesn't look nice in all cases. In a next step we will modify the criterion for the selection. Instead of summing up all overlappings we look at the minimum distance between two element borders. A new configuration is used only if this value is larger or equal to the old value. The decision to prefer the "'mutated" configuration even if its "fitness value" is the same brings some more noise to the process. This may help to find a better solution (recover from local optimums). The elements in this example will not move more than an allowed value. Use "ALT-H" again to toggle the controls.

Source: http://download.j-raedler.de/Processing/EvoCircle3

You will see that after some time a configuration with a very constant distribution of the elements will be found. If may not be the optimal distribution but a good one.

For special cases like 12 elements of the same size it will very often find the well-known analytical solution:

This "poor man's evolution" is very easy to implement and may lead to good results in many cases. When you have an optimization problem you should consider using this super-simple approach first. If the results are not good enough you may switch to a full-fledged genetic algorithm.

Source: http://download.j-raedler.de/Processing/KochCurve/

Source: http://download.j-raedler.de/Processing/Euklid/

View pictures here (password required).

• switched from autoconf to cmake
• tested to compile on Linux, Windows and MacOS
• the easy API (EA) was completed
• EA works now with Modelica (Dymola):
  • a weather file reader was implemented and tested with the  modelica library FluidFlow
• new documentation in english
• support for netCDF attributes was completed