Ein kleines Projekt

Das kleine Projekt soll in einem Überschaubaren Rahmen demonstrieren wie die Fähigkeiten von SiSy für die zeiteffiziente Entwicklung von PC-Anwendungen gekoppelt mit Mikrocontrollerlösung genutzt werden können.

Aufgabenstellung

Es ist eine Lösung zu entwickeln die über einen längeren Zeitraum die Helligkeit an einem Standort aufzeichnet und als Datei für die weitere Verarbeitung speichert. Die Standorthelligkeit soll mit dem Lichtsensor auf einem Mikrocontroller-Board einmal pro Sekunde erfasst und an eine PC-Anwendung zur Aufzeichnung gesendet werden. Die PC-Anwendung empfängt den Helligkeitswert, visualisiert den Aktuellen Wert und den Verlauf die letzten Messwerte. Die empfangenen Werte soll an eine Log-Datei im CSV-Format erfasst werden.

Projektplanung

Wer eine SiSy Ausgabe Developer oder Professional hat kann das kleine Projekt gern mit den dort enthaltenen Planungswerkzeugen (Bild: Netzplan) begleiten.

Zunächst soll mit ein wenig Methodik geklärt werden WAS zu tun ist. Die eigentliche Softwareentwicklung kann entweder Parallel oder in zwei Projektiterationen die geforderte Firmware für den Mikrocontroller und die PC-Anwendung erarbeiten.

Analyse

Leider sind die Aktivitäten die gemeinhin als Analyse bezeichnet werden, also dem verstehenden Erarbeiten oder den erarbeitenden Verstehen WAS eine Anwendung leisten soll, oftmals auf das schnöde Aufstellen von Anforderungslisten mit mehr oder weniger leistungsfähigen Werkzeugen reduziert. Natürlich ist Requirements Management wichtig aber Requirements Engineering ist eben mehr als das und methodische Analyse noch ein bisschen mehr. Auch wenn unser kleines Projekt von einem erfahrenen Entwickler locker überblickt wird wollen wir eine gewisse Methodik des Eindringens in die Aufgabenstellung andeuten. Vielleicht erhalten Sie ja Anregungen für Ihre Projekte.

User-Story / Storyboard

Eine der wichtigsten und effizientesten Analysewerkzeuge (das menschliche Gehirn setzen wir als pre condition mal voraus) sind Papier und Stift. „Der Mensch ist doch ein Augentier …“ Lyrics RAMMS+EIN Als Beweis soll die in Projekten oft erhobene Forderung nach dem berühmt-berüchtigten Big Picture dienen. Wir lehnen uns an einer an Arbeitstechnik die aus der Filmbranche bekannt ist, dem Story Board (vgl. user story, Papierprototyp, mock up).

Anwendungsfälle

Etwas formaler geht es dann schon in der UML zu. Die bildliche Darstellung ist als Kommunikationsmittel zwischen Anwender/Auftraggeber und Softwareentwickler schon mal ein erster Schritt aber muss trotzdem weiter präzisiert werden. Dazu bietet die UML als Einstiegspunkt die Modellierung von Anwendungsfällen. Das Anwendungsfalldiagramm beschreibt WAS ein Anwender mit einem System machen, also wozu er es benutzen (anwenden) kann. Die Ähnlichkeit des Anwendungsfallsiagramms mit der obigen Skizze sollte hier erkennbar sein.

Szenarios

Als Szenarien werden textuelle oder grafische Beschreibungen bezeichnet die verdeutlichen WIE ein System bestimmte Leistungen, in unserem Beispiel Anwendungsfälle, realisiert. Die UML bietet für die grafische Abbildung von Szenarien unter Anderem das Aktivitätsdiagramm an. Diese Darstellungsform ist deshalb besonders zur Präzisierung von Anwendungsfällen geeignet, da die Notation sehr stakt an Flussdiagramme (Programmablaufpläne) erinnert und diese sich einer recht hohe Akzeptanz auch bei Nichtprogrammierern erfreuen.

Entwurf und Realisierung der Mikrocontrollerlösung

Entwurf und Realisierung der Mikrocontrollerlösung soll hier nur kurz angedeutet werden. Für die nähere Auseinandersetzung mit der Programmierung von Mikrocontroller soll hier auf unsere Mikrocontroller-Tutorials verwiesen werden:

Grundsätzlich kann die Controllerlösung mit allen drei angebotenen Systemen (myAVR, mySTM32, myXMC) realisiert werden. Das hier gezeigte Klassendiagramm verdeutlicht die Struktur einer Mikrocontrollerlösung basierend auf einem SiSy-Mikrocontroller-Framework.

