• wbh-diag 0.89 : seem to work (unstable connection)
• monoscan 2.30: seem to work, but does not have ’set basic settings’ feature
• VAG-COM 3.11/4.09: seem to work (you have to power off/on ignition while connecting as it sends some data before waking up and that confuses my engine ECU)
• CarPort 1.3.2: seem to work (you have to power off/on ignition while connecting as it sends some data before waking up and that confuses my engine ECU)

So, using the KW1281 protocol, the correct initialization timing (baud 5) is critical, and some software does not wait before waking up the ECU. Finally, I decided to develop something on my own. Note: my software only supports the older KW1281 protocol!

Features of my KW1281 diagnostic software:

• Read sensors (measurements)
• Set basic settings - useful, if you want to start motor ECU throttle adaption
• Read errors
• Clear errors
• Read ROM (does not work for all ECUs)
• Showing sensor values in graph

What you need:

• a PC runing Windows (XP/Vista/Win7)
• an USB KKL adapter (it provides a virtual COM port, for example ‘AutoDia K409 Profi USB‘ - it uses the FTDI chipset to emulate a serial line)

Screenshot:

Download: kw1281

Please send me your feedback! Thanks If you send your feedback, please always send me the complete debug output.

My car’s OBD data:

- Audi A4 B5 1.8, 1997, ADR
- Engine ECU:
     Part Number : 8D0907558B      Component : 1,8L R4/5V  MOTR HS D02
- Dash board ECU
     Part Number : 8D0919860G      Component : B5-KOMBIINSTR.UN4   D01
     Descriptor 5 : IMMO-IDENTNR: AUZ8Z0V5170015

Naja, nicht ganz
PS: Ein nettes Spielzeug   (J-3 Cub Ultra Micro RC)

gcc-4.2 -mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk ...

When trying to run the executable on a OS X 10.5 machine, you may get this error:

Dyld Error Message:

unknown required load command 0x80000022

The reason is that OS X 10.5 doesn’t understand the load command  'LC_DYLD_INFO_ONLY' (0×80000022) that was used by the OS X 10.6 linker.

Solution: Make sure you are using a deployment target by setting the environment variable just before your link command:

export MACOSX_DEPLOYMENT_TARGET=10.5

(or   setenv MACOSX_DEPLOYMENT_TARGET=10.5)

You can always check the load commands of the executable like this:

(without using deployment target)
otool -l binary

Load command 4
cmd LC_DYLD_INFO_ONLY
cmdsize 48
rebase_off 0
rebase_size 0
bind_off 462848
bind_size 1320
weak_bind_off 0
weak_bind_size 0
lazy_bind_off 464168
lazy_bind_size 2624
export_off 466792
export_size 4568

(using deployment target)
otool -l binary

Load command 4
cmd LC_DYLD_INFO
cmdsize 48
rebase_off 0
rebase_size 0
bind_off 466944
bind_size 1400
weak_bind_off 0
weak_bind_size 0
lazy_bind_off 468344
lazy_bind_size 2656
export_off 471000
export_size 4568

Another solution:  Read this Intel article here - it may give you another possible solution.

Ruby has excellent libraries (HTTP, SSL, SOAP, XML, etc.) that can be used to write your own music player for streaming music from online services like Rhapsody or last.fm - so why not use them? Here are code snippets to help you getting started! They show you…

