Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Ergebnis 1 bis 10 von 10

Thema: PP45 USB Schnittstelle zum speichern von Daten

  1. #1
    Registriert seit
    25.09.2011
    Beiträge
    53
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Ich benötige etwas Hilfe für das einbinden eines USB Speichergerätes in Automation Studio. Das Touch Panel inkl. CPU (Power Panel 45 monochrom) hat 2 USB Schnittstellen, für Tastatur, USB Stick und/oder Drucker.

    Den USB (Sandisk Cruzer) habe ich an den USB Port 2 angeschlossen und in der Phy. Configuration bereits eingerichtet.

    Was möchte ich nun machen? Ich möchte gerne für den Prototypen entsprechende Werte der Variablen mitschreiben (vorallem PT100-Werte), sodass ich diese später am PC auswerten lassen kann.
    Zitieren Zitieren PP45 USB Schnittstelle zum speichern von Daten  

  2. #2
    Registriert seit
    13.09.2010
    Beiträge
    115
    Danke
    0
    Erhielt 18 Danke für 18 Beiträge

    Standard

    Dann mach noch ein DevLink() auf die Schnittstelle und dann nix wie rauf auf den Stick.
    Du kannst Dir die Daten aber auch bequem per FTP holen.

  3. #3
    Registriert seit
    22.10.2012
    Beiträge
    40
    Danke
    8
    Erhielt 7 Danke für 7 Beiträge

    Standard

    Beim PP45 bin ich mir nicht ganz so sicher aber im Allgemeinen kann man an einer B&R-Steuerung in den File-Devices auch feste Devices anlegen.
    Da spart man sich den DevLink und DevUnlink. Es gibt dann die FileIO-Bibliothek um Dateien anzulegen, zu Beschreiben etc.
    Es gibt in der Hilfe auch ein Beispiel welche alle notwendigen Funktionen beinhaltet. Man muss nur beachten, dass dieses Beispiel eine Datei anlegt,
    etwas schreibt, wieder liest und dann die Datei gleich wieder löscht. Hatte mich zuerst gewundert warum nie eine Datei da war.
    Wenn man mit dem Offset beim Filewrite arbeitet, kann man neue Daten an eine Datei einfach immer nur anhängen.
    Die File Devices sind übrigens im Configuration View in der sysconf.br zu finden.

    Grüße

  4. #4
    Registriert seit
    25.09.2011
    Beiträge
    53
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Mit dem Devlink komm ich mit allen 3 Beispielen nicht klar. Die Sache mit dem FileIO hört sich einfacher an, werde die Steuerung gleich ebend wieder anschließen und schauen, ob es machbar ist.

    In der sysconf.br bin ich, wie bestimme ich den Pfad? Bzw. wie sollte er heißen?
    Wäre der Pfad so richtig


    /DEVICE=IF4.ST1
    Habe es mit folgenden Beispiel aus der Hilfe versucht: Beispiel 1
    AsUSB - Beispiel 1 in ANSI C

    Beispielbeschreibung

    Unterstützung eines SanDisk USB Sticks an einem beliebigen USB Port




    Code:
    /* //////////////////////////////////////////////////////////////////// INCLUDES
    ////////////////////////////////////////////////////////////////// */
    #include <bur/plc.h>
    #include <bur/plctypes.h>
    #define _REPLACE_CONST 
    #include <asusb.h>
    #include <fileio.h>
    #include <string.h>
    /* //////////////////////////////////////////////////////////////////
    // DEFINES
    ////////////////////////////////////////////////////////////////// */
    #define OK 0
    #define FALSE 0
    #define TRUE 1
    #define MAXUSBDEVICES 32
    #define SANDISK_VENDOR_ID 0x0781
    #define SANDISK_PRODUCT_ID 0x7105
    #define SANDISK_BCD 0x1033
    #define USB_GETNODELIST 1
    #define USB_SEARCHDEVICE 2
    #define USB_DEVICELINK 3
    #define USB_DEVICEUNLINK 4
    #define USB_FILEACCESS 5
    #define MSDEVICE "MS_DEVICE"
    #define PARAMDEVICE "/DEVICE="
    /* //////////////////////////////////////////////////////////////////
    // DECLARATION
    ////////////////////////////////////////////////////////////////// */
    _LOCAL UsbNodeListGet_typ UsbNodeListGetFub;
    _LOCAL UsbNodeGet_typ UsbNodeGetFub;
    _LOCAL usbNode_typ usbDevice;
    _LOCAL DevLink_typ DevLinkFub;
    _LOCAL DevUnlink_typ DevUnlinkFub;
    _LOCAL DirInfo_typ DirInfoUsbDev;
    _LOCAL BOOL enable,deviceLinked;
    _LOCAL UINT status;
    _LOCAL UDINT usbAttachDetachCount;
    _LOCAL UINT usbAction,usbNodeIx;
    _LOCAL UDINT usbNodeList[MAXUSBDEVICES];
    _LOCAL UDINT usbNodeId;
    _LOCAL char szDevParamName[asusb_DEVICENAMELENGTH+sizeof(PARAMDEVICE)];
    /* //////////////////////////////////////////////////////////////////
    // INIT UP
    ////////////////////////////////////////////////////////////////// */
    _INIT void init(void)
    {
        usbAttachDetachCount = 0;
        usbNodeIx = 0;
        /* usbAction = USB_GETNODELIST; */
    }
    /* //////////////////////////////////////////////////////////////////
    // CYCLIC TASK
    ////////////////////////////////////////////////////////////////// */
    _CYCLIC void cyclic(void)
    {
        switch (usbAction)
        {
            case USB_GETNODELIST:
                UsbNodeListGetFub.enable = 1;
                UsbNodeListGetFub.pBuffer = (UDINT)&usbNodeList;
                UsbNodeListGetFub.bufferSize = sizeof(usbNodeList);
                UsbNodeListGetFub.filterInterfaceClass = asusb_CLASS_MASS_STORAGE;
                UsbNodeListGetFub.filterInterfaceSubClass = asusb_SUBCLASS_SCSI_COMMAND_SET;
                UsbNodeListGet(&UsbNodeListGetFub);
                if (UsbNodeListGetFub.status == OK && UsbNodeListGetFub.listNodes)
                {
                    /* USB Device Attach or detach */
                    usbAction = USB_SEARCHDEVICE;
                    usbNodeIx = 0;
                    usbAttachDetachCount = UsbNodeListGetFub.attachDetachCount;
                }
                else if (UsbNodeListGetFub.status == asusbERR_BUFSIZE
                         || UsbNodeListGetFub.status == asusbERR_NULLPOINTER)
                {
                    /* Error Handling */
                }
                break;
            case USB_SEARCHDEVICE:
                UsbNodeGetFub.enable = 1;
                UsbNodeGetFub.nodeId = usbNodeList[usbNodeIx];
                UsbNodeGetFub.pBuffer = (UDINT)&usbDevice;
                UsbNodeGetFub.bufferSize = sizeof(usbDevice);
                UsbNodeGet(&UsbNodeGetFub);
                if (UsbNodeGetFub.status == OK )
                {
                    /* SanDisk ? */
                    if (usbDevice.vendorId == SANDISK_VENDOR_ID 
                        && usbDevice.productId == SANDISK_PRODUCT_ID
                        && usbDevice.bcdDevice == SANDISK_BCD)
                    {
                        /* SanDisk found */
                        strcpy(szDevParamName,PARAMDEVICE);
                        strcat (szDevParamName,usbDevice.ifName);
                        usbNodeId = usbNodeList[usbNodeIx];
                        usbAction = USB_DEVICELINK;
                    }
                    else 
                    {
                        usbNodeIx++;
                        if (usbNodeIx >= UsbNodeListGetFub.allNodes) 
                        {
                            /* USB Device not found */
                            usbAction = USB_GETNODELIST;
                        }
                    }
                }
                else if (UsbNodeGetFub.status == asusbERR_USB_NOTFOUND)
                {
                    /* USB Device not found */
                    usbAction = USB_GETNODELIST;
                }
                else if (UsbNodeGetFub.status == asusbERR_BUFSIZE
                         || UsbNodeGetFub.status == asusbERR_NULLPOINTER)
                {
                    /* Error Handling */
                }
                break;
            case USB_DEVICELINK:
                DevLinkFub.enable = 1;
                DevLinkFub.pDevice = (UDINT)MSDEVICE;
                DevLinkFub.pParam = (UDINT)szDevParamName;
                DevLink(&DevLinkFub);
                if (DevLinkFub.status == OK)
                { 
                    usbAction = USB_FILEACCESS;
                    deviceLinked = TRUE;
                }
                break;
            case USB_DEVICEUNLINK:
                DevUnlinkFub.enable = 1;
                DevUnlinkFub.handle = DevLinkFub.handle;
                DevUnlink(&DevUnlinkFub);
                if (DevUnlinkFub.status == OK)
                { 
                    usbAction = USB_GETNODELIST;
                    deviceLinked = FALSE;
                }
                break;
            case USB_FILEACCESS:
                /* Check USB Device */
                UsbNodeGetFub.enable = 1;
                UsbNodeGetFub.nodeId = usbNodeId;
                UsbNodeGetFub.pBuffer = (UDINT)&usbDevice;
                UsbNodeGetFub.bufferSize = sizeof(usbDevice);
                UsbNodeGet(&UsbNodeGetFub);
                if (UsbNodeGetFub.status == OK )
                {
                    /* File Access */
                    DirInfoUsbDev.enable = 1;
                    DirInfoUsbDev.pDevice = (UDINT)MSDEVICE;
                    DirInfoUsbDev.pPath = 0;
                    DirInfo(&DirInfoUsbDev);
                }
                else if (UsbNodeGetFub.status == asusbERR_USB_NOTFOUND)
                {
                    /* USB Device detached */
                    usbAction = USB_DEVICEUNLINK;
                }
            default:
            break; 
        }
    }
    Der haut mir den Compiler entsprechend so um die Ohren. Im Einsatz ist ein Sandisk Cruzer. (nicht von B+R bezogen). Das Mapping hab ich auf IF.ST1 gelegt, wo der USB Stick steckt.
    Code:
    [...]C:/Users/sschultewolter/Desktop/Daro/Automation Studio/daro_2013_04_22/Temp/Objects/Config1/PLC1/NewProgra1.br : Error 6024: Unknown PV usbNodeId
    Building configuration object "iomap" ...
    No relevant changes.
    Generating transfer list...
    Error 430: Unable to open file C:\Users\sschultewolter\Desktop\Daro\Automation Studio\daro_2013_04_22\Binaries\Config1\PLC1\NewProgra1.br
    Build: 2 error(s), 0 warning(s)

  5. #5
    Registriert seit
    22.10.2012
    Beiträge
    40
    Danke
    8
    Erhielt 7 Danke für 7 Beiträge

    Standard

    Hallo sschultewolter,

    das mit der AsUSB-Bibliothek würde ich erst mal stecken lassen.
    Die braucht man eigentlich nur, wenn man auf spezielle USB-Geräte zugeifen will, wie z.B. Identifikationssystem o.ä.
    USB-Sticks brauchen das normalerweise nicht.
    Beim USB-Stick übrigens nicht mehr als 4GB verwenden, ich bin mir wegen des Dateisystems nicht sicher ob das sonst klappt.
    Zumindes die FileIO-Funktion, die für die Berechnung des freien und belegten Speichers zuständig ist rechnet mit UDINTs und da ist bei 4GB Schluß.
    So, zur FileIO.
    Gib in der Hilfe einfach mal FileIO im Suchen-Fenster ein. Der zweite gefundene Punkt führt direkt zu den Beispielen.
    Es gibt da ganze Beispiel-Programme (z.B. LibFileIO1_ST) aber unten unter der jeweiligen Programmiersprache finden sich noch Beispiele
    zu den einzelnen FileIO-Funktionen. (Ist fast immer das gleiche.)
    Nimm einfach mal das von FileWrite() und schau was da so alles kommt.
    Zu den File devices:
    Ich habe gerade kein AS zur Hand um Nachzusehen. Aber du brauchst einen Namen für dein device z.b. Herbert und den Pfad.
    Der Pfad ist für die CF-Karte einfach C:\ oder D:\Tralala\ ...
    Wobei dann das Verzeichnis Tralala auf der D-Partition natürlich existieren muss.
    Bei den USB's bin ich mir nicht ganz sicher, sollte aber in der Hilfe zu finden sein.
    Müsste aber ungefähr so heißen wie: IF6.ST1 so wie der USB-Steckplatz im physical View halt benannt ist.

    Gruß

  6. #6
    Registriert seit
    12.10.2012
    Beiträge
    42
    Danke
    1
    Erhielt 15 Danke für 13 Beiträge

    Standard

    Hallo sschultewolter,

    hier mal ein File-Device Beispiel für ein USB Stick, das ist vom PP420, sollte aber bei deinem ähnlich sein.

    FileDevice.JPG
    Zitieren Zitieren File-Device  

  7. #7
    Registriert seit
    06.03.2008
    Ort
    Herisau
    Beiträge
    44
    Danke
    8
    Erhielt 2 Danke für 2 Beiträge

    Standard

    Zitat Zitat von sschultewolter Beitrag anzeigen
    Mit dem Devlink komm ich mit allen 3 Beispielen nicht klar. Die Sache mit dem FileIO hört sich einfacher an, werde die Steuerung gleich ebend wieder anschließen und schauen, ob es machbar ist.

    In der sysconf.br bin ich, wie bestimme ich den Pfad? Bzw. wie sollte er heißen?
    Wäre der Pfad so richtig


    /DEVICE=IF4.ST1
    Habe es mit folgenden Beispiel aus der Hilfe versucht: Beispiel 1
    AsUSB - Beispiel 1 in ANSI C

    Beispielbeschreibung

    Unterstützung eines SanDisk USB Sticks an einem beliebigen USB Port




    Code:
    /* //////////////////////////////////////////////////////////////////// INCLUDES
    ////////////////////////////////////////////////////////////////// */
    #include <bur/plc.h>
    #include <bur/plctypes.h>
    #define _REPLACE_CONST 
    #include <asusb.h>
    #include <fileio.h>
    #include <string.h>
    /* //////////////////////////////////////////////////////////////////
    // DEFINES
    ////////////////////////////////////////////////////////////////// */
    #define OK 0
    #define FALSE 0
    #define TRUE 1
    #define MAXUSBDEVICES 32
    #define SANDISK_VENDOR_ID 0x0781
    #define SANDISK_PRODUCT_ID 0x7105
    #define SANDISK_BCD 0x1033
    #define USB_GETNODELIST 1
    #define USB_SEARCHDEVICE 2
    #define USB_DEVICELINK 3
    #define USB_DEVICEUNLINK 4
    #define USB_FILEACCESS 5
    #define MSDEVICE "MS_DEVICE"
    #define PARAMDEVICE "/DEVICE="
    /* //////////////////////////////////////////////////////////////////
    // DECLARATION
    ////////////////////////////////////////////////////////////////// */
    _LOCAL UsbNodeListGet_typ UsbNodeListGetFub;
    _LOCAL UsbNodeGet_typ UsbNodeGetFub;
    _LOCAL usbNode_typ usbDevice;
    _LOCAL DevLink_typ DevLinkFub;
    _LOCAL DevUnlink_typ DevUnlinkFub;
    _LOCAL DirInfo_typ DirInfoUsbDev;
    _LOCAL BOOL enable,deviceLinked;
    _LOCAL UINT status;
    _LOCAL UDINT usbAttachDetachCount;
    _LOCAL UINT usbAction,usbNodeIx;
    _LOCAL UDINT usbNodeList[MAXUSBDEVICES];
    _LOCAL UDINT usbNodeId;
    _LOCAL char szDevParamName[asusb_DEVICENAMELENGTH+sizeof(PARAMDEVICE)];
    /* //////////////////////////////////////////////////////////////////
    // INIT UP
    ////////////////////////////////////////////////////////////////// */
    _INIT void init(void)
    {
        usbAttachDetachCount = 0;
        usbNodeIx = 0;
        /* usbAction = USB_GETNODELIST; */
    }
    /* //////////////////////////////////////////////////////////////////
    // CYCLIC TASK
    ////////////////////////////////////////////////////////////////// */
    _CYCLIC void cyclic(void)
    {
        switch (usbAction)
        {
            case USB_GETNODELIST:
                UsbNodeListGetFub.enable = 1;
                UsbNodeListGetFub.pBuffer = (UDINT)&usbNodeList;
                UsbNodeListGetFub.bufferSize = sizeof(usbNodeList);
                UsbNodeListGetFub.filterInterfaceClass = asusb_CLASS_MASS_STORAGE;
                UsbNodeListGetFub.filterInterfaceSubClass = asusb_SUBCLASS_SCSI_COMMAND_SET;
                UsbNodeListGet(&UsbNodeListGetFub);
                if (UsbNodeListGetFub.status == OK && UsbNodeListGetFub.listNodes)
                {
                    /* USB Device Attach or detach */
                    usbAction = USB_SEARCHDEVICE;
                    usbNodeIx = 0;
                    usbAttachDetachCount = UsbNodeListGetFub.attachDetachCount;
                }
                else if (UsbNodeListGetFub.status == asusbERR_BUFSIZE
                         || UsbNodeListGetFub.status == asusbERR_NULLPOINTER)
                {
                    /* Error Handling */
                }
                break;
            case USB_SEARCHDEVICE:
                UsbNodeGetFub.enable = 1;
                UsbNodeGetFub.nodeId = usbNodeList[usbNodeIx];
                UsbNodeGetFub.pBuffer = (UDINT)&usbDevice;
                UsbNodeGetFub.bufferSize = sizeof(usbDevice);
                UsbNodeGet(&UsbNodeGetFub);
                if (UsbNodeGetFub.status == OK )
                {
                    /* SanDisk ? */
                    if (usbDevice.vendorId == SANDISK_VENDOR_ID 
                        && usbDevice.productId == SANDISK_PRODUCT_ID
                        && usbDevice.bcdDevice == SANDISK_BCD)
                    {
                        /* SanDisk found */
                        strcpy(szDevParamName,PARAMDEVICE);
                        strcat (szDevParamName,usbDevice.ifName);
                        usbNodeId = usbNodeList[usbNodeIx];
                        usbAction = USB_DEVICELINK;
                    }
                    else 
                    {
                        usbNodeIx++;
                        if (usbNodeIx >= UsbNodeListGetFub.allNodes) 
                        {
                            /* USB Device not found */
                            usbAction = USB_GETNODELIST;
                        }
                    }
                }
                else if (UsbNodeGetFub.status == asusbERR_USB_NOTFOUND)
                {
                    /* USB Device not found */
                    usbAction = USB_GETNODELIST;
                }
                else if (UsbNodeGetFub.status == asusbERR_BUFSIZE
                         || UsbNodeGetFub.status == asusbERR_NULLPOINTER)
                {
                    /* Error Handling */
                }
                break;
            case USB_DEVICELINK:
                DevLinkFub.enable = 1;
                DevLinkFub.pDevice = (UDINT)MSDEVICE;
                DevLinkFub.pParam = (UDINT)szDevParamName;
                DevLink(&DevLinkFub);
                if (DevLinkFub.status == OK)
                { 
                    usbAction = USB_FILEACCESS;
                    deviceLinked = TRUE;
                }
                break;
            case USB_DEVICEUNLINK:
                DevUnlinkFub.enable = 1;
                DevUnlinkFub.handle = DevLinkFub.handle;
                DevUnlink(&DevUnlinkFub);
                if (DevUnlinkFub.status == OK)
                { 
                    usbAction = USB_GETNODELIST;
                    deviceLinked = FALSE;
                }
                break;
            case USB_FILEACCESS:
                /* Check USB Device */
                UsbNodeGetFub.enable = 1;
                UsbNodeGetFub.nodeId = usbNodeId;
                UsbNodeGetFub.pBuffer = (UDINT)&usbDevice;
                UsbNodeGetFub.bufferSize = sizeof(usbDevice);
                UsbNodeGet(&UsbNodeGetFub);
                if (UsbNodeGetFub.status == OK )
                {
                    /* File Access */
                    DirInfoUsbDev.enable = 1;
                    DirInfoUsbDev.pDevice = (UDINT)MSDEVICE;
                    DirInfoUsbDev.pPath = 0;
                    DirInfo(&DirInfoUsbDev);
                }
                else if (UsbNodeGetFub.status == asusbERR_USB_NOTFOUND)
                {
                    /* USB Device detached */
                    usbAction = USB_DEVICEUNLINK;
                }
            default:
            break; 
        }
    }
    Der haut mir den Compiler entsprechend so um die Ohren. Im Einsatz ist ein Sandisk Cruzer. (nicht von B+R bezogen). Das Mapping hab ich auf IF.ST1 gelegt, wo der USB Stick steckt.
    Code:
    [...]C:/Users/sschultewolter/Desktop/Daro/Automation Studio/daro_2013_04_22/Temp/Objects/Config1/PLC1/NewProgra1.br : Error 6024: Unknown PV usbNodeId
    Building configuration object "iomap" ...
    No relevant changes.
    Generating transfer list...
    Error 430: Unable to open file C:\Users\sschultewolter\Desktop\Daro\Automation Studio\daro_2013_04_22\Binaries\Config1\PLC1\NewProgra1.br
    Build: 2 error(s), 0 warning(s)
    Hallo sschultewolter,

    1. Grundsätzlich unterstützt die FileIO Library nur FAT-Dateisystem (Standard bei USB-Sticks). Überprüf doch mal ob der Stick auch so formatiert ist.
    2. Ich kenne zwar das PP45 nicht aber bei den APC's gibt es da einiges zu beachten. Früher (APC620) waren die USB Anschlüsse Steckplatz-Orientiert und konnten entsprechend Offline als FileDevice eingerichtet werden. Neu (APC510) werden die USB Anchlüsse dynamisch zugewiesen (wie bei Windows). Der Pfad um einen FileDevice auf den USB-Stick einzurichten muss dann mit der AsUSB-Library bezogen werden und hat nichts mehr mit dem Steckplatz in der Physical View zu tun. Die Zuweisung scheint aber immer nach dem gleichen Schema zu erfolgen. Der erste gesteckte Device erhält vom System den Pfad /bd0, der zweite /bd5, der dritte /bd10 und so weiter... Ich habe die File-Devices entsprechend eingerichtet und konnte anschliessend direkt mit der FileIO darauf zugreifen
    27-04-2013 13-58-16.png

    Ob sich das beim PP45 gleich verhält kann ich nicht sagen. Poste doch einmal deine Pysical View dort sollte der Steckplatz eigentlich ersichtlich sein.

    MfG

  8. #8
    Registriert seit
    25.09.2011
    Beiträge
    53
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hallo,

    ich danke schon mal allen dir mit entgegen kamen. Ich habe nach euren Vorschlägen nun wie folgt verfahren.


    1) Bibiothek "FileIO" dem Programm hinzugefügt.

    2) Physical View im IF4 Slot ein Massenspeicher hinzugefügt (usbms01-> IF4.ST1.

    3) In Configuration View die sysconf.br öffnen. Dort habe ich unter File Devices den USB angemeldet mit Devicename "HARDDISK" und dem Pfad "IF4.ST1".

    4) Bei den ersten Test hatte ich einen 16GB Stick genutzt, die wollte aber nicht, vermutlich aufgrund der Dateigrößenbeschränkungen. Habe nun einen alten Stick mit 4GB noch gefunden. Fat32 formatiert und das Gerät "HARDDISK" bennant.

    5) Danach das Beispiel in ein neues Programm gepackt. Den Schritt zum Löschen habe ich auskommentiert. Nach ein paar Tests nun das erleichterne Ergebnis. Die Testfile wurde auf dem USB Stick erstellt.

    Werde nun ein bisschen weiter rumtesten, dass ich später meine Werte dort hineinschreiben kann.

  9. #9
    Registriert seit
    25.09.2011
    Beiträge
    53
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Habe mich mal an der Beispielsdatei gehalten und diese ensprechend abgewandelt. Habe nun 100 Werte zur Verfügung. Alle nicht benutzen Werte im Array bleiben auf 0. Nun habe ich ein Problem mit der Datenausgabe. Kann die TestFile.txt am PC auslesen. Jedoch erscheint der Wert nur im Ascii Code. Kann ich dieses in Automation Studio umstellen? Des weiter würde ich gerne die Daten getrennt haben (";", "_", o.ä.).

    Das zweite was nicht schlecht wäre, wenn ich sagen könnte, dass der mir alle z.B. alle 10 Sekunden die neuen Werte in der nächsten Zeile reinschreibt. Somit habe ich später eine Möglichkeit, die Werte in Excel/Calc in einem Trend darzustellen.

    Ich habe Schritt 6 abgeändert, denn ich möchte es nicht löschen. Hier setze ich die Variable zeit immer + 10s. Die Ausabe später wie folgt aussehen.



    Code:
    var1;var2;var3;var4
    Code:
    0;10.0;11.0;12.0;13.0
    10;10.8;12.0;13.1;14.1;15.9

    Code:
    PROGRAM _INIT	
    (* Initialize variables *)
    bOK             := FALSE;
    byStep          := 1;
    byErrorLevel    := 0;
    strDevice       := 'HD2';
    strFile         := 'TestFile.txt';
    (* Initialize read and write data *)
    test1 := 10.0;
    test2 := 11.0;
    test3 := 12.0;
    test4 := 13.0;
    zeit := 0;
    
    
    byWriteData[0] := zeit;
    byWriteData[1] := test1;
    byWriteData[2] := test2;
    byWriteData[3] := test3;
    byWriteData[4] := test4;
    byWriteData[5] := test5;
    END_PROGRAM
    
    
    
    
    PROGRAM _CYCLIC
    CASE byStep OF
            0: (**** Error step ****)
                    bOK := FALSE;
            1: (**** Try to open existing file ****)
                    (* Initialize file open structrue *)
                    
    				FOpen.enable    := 1;
                    FOpen.pDevice   := ADR(strDevice);
                    FOpen.pFile     := ADR(strFile);
                    FOpen.mode      := FILE_RW;  (* Read and write access *)
                    (* Call FUB *)
                    FOpen();
                    (* Get FUB output information *)
                    dwIdent := FOpen.ident;
                    wStatus := FOpen.status;
                    (* Verify status (20708 -> File doesn't exist) *)
                    IF (wStatus = 20708) THEN
                            byStep := 2;
                    ELSE
                            IF (wStatus = 0) THEN
                                    byStep := 3;
                            ELSE
                                    IF (wStatus <> 65535) THEN
                                            byErrorLevel    := 1;
                                            byStep          := 0;
                                            IF (wStatus = 20799) THEN
                                                    wError := FileIoGetSysError();
                                            END_IF
                                    END_IF
                            END_IF
                    END_IF
            2: (**** Create file ****)
                    (* Initialize file create structure *)
                    FCreate.enable  := 1;
                    FCreate.pDevice := ADR(strDevice);
                    FCreate.pFile   := ADR(strFile);
                    (* Call FUB *)
                    FCreate();
                    (* Get output information of FUB *)
                    dwIdent := FCreate.ident;
                    wStatus := FCreate.status;
                    (* Verify status *)
                    IF (wStatus = 0) THEN
                            byStep := 3;
                    ELSE
                            IF (wStatus <> 65535) THEN
                                    byErrorLevel    := 2;
                                    byStep          := 0;
                                    IF (wStatus = 20799) THEN
                                            wError := FileIoGetSysError();
                                    END_IF
                            END_IF
                    END_IF
            3: (**** Write data to file ****)
                    (* Initialize file write structure *)
                    FWrite.enable   := 1;
                    FWrite.ident    := dwIdent;
                    FWrite.offset   := 0;
                    FWrite.pSrc     := ADR(byWriteData[0]);
                    FWrite.len      := SIZEOF(byWriteData);
                    (* Call FUB *)
                    FWrite();
                    (* Get status *)
                    wStatus := FWrite.status;
                    (* Verify status *)
                    IF (wStatus = 0) THEN
                            byStep := 4;
                    ELSE
                            IF (wStatus <> 65535) THEN
                                    byErrorLevel    := 3;
                                    byStep          := 0;
                                    IF (wStatus = 20799) THEN
                                            wError := FileIoGetSysError();
                                    END_IF
                            END_IF
                    END_IF
            4: (**** Read data from file ****)
                    (* Initialize file read structure *)
                    FRead.enable    := 1;
                    FRead.ident     := dwIdent;
                    FRead.offset    := 0;
                    FRead.pDest     := ADR(byReadData[0]);
                    FRead.len       := SIZEOF(byReadData);
                    (* Call FUB *)
                    FRead();
                    (* Get status *)
                    wStatus := FRead.status;
                    (* Verify status *)
                    IF (wStatus = 0) THEN
                            byStep := 5;
                    ELSE
                            IF (wStatus <> 65535) THEN
                                    byErrorLevel    := 4;
                                    byStep          := 0;
                                    IF (wStatus = 20799) THEN
                                            wError := FileIoGetSysError();
                                    END_IF
                            END_IF
                    END_IF
            5: (**** Close file ****)
                    (* Initialize file close structure *)
                    FClose.enable   := 1;
                    FClose.ident    := dwIdent;
                    (* Call FUB *)
                    FClose();
                    (* Get status *)
                    wStatus := FClose.status;
                    (* Verify status *)
                    IF (wStatus = 0) THEN
                            byStep := 6;
                    ELSE
                            IF (wStatus <> 65535) THEN
                                    byErrorLevel    := 5;
                                    byStep          := 0;
                                    IF (wStatus = 20799) THEN
                                            wError := FileIoGetSysError();
                                    END_IF
                            END_IF
                    END_IF
                    
    		6:		input := 1;
    		(* cyclic program *)(* call function block *)TON_01( IN:=input, PT:=T#10s );
    				(* assign results to variables *)output := TON_01.Q;elapsedTime := TON_01.ET;
    				IF output = 1 THEN
    					byStep := 1;
    					zeit := zeit + 10;
    					input := 0;
    				END_IF;
    				
    				
    				
    //        6: (**** Delete file ****)
    //                (* Initialize file delete structure *)
    //                FDelete.enable  := 1;
    //                FDelete.pDevice := ADR(strDevice);
    //                FDelete.pName   := ADR(strFile);
    //                (* Call FUB *)
    //                FDelete();
    //                (* Get status *)
    //                wStatus := FDelete.status;
    //                (* Verify status *)
    //                IF (wStatus = 0) THEN
    //                        bOK     := TRUE;
    //                        byStep  := 7;
    //                ELSE
    //                        IF (wStatus <> 65535) THEN
    //                                byErrorLevel    := 6;
    //                                byStep          := 0;
    //                                IF (wStatus = 20799) THEN
    //                                        wError := FileIoGetSysError();
    //                                END_IF
    //                        END_IF
    //                END_IF
    END_CASE
    
    
    
    
    
    
    END_PROGRAM
    
    
    PROGRAM _EXIT
    
    
    
    
    (* TODO : Add your code here *)
    
    
    
    
    END_PROGRAM

  10. #10
    Registriert seit
    17.10.2007
    Beiträge
    263
    Danke
    5
    Erhielt 52 Danke für 48 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo schultewolter,

    grundsätzlich muss du den Dateiinhalt selbst zusammenstellen und auch formatieren.
    Einfach ein Array an die Funktion 'FileWrite' übergeben (Zeile 'FWrite.pSrc := ADR(byWriteData[0]);' in deinem Code) reicht da nicht.


    Ich würde in deinem Fall den Dateiinhalt in einer Schleife zusammenbauen (ohne Gewähr, auf die Schnelle zusammengeschrieben):

    contentItem := REAL_TO_STRING(byReadData[0]);
    fileContent := contentItem;
    for i := 1 to 4
    fileContent := CONCAT(fileContent, ';');
    contentItem := REAL_TO_STRING(byReadData[i]);
    fileContent := CONCAT(fileContent, contentItem);
    end_for

    Die Variablen 'contentItem' und 'fileContent' sind dabei vom Typ String und werden dann an die FileWrite-Funktion übergeben.


    Die neuen Werte kannst du ganz einfach an die bestehende Datei anhängen, wenn du beim Öffnen der Datei die aktuelle Dateigröße abfragst und diesen Wert der FileWrite-Funktion als Offset übergibst. Wichtig dabei: der Parameter 'len' muss dann 'Offset + Länge der neuen Daten' sein.


    Gruß, Fred

Ähnliche Themen

  1. Antworten: 5
    Letzter Beitrag: 10.02.2016, 23:50
  2. Speichern von Daten in SCL
    Von Karlson im Forum Simatic
    Antworten: 36
    Letzter Beitrag: 31.07.2012, 12:56
  3. HEX-Daten von USB in DB
    Von tommy2547 im Forum Simatic
    Antworten: 1
    Letzter Beitrag: 16.06.2012, 14:14
  4. Antworten: 15
    Letzter Beitrag: 26.12.2008, 11:05
  5. OPC-Daten (von Allen Bradley) am PC in ASCII-File speichern
    Von ANo im Forum Sonstige Steuerungen
    Antworten: 2
    Letzter Beitrag: 25.05.2005, 09:37

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •