RSS-Reader

Aus toolbox_interaktion
Wechseln zu: Navigation, Suche
128px-Generic Feed-icon.svg.png

Schon seit vielen Jahren werden im Internet Informationen über sogenannte RSS-Feeds bereitgestellt. Viele Internetseiten bieten ihre neusten Inhalte als kurze Texte in dieser Form an. Idee dieses Projektes ist es, aktuelle Informationen eines RSS-Anbieters auf einem LCD-Displays auszugeben, welches über einen Mikrocontroller angesteuert wird. Die Kommunikation mit dem Computer wird durch eine USB-Schnittstelle auf dem Mikrocontrollerboard realisiert.

Allgemeines zum Thema RSS

Unter einem RSS-Reader oder Feedreader versteht man ein Programm, dass im Stande ist, spezielle Internetadressen die Nachrichten bereitstellen, beziehungsweise deren Elemente, auszulesen und zu verwalten. Erstere tragen die Bezeichnung RSS-Channels, ihre Informationen werden RSS-Feeds genannt. Heutzutage stellen viele Internetseiten ihre Inhalte in Form von Feeds bereit. Sie sind an den Endungen ".rss" beziehungsweise ".xml" zu erkennen und enthalten beispielsweise die neuesten Nachrichten, Themenbeiträge oder Podcasts, also auch Video- oder Audiodatein. Es muss aber darauf hingewiesen werden, dass nicht jeder RSS-Channel gleich ist. Dies ist historisch bedingt und wird im Folgenden genauer beleuchtet. Im Jahre 1999 stellte die Firma Netscape den ersten RSS-Standard "RSS 0.90" vor. Er fand Anwendung in ihrem "My Netscape Network", einer individualisierbaren Nachrichtenseite von Netscape. Dieser Standard basierte zu diesem Zeitpunkt noch auf der Metasprache Resource Description Framework (kurz RDF). Dies wurde aber schon relativ bald geändert. Durch die zu große Komplexität des Standards wurde eine Vereinfachung benötigt. Im Jahr 2000 veröffentlichte Dave Winner die leichter zu benutzende Version RSS 0.91, in der auch die Auszeichnungssprache XML1.0 Anwendung fand und das RDF-Format ersetzte. Die Firma UserLand entwickelte von nun an die weiteren RSS 0.9x Versionen. Die Abkürzung RSS bedeutet hier "Rich Site Summary". Es folgte im Dezember 2000 die, von der unabhängigen Programmiergruppe RSS-DEV entwickelte, Version RSS1.0. Diese Version unterscheidet sich wieder grundlegend von den Versionen ab 0.91, da man bei RSS1.0 wieder auf das ursprüngliche RDF Format zurückgreift. Das Akronym "RSS" hat hier nun die Bedeutung „RDF Site Summary“. Die Firma UserLand Software arbeitete aber parallel weiter an ihren RSS0.9x Versionen und veröffentlichte im Winter 2002 die Version RSS2.0, welche nicht vollständig zu den vorigen 0.9x Standards kompatibel ist. Hier steht das RSS für Really Simple Syndication. Ein bedeutender Vorteil gegenüber ihren Vorgängern ist die Möglichkeit beliebig viele Elemente einzufügen, solange diese nur korrekt implementiert worden sind. Diese Version gilt mittlerweile als sehr weit verbreitet. Gerade im Zusammenhang mit Blogging wurde auch ein ähnliches Format für das "Feeden" auf Basis von XML entwickelt. Das "Atom"-Format soll in Zukunft den RSS-Standard ablösen. Bei der Konzipierung wurde ein großer Fokus auf die Benutzerfreundlichkeit beim Bloggen gelegt. Es sei aber auch erwähnt, dass beide Formate nicht kompatibel untereinander sind. Es besteht aber die Möglichkeit einen Atom-Feed in einen RSS-Feed zu konvertieren. Das bedeutet folglich auch, dass nicht jedes RSS-Reader Programm automatisch jede Art von Feeds korrekt auslesen kann. Der hier erstellte RSS-Reader kann Daten vom Typ XML verarbeiten und funktioniert somit mit den RSS-Versionen der 0.9er Familie ab 0.91, sowie dem RSS2.0 Standard.

Hardware-Aufbau

