Pointer auf Array mit Labview übertragen und darstellen

Das wäre eine Überlegung, alles mit Labview zu machen.
Zum Code: Wie gesagt, ist in der Überarbeitungsphase, von daher ist der obige Code nicht mehr in Verwendung.
Aber auf jeden Fall vielen Dank für die Hilfe!

Anzeige

So, ich habe meinen Code mal überarbeitet:

Code:

__declspec(dllexport) int* gen_WLTable(std::string CCD_Filename)
{
    int *ptr;
    ptr = &WAVENUMBERS[0];
    std::ifstream LUT(CCD_Filename, std::ifstream::in);
    std::string inputline;
    std::vector<std::string> tempstr;
    int i = 0;
    while(!LUT.eof())
    {
        std::getline(LUT, inputline);
        boost::split(tempstr, inputline, boost::is_any_of("\t"));
        std::vector<float> v;
        std::istringstream iss(tempstr[0]);
        std::copy(std::istream_iterator<float>(iss), std::istream_iterator<float>(), std::back_inserter(v));
        if(v.size())
        {
            WAVENUMBERS[i] = (int)(v[0]+0.5);
            i++;
        };
    };
    SIZEOFWN = i;
    return ptr;
};

(Funktion, um WAVENUMBERS zu füllen, und den Pointer darauf zurückzugeben)
Nur weiß ich jetzt noch nicht, wie ich den String in die obige Funktion bekomme. Wie mache ich denn das am dümmsten?
Umsatteln auf eine reine LabView-Version geht leider nicht, da in der Zwischenzeit noch ein paar Funktionen, die ich nur ungern umbauen möchte, hinzugekommen sind.
Vielen Dank!

(04.07.2013 14:50 )lupus022 schrieb:  So, ich habe meinen Code mal überarbeitet:

Code:

__declspec(dllexport) int* gen_WLTable(std::string CCD_Filename)
{
    int *ptr;
    ptr = &WAVENUMBERS[0];
    std::ifstream LUT(CCD_Filename, std::ifstream::in);
    std::string inputline;
    std::vector<std::string> tempstr;
    int i = 0;
    while(!LUT.eof())
    {
        std::getline(LUT, inputline);
        boost::split(tempstr, inputline, boost::is_any_of("\t"));
        std::vector<float> v;
        std::istringstream iss(tempstr[0]);
        std::copy(std::istream_iterator<float>(iss), std::istream_iterator<float>(), std::back_inserter(v));
        if(v.size())
        {
            WAVENUMBERS[i] = (int)(v[0]+0.5);
            i++;
        };
    };
    SIZEOFWN = i;
    return ptr;
};

(Funktion, um WAVENUMBERS zu füllen, und den Pointer darauf zurückzugeben)
Nur weiß ich jetzt noch nicht, wie ich den String in die obige Funktion bekomme. Wie mache ich denn das am dümmsten?
Umsatteln auf eine reine LabView-Version geht leider nicht, da in der Zwischenzeit noch ein paar Funktionen, die ich nur ungern umbauen möchte, hinzugekommen sind.
Vielen Dank!

Also wenn Du mit String den CCD_filenamen Parameter meinst, das geht grundsätzlich nicht. Da musst Du doch wirklich ein char* übergeben und den std:string halt in der Funktion von diesem erzeugen. C++ und Templates ist ja alles schön und gut, aber nur wenn Du sowohl den Caller als die Funktion selber voll unter Kontrolle hast. Ansonsten ist das praktisch nicht zu managen und im Fall von LabVIEW (und jeder anderen Applikation, auch solchen in C wo man meist nicht sicher weiss mit welcher C und C++ Runtime die Library gelinkt wurde) hat man nunmal vor allem Probleme.

Zudem, planst Du wirklich um WAVENUMBERS als globales Array irgendwo anzulegen und durch eine weitere Funktion in LabVIEW zu lesen? Das kann ja heiter werden! Ahh nein Du übergibst das Array als return value. Das ist ja genau so schlimm. LabVIEW kann keine Arrays als return value einlesen, da es ja keinerlei Möglichkeit hat zu bestimmen wieviele Elemente es den aus dem Array in ein LabVIEW Array kopieren kann.

