Category Archives: Microcontrollers

all about Microcontrollers

Alexander’s car diagnostic software (OBD KW1281)

-Arduino Version-

Update 2015:   I developed an Arduino OBD reader for the older OBD KW1281 protocol:

  1. An OBD USB adapter (USB KKL adapter  ‘AutoDia K409 Profi USB‘) was hacked, so I could connect the car OBD to the Arduino (TX/RX via software serial).
  2. An Arduino LCD display (‘YwRobot LCMI602 IIC V1’) was attached to the Arduino.
  3. Arduino code was written for the KW1281 protocol to read car sensor data (RPM, oil/coolant temperature, throttle, air, etc.) and show them on the display.

obd_adapter_arduinoobd_kw1281_arduinoobd_arduino_car obd_arduino_display1 obd_arduino_display2

Download Arduino Code for the KW1281 OBD protocol: arduino_kw1281

-PC Version-

My Audi A4/B5 (1997) and many other old cars use the older OBD KW 1281 protocol – I tried to find any suitable OBD software for my car to speak to my motor and dashboard control units (ECU), however:

  • 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)


obd_kw1281  (executable)
obd_kw1281  (freepascal_lazarus code)

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

Tianchen TC-G158 Robot Mower Hacks (Arduino/ATMEGA)

In the year 2009, I did purchase a Tianchen TC-G158 robot mower (via ChinaVasion) and this article describes some of the robot’s electronics internals, how to add an ultrasonic sensor to it,  and how to connect your own microcontroller (e.g. Arduino) to the robot mower board so that you can write your own custom software for it.
One primary warning already: Everything that includes opening your robot will loose your robot’s warranty. If you really need to do this (like me), be aware of this.

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

1. TC-G158 technical internals
This section should give you an overall idea of the components present in your mower. It’s good to roughly understand them for your own hacks!

Tianchen robot mower

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) – also see example schematics here
-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)

2. Adding an ultrasonic sensor (Arduino hack)
An ultrasonic distance  sensor greatly helps to avoid bumping obstacles (or to drive into shrubberies). We use the HC-SR04 as it’s easy to use (you can find these boards on eBay).

Ultrasonic Sensor

This hack is universal – actually, you can add it to ANY robot mower.  The good thing is you can keep the robot’s stock MCU firmware, and it’s easy to add: Just add another two wires to the front bumper push buttons, and your Arduino will simulate one of the bumpers (by switching the bumper signal to LOW) when the ultrasonic distance sensor detects an obstacle!

We use an Arduino Nano board for the controller as it’s very popular and very easy to program.

Arduino <—> robot wiring
Pin 7 <—-> robot left bumper signal pin (P8.2, see below)
Pin 8 <—-> robot right bumper signal pin (P8.4, see below)
Pin 12 <—-> ultrasonic board (trigger pin)
Pin 11 <—-> ultrasonic board (echo pin)
VCC <—-> robot +5V (P6.1, see below)
GND <—-> robot GND (P6.4, see below)

Robot bumpers pinout (P8) is (left-to-right):
2-left bumper signal pin
4-right bumper signal pin

Robot P6 pinout is (top-to-bottom):
1-VCC (+5V)

(the first photo shows the version for the Ambrogio L50 robot mower using two ultrasonic sensors)

Arduino ultrasonic
Tianchen TC-G158 Robot Mower Ultrasonic

For debugging purpose, you can add a piezo speaker:

Finally, you can see everything in action (NOTE: In this video, there is no perimeter that can stop the robot, it is only the ultrasonic sensor that can stop it)

NOTE: I have not tested yet how the ultrasonic sensor can be automatically deactived when the robot drives into the charging station – I’m not using any perimeter with this robot, so at least it works without perimeter…

For Arduino code, see resources section further below.

Hardware/software used for the hack:

  • A microcontroller that is easy to program: I did choose the Arduino Nano for all my hacks. You can find the Arduino Nano controllers on eBay (8-10 EUR)
  • Ultrasonic sensor board HC-SR04 – you can find those board on eBay (5-7 EUR)
  • he software to develop+flash the Arduino (it’s free/open source):

3. Replacing the stock MCU firmware (ATMEGA hack)
Replacing the stock MCU firmware requires to  write a new firmware, and I did choose the Atmel ATMEGA-168 (on a ready myAVR board MK2 USB)  as a replacement for the original 8051 MCU.