Im Folgenden ist die Realisierung mit dem myAVR System, einem kleinen Programm und in einfachem C++.

//-----------------------------------------------------------------------------
// Titel     : Mikrocontrollerlösung für das kleine Projekt
//-----------------------------------------------------------------------------
// Funktion  : erfasst ein mal pro Sekunde die Helligkeit und
//             sendet den Wert an die PC-Lösung
// Schaltung : Helligkeitssensor an PortC Bit0
//-----------------------------------------------------------------------------
// Prozessor : ATmega8
// Takt      : 3686400
// Sprache   : AVR C++
// Datum     : 16.04.2014
// Version   : 1
// Autor     : Alexander Huwaldt
//-----------------------------------------------------------------------------
class Application : public Controller
{
    // Bausteine und Attribute .........................................
    protected: uint8_t wert;
	protected: Uart pc;
	protected: AnalogDevice sensor;
 
    // Funktionen ......................................................
    public: void onStart()
    {
        // Startwert festlegen
        wert=0;
        // Sensor auf ADC Chanel 0 konfigurieren
        sensor.config(0);
        // UART Verbindung zum PC mit 9600 Baud konfigurieren
        pc.config(9600);
    }
 
    public: void onWork()
    {
        // Helligkeitswert erfassen
        wert=sensor.getValue8();
        // Wert an PC senden
        pc.sendByte(wert);
        // 1 Sekunde warten
        waitMs(1000);
    }
} app;  // Anwendungsinstanz
//-----------------------------------------------------------------------------

Die Mikrocontrollerlösung muss gebildet und auf den Controller übertragen werden. Von dem moment an sendet der Controller einmal pro Sekunde einen Helligkeitswert, egal ob dieser empfangen oder ignoriert wird (asynchrone Datenübertragung).

Entwurf der PC-Lösung

Die ersten Schritte für die PC-Lösung sind ein entsprechendes SVL-Projekt mit SiSy anzulegen, die aktuelle SVL aus dem LibStore zu laden und ein Klassendiagramm zu erstellen.

Der Klasse MainWnd sind über den ControlWizard folgende Steuerelemente (Controls) als Attribute hinzuzufügen.

Die Anwendung kann bereits gebildet und die Steuerelemente angeordnet werden.

Realisierung der PC-Lösung

Für den Empfang und die Verarbeitung der Helligkeitswerte ist die Operation onComportData zu überschreiben.

Der Quellcode der Operationen onInitWindow und onComportData sind wie folgt zu ergänzen:

mainWnd:onInitWindow
// ...
// Wertebereich der Controls auf 8 Bit 0-255 konfigurieren
verlauf.setRange(0,255);
helligkeit.setRange(0,255);
// ProgressControl auf Style Rund konfigurieren
helligkeit.setStyle(2);
mainWnd:onComportData
// emfangenen Wert an die Controls senden
helligkeit.setPos(newData);
verlauf.addValue(newData);

Test, Weiterentwicklung und Übergabe

Vergleichen Sie die Quelltexte mit den oben modellierten Szenarien. Erstellen und Testen Sie die Anwendung.

Die Weiterentwicklung umfasst die Aufzeichnung der Daten. Dazu ist der Klassenentwurf wie folgt zu erweitern:

Für die Dateiarbeit nutzen wir die Klasse SFile. Die zu speichernden Datensätze sollen zusätzlich das datum und die Uhrzeit der erfassten Helligkeit enthalten. Dafür nutzen wir die Klasse STime. Ergänzen Sie die Operationen wie folgt:

MainWnd::onInitWindow
// ...
// Datei anlegen bzw überschreiben
log.open(dateiName,"w+");
// Dateikopf schreiben
log.writeText("Zeitstempel; Helligkeit\r\n");
log.close();
MainWnd::onComportData
// ...
// Helligkeitswerte Aufzeichen
SString datensatz;
STime time;
datensatz=time.getText("%d.%m.%y %H:%M:%S");
datensatz.formatAdd("; %d\r\n",newData);
if (log.open(dateiName,"r+"))
{
	log.seek(0,SEEK_END);
	log.writeText(datensatz);
	log.close();
}

Erstellen und Testen Sie die Anwendung. Die erstellte CSV-Datei kann zum Beispiel mit einer Tabellkalkulation weiter verarbeitet werden.

Videozusammenfassung

<flashplayer width=„640“ height=„500“ position=„0“>file=http://youtu.be/???</flashplayer>

Nächstes Thema

ein_kleines_projekt.txt · Zuletzt geändert: 2019/02/07 09:45 (Externe Bearbeitung)