Wenn ich das ganze nicht als globales Array anlege, dann ist es doch nach Aufruf und Beendigung der Funktion wieder verschwunden, und kann daher nicht von extern gelesen werden, oder irre ich mich da? Was wäre denn eine bessere Alternative?
Den String ersetze ich mal durch einen char*, vielen Dank für den Hinweis.

(04.07.2013 15:37 )lupus022 schrieb:  Wenn ich das ganze nicht als globales Array anlege, dann ist es doch nach Aufruf und Beendigung der Funktion wieder verschwunden, und kann daher nicht von extern gelesen werden, oder irre ich mich da? Was wäre denn eine bessere Alternative?
Den String ersetze ich mal durch einen char*, vielen Dank für den Hinweis.

Und wenn Du es als globales Array anlegst, wer dealloziert es dann und wann? Höre ich Memory leak? Die bessere Alternative wäre um das Array als Parameter zu übergeben. Das ist auch nicht trivial, denn dynmische Arrays zwischen DLLs zu übergeben ist grundsätzlich schwierig. Entweder übergibst Du C Array Pointer und allozierst die vor dem Aufruf entsprechend oder Du liest Dich ein in das External Code Referenz manual von LabVIEW und erzeugst richtige LabVIEW Arrays in Deinem C Code. Wenn Du dazu die LabVIEW Memory Manager Funktionen verwendest kann Dein C Code Arrays erzeugen und manipulieren die LabVIEW direkt verarbeiten kann und dann kannst Du die dynamisch in Deiner C Funktion anlegen und resizen.

Wenn ich derartige Arrays mit dem LV Memory Manager erstelle, dann habe ich doch immer noch das Problem, dass sie sich auflösen, sobald die Funktion wieder beendet wird, oder nicht (Was damit an der Situation nichts ändern würde)?
Ach ja, noch eine Frage: Wie erstelle ich denn ein 2D-Long-Array in Labview als Datensenke? (Ähnlich wie der Ausgang in angehängtem Bild)
Vielen Dank!

(04.07.2013 16:05 )lupus022 schrieb:  Wenn ich derartige Arrays mit dem LV Memory Manager erstelle, dann habe ich doch immer noch das Problem, dass sie sich auflösen, sobald die Funktion wieder beendet wird, oder nicht (Was damit an der Situation nichts ändern würde)?
Ach ja, noch eine Frage: Wie erstelle ich denn ein 2D-Long-Array in Labview als Datensenke? (Ähnlich wie der Ausgang in angehängtem Bild)
Vielen Dank!

Also was meinst Du hier wieder mit einer Datensenke? Das ist ein Ausgang oder Indicator und das Letzte was ich das nennen würde ist eine Datensenke, denn die Daten verschwinden ja nicht darin, sondern kommen ja eigentlich gerade damit aus dem VI heraus.

Wenn Du unbedingt auf C beharren willst statt alles einfach in LabVIEW zu machen solltest Du Dir ein paar Dinge überlegen. Erstens ist aus Deinem Code ersichtlich dass alle Reihen und Kolonnen jeweils die selbe Länge haben. Es ist deshalb viel sinnvoller die Daten in ein richtiges zweidimensionales Array (das als ein einziger Speicherbereich angelegt ist) abzuspeichern dann als ein Array von Pointern zu Arrays.

Das ergäbe dann so etwas in dieser Art:

Code:

int32 C_function(char *path, int32 *array, int32 rows, int32 cols)
{
     for (long c = 0; c < cols; c++)
     {
         for (long r = 0; r < rows; r++)
         {
               *array++ = something;
         }          
     }
     return noErr;
}

Und ja man muss zuvor wissen wieviele Kolonnen und Reihen das Array hat und man muss dieses auch in LabVIEW vor dem Aufruf in der entsprechenden Grösse initialisieren (Initialize Array). Der Array Parameter wird dann als Array, 2 Dimensional, C Array Data Pointer konfiguriert.

Wenn Du das anders machen willst ist die nächstbessere Weise um in Deinem C Code mit richtigen LabVIEW Arrays zu arbeiten.

Code:

#include "extcode.h"

