Programmierung mit NanoJ

Ein NanoJ-Programm erhält zyklisch im 1 ms-Takt Rechenzeit (siehe folgende Abbildung). Da durch Interrupts und Systemfunktionen der Firmware Rechenzeit verloren geht, stehen dem Benutzerprogramm (abhängig von Betriebsart und Anwendungsfall) nur ca. 30% … 50% Rechenzeit zur Verfügung. In dieser Zeit muss das Benutzerprogramm den Zyklus durchlaufen und entweder beenden oder durch Aufruf der Funktion yield() die Rechenzeit abgeben. Bei Ersterem wird das Benutzerprogramm mit dem Beginn des nächsten 1 ms-Zyklus wieder neu gestartet, letzteres bewirkt eine Fortsetzung des Programms an dem der Funktion yield() nachfolgenden Befehl beim nächsten 1 ms-Zyklus.

Falls das NanoJ-Programm mehr als die ihm zugeteilte Zeit benötigt, wird es beendet und im Objektverzeichnis ein Fehlercode gesetzt.

Ein NanoJ-Programm hat mehrere Möglichkeiten, mit der Steuerung zu kommunizieren:

• Lesen und Schreiben von OD-Werten per PDO-Mapping
• direktes Lesen und Schreiben von OD-Werten über NanoJ-Funktionen
• Aufruf sonstiger NanoJ-Funktionen (z. B. Debug-Ausgabe schreiben)

Über ein PDO-Mapping werden dem Benutzerprogramm OD-Werte in Form von Variablen zur Verfügung gestellt. Bevor ein Benutzerprogramm die 1 ms-Zeitscheibe erhält, werden dazu von der Firmware die Werte aus dem Objektverzeichnis in die Variablen des Benutzerprogramms übertragen. Sobald das Benutzerprogramm Rechenzeit erhält, kann es diese Variablen wie gewöhnliche C-Variablen manipulieren. Am Ende der Zeitscheibe werden letztendlich die neuen Werte von der Firmware wieder automatisch in die jeweiligen OD-Einträge kopiert.

Um die Performance zu optimieren, werden dabei drei Arten von Mappings definiert: Input, Output und Input/Output (In, Out, InOut).

• Input Mappings lassen sich nur lesen und werden nicht zurück ins Objektverzeichnis übertragen.
• Output Mappings lassen sich nur schreiben.
• Input/Output Mappings erlauben hingegen Lesen und Schreiben.

Die gesetzten Mappings können über die GUI bei den Objekten 2310_h, 2320_h, und 2330_h ausgelesen und überprüft werden. Für jedes Mapping sind maximal 16 Einträge erlaubt.

Über die Angabe der Linker-Section wird in Plug & Drive Studio gesteuert, ob eine Variable im Input-, Output- oder Datenbereich abgelegt wird.

Zusammengefasst besteht das NanoJ-Programm bei der Ausführung eines Zyklus hinsichtlich des PDO-Mappings aus folgenden drei Schritten:

1. Werte aus dem Objektverzeichnis lesen und in die Bereiche Inputs und Outputs kopieren
2. Benutzerprogramm ausführen
3. Werte aus den Bereichen Outputs und Inputs zurück in das Objektverzeichnis kopieren

Die Konfiguration der Kopiervorgänge ist dem CANopen-Standard angelehnt.

Zusätzlich kann über NanoJ-Funktionen auf Werte des Objektverzeichnisses zugegriffen werden. Dies ist im Allgemeinen deutlich langsamer und daher sind Mappings vorzuziehen. Die Anzahl an Mappings ist begrenzt (jeweils 16 Einträge in In/Out/InOut).

Eine Liste verfügbarer NanoJ-Funktionen findet sich im Kapitel NanoJ-Funktionen im NanoJ-Programm.

Ein Benutzerprogramm besteht aus mindestens zwei Anweisungen:

• der Präprozessoranweisung #include "wrapper.h"
• der Funktion void user(){}

In der Funktion void user() lässt sich der auszuführende Code hinterlegen.

Beispiele:

Die globale Variable soll erst innerhalb der Funktion void user() initialisiert werden:

unsigned int i; 
void user(){
 i = 1;
 i += 1; 
} 

Folgende Zuweisung ist nicht korrekt :

unsigned int i = 1;
 void user() {
 i += 1; 
} 

Das Beispiel zeigt das Programmieren eines Rechtecksignals in das Objekt 2500_h:01_h.

// file main.cpp
map S32 outputReg1 as inout 0x2500:1
#include "wrapper.h"

// user program
void user()
{
  U16 counter = 0;
  while( 1 ) 
  {
    ++counter; 

    if( counter < 100 )
     InOut.outputReg1 = 0;
    else if( counter < 200 )
      InOut.outputReg1 = 1;
    else
      counter = 0;

    // yield() 5 times (delay 5ms)
    for(U08 i = 0; i < 5; ++i )
      yield();
  }
}// eof

