PP45 USB Schnittstelle zum speichern von Daten

sschultewolter

Level-1
Beiträge
54
Reaktionspunkte
0
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.
 
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.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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
 
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
[h=1]AsUSB - Beispiel 1 in ANSI C[/h][h=2]Beispielbeschreibung[/h]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,

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ß
 
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
 
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.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
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
 
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);
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
 
Zurück
Oben