The first step is to desolder the MCU socket as you can see on my robot mower board .

Here you can see how I managed to connect my Atmel MCU to the old MCU socket (using some DIY adapter). Alternatively, you can directly connect the individual board pins to your Arduino board using 1-pin-cables (you can find them on eBay).

robot mower own MCU

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

For ATMEGA code, see resources section further below.

4. Adding a PID control for the wheels
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) …

robot mower garden

(Also have a look at my mower simulation that demonstrates the difference ‘lawn with and wihtout slope’).

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).

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):

robot mower right interrupter

5. Resources (wiring diagram, code etc.)

  1. Wiring(motors, bumpers, charger, battery etc.)
  2. Main MCU pin description
  3. 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!)
  4. Charger induction loop signal (measured at induction loop cable output)
    Charger Induction Loop Signal
  5.  Induction loop coil signal (measured at induction coil connector)
    Connector pinout: +5V, GND, vertical coil output, horizontal coil output
    Induction Loop Coil Signal
  6. Remote control protocol
  7. Robot Mower Ultrasonic Code
  8. ATMEGA 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!)
  9. Pinout of ICs
    LM2575S(voltage regulator)
    IRFZ44N(N channel power MOSFET)
    LM324(operation amplifier)
    L298N (motor driver)
    STC5406AD (MCU)

    6. External resources on the Internet

    1. Wiring diagram for the updated version of the robot (additional security board) which turns-off the mower when the front wheels have no contact
    2. Induction loop receiver board schematics (and more) at robi2mow

    8051 Quickstart using STC MCU

    This article describes the first steps how you start programming a 8051 compatible MCU (aka C51), in this case the STC12C5412AD using a USB-to-TTL adaptor.


    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 !)


    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).

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

    mySmartUSB goes Bluetooth

    Dieser Artikel beschreibt, wie man ein Bluetooth-Modul mit einem ISP-Programmer (hier: das ‘mySmartUSB-Modul’ der Firma Laser & Co. Solutions GmbH) verbindet und auf diese Weise Mikrocontroller via Bluetooth mit dem PC programmieren und zusätzlich Daten mit dem Mikrocontroller und dem PC austauschen kann. Diese Möglichkeit, beides kabellos zu bewerkstelligen (Mikrocontrollerprogrammierung  -und RS232-Datentransfer) , dürfte relativ einzigartig sein!


    Manchmal wäre es ‘Nice-to-have’, manchmal geht es aber auch nicht anders:  man möchte das Kabel zwischen Mikrocontroller und PC loswerden. In unserem Fall sollte ein mobiler Roboter per Funk vom PC programmiert und später dessen Sensordaten im Betrieb an diesen PC übertragen werden.

    Warum überhaupt Bluetooth?

    • es gibt kostengünstige USB-Bluetooth-Dongles für den PC (wenige Euro)  (PC-seitig braucht man also nichts entwickeln!)
    • Bluetooth simuliert eine serielle Schnittstelle (COM-Port) am PC – man kann also alle bisherigen Tools und  Programme weiterverwenden  (PC-seitig bleibt also alles beim Alten!)
    • die Reichweite ist akzeptabel (100-150 m , Bluetooth class1)
    • es gibt kostengünstige (ca. 15 €) Bluetooth-Module mit 3.3V TTL UART-Schnittstelle (4 Pins werden davon benutzt:  3.3V VCC,  GND,  TX und RX)

    Warum mySmartUSB als ISP-Mikrocontroller-Programmer?

    • er unterstützt die gängigsten Programmierprotokolle (AVR910/AVR911)
    • einziger ISP-Programmer (meines Wissen), der auch als UART-Bridge fungieren kann und diese ist dazu auch noch per UART-Kommando schaltbar(!) (mehr dazu unten) – den USB-zu-UART Konverter (CP2102) brauchen wir hier jedoch nicht

    Verwendete Komponenten

    1. myAVR mySmartUSB (v2.10) zur µC-Programmierung/UART Datentransfer mit diesem
    2. myAVR Board mit ATmega168
    3. Bluetooth-Modul BTM220
    4. 3.3V Spannunsgregler (LF33CV), 2 Elkos, 4 Widerstände, 1 LED, 1 IC (74HCT14N) für den Bluetooth-Adapter

    Schritt 1 :  Bluetooth-Adapter für mySmartUSB bauen

    Für diesen Zweck wird hier das Rayson Bluetooth-Modul ‘BTM220A’ verwendet, welches eine UART-Schnittstelle verwendet. Da dieses Modul jedoch mit 3.3V Spannungsversorgung arbeitet, wird ein 3.3V Spannungsregler sowie ein 3.3V zu 5V TTL Pegel-Wandler (für RX/TX) eingesetzt. Die genaue Adapter-Schaltung kann z.B. dem Blog von Martin Hänsler entnommen werden. Zur Pegel-Wandlung der TX- bzw. RX-Leitungen wird dort ein invertierendes Schmitt-Trigger IC verwendet, ein Spannungsteiler sorgt bei der RX-Leitung für den 3.3V Level.

    Nach einer nachmittaglichen Bastelarbeit könnte das vollständige Bluetooth-Modul dann z.B. so aussehen 🙂


    Ergebnis: Bluetooth-Modul mit 5V TTL UART (mit vier Anschlußpins: 5V VCC, GND, TX und RX)

    Schritt 2 :  TX und RX am mySmartUSB suchen

    Im nächsten Schritt soll mit diesem Bluetooth-Modul ein ATmega168 auf einem myAVR Board programmiert werden können (natürlich über Bluetooth). Zusätzlich soll aber auch das ATmega UART-Modul mit dem PC über Bluetooth angebunden werden, so dass man kabellos Daten mit dem Mikrocontroller austauschen kann. Für beide Zwecke bietet sich die ‘mySmartUSB-Tocherplatine‘ des myAVR-Boards geradezu an, da es über einfache UART-Kommandos zwischen Programmier- und Datenmodus umschalten kann.

    Ein Problem muss allerdings noch gelöst werden: der Programmer verfügt offensichtlich nur über einen USB-Anschluß als Programmierschnittstelle, die TX/RX-Leitungen zum Programmer hin müssen also ausfindig gemacht werden -vom CP2102-USB-zu-seriell Konverter Baustein ausgehend findet man RX an Pin5 und TX an Pin4 der mySmartUSB-Steckpfosten links:
    (Anmerk.:  in der mySmartUSB Dokumentation findet man nur die rechten TX und RX Pins für die UART-Bridge – diese können aber nicht zum programmieren sondern nur für den Datenaustausch verwendet werden).

    Die benötigte 5V Spannungsversorgung für den Spannungsregler des Bluetooth-Moduls muss man sich ggf. über das myAVR-Board holen – ohne USB-Anschluß scheint der Programmer nur etwa 4V über das myAVR-Board zu bekommen.

    Schritt 3 :  mySmartUSB und Bluetooth-Adapter verbinden

    Dann kommt der spannende Augenblick beide Module miteinander zu verbinden 🙂
    Wichtig: RX vom Bluetooth-Modul geht auf TX vom mySmartUSB  (was der eine sendet, muss der andere empfangen)


    Und siehe da!  Ein erstes Austesten mit den bisherigen myAVR-Tools und Programmen zeigt : alle Funktionen laufen wie erwartet!

    Im nächsten Schritt werde ich wohl die mögliche Reichweite dieses Bluetooth-Moduls austesten – 100 Meter im Freien sollten damit machbar sein 🙂

    Fazit:  …ich bin mir sicher:  so ein fertig aufgebautes Bluetooth-Modul wäre garantiert eine ideale Ergänzung des myAVR-Sortiments   😉

    Kameraposititionssteuerung via Internet

    Endlich mal wieder ein kleines Projekt, welches viele Dinge der Informatik miteinander verbindet: Servos, Mikrocontroller, USB-Kamera, Mikrocontroller <-> PC-Kommunikation, HTTP-Server, Javascript, AJAX, Python …


    Aber jetzt erstmal im Detail:

    Wie der Titel schon andeutet, geht es darum, eine USB-Webcam, welche auf zwei Servos montiert wurde via einem Web-Interface fernzusteuern – und natürlich das Bild der Kamera zu übertragen.

    Das Projekt ist ähnlich dem Projekt von Tobias Weis – allerdings wird hier Windows und als Skriptsprache Python (statt Linux und PHP) verwendet.


    Die Servos werden über Pulsweitenmodulation (PWM) vom Mikrocontroller angesteuert, der Mikrocontroller erhält die Steuerbefehle via RS232-Schnittstelle (RS232 through USB).  Ein auf dem PC laufender und in Python geschriebener Web-Server liest regelmäßig Bilder von der USB-Kamera, nimmt Befehle vom Web-Client entgegen (Kamera nach rech/links/oben/unten) und schickt diese Befehle dann an den Mikrocontroller.

    Benötigte Hardware

    • Mikrocontroller Atmel ATMEGA8L (ich verwende das myAVR Board MK2 USB von myAVR) – dieses Board enthält den Mikrocontroller sowie einen Programmer zum Übertragen der Software in den Mikrocontroller via USB.
    • 2 handelsübliche Servos (werden im Modellbau eingesetzt und gibt es teilweise recht günstig bei eBay – ansonsten beim Modellbauer, Conrad, …)
    • USB-Webcam (gibt’s überall)
    • Ein Netzteil (5V, ca. 1A) zur Energieversorgung der Servos

    Benötigte Software

    Schritt 1: Servos montieren und mit Mikrocontroller verbinden

    Den ersten Servo auf ein Brett fixieren, den zweiten Servo auf den ersten montieren und die Kamera auf den zweiten Servo befestigen. Dann die Steuerleitungen der Servos mit den Atmel Pins PB1 (OC1A) und PB2 (OC1B) verbinden. Zuletzt die +5V und Masse-Leitung der Servos mit dem externen Netzteil verbinden und die Masse-Leitung des externen Netzteils mit der Masse des Atmels verbinden (siehe auch das Schaltbild von Tobias).

    Schritt 2: Mikrocontroller programmieren

    Als nächstes wird der Atmel-Mikrocontroller programmiert. Zunächst sicherstellen dass die Fuse Bits des Atmels so eingestellt sind, dass dieser mit dem externen 3.6864 Mhz Quartz arbeitet (wichtig für die RS232 Kommunikation), z.B. mit dem Tool AVROSPII. Dann die Mikrocontroller-Software (avr/test2.c bzw. Projektdatei avr/test2.aps) in den Atmel mit AVR Studio übertragen (Build->Build und danach Tool-AVR Prog). Falls das myAVR-Board nicht gefunden wird, überprüfen ob COM1 oder COM2 für den USB-Treiber (->Gerätemanager) verwendet wird.

    Nach erfolgereicher Übertragung der Mikrocontroller-Software kann man die Servos mit der Batch-Datei (avr/term.bat) austesten, welche ein RS232-Terminal startet. Durch Drücken der Tasten 1, 2, 3 oder 4 kann man die Servos steuern (rechts/links/oben/unten).

    Schritt 3: Web-Server starten

    Die WebCam mit dem PC verbinden. Dann den Web-Server starten (im Verzeichnis control ausführen:  python Nach ein paar Sekunden läuft der Web-Server dann auf Port 8080. Im Web-Browser gibt man also “http://localhost:8080” als URL ein und mit ein bisschen Glück sieht man das Web-Interface der Steuerungssoftware.

    Download der Software


    Wouldn’t it be nice to lie in the sun and have a robotic mower mow the lawn (and do the boring work)? Well, at least this is the aim (among other aspects as learning more about designing such systems) of this project…

    A) Mechanics

    • Two wheels of a seed vehicle
    • Two office chair front wheels
    • Two DC motors motors (12V, 40W) with gear (23:1)

    B) Mowing unit

    • DC motor from a 18V battery lawn trimmer

    C) Controller

    • Microcontroller board ATMEGA168 (myAVR, 50 EUR) for reading the sensors and controlling the motors (two rear motors).

    D) Sensors

    • Three Sharp IR sensors to detect near obstacles
    • RGB color sensor to detect non-lawn/lawn areas (no need to build a virtual fence in your garden!)
    • Bumper with three micro switches

    E) All other parts

    • A wooden board (38 x 53 cm) for assembly of everything
    • Two gel-lead batteries (2 x 12V, 10Ah)

    F) First version (without mowing unit), without sensors


    Click here to see video (9 MB)
    which shows this mower prototype in action (indoor) 🙂
    G) Second version – now with sensors and mowing unit!

    The color sensor is working – the RGB color value is measured periodically and then converted into HSV (hue/saturation/value) color model. A first test with real lawn shows it can detect areas with a green color very precisely. For testing the algorithm, the first goal was to keep the robot on the blue piece of carpet – it successfully stayed on there, even after ‘mowing’ for 30 minutes!