Arduino Pin Ziel Pin Verwendungszweck
+5V LCD +5V Spannungsversorgung
gnd LCD gnd Ground Anschluss
2 – 5 LCD D7 bis D4 Datenpins zur Informationsübertragung
12 LCD RS Register Auswahl
11 LCD Enable Pin Ein/Aus Funktion
13 LED + Ansteuerung der LED

Zum Durchführen des Hardwareaufbaus sind Kenntnisse im Löten und Verdrahten nötig. Da es sich um sehr kleine Elektronik handelt sollte eine dünne Lötspitze und Elektroniklot verwendet werden. Zudem ist grundlegendes Werkzeug wie eine Spitzzange und ein Multimeter zu empfehlen.

Verwendete Komponenten

Zum Aufbau des Projekts wurden folgende Komponenten verwendet:

  • USB Arduino Board mit ATMEGA328P Mikrocontroller
  • HD44780 kompatibles 16x2 LCD Panel mit weisser Schrift auf blauem Grund
  • USB Kabel – Typ A Stecker zu Typ B Stecker
  • kräftige LED in blau
  • Potentiometer 10k
  • Widerstand 47 Ohm
  • Kabel je nach Anordnung des Aufbaus ca. 80cm
  • Experimentierbord mit passendem Lochmaß
Schaltbild des kompletten Aufbaus

Der R/W (Read/Write ) Anschluss der LCD-Platine wird nicht angeschlossen, da wir das LCD nur im Schreibmodus betreiben wollen. An angelegtes High-Signal würde dementsprechend den Lesemodus aktivieren und das Lesen aus der Registern des LCD Moduls ermöglichen. Die LiquidCrystal Library ermöglicht das nutzen eines 4-Bit Datenmodus für die Kommunikation mit dem Display, weswegen hier auch nur 4 Datenpins belegt werden. Es ist jedoch darauf zu achten das im 4bit Modus immer die höherwertigen Bits belegt werden müssen. In diesem Fall also D4 bis D7. Bei der Verwendung HD44780 kompatibler LCD Panels ist die Belegung der Anschlüsse auf der LCD Platine immer gleich. Es ist also nicht unbedingt nötig das Datenblatt des entsprechenden Panels zu Rate zu ziehen. Anders ist dies bei nicht konformen Panels, bei denen die Anschlüsse öfters gespiegelt werden oder bestimmte Anschlusspins gar nicht zur Verfügung stehen. Ist man sich über die benötigte Spannung für Hintergrundbeleuchtung (hier: Bk1+) und Kontrast (hier: Vo) im Unklaren sollte auch da im Datenblatt des jeweiligen Displays nachgeschaut werden. Das Datenblatt zum hier verwendeten „TC1602A-09“ LCD beinhaltet neben den Pin Belegungen des Moduls auch eine technische Zeichnung mit allem Bemaßungen und ein Blockdiagramm der internen Kommunikation.

Schaltungsaufbau

Experimenteller Aufbau der Schaltung

Die Schaltung besteht aus zwei Hauptkomponenten, dem Arduino Board und dem LCD Display. Die vom USB Anschluss her kommende Versorgungsspannung von 5 Volt wird über das Controllerboard an das LCD weitergeleitet. Der Pin Vo steuert den Kontrast des Display und muss mit etwa 4,2 Volt angesteuert werden. Zu diesem Zweck wird ein Potentiometer zwischengeschaltet, welches einen einfachen Spannungsteiler bildet. Im laufenden Betrieb lässt sich dann durch Verstellen des Potentiometers und Beobachten des Display die optimale Einstellung für den Kontrast finden. Die Hintergrundbeleuchtung wird an den Pins 15 (Spannungsversorgung) und Pin 16 (Ground) beschalten. Für den Spannungeingang wird ein 100 Ohm Vorwiderstand verwendet. Der RS-Eingang des Displays dient zum Signalisieren eines Datenübertragung. Werden Zeichen auf das Display geschrieben liegt hier ein High-Signal an. Andernfalls werden alle empfangenen Daten als Befehle interpretiert. Da wir in unserem Fall nur Nachrichten schreiben wollen, jedoch nichts vom LCD lesen wollen, muss der R/W Pin immer auf Low sein und wird somit einfach auf Ground verdrahtet. Das Ein- und Ausschalten des Displays erfolgt über den Enable-Eingang. Auf den Pins D4-D7 werden schließlich die eigentlichen Nutzdaten empfangen.