typedef struct {
    int32 dimSize1;
    int32 dimSize2;
    int32 elms[];
} 2DIntArray, **2DIntArrayHdl;

int C_function(char *path, 2DIntArrayHdl *array)
{
     MgErr err;
     int32 rows, cols;

     // find the number of rows and columns
     rows = x
     cols = y;

     // Resize the LabVIEW array handle
     err = NumericArrayResize(iL, 2, (UHandle)array, rows * cols);
     if (!err)
     {
         int32 *ptr = (**array)->elms;
         for (long c = 0; c < cols; c++)
         {
              for (long r = 0; r < rows; r++)
              {
                  ptr++ = something;
              }          
          }
          (**array)->dimSize1 = rows;
          (**array)->dimSize2 = cols;
     }
     return err;
}

Eventuel musst Du dimSize1 und dimSize2 vertauschen, bin gerade zu faul um das zu testen.
Hier müsste man den Array Parameter als Array, 2 Dimensional, Pointer to Handle konfigurieren.

(09.07.2013 09:01 )rolfk schrieb:  

(04.07.2013 16:05 )lupus022 schrieb:  Wenn ich derartige Arrays mit dem LV Memory Manager erstelle, dann habe ich doch immer noch das Problem, dass sie sich auflösen, sobald die Funktion wieder beendet wird, oder nicht (Was damit an der Situation nichts ändern würde)?
Ach ja, noch eine Frage: Wie erstelle ich denn ein 2D-Long-Array in Labview als Datensenke? (Ähnlich wie der Ausgang in angehängtem Bild)
Vielen Dank!

Also was meinst Du hier wieder mit einer Datensenke? Das ist ein Ausgang oder Indicator und das Letzte was ich das nennen würde ist eine Datensenke, denn die Daten verschwinden ja nicht darin, sondern kommen ja eigentlich gerade damit aus dem VI heraus.

Zumindest zeigt mir das so die LabView-Hilfe an, dass ich eine "Datenquelle" benötige und eine "Datensenke". Aber ich denke, das Problem konnte ich lösen.
Den Code schau ich mir mal an, aber bin noch am Überlegen, ob es sich noch lohnt, diesen jetzt umzusetzen, oder erst später, da die aktuelle Version halbwegs funktioniert (Stichwort: Speicherleck), und ich meine BA demnächst abgeben muss.
Vielen Dank für die Hilfe!

So, ich bin gerade wieder am Code dran, und habe folgende Frage:
Ich habe ein simples Array von Pointern auf Pointer-Arrays (int **array), das ich dynamisch erstellen und löschen kann.
Dieses wird mit folgendem Code erstellt:

Code:

int ** testptr = NULL;
int ** gen_multiarr(int row, int col)
{
    testptr = new int*[row];
    for(int i = 0; i < row; i++)
        testptr[i] = new int[col];
    for(int i = 0; i < row; i++)
        for(int j = 0; j < col; j++)
            testptr[i][j] = i+j;
    return testptr;
}

void del_multiarr(int ** ptr)
{
    delete[] *ptr;
    delete[] ptr;
};

Wenn ich diese Funktion dann mit Labview aufrufe, und das erste Mal dereferenziere (mit GetValueByPointer.xnode), erhalte ich ein 1D-Array mit [row]-Pointern, was ja logisch ist. Wenn ich diese Pointer dann erneut [col]-mal dereferenziere (mit GetValueByPointer.xnode), erhalte ich als Werte jedoch wieder irgendwelchen hohen Zahlen, und nicht die Werte, die ich in das Array hineingeschrieben habe. Das VI dazu ist im Anhang.
Wieso?
Vielen Dank!

Unter der Annahme, dass der Datentyp int bei deinem C-System int32 ist und du unter einem 32bit-Betriebssystem arbeitest:
Wieso holst du die Adressen als U64 ab?
Wieso holst du die Werte als U64 ab?

Kannst du vielleicht die TestDLL.dll zu deinem letzten VI ebenfalls bereit stellen?

EDIT: Vielleicht stimmt auch die ByteOrder des abgeholten Wertes nicht. Das Resultat schon im HEX-Code angeschaut?

Gruß, Jens