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 (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

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)

Ausgangslage

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 Pin14 und TX an Pin15 der mySmartUSB-Steckpfosten

(Anmerk.:  in der mySmartUSB Dokumentation findet man andere 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  

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.

Funktionsweise

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

•  Atmel AVR Studio 4 (kann man bei Atmel herunterladen) - zum Kompilieren/Übertragen der Mikrocontrollersoftware
• Python 2.6 - Skriptspraceh zum Ausführen des Web-Servers, Kamera-Zugriff, Mikrocontroller-Kommunikation etc.
• Python Windows Extensions - wird für von der Universal Serial Port Python Library benötigt
• Python Imaging Library (PIL) - wird für die Python VideoCapture Library benötigt

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

• ein 28″ Damen-Fahrrad
• einen Nine-Continent Vorderradnabenmotor 250 W, 36V
• Motor-Steuerelektronik
• Pedal-Sensor
• und Bremsschalter  (alles zusammen 180 EUR als Bausatz)
• 3 x 12 V, 7Ah Blei-Gel-Akkus (60 EUR)

…und heraus kommt ein Elektro-Bike

Das Gesamtgewicht (Fahrrad, Elektromotor und Akkus) liegt für diese Variante bei ca. 30 kg.Zum Fahren (max. 25 km/h, max. 250 W, im Pedelec-Betrieb, d.h. Einschalten des Motors durch Treten) braucht man keine Versicherung.

Die erreichbare Höchstgeschwindigkeit liegt bei 25 km/h (mit aktivierter Begrenzung), und bis zu 40 km/h (ohne Begrenzung).

Endlich machen Gebirgsfahrten (hier 19% Steigung an der steilsten Stelle) mit dem Drahtesel Spaß

Reichweite: 17. Juni 2009 - Heute wurde die erste “Langstrecke” mit dem E-Bike (mit dem vollen 7Ah Akku) gemacht, 13.6 km lang (incl. kleineren ‘Bergen’) - mit Unterstützung in den Pedalen hat der Akku gerade so gereicht - beim letzten Anstieg setzte die Steuerung ab und zu aus - ein Zeichen dafür, dass der Akku langsam schlapp macht und geladen werden muss.  Fazit: Für noch längere Strecken sollte ein 10Ah Akku oder besser verwendet werden.

Wie ich finde, ist das ein interessantes Ergebnis: Der Desktop PC im Standby verbraucht beinahe genauso viel Energie wie ein MacBook im Vollbetrieb - ein altes Fax von 1980 verbraucht im Standby weniger als die Hälfte eines modernen Fax-Gerätes im Standby - und ein Fernseher verbraucht im Standby mehr als ein MacBook im Vollbetrieb… Moderne Geräte sind (bis auf wenige Ausnahmen) im Standby erstaunlich energiehungrig.

Mein Vorschlag: ein weltweites Siegel für den Konsumenten für jedes Elektrogerät mit Angabe des Energieverbrauchs (Watt Vollbetrieb/Standby), nicht zuletzt damit wir unser weltweites CO2 Ziel erreichen?

1. simulates the flight dynamics of an RC aircraft and
2. automatically controls that aircraft so that it avoids obstacles (ground/mountains etc.), only by analysing the optical flow in front of the aircraft. For the optical flow sensor, an optical mouse CCD (20×20 pixels) with a lense is simulated.  

Also click here to see how the same technique is used in 2D to navigate a robot, only by optical flow. 

In detail, this example project shows:

1. How to create a virtual environment for a virtual robot and display the robot’s camera view
2. Capture the robot’s camera view for analysing
3. Compute the optical flow field of the camera view
4. Estimate Focus of expansion (FOE) and Time-to-contact (TTC)
5. Detect obstacles and make a balance decision (turn robot right/turn left)

Matlab’s Virtual Reality toolbox makes it possible to not only visualize a virtual world, but also capture it into an image from a specified position, orientation and rotation. The virtual world was created in VRML with a plain text editor and it can be viewed in your internet browser if you have installed a VRML viewer (you can install one here).

(Click here to view the VRML file with your VRML viewer) .

For calculating the optical view field of two successive camera images, I used a C optimized version of Horn and Schunk’s optical flow algorithm - see here for details).

Based on this optical flow field, the flow magnitudes of right and left half of each image is calculated. If the sum of the flow magnitudes of the view reaches a certain threshold, it is assumed there is an obstacle in front of the robot. Then the computed flow magnitude of right and left half image is used to formulate a balance strategy: if the right flow is larger than the left flow, the robot turns left - otherwise it turns right.

Robot’s camera view at the same time:

Click here to see a video recording of a robot session. 

Click here to download Matlab code.