• …how to make a HTTPS GET or POST request using SSL (https://…)
• …how to easily parse the XML response of such a request
• …how to stream music data (e.g. MP3) from some HTTP URL and how to pipe that stream data to another process (e.g. mplayer) for playing it back while streaming
• …how to use SOAP requests with custom SSL certificates (https://…)
• …how to encrypt/decrypt 64-bit DES ECB data

My own Ruby (1.8)-based Rhapsody player has 400 lines of Ruby code, my lasm.fm player has 200 lines of Ruby code  -   Do you think other languages can do better ?

Using HTTPS POST and SSL (HTTPS GET works similar using the Net::HTTP::Get class)

require 'net/http'
require 'net/https'

dict['api_key'] = @apikey
url = "https://someurl"

uri = URI.parse(url)
sock = Net::HTTP.new(uri.host, uri.port)
sock.use_ssl = true

req = Net::HTTP::Post.new(url)
req.set_form_data(dict)
res = sock.start{|http| http.request(req) }
puts res.body

Parsing XML response data

require 'rexml/document'
res = http_post( {'method'=> 'radio.getPlaylist', 'sk' => @sk })

doc = REXML::Document.new(res)

printf("%-30s %-50s %-40sn", "title", "album", "creator")
doc.elements.each("*/*/*/track") do |element|
  title    = element.elements["title"].text
  album    = element.elements["album"].text
  creator  = element.elements["creator"].text
  location = element.elements["location"].text
  image    = element.elements["image"].text
  printf("%-30s %-50s %-40sn", title, album, creator)
end

Streaming HTTP music data  (e.g. MP3) and piping it to another process (e.g. mplayer)

    uri = URI.parse(url)
    Net::HTTP.start(uri.host) do |http|
      http.request_get(uri.path) do |resp|
        pipe = IO.popen("mplayer -cache 256 -", "w")
        resp.read_body do |segment|
          if segment.length > 0
            pipe.write(segment)
          end
        end
        pipe.close
      end
    end

Of course, you can always pipe using bash..

macbook-pro:~ nero$ lastfm.rb | mplayer -cache 64 -

...however this wouldn't allow you to write something else to STDOUT except the music data.

Using SOAP requests and custom SSL certificates

require 'openssl'
require "rubygems"
gem "httpclient", "2.1.5.2"
gem 'soap4r'
require 'soap/rpc/driver'

driverPlay = SOAP::RPC::Driver.new('https://someurl', 'urn:someurn')
driverPlay.options["protocol.http.ssl_config.verify_mode"] = nil
driverPlay.options["protocol.http.ssl_config.client_cert"] = File.join(@dir, "somefile.cert.pem")
driverPlay.options["protocol.http.ssl_config.client_key"] = File.join(@dir, "somefile.key.pem")
driverPlay.return_response_as_xml = true
# define some method
driverPlay.add_method('startPlaybackSession', 'developerKey', 'cobrandId', 'logon', 'password', 'clientType')

Using 64-bit DES ECB encryption
(the key is to use ‘cipher.padding = 0′  - it took me 2 hours to figure that out …)

  require 'openssl'
  def testDES
    puts '*** TESTDES ***'
    key         = "x01x23x45x67x89xabxcdxef"
    plain       = "x01x23x45x67x89xabxcdxe7"
    cryptdata   = "xc9x57x44x25x6ax5exd3x1d"

    puts "key      = " + key.unpack("H*").to_s
    puts "plain    = " + plain.unpack("H*").to_s
    #puts OpenSSL::Cipher.ciphers

    puts "encrypt..."
    cipher = OpenSSL::Cipher::Cipher.new('des-ecb')
    cipher.encrypt
    cipher.key = key
    cipher.padding = 0
    res = cipher.update(plain)
    puts "res      = " + res.unpack("H*").to_s
    puts "crypted  = " + cryptdata.unpack("H*").to_s

    puts "decrypt..."
    cipher.decrypt
    res = cipher.update(res) + cipher.final
    puts "res      = " + res.unpack("H*").to_s
    puts "plain    = " + plain.unpack("H*").to_s

    puts "triple..."
    cipher.decrypt
    plain = cipher.update(plain) + cipher.final
    cipher.encrypt
    cipher.key = plain
    plain = cipher.update(plain)
    cipher.decrypt
    cipher.key = key
    res = cipher.update(plain) + cipher.final
    puts "res      = " + res.unpack("H*").to_s
  end

Ein wirklich tolles (Lehr-)Projekt - nicht nur für Kinder! Es sollte mehr solcher Projekte in Lehre und Forschung geben!

Funktionsprinzip: Speist man eine Wechselspannung gegen Erde (als Masse) auf den unterbrochenen Leiter, so erzeugt diese ein elektrisches Feld um den Leiter. Dieses Feld kann man mit einer Spule detektieren. Wählt man für das Wechselsignal eine Frequenz von z.B. 400 bis 4000 Hz, so kann man dieses Signal um den Leiter herum mit einem kleinen Verstärker (z.B. Walkman) hörbar machen.

Verwendete Komponenten:

Der Sender:

1. Eine fertige PWM-Motor-Controller Schaltung (min. 30V), gefunden bei eBay (ist quasi ein fertiger Rechtecksignal-Frequenzgenerator mit Verstärker)
2. Ein Gleichstromnetzteil (30V - Achtung: auf keinen Fall mit höherer Spannung arbeiten)

Der Empfänger:

1. Eine Spule mit vielen Windungen aus einem alten 230V-Relais
2. Ein alter Walkman (oder Mikrofonverstärker)

Schritt 1:  Den Sender aufbauen

Zunächst wurde der PWM-Controller mit nur 10Volt und einem Lautsprecher als “Motor” betrieben, und dabei die fertige PWM-Schaltung durch einen parallel ergänzten Kondensator so eingstellt, dass die Schaltung ein Rechteck-Signal mit gut hörbarer Frequenz erzeugt. Danach wurde der Lautsprecher entfernt, das Netzteil angeschlossen und als “Last” das offene Ende der Induktionsschleife und die “Rückführung” über einen Erdungsleiter (einfach ein Stahlrohr in die Erde gerammt).

Schritt 2: Der Empfänger

Ein alter Walkman wurde geöffnet und anstelle des Tonkopfes eine Spule angeschlosen. Wenn man nun den Walkman betreibt, hört man in der Nähe von Netzteilen/Steckdosen/etc. das typische 50 Hz Brummen - ein Zeichen dafür, dass der Empfänger funktioniert.

Schritt 3: Das Induktionskabel “abfahren”

Zum ersten Test nimmt man das Kabel für den Erdungsleiter einfach in die Hand (damit ist der abzufahrende Induktionskabel geerdet). Nun hört man in der Nähe (1-2 m) des Induktionskabels einen Ton, dessen Lautstärke durch Annäherung an das Kabel zunimmt. Genau an der Stelle der Unterbrechung hört der Ton auf und man hat die Stelle der Unterbrechung gefunden.

Viel Spaß beim Nachbauen

One primary warning already: Everything that includes opening your robot will loose your robot’s guarantee. If you really need to do this (like me), be aware of this.

My purchased Tianchen TC-G158 robot mower has the following components:

• Main MCU: STC12C5410AD  (8051 clone, 10K flash memory, 33 Mhz)
• Hope RF HM 433 Mhz receiver module (for remote control)
• Remote control decoder MCU: STC12C2052AD  (sends remote control key data to main MCU, see protocol below)
• Induction unit quad op amp: LM32 (for induction loop inductor amp)
• Optical roll ball sensor: HT RBS33 (theta=45 degree , switches off mowing motor above theta degree)
• Dual 4-channel mux/demux: 74HC4052D (to read in induction loop inductors and battery sense/rain sensor)
• Power MOSFET: IRFZ44N (for mowing motor)
• Full bridge driver: L298N (for the left and right motors)
• 1A step-down simple switch voltage regulator: LM2575S (for main board voltages)
• Solid state amp: SR840 (for mowing motor)
• Timer: NE555 (for IR modulation?)
• Dual op-amp: LM358 (for induction loop inductor)

After purchasing, I noticed the robot has a small problem:  when moving from the lower part to the higher part of my garden, it doesn’t move a straight line - it makes circles of 90 degress and less (due to the heavy lead acid batteries my mower is using) …

So I decided to add some software PID controller to it to control the left-right wheel balance and it solved this specific problem (see videos with and without balance controller).

Of course, this required writing a new MCU software, and I did choose the Atmel ATMEGA-168 (on a ready myAVR board MK2 USB)  as a replacement for the original 8051 MCU.

Here you can see how I managed to connect my Atmel MCU to the old MCU socket (using some DIY adapter):

And here you can see how I added photo interruptors (LTH301-07) for the left and right motors to measure the wheel movement (for the left-right wheel balance control):

After a while, I noticed that I need something more fancy to upload my new custom software revisions into my mower while sitting comfortable in a chair meters away: a Bluetooth module!
The bluetooth module extends the ordinary ISP RX/TX serial line (RS232) and also allows me to monitor sensor data and robot state changes (and believe me, this feedback is absolutely necessary for debugging your code…)

So this is my final system today:

Original board <==> ATMEGA168 <==> ISP (TTL UART) <==> Bluetooth module <~~> PC (Bluetooth dongle)

I upload new software builds into the mower via Bluetooth and the serial data of the mower is transmitted via Bluetooth too.
My latest software periodically displays the state of the mower (state, state time, bumper states, IR state, inclination sensor, motor PWM, motor PID controller wxy, motor current, induction coins values, battery state, rain sensor):

All components I needed for this solution:

• myAVR microntroller board - includes mySmartUSB programmer (ISP)
• ATMEGA168 microcontroller (16K flash, operating at 5V)
• 12 Mhz oscillator
• Bluetooth module BTM220 , an inverter  74HCT14N for level shift conversion (because my BTM220 operates at 3.3V, I needed a level shift conversion to 5V)
• RS232 TTL USB module (to configure the Bluetooth module)
• Multiplexer CD74HC4067 (to reduce the number of required pins at the microcontroller)
• Two photo sensors to measure the wheel movement (wheel left/right balance control) - later I replaced this by a declination sensor which works great too

If you are talent enough, my material should give you a good start for your own experiments and adjustments - Happy mowing

Resources:

Main MCU pin description

My pseudo-schematics (1), (2)  (Warning: always measure and verify using your own board - manufacturers often change their layouts and make adjustments, and without measuring you may damage your own board!)

Remote control protocol

My robot mower code (code also describes the MCU socket<->ATMEGA168 wiring  -  Warning:  don’t expect this code to work at once in your own configuration - you’ll need to study schematics, your MCU specifications and much more to get it working!)

You develop software for the consumer market in a professional manner? But you cannot afford a team of 30 developers? Your code changes quickly? And at the end you need to deliver your products to your customers, not just prototypes, right?

Don’t take me wrong, we have been using several programming languages over the years (including C++, Java, Python) and still use them all over the time. I rather think the general idea is that e.g. C++ is not always the right choice - Here’s what you get if you use FreePascal/Lazarus:

• FreePascal is *not* just Pascal - you get a 100% programming OO-language with objects, classes, generics, interfaces, type-saftety and a clean and easy syntax like Java or C# - everything in a compiler.
  You might ask: Does it have the same quality like gcc or VC++? We think: YES.
• FreePascal is multi-platform - after you wrote your application for Windows, it will run without modifications on the Mac - natively.
• FreePascal is extendable - you can easily add shared libraries written in C or any other language.
• Lazarus is *not* just another IDE - you get a multi-platform integrated source code editor including syntax checking, code completion, refactoring tools, and with an integrated WYSIWYG user interface editor for managing your application’s user interface:  menus, windows, text labels, edit fields, buttons, etc. - including ‘layout manager’ - everything with full preview and without recompiling your code!
• Lazarus LCL (component library) is a multi-platform, Unicode-capable GUI library - after you designed your user interface on Window, it will run without any modifications on the Mac.
  You might ask: Does this LCL have the quality of something like wxWidgets or QT?  We think: YES.
• The ‘edit-compile-run‘ cycle is *fast* - you don’t have to wait for the executables, they are just there after hitting the compilation button.
• Needless to say: it is Open Source - If you find a bug, it’s often easy to fix it yourself. Plus, the source of your issue is just a click away (CTRL+mouse click shows the IDE/GUI library code of the clicked method).
  It comes with a modified GPL license which means you are fully allowed to build and ship your commerical applications with it, and of course without having to ship your own source code.

Enough to  say - try it out yourself:

1. Download the Lazarus package (already includes the compiler)
   http://www.lazarus.freepascal.org/
   http://www.freepascal.org/
2. Start learning the language (like you would do with C#, Objective-C, Smalltalk or something else)
3. Watch the YouTube tutorial videos
4. Read our FreePascal/Lazarus success story :-)…

Do you need someone else to develop the application for you using FreePascal? Then don’t hesitate to ask us!

Example: As you can see from the program output, the variable ‘otherdata’ has been corrupted by the variable ‘data. Imagine, between the corruption and using again the variable ‘otherdata’ million of code lines could be executed!

program project1;
type p64 = ^int64;

procedure testme;
var
  otherdata: integer;
  data: integer;
begin
  writeln('data=',hexStr(data, 8));
  writeln('otherdata=',hexStr(otherdata, 8));
  writeln;

  p64(@data)^:=$00AABBBBCCCCDDDD;  // overwrites otherdata
  writeln('dummy');
  writeln('dummy');
  writeln('data=',hexStr(data, 8));
  writeln('otherdata=',hexStr(otherdata, 8));
end;

begin
  testme();
end.

C:Projectsfrtestdebugger>project1.exe

data=7FFDB000
otherdata=0042C294
dummy
dummy
data=CCCCDDDD
otherdata=00AABBBB

Solution: GDB has the ability to ‘watch‘ for variable changes and trigger them! In this example, it will stop execution at the line that corrupts the OTHERDATA variable.

C:\Projects\fr\test\debugger>gdb project1.exe

GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type “show copying”
and “show warranty” for details.
This GDB was configured as “i686-pc-mingw32″…
(gdb)

(gdb) break TESTME
Breakpoint 1 at 0×4014ff: file project1.lpr, line 23.

Breakpoint 1, TESTME () at project1.lpr:23
23        writeln(’data=’,hexStr(data, 8));

(gdb) watch OTHERDATA
Hardware watchpoint 2: OTHERDATA

(gdb) continue
Continuing.
data=7FFDC000
otherdata=0042C294

Hardware watchpoint 2: OTHERDATA

Old value = 4375188
New value = 11189179
TESTME () at project1.lpr:27
27        writeln(’dummy’);

Hopefully this feature will get into Lazarus soon

Why 8051/C51 ?

• very popular (you can find plenty of code examples)
• simple to program (simple register maps etc.)
• cheap
• Todays 8051 compatible MCUs have most needed integrated (flash memory, EEPROM, ADC, UART, PWM, …)
• almost nothing has changed since its beginning (same registers - the 1980’s code you find still works)

Why STC MCU?

• cheap
• easy to flash: no external programmer is required - TX/RX line is used to flash the MCU

What you need:

• STC MCU (STC12C5410AD, STC12C5412AD, STC12C5620AD, …) - here we using the LQFP-32 pins version (right chip in the picture above)
• USB-to-TTL (5V) adaptor like in the picture above (these can be found easily via eBay) - my adaptor uses the popular CP2102 USB-to-UART bridge
• Wire, adaptor board, …
• a PC
• a book about 8051 programming (STC doesn’t provide a real 8051 programming reference paper, however this isn’t needed as their MCUs are 100% compatible to the original 8051 generic MCU programming !)

Steps:

1. Connect the STC MCU to the USB-to-TTL adaptor:
   USB-adaptor TX <—> MCU RX
   USB-adaptor RX <—> MCU TX
   USB-adaptor +5V <—>  MCU VCC
   USB-adaptor GND <—> MCU GND
   That’s too easy isn’t it?
2. Download STC ISP software v4.80 (Chinese user interface) - I needed v4.80 for my MCU, newer MCUs need newer ISP versions!
3. Download Keil uVision IDE and Compiler (evaluation)
   
4. Install uVision, create a new project “Atmel AT89S52″, no startup file. Under Project options, set OSC frequency, and check “hex file” output.
5. In uVision, create a new file (test1.c), and add it to the project.  Write your first MCU program in this file.
6. Add the corresponding STC MCU header file to your project and include it (e.g. STC12C5410AD.H or STC12C5620AD.H). They contain the port and memory definitions for your type of MCU. You can find them in the download below.
7. Compile to .hex file
8. Upload .hex file using the ISP software.  Important: the STC MCU automatically starts reading and flashing the program via RX line when a certain sequence is sent at start up - therefore, you first need to start the ‘Download’ in the ISP software, and _after_ that turn on the MCU !  Also, both the ISP software and MCU will automatically handshake a good baud rate  (e.g. if the internal 6 Mhz OSC is used, the ISP software will probe a ‘good’ baud rate, so that the MCU will start downloading).

Downloads:

stc_demo.zip
(shows how to initialize the UART, ADC and successively sends the value of ADC0 via UART to the PC)