UDOO - Der kleine Alleskönner

UDOO ist ein Computer, welcher die Welt der Hardware und der Software auf einer leistungsfähigen Platine vereint. Sowohl Anfänger als auch Fortgeschrittene können mit UDOO schnell erste Projekte realisieren und dabei Erfahrungen mit der hardwarenahen Programmierung sammeln.

Programmierbare Hardwarecontroller gibt es bereits seit geraumer Zeit. Leider waren diese Controller früher teuer und für Laien kaum verständlich. Die erfolgreiche Plattform Arduino hat dies geändert und selbst Anfänger haben spielerisch den Umgang mit den Programmiersprachen C / C++ und den benötigten Hardwareschnittstellen gelernt. UDOO geht einen Schritt weiter und vereint einen Computer mit einem Hardwarecontroller auf einer Platine. Damit ist es möglich, die Hardware der Platine über diverse Betriebssysteme zu steuern, was die Bewältigung komplexer Aufgaben ermöglicht.

In diesem Artikel erfahren Sie, wie die verschiedenen Komponenten von UDOO gemeinsam genutzt werden können, um Projekte aller Art zu realisieren.



1.Das Projekt

In diesem Artikel zeige ich ein möglichst simples Beispiel, welches dennoch alle wichtigen Komponenten von UDOO involviert. Das folgende Beispiel zeigt die Ansteuerung einer LED über eine Android-Applikation. Dazu benötigen wir eine Serverapplikation, die auf dem installierten Betriebssystem von UDOO läuft und auf Kommandos der Android-Applikation wartet. Nach Empfang des Kommandos auf dem Server muss dieses interpretiert und die entsprechende Aktion ausgeführt werden. Die Ausführung dieser Aktion wird vom Hardwarecontroller kontrolliert – es muss also die interne Schnittstelle zwischen Computer und Hardwarecontroller genutzt werden.

Um das Zusammenspiel obiger Komponenten zu gewährleisten, realisieren wir folgende Punkte:

Im den folgenden Abschnitten erläutere ich Ihnen das Vorgehen zur Realisierung der einzelnen Punkte. Das folgende Schema zeigt die Idee des Projekts und die beteiligten Komponenten auf.

2.Der Hardwarecontroller

Der wohl wichtigste Schritt ist die Ansteuerung der LED durch den Hardwarecontroller, welcher eigentlich eine Arduino-Platine ist. Um eine Vorstellung zu erhalten, welche Anschlüsse der UDOO besitzt, empfehlen wir ihnen das Pinout-PDF Dokument anzuschauen.

Damit eine LED leuchtet, muss sie mit Strom versorgt werden. Die Stromversorgung einer LED bedarf in unserem Fall keiner grossen Rechnungen, da die Ausgangsgrössen von UDOO klein genug sind. Die LED kann also kurzzeitig ohne Widerstand betrieben werden, ohne dass sie Schaden nimmt. Bei einem langfristigen Betrieb der LED kann ein Wiederstand von ca. 220 Ohm eingesetzt werden.

In unserem Beispiel verwenden wir eine rote LED, welche direkt auf den UDOO Pins angeschlossen wird (Pin 13). Das längere Beinchen der LED (die Anode) muss hierbei an Pin 13 angeschlossen werden, das Kürzere (die Kathode) an den unnummerierten Pin neben Pin 13 (Ground).

Um die LED zum Leuchten zu bringen, muss lediglich eine Spannung an Pin 13 anliegen. Da wir die LED nur ein- bzw. ausschalten möchten, unterscheiden wir ausschliesslich zwischen HIGH (5V) oder LOW (0V).

Der folgende Code erledigt zwei Aufgaben. Er liest laufend Daten vom Serial-Port und entscheidet dabei, ob die LED nun ein- oder ausgeschaltet werden muss. Dabei wird jeweils ein Byte gelesen und überprüft. Ist der Wert grösser als 0 wird die LED eingeschaltet (Zeile 30), ansonsten wird sie ausgeschaltet (Zeile 32).

#include <stdio.h>

#define LED_PIN 13
int initialState = HIGH;

void setup()
{
	//prepare output pin for led
	pinMode(LED_PIN, OUTPUT);

	//set communiation speed
	Serial.begin(230400);

	//set initial state of led
	digitalWrite(LED_PIN, initialState);
}

void loop()
{
	//prepare var for received data
	byte incomingByte = 0;

 	//read available data from serial port
	while (Serial.available() > 0) {
		//read a byte from serial port
		incomingByte = Serial.read();

   		//decide whether to turn led on or off
   		if (incomingByte > 0) {
			digitalWrite(LED_PIN, HIGH);
   		} else {
			digitalWrite(LED_PIN, LOW);
   		}
	}

	//wait a moment
	delay(50);
}

3.Der Server

Der Server-Teil, welcher auf dem Rasperry-Teil des UDOO läuft, macht nichts anderes als Daten via Netzwerk (in unserem Fall WLAN) zu empfangen und an den internen Serial-Port weiterzuleiten. Dieser dient als Brücke zwischen dem Rasperry- und dem Arduino-Teil des UDOO.

Obwohl diese Aufgabe mit wenigen Zeilen Code lösbar ist, werden wir hier auf ein bestehendes und frei verfügbares Projekt zurückgreifen. Der Carmadillo-Server erledigt genau diese Aufgabe.

Nachfolgend der relvante Code-Teil des Cardmadillo-Servers, welcher die Daten weiterleitet. Es handelt sich hierbei um einen Ausschnitt aus der Datei UDPReceiveCommandServer.java.