Der Aufbau ist experimentell gestaltet und soll kein endgültige Lösung darstellen. Für das einfache Verbinden der Bauteile wurde ein Experimentierboard verwendet. Die Löcher in der Mitte des Boards sind horizontal gebrückt. Die anderen vier Lochbereiche sind vertikal miteinander verbunden. Damit lässt sich die Schaltung mit wenigen Verdrahtungsaufwand erstellen. Auch das Potentiometer und der Widerstand können gesteckt werden. Ein entsprechendes Gehäuse würde den Aufbau ansprechender und stabiler machen, ist aber nicht Gegenstand des Projekts.

Programmierung des Mikrocontrollers

Das verwendete Controllerboard basiert auf der Arduino-Plattform. Dabei handelt es sich um ein Open Source Projekt, welches sowohl die Hardware, als auch die Software beinhaltet. Die Hardware basiert dabei immer auf einem Atmel AVR-Mikrocontroller, der über einen FTDI-USB-Seriell-Konverter mit dem PC verbunden werden kann. Der eingebaute Mikrocontroller ist ein Atmega328. Bei der hier verwendeten Ausführung des Arduino Boards wurde der USB-Seriell-Konverter bereits auf der Platine realisiert. Auch die Stromversorgung erfolgt über die USB-Verbindung. Um den Mikrocontroller programmieren zu können, steht die Arduino-IDE zur Verfügung. Dies ist eine plattformunabhängige Java-Anwendung die sowohl Code-Editor als auch Compiler ist. Außerdem kann über das Tool eine serielle Verbindung zum Board aufgebaut werden. Diese kann dann sowohl Daten senden als auch empfangen und somit auch das erstellten Programm in den Mikrocontroller laden. Als Programmiersprache wird eine objektorientierte Sprache namens Processing verwendet, welche Wiring abgeleitet ist. Diese C-ähnliche Sprache wird mit dem GNU Compiler programmiert und kann auch verschiedene Libaries verwenden, was die Erstellung von Programmen erheblich erleichtert. Der Aufbau und Ablauf eines solchen Programms soll nun direkt am selbst erstellten Programm zur LCD Ansteuerung erläutert werden.

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int ledPin = 13;

Wie aus der Programmiersprache C gewohnt, beginnt das Programm mit dem Inkludieren von Bibliotheken. Die LiquidCrystal.h ist eine im Open Source Projekt Arduino frei verfügbare Bibliothek, welche Routinen zur Ansteuerung von LCD Displays bereitgestellt. Zur Initialisierung werden de verwendeten Pin-Nummern an die Konstruktor der Klasse 'LiquidCrystal' übergeben. Außerdem wir eine LED auf Pin 13 initialisiert. Die Verwendung des Schlüsselworts 'int' ist möglich, weil grundlegende Bibliotheken, vergleichbar mit der 'stdio.h' von C bereits durch die Programmierumgebung in jedes erstellte Programm eingebunden werden. Basisfunktionalitäten wie die Syntax für Datentypen, Rechenoperationen und Ablaufsteuerung sind also immer verfügbar, ohne das hierfür explizit eine Bibliothek inkludiert werden muss. Auch das Ansteuern sämtlicher Ein- und Ausgänge des Arduino Boards ist eine Grundfunktion.

void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(ledPin, OUTPUT);
}

Als Nächstes folgt der Setup-Abschnitt. Dabei handelt es sich um eine Codebereich, der nur einmal nach dem Aufruf des Programms, bzw. dem Einschalten des Mikrocontrollerboards durchlaufen wird. Mit 'Serial.begin' wird die Baudrate für die Kommunikationsverbindung festgelegt. Aus der LCD Bibliothek wird die Funktion 'lcd.begin' verwendet. Die Argumente dieser Funktion sind Spalten- und Zeilenanzahl des verwendeten Displays. Wir können also 2 mal 16 Zeichen, also 32 Zeichen auf einmal darstellen. Die Funktion 'pinMode' deklariert die in der Initialisierung verwendete Variable 'ledPin' als Ausgang. Somit ist über das Ansteuern dieser Variable das Beschalten der LED am Pin 13 möglich.