Weitere Beispiele finden Sie auf www.nanotec.de.

Die Deklaration des Mappings gliedert sich dabei folgendermaßen:

map <TYPE> <NAME> as <input|output|inout> <INDEX>:<SUBINDEX>

Dabei gilt:

• <TYPE> 

  Der Datentyp der Variable; U32, U16, U08, S32, S16 oder S08.

• <NAME>

  Der Name der Variable; wie sie im Benutzerprogramm verwendet wird.

• <input|output|inout> 

  Die Schreib- und Leseberechtigung einer Variable: Eine Variable kann entweder als input, output oder inout deklariert werden. Damit wird festgelegt, ob eine Variable lesbar (input), schreibbar (output) oder beides ist (inout) und über welche Struktur sie im Programm angesprochen werden muss.

• <INDEX>:<SUBINDEX> 

  Index und Subindex des zu mappenden Objekts im Objektverzeichnis.

Jede deklarierte Variable wird im Benutzerprogramm über eine der drei Strukturen In, Out oder InOut angesprochen, je nach definierter Schreib- und Leserichtung.

Beispiel eines Mappings und der zugehörigen Variablenzugriffe:

// 6040h:00h is UNSIGNED16 
map U16 controlWord as output 0x6040:00
// 6041h:00h is UNSIGNED16
map U16 statusWord as input 0x6041:00

// 6060h:00h is SIGNED08 (INTEGER8)
map S08 modeOfOperation as inout 0x6060:00

#include "wrapper.h"

void user()
{
  [...]
  Out.controlWord = 1;
  U16 tmpVar = In.statusword;
  InOut.modeOfOperation = tmpVar;
  [...]
}

Eine mögliche Fehlerquelle ist ein schreibender Zugriff mittels der Funktion od_write() (siehe NanoJ-Funktionen im NanoJ-Programm) auf ein Objekt im Objektverzeichnis, welches gleichzeitig als Mapping angelegt wurde. Nachfolgend aufgelisteter Code ist fehlerhaft:

map U16 controlWord as output 0x6040:00
#include " wrapper.h"
void user()
{
 [...]
  Out.controlWord = 1;
  [...]
  od_write(0x6040, 0x00, 5 ); // der Wert wird durch das Mapping überschrieben
  [...]
}

Die Zeile mit dem Befehl od_write(0x6040, 0x00, 5 ); ist wirkungslos. Wie in der Einleitung beschrieben, werden alle Mappings am Ende jeder Millisekunde in das Objektverzeichnis kopiert.

Damit ergibt sich folgender Ablauf:

1. Die Funktion od_write schreibt den Wert 5 in das Objekt 6040_h:00_h.
2. Am Ende des 1 ms-Zyklus wird das Mapping geschrieben, welches ebenfalls das Objekt 6040_h:00_h beschreibt, allerdings mit dem Wert 1.
3. Somit wird - aus Sicht des Benutzers - der od_write-Befehl wirkungslos.

void od_write (U32 index, U32 subindex, U32 value)

Diese Funktion schreibt den übergebenen Wert an die angegebene Stelle in das Objektverzeichnis.

U32 od_read (U32 index, U32 subindex)

Diese Funktion liest den Wert an der angegebenen Stelle aus dem Objektverzeichnis und gibt ihn zurück.

while (od_read(2400,2) != 0) // wait until 2400:2 is set
{ yield(); }

void yield() 

Diese Funktion gibt die Prozessorzeit wieder an das Betriebssystem ab. Das Programm wird in der nächsten Zeitscheibe wieder an der Stelle nach dem Aufruf fortgesetzt.

void sleep (U32 ms)

Diese Funktion gibt die Prozessorzeit für die angegebene Zahl an Millisekunden an das Betriebssystem ab. Das Benutzerprogramm wird anschließend an der Stelle nach dem Aufruf fortgesetzt.

Die folgenden Funktionen geben einen Wert in die Debug-Konsole aus. Sie unterscheiden sich anhand des Datentyps des zu übergebenden Parameters.

bool VmmDebugOutputString (const char *outstring)

bool VmmDebugOutputInt (const U32 val)

bool VmmDebugOutputByte (const U08 val)

bool VmmDebugOutputHalfWord (const U16 val)

bool VmmDebugOutputWord (const U32 val) 

bool VmmDebugOutputFloat (const float val) 

Ist der Puffer vollgeschrieben, so schlägt VmmDebugOutputxxx() zunächst fehl, das Benutzerprogramm wird dann nicht weiter ausgeführt und hält an der Stelle der Debug-Ausgabe an. Erst wenn die GUI den Puffer ausgelesen hat und danach Subindex 00 wieder zurückgesetzt hat, wird das Programm wieder fortgesetzt und VmmDebugOutputxxx() kehrt ins Benutzerprogramm zurück.