@Override
public void run() {
	while (running) {
		try {
			//read incoming data from network
			datagramPacket = new DatagramPacket(incomingBytes, incomingBytes.length);
			datagramSocket.receive(datagramPacket);

			//write to serial port
			CarmadilloMain.serialWrite(incomingBytes);

			//wait a moment
			Thread.sleep(50);
		} catch (Exception e) {
			System.out.printLn(e.getMessage());
		}
	}
}

4.Die Android-Applikation

Die Android-Applikation zeigt lediglich einen Toggle-Button an, mit welchem das Ein- bzw. Ausschaltkommando an den Server gesendet wird. Der folgende Ausschnitt zeigt ihnen die Android-Activity, welche den Button enthält und vom User bedient wird. Da diese App sehr einfach ist, verzichte ich darauf, den gesamten App-Code einzufügen.

package ch.asinfotrack.rac.udoo;

import android.app.Activity;
import android.view.View;
import android.widget.ToggleButton;
import ch.asinfotrack.rac.udoo.UdpSenderThread

public class ActivityMain extends Activity {

	//initial state of the toggle-button
	private static final boolean INIT_STATE = true;

	//ip of the udoo
	private static final String UDOO_IP = "192.168.1.17";

	//reference to the sending thread
	private UdpSenderThread _senderThread;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		//get reference to toggle button and prepare it
		ToggleButton btnToggle = (ToggleButton) findViewById(R.id.btnToggle);
		btnToggle.setChecked(INIT_STATE);

		//add listener to toggle button
		btnToggle.setOnClickListener(new View.OnClickListener() {
			public void onClick(View v) {
				//call sending method with current value of toggle button
				ActivityMain.this.sendState(((ToggleButton) v).getChecked());
			}
		});

		//get instance of our service-thread
		_senderThread = new UdpSenderThread(UDOO_IP);
		_senderThread.start();
	}

	@Override
	public void onResume() {
		super.onResume();

		//start sending
		_senderThread.startRunning();
	}

	@Override
	public void onPause() {
		super.onPause();

		//stop sending
		_senderThread.stopRunning();
	}

	private void sendState(boolean state) {
		_senderThread.setState(state);
	}

}

Zusätzlich zur Activity habe ich einen Thread programmiert, welcher sich um das eigentliche Senden kümmert. Dieser Thread sendet die Daten an den UDOO.

package ch.asinfotrack.rac.udoo;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UdpSenderThread extends Thread {

	//the port to use
	private static final int PORT = 9002;

	//whether or not the thread is running
	private boolean _isRunning = false;

	//address of udoo
	private InetAddress _udooAddress;

	//socket to use
	private DatagramSocket _socket;

	//the actual packet whick will be sent
	private DatagramPacket _packet;

	//the current state
	private boolean _currentState

	//flag to decide if a new send is required
	private boolean _needsSend = true;

	//the byte which will be sent to udoo
	private byte[] _outgoingBytes;

	public UdpSenderThread(String udooAddress) {
		this(udooAddress, true);
	}

	public UdpSenderThread(String udooAdress, initialState) {
		//prepare initial state
		_currentState = initialState;

		//prepare address
		try {
			_udooAddress = InetAddress.getByName(udooAddress);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}

		//prepare socket
		try {
			_socket = new DatagramSocket();
		} catch (SocketException e) {
			e.printStackTrace();
		}
	}

	public void startRunning() {
		_isRunning = true;
	}

	public void stopRunning() {
		_isRunning = false;
	}

	public void setState(boolean state) {
		if (_currentState == state) return;
		_currentState = state;
		_needsSend = true;
	}

	@Override
	public void run() {
		try {
			//the running-loop
			while (_isRunning) {
				try {
					if (_needsSend) {
						//prepare the payload data
						_outgoingBytes = new byte[] { _currentState ? 1 : 0 };
						//prepare the packet
						_packet = new DatagramPacket(_outgoingBytes, _outgoingBytes.length, _udooAddress, PORT);
						//send the packet
						_socket.send(_packet);
						//set the flag to false
						_needsSend = false;
					}

					//wait a moment
					Thread.sleep(50);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

5.Zusammenfassung

Das hier vorgestellte Beispiel dient hauptsächlich dem Verständnis und zeigt die Möglichkeiten von UDOO auf. Selbstverständlich kann die Hardware auch direkt angesteuert werden, was den gesamten Code auf wenige Zeilen beschränkt. Grundsätzlich ist das Prinzip jedoch immer gleich und mit gezeigtem Beispiel werden bereits alle relevanten Bereiche abgedeckt. Eine kurze Suche nach Arduino-UDOO-Projekten im Internet zeigt die enorme Vielseitigkeit dieser kleinen Platine. Falls Sie obiges Beispiel abgeschreckt haben sollte, dann schauen Sie die Basic Tutorials von Arduino Arduino Guides an. Sie werden sehen, dass es auch viel einfacher geht.


Pascal Müller

Bereichsleiter Software Engineering


Als ich das erste Mal von UDOO gehört habe, war ich begeistert. Ich habe bereits zuvor einige Experimente mit Arduino durchgeführt und sehe auch etliche Einsatzgebiete dafür. UDOO ist - genau wie Arduino - in erster Linie ein Prototyping-Board und deshalb für Experimente und schnelle Erfolgserlebnisse hervorragend geeignet. Wer sich gerne mit Elektronik und Informatik beschäftigt, ist sowohl mit UDOO als auch Arduino bestens bedient und kann ohne Vorwissen dank umfangreicher Dokumentation schnelle Erfolge erzielen.