void loop()
{
  if (Serial.available() > 0)
  {
   incomingByte = Serial.read();
     	...

Nach dem Setup-Abschnitt folgt der Loop-Abschnitt. Dieser Programmteil wird nach Programmstart zyklisch immer wieder durchlaufen, wie das Hauptprogramm einer Speicherprogrammierbaren Steuerung. In der if-Schleife wird geprüft, ob Daten an der seriellen Verbindung anliegen. Ist dies der Fall wird Eingelesen und an eine lokale Variable übergeben.

   switch(incomingByte)
   {
   case 'ä': incomingByte = 100; break;
   case 'ö': incomingByte = 246; break;
   case 'ü': incomingByte = 252; break;
   case 'Ä': incomingByte = 196; break;
   case 'Ö': incomingByte = 214; break;
   case 'Ü': incomingByte = 220; break;
   default : break;
   }

Da es eine gewisse Inkompatibilität zwischen den ASCII-Tabellen von PC, Mikrocontroller und LCD Display gibt, ist das einfache Übergeben von deutschen Umlauten nicht möglich. Durch Vergleiche der verschiedene Tabellen konnte die hier realisierte Zuordnung der ASCII-Werte gefunden werden. Diese switch-Anweisung ist der Ausgabe vorgelagert und kann so „falsche“ ASCII-Werte vorher korrigieren.

if (i<16)
   {
     lcd.setCursor(i, 0); i++; //Setzt Cursor in der ersten Zeile
     lcd.print(incomingByte);  //Schreibt Zeichen
   }
   else
   {
     lcd.setCursor(j, 1); j++; //Setzt Cursor in die zweite Zeile
     lcd.print(incomingByte);  //Schreibt Zeichen
     
     if (j>15) // Die blinkende LED zeigt die Lesezeit an
     {
       for(i=0;i<3;i++) // ~3 Sekunden Zeit zum Lesen
       {
         digitalWrite(ledPin, HIGH);   // LED an
         delay(400);                   // 0,4 sec warten
         digitalWrite(ledPin, LOW);    // LED aus
         delay(400);                   // 0,4 sec warten
       }
       i=0;j=0; // zurück nach links oben
     }
   }

Die Ausgabe der einzelnen Zeichen wird in diesem Codeabschnitt realisiert. Zum besseren Verständnis sind Kommentare im Code eingefügt wurden. Das Prinzip der Ausgabe soll jedoch trotzdem kurz erklärt werden. Nachdem ein Zeichen diesen Codeabschnitt erreicht wird es auf dem Bildschirm platziert. Die Platzierung beginnt links oben und wird dann für weitere 15 Zeichen in der ersten Zeile fortgesetzt. Ist das Ende der Zeile erreicht, wird in die zweite Zeile gesprungen. Ist auch das Ende der zweiten Zeile erreicht, wird dem Leser etwa 3 Sekunden Zeit gewährt um den Text zu erfassen. Zur Verdeutlichung dieser Lesezeit blinkt die LED dreimal. Liegen dann weitere Zeichen an der seriellen Schnittstelle an, wiederholt sich der Vorgang. Der Schreibcursor wird wieder nach links oben gesetzt, und der Ablauf beginnt von Neuem.

Kommunikation mit dem Mikrocontroller

Wie schon im vorangegangenen Kapitel erwähnt, besitzt die Arduino Entwicklungsoberfläche bereits die Möglichkeit einer seriellen Kommunikation. Dieses einfache Tool besteht aus einem kleinen Fenster über welches man Zeichen senden und empfangen kann. Zu Debug-Zwecken sendet der Mikrocontroller das von ihm empfangene Zeichen wieder an den Rechner zurück. Hierzu stehen die Funktionen 'Serial.print' und 'Serial.println' zur Verfügung. Die eigentliche Herausforderung besteht jedoch darin, dem nun bereits programmierten Mikrocontroller Daten über ein automatisiertes Programm zu übergeben und reibungslosen Ablauf der Kommunikation auch im Dauerbetrieb zu gewährleisten. Zur Realisierung unserer PC-seitigen Softwareumgebung haben wir uns für die Programmiersprache C++ entschieden. Die verwendeten Programmierumgebungen sind 'Visual Studio 2005' und 'Visual Studio 2008 Professional'. Diese Tools wurden wegen der Möglichkeit ausgesucht, relativ einfach grafische Bedienoberflächen erstellen zu können. Im Folgenden sollen nun in Auszügen die Ansteuerung des Mikrocontrollers mit C++ erläutert werden. Für die Basisfunktionen der seriellen Verbindung zum Board werden Funktionen aus dem Arduino Playground verwendet.

class Serial
{
    private:
        HANDLE hSerial;
        bool connected;
        ...

    public:
        Serial(LPCWSTR portName);
        virtual ~Serial();
        int ReadData(char *buffer, unsigned int nbChar);
        bool WriteData(char *buffer, unsigned int nbChar);
        bool IsConnected();
};

Der erste Codeausschnitt stammt aus der Headerdatei 'SerialClass.h' zur seriellen Verbindungsklasse. Die Klassendeklaration beinhaltet die Prototypen für die in Funktionen der Klasse. So kann zum Beispiel mit 'WriteData( Zeichenpuffer, Länge_der_Zeichenkette )' der Inhalt der Speicherstelle auf die ein übergebener Zeiger deutet über die serielle Verbindung ausgegeben werden. Mit der Funktion 'IsConnected()' kann abgefragt werden, ob der Aufbau der seriellen Verbindung erfolgreich war. Ausprogrammiert sind diese Funktionen in der zugehörigen Quelldatei 'Serial.cpp'. An dieser Stelle soll nun nicht weiter auf diesen Programmabschnitt eingegangen werden. Für weiterführen Informationen empfiehlt sich die englischsprachige Website „TheCodeProjekt“.

Im Sinne der Modularität wird für unser spezifische Anwendung eine weitere Klasse mit dem Namen 'LCD' erstellt. Das Ziel ist es im letztendlichen Hauptprogramm (main) nur eine einen Zeiger übergeben zu müssen, der auf den wiederzugebenden Nachrichtentext deutet. Mit 'lcd.h' wird diese Brücke zwischen der vorgestellten Klasse 'Serial' und der gewünschten einfachen Zeigerübergabe geschlagen. Es sollen nun wieder die Funktionen der Klasse vorgestellt werden.

class lcd
{
	private:
		char buf_out[nach_anz][nach_laeng];
		int addy;	// aktuelle Anzahl der Segmente
		string str_akt; // aktuell laufender Nachrichtenstring
	public:
		void schreiblcd(string *str_input);
		void wandel(string str_in);
};

Mit 'schreiblcd' kann der Inhalt der Speicherstelle auf den ein übergebener String-Zeiger, also eine Zeiger auf eine Zeichenkette zeigt auf die serielle Schnittstelle geschrieben werden. Diese Funktion hat im Vergleich zur Funktion 'WriteData' einige Vorteile. So kann hier mit einem Aufruf eine ganze Zeichenkette geschrieben werden und nicht wie zuvor nur ein einzelnes Zeichen. Das Argument ist in seiner Größe nur durch die im zweidimensionalen Array 'buf_out' verwendete, frei wählbare Variable 'nach_anz' beschränkt. Diese stellt die Anzahl der 32 Zeichen langen Textsegmente dar, welche jeweils einmal den kompletten Displayplatz füllen. Die absolute Zeichenanzahl des Arguments darf also das Produkt aus Nachrichtenanzahl und Segmentlänge nicht überschreiten. Da wir aber immer nur die Schlagzeile, technisch gesehen den Abschnitt 'Title' eines RSS-Feeds ausgeben wollen, ist ein überschreiten dieser Grenze nicht zu erwarten. Sollte dieser Fall doch eintreten, kann immer noch die Größe des Pufferarrays erhöht werden. Außerdem realisiert diese Funktion zusätzlich das ständige Senden der Textsegmente in einem definierten Zeitabstand. Dieser Zeitabstand ist mit der Verarbeitungszeit des Mikrocontrollers abgestimmt und der störungsfreie Betrieb ist in einem Langzeittests bestätigt worden.

Timetable.png


Die Grafik zeigt wie man sich den zeitlichen Ablauf der Prozesse an Computer (gelb) und Mikrocontroller (blau) vorstellen kann. Im Zeitbereich Bildschirmaufbau (1100ms) steckt außerdem auch das warten auf anliegen des nächsten Zeichens auf der seriellen Verbindung, was eine busywait-Situation darstellt. Auch sollten die Laufzeiten des USB-Seriell-Konverter erwähnt werden. Die Funktion 'wandel' stellt nur eine Hilfsfunktion der Schreibroutine dar. Wird eine neue Nachricht von RSS-Reader gesendet, muss diese aus ihrer ursprünglichen String-Form in Segmente zu je 32 Zeichen zerlegt und anschließen in den Ausgangspuffer geschrieben werden. Mit der vorgestellten Array-Lösung kann dann über die Variable 'nach_anz' der Nachrichtentext der Reihe nach ausgegeben werden. Über die private-Variable 'addy' teilen sich die beiden Funktionen den die aktuelle Anzahl der Segmente mit.

Zur Verwendung im Hauptprogramm müssen die Klassen "lcd.h" und "serial.h" sowie deren Quelldateien in das Projekt eingebunden, und eine Instanz der Klasse "lcd.h" angelegt werden.

Realisierung der Funktionalität des Dialogfeldes

Vorbedingungen

Anhand des beigefügten Tutorials zur Oberflächengestalltung (siehe Anhang) wurde ein analog zum RSS-Reader erstelltes Programm erläutert, weshalb hier an dieser Stelle nicht weiter auf die Programmierung der Oberfläche eingegangen wird. Für die Realisierung des Auslesens der Feeds wurde die CFeed Klasse eines frei verfügbarer RSS-Readers als Vorlage benutzt, die Funktionalität um das Löschen der Datenbank erweitert und einige Codeoptimierungen vorgenommen. Die elementaren Vorgänge werden in den folgenden Abschnitten mit erörtert, ohne dass auf ihre genaue Implementierung eingegangen wird.

UML-Diagramme zur Übersicht

Um einen Überblick über die diversen internen Abläufe des Dialogfensters zu gewinnen kann zuerst das Ablaufdiagramm im linken Bild unter diesem Kapitel betrachtet werden.

Das Programm befindet sich nach dem Start in einem Initalzustand. Hier kann der Link des RSS-Channels eingegeben werden, sowie der Aktualisierungszyklus definiert werden. Das Programm verlässt diesen Zustand, sobald der "Get Feed Now!" Button betätigt wird. Anschließend ließ das Proramm die eingegebenen Parameter aus und aktiviert den Timer, entsprechend der eingestellten Zykluszeit, für die Aktualisierung. Im nächsten Schritt wird die Datenbank, in der die Nachrichten liegen sollen, geleert und mit dem Download der RSS-Channel Informationen und der Feeds begonnen. Die so erhaltenen Daten werden zuerst in einem XML Dokument gespeichert und dann in die Datenbank eingefügt. Um eine weitere Verarbeitung zu ermöglichen müssen zuerst verschiedene Konvertierungen an den Daten innerhalb des Programms vorgenommen werden. Stellt das Programm fest, dass sich die alten von den neuen Daten unterscheiden wird ein Signal an der Audioausgabe des PC ausgegeben und die Daten für die Anzeige auf dem LCD Display modifiziert. Haben sich die Daten hingegen nicht verändert werden die Daten sofort wieder an das Dialogfeld gesendet. Danach wartet das Programm bis die eingestellte Zykluszeit abgelaufen ist oder erneut der "Get Feed Now!" Button betätigt wird. Trifft dies zu, wird wieder mit dem Auslesen der Parameter begonnen und das Programm zyklisch fortgeführt. Das Zusammenspiel der wichtigsten Elements des Fensters, void CRSSReaderDlg::OnBnClickedButton1(), mit der CFeed Klasse, zur Interpretation der Feeds, wird im Seqenzdiagramm unten rechts aufgezeigt.

vereinfachtes Ablaufdiagramm der RSS Software
Sequenzdiagramm des Programmablaufs
Programmoberfläche unter Windows 7

Programmoberfläche

Die Oberfläche der Applikation wurde auf eine besonders einfache und intuitive Bedienung hin konzipiert. Links oben befindet sich das Symbol der Applikation, ein "RA" als Abkürzung für die beiden Kernelemente des Projetks, "RSS" und "Arduino". Daneben befindet sich dem der Name des Programms. In der rechten oberen Ecke befinden sich die Windows-typischen Felder für "Minimieren", "Maximieren/Verkleinern" und "Schließen".Unter dem Text "Please enter RSS-Link here" befindet sich ein Eingabefeld. Hier ist der Link des auszelesenden RSS-Channels einzutragen.Rechts neben "Auto-Refreshtime in minutes" wird die Zeit eingestellt die vergehen soll, bis der Channel erneut ausgelesen wird. Der Zahlenwert wird in Minuten interpretiert und kann sowohl manuell, durch eintippen der gewünschten Zeit, als auch über die Pfeiltasten am Rand des Feldes um jeweils eine Minute erhöht oder erniedrigt werden. Durch Druck auf die Taste "Get Feed Now!" werden die eingegebenen Daten übernommen. Der RSS-Channel wird ausgelesen und in dem mehrzeiligen, schreibgeschützen Ausgabefeld wird zuerst die Zeit der Erstellung des neuesten Feeds dargestellt. Es folgt ein Doppelpunkt und der Titel der neuesten Nachricht.Um die eingegebenen Daten zu ändern muss nur der neue Link eingegeben, beziehungsweise die Zeit verändert werden. Die Daten können wieder durch Druck des "Get Feed Now!"-Buttons übernommen werden. Es ist aber auch möglich die Daten nur zu verändern ohne dies direkt zu bestätigen. In diesem Fall werden die aktuellen Parameter nach Ablauf der zuletzt eingestellten Zeit werden übernommen.Der "Exit"-Button beendet das Programm und löscht die Datenbank. Eine umfangreiche Anleitung zur Oberflächenprogrammierung in C++ für Windows Betriebssysteme wurde im Zuge der Projektdokumentation erstellt und steht hochschulintern zur Verfügung.

Erweiterungen

Um die Elektronik zu schützen und das Projekt zu einem Gegenstand des täglichen Gebrauchs werden zulassen, ist es ratsam eine passendes Gehäuse zu entwickeln. Da in unserem Projekt das Hauptaugenmerk auf der komplexen Kommunikation der Komponenten liegt, ist dieses Gehäuse noch nicht umgesetzt worden. Trotzdem wurde bereits ein Entwurf angefertigt, der in den folgenden Bildern gezeigt wird.

Integrierter USB-Anschluss, USB-Stecker Typ B [1]
Kompakte Bauform, Gehäuse aus Kunststoff oder lakiertem Holz
Meldeleuchte, hier aus dem Gehäuse herrausstehend

Zur Verbesserung der momentanen Software können einige neue Features implementiert werden. Eine Möglichkeit wäre die Verwaltung mehrere Feeds über die Softwareoberfläche zu ermöglichen. Somit wäre das Einfügen einer Adresse nicht mehr zwingend erforderlich. Man könnte zum Beispiel eine Favoriten-Liste in Form eines Dropdown-Menüs realisieren. Eine weitere Idee ist das Einbauen zweier Taster am RSS-Reader, mit denen dann innerhalb eines RSS Kanals durch die Nachrichten navigiert werden kann. Dies wäre eine sehr umfangreiche Erweiterung, da Sie in fast allen Teilbereichen des Projekts Änderungen erfordert. Eine weitaus weniger aufwändige Erweiterungsmöglichkeit ergibt sich aus der Modularität des Projekts. So kann Hardware nun über jede Programmiersprache angesteuert werden, mit welcher es möglich ist die serielle Schnittstelle eines PCs zu kontrollieren. Will man die Ansteuerung nicht neu erfinden, gibt einem die vorhandene Schnittstelle über C++ die Möglichkeit, beliebige Daten in Textform an das Display auszugeben. Einige Beispiele für Nachrichteninhalte:

  • Hardwarestatistiken des Computers, Prozessorlast, Speicherauslastung, …
  • andere Nachrichtendienste wie Twitter, Atom, Instant Messenger
  • Persönliche Daten wie Emails (neuste Betreffzeilen), Kalender (kommende Termine), Onlineauktionshäuser (auslaufende Angebote)
  • kleine Gadgets wie Kurzzeitwecker, Uhrzeit, Wetter, Fortschrittsanzeigen (z.B. einer Dateiübertragung)
  • und viele weitere Möglichkeiten …

Weblinks