|
|
@@ -0,0 +1,590 @@
|
|
|
+/*=============================================================================|
|
|
|
+| PROJECT SNAP7 1.4.0 |
|
|
|
+|==============================================================================|
|
|
|
+| Copyright (C) 2013, 2014 Davide Nardella |
|
|
|
+| All rights reserved. |
|
|
|
+|==============================================================================|
|
|
|
+| SNAP7 is free software: you can redistribute it and/or modify |
|
|
|
+| it under the terms of the Lesser GNU General Public License as published by |
|
|
|
+| the Free Software Foundation, either version 3 of the License, or |
|
|
|
+| (at your option) any later version. |
|
|
|
+| |
|
|
|
+| It means that you can distribute your commercial software linked with |
|
|
|
+| SNAP7 without the requirement to distribute the source code of your |
|
|
|
+| application and without the requirement that your application be itself |
|
|
|
+| distributed under LGPL. |
|
|
|
+| |
|
|
|
+| SNAP7 is distributed in the hope that it will be useful, |
|
|
|
+| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
|
+| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
|
+| Lesser GNU General Public License for more details. |
|
|
|
+| |
|
|
|
+| You should have received a copy of the GNU General Public License and a |
|
|
|
+| copy of Lesser GNU General Public License along with Snap7. |
|
|
|
+| If not, see http://www.gnu.org/licenses/ |
|
|
|
+|==============================================================================|
|
|
|
+| |
|
|
|
+| Client Example |
|
|
|
+| |
|
|
|
+|=============================================================================*/
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <ctype.h>
|
|
|
+#include <unistd.h>
|
|
|
+#include <string.h>
|
|
|
+#include "snap7.h"
|
|
|
+
|
|
|
+
|
|
|
+#ifdef OS_WINDOWS
|
|
|
+# define WIN32_LEAN_AND_MEAN
|
|
|
+# include <windows.h>
|
|
|
+#endif
|
|
|
+ S7Object Client;
|
|
|
+ unsigned char Buffer[65536]; // 64 K buffer
|
|
|
+ int SampleDBNum = 1000;
|
|
|
+
|
|
|
+ char *Address; // PLC IP Address
|
|
|
+ int Rack=0,Slot=2; // Default Rack and Slot
|
|
|
+
|
|
|
+ int ok = 0; // Number of test pass
|
|
|
+ int ko = 0; // Number of test failure
|
|
|
+
|
|
|
+ int JobDone=false;
|
|
|
+ int JobResult=0;
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Async completion callback
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// This is a simply text demo, we use callback only to set an internal flag...
|
|
|
+void S7API CliCompletion(void *usrPtr, int opCode, int opResult)
|
|
|
+{
|
|
|
+ JobResult=opResult;
|
|
|
+ JobDone = true;
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// SysSleep (copied from snap_sysutils.cpp) multiplatform millisec sleep
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void SysSleep(longword Delay_ms)
|
|
|
+{
|
|
|
+#ifdef OS_WINDOWS
|
|
|
+ Sleep(Delay_ms);
|
|
|
+#else
|
|
|
+ struct timespec ts;
|
|
|
+ ts.tv_sec = (time_t)(Delay_ms / 1000);
|
|
|
+ ts.tv_nsec =(long)((Delay_ms - ts.tv_sec) * 1000000);
|
|
|
+ nanosleep(&ts, (struct timespec *)0);
|
|
|
+#endif
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Usage Syntax
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void Usage()
|
|
|
+{
|
|
|
+ printf("Usage\n");
|
|
|
+ printf(" client <IP> [Rack=0 Slot=2]\n");
|
|
|
+ printf("Example\n");
|
|
|
+ printf(" client 192.168.1.101 0 2\n");
|
|
|
+ printf("or\n");
|
|
|
+ printf(" client 192.168.1.101\n");
|
|
|
+ getchar();
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// hexdump, a very nice function, it's not mine.
|
|
|
+// I found it on the net somewhere some time ago... thanks to the author ;-)
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+#ifndef HEXDUMP_COLS
|
|
|
+#define HEXDUMP_COLS 16
|
|
|
+#endif
|
|
|
+void hexdump(void *mem, unsigned int len)
|
|
|
+{
|
|
|
+ unsigned int i, j;
|
|
|
+
|
|
|
+ for(i = 0; i < len + ((len % HEXDUMP_COLS) ? (HEXDUMP_COLS - len % HEXDUMP_COLS) : 0); i++)
|
|
|
+ {
|
|
|
+ /* print offset */
|
|
|
+ if(i % HEXDUMP_COLS == 0)
|
|
|
+ {
|
|
|
+ printf("0x%04x: ", i);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* print hex data */
|
|
|
+ if(i < len)
|
|
|
+ {
|
|
|
+ printf("%02x ", 0xFF & ((char*)mem)[i]);
|
|
|
+ }
|
|
|
+ else /* end of block, just aligning for ASCII dump */
|
|
|
+ {
|
|
|
+ printf(" ");
|
|
|
+ }
|
|
|
+
|
|
|
+ /* print ASCII dump */
|
|
|
+ if(i % HEXDUMP_COLS == (HEXDUMP_COLS - 1))
|
|
|
+ {
|
|
|
+ for(j = i - (HEXDUMP_COLS - 1); j <= i; j++)
|
|
|
+ {
|
|
|
+ if(j >= len) /* end of block, not really printing */
|
|
|
+ {
|
|
|
+ putchar(' ');
|
|
|
+ }
|
|
|
+ else if(isprint((((char*)mem)[j] & 0x7F))) /* printable char */
|
|
|
+ {
|
|
|
+ putchar(0xFF & ((char*)mem)[j]);
|
|
|
+ }
|
|
|
+ else /* other char */
|
|
|
+ {
|
|
|
+ putchar('.');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ putchar('\n');
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Check error
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+int Check(int Result, char * function)
|
|
|
+{
|
|
|
+ int ExecTime;
|
|
|
+ char text[1024];
|
|
|
+ printf("\n");
|
|
|
+ printf("+-----------------------------------------------------\n");
|
|
|
+ printf("| %s\n",function);
|
|
|
+ printf("+-----------------------------------------------------\n");
|
|
|
+ if (Result==0) {
|
|
|
+ Cli_GetExecTime(Client, &ExecTime);
|
|
|
+ printf("| Result : OK\n");
|
|
|
+ printf("| Execution time : %d ms\n",ExecTime);
|
|
|
+ printf("+-----------------------------------------------------\n");
|
|
|
+ ok++;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ printf("| ERROR !!! \n");
|
|
|
+ if (Result<0)
|
|
|
+ printf("| Library Error (-1)\n");
|
|
|
+ else
|
|
|
+ {
|
|
|
+ Cli_ErrorText(Result, text, 1024);
|
|
|
+ printf("| %s\n",text);
|
|
|
+ }
|
|
|
+ printf("+-----------------------------------------------------\n");
|
|
|
+ ko++;
|
|
|
+ }
|
|
|
+ return !Result;
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Multi Read
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void MultiRead()
|
|
|
+{
|
|
|
+ int res;
|
|
|
+
|
|
|
+ // Multiread buffers
|
|
|
+ byte MB[16]; // 16 Merker bytes
|
|
|
+ byte EB[16]; // 16 Digital Input bytes
|
|
|
+ byte AB[16]; // 16 Digital Output bytes
|
|
|
+ word TM[8]; // 8 timers
|
|
|
+ word CT[8]; // 8 counters
|
|
|
+
|
|
|
+ // Prepare struct
|
|
|
+ TS7DataItem Items[5];
|
|
|
+
|
|
|
+ // NOTE : *AMOUNT IS NOT SIZE* , it's the number of items
|
|
|
+
|
|
|
+ // Merkers
|
|
|
+ Items[0].Area =S7AreaMK;
|
|
|
+ Items[0].WordLen =S7WLByte;
|
|
|
+ Items[0].DBNumber =0; // Don't need DB
|
|
|
+ Items[0].Start =0; // Starting from 0
|
|
|
+ Items[0].Amount =16; // 16 Items (bytes)
|
|
|
+ Items[0].pdata =&MB;
|
|
|
+ // Digital Input bytes
|
|
|
+ Items[1].Area =S7AreaPE;
|
|
|
+ Items[1].WordLen =S7WLByte;
|
|
|
+ Items[1].DBNumber =0; // Don't need DB
|
|
|
+ Items[1].Start =0; // Starting from 0
|
|
|
+ Items[1].Amount =16; // 16 Items (bytes)
|
|
|
+ Items[1].pdata =&EB;
|
|
|
+ // Digital Output bytes
|
|
|
+ Items[2].Area =S7AreaPA;
|
|
|
+ Items[2].WordLen =S7WLByte;
|
|
|
+ Items[2].DBNumber =0; // Don't need DB
|
|
|
+ Items[2].Start =0; // Starting from 0
|
|
|
+ Items[2].Amount =16; // 16 Items (bytes)
|
|
|
+ Items[2].pdata =&AB;
|
|
|
+ // Timers
|
|
|
+ Items[3].Area =S7AreaTM;
|
|
|
+ Items[3].WordLen =S7WLTimer;
|
|
|
+ Items[3].DBNumber =0; // Don't need DB
|
|
|
+ Items[3].Start =0; // Starting from 0
|
|
|
+ Items[3].Amount =8; // 8 Timers
|
|
|
+ Items[3].pdata =&TM;
|
|
|
+ // Counters
|
|
|
+ Items[4].Area =S7AreaCT;
|
|
|
+ Items[4].WordLen =S7WLCounter;
|
|
|
+ Items[4].DBNumber =0; // Don't need DB
|
|
|
+ Items[4].Start =0; // Starting from 0
|
|
|
+ Items[4].Amount =8; // 8 Counters
|
|
|
+ Items[4].pdata =&CT;
|
|
|
+
|
|
|
+ res=Cli_ReadMultiVars(Client, &Items[0], 5);
|
|
|
+ if (Check(res,"Multiread Vars"))
|
|
|
+ {
|
|
|
+ // Result of Client->ReadMultivars is the "global result" of
|
|
|
+ // the function, it's OK if something was exchanged.
|
|
|
+
|
|
|
+ // But we need to check single Var results.
|
|
|
+ // Let shall suppose that we ask for 5 vars, 4 of them are ok but
|
|
|
+ // the 5th is inexistent, we will have 4 results ok and 1 not ok.
|
|
|
+
|
|
|
+ printf("Dump MB0..MB15 - Var Result : %d\n",Items[0].Result);
|
|
|
+ if (Items[0].Result==0)
|
|
|
+ hexdump(&MB,16);
|
|
|
+ printf("Dump EB0..EB15 - Var Result : %d\n",Items[1].Result);
|
|
|
+ if (Items[1].Result==0)
|
|
|
+ hexdump(&EB,16);
|
|
|
+ printf("Dump AB0..AB15 - Var Result : %d\n",Items[2].Result);
|
|
|
+ if (Items[2].Result==0)
|
|
|
+ hexdump(&AB,16);
|
|
|
+ printf("Dump T0..T7 - Var Result : %d\n",Items[3].Result);
|
|
|
+ if (Items[3].Result==0)
|
|
|
+ hexdump(&TM,16); // 8 Timers -> 16 bytes
|
|
|
+ printf("Dump Z0..Z7 - Var Result : %d\n",Items[4].Result);
|
|
|
+ if (Items[4].Result==0)
|
|
|
+ hexdump(&CT,16); // 8 Counters -> 16 bytes
|
|
|
+ };
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// List blocks in AG
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void ListBlocks()
|
|
|
+{
|
|
|
+ TS7BlocksList List;
|
|
|
+ int res=Cli_ListBlocks(Client, &List);
|
|
|
+ if (Check(res,"List Blocks in AG"))
|
|
|
+ {
|
|
|
+ printf(" OBCount : %d\n",List.OBCount);
|
|
|
+ printf(" FBCount : %d\n",List.FBCount);
|
|
|
+ printf(" FCCount : %d\n",List.FCCount);
|
|
|
+ printf(" SFBCount : %d\n",List.SFBCount);
|
|
|
+ printf(" SFCCount : %d\n",List.SFCCount);
|
|
|
+ printf(" DBCount : %d\n",List.DBCount);
|
|
|
+ printf(" SDBCount : %d\n",List.SDBCount);
|
|
|
+ };
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// CPU Info : catalog
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void OrderCode()
|
|
|
+{
|
|
|
+ TS7OrderCode Info;
|
|
|
+ int res=Cli_GetOrderCode(Client, &Info);
|
|
|
+ if (Check(res,"Catalog"))
|
|
|
+ {
|
|
|
+ printf(" Order Code : %s\n",Info.Code);
|
|
|
+ printf(" Version : %d.%d.%d\n",Info.V1,Info.V2,Info.V3);
|
|
|
+ };
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// CPU Info : unit info
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void CpuInfo()
|
|
|
+{
|
|
|
+ TS7CpuInfo Info;
|
|
|
+ int res=Cli_GetCpuInfo(Client, &Info);
|
|
|
+ if (Check(res,"Unit Info"))
|
|
|
+ {
|
|
|
+ printf(" Module Type Name : %s\n",Info.ModuleTypeName);
|
|
|
+ printf(" Seriel Number : %s\n",Info.SerialNumber);
|
|
|
+ printf(" AS Name : %s\n",Info.ASName);
|
|
|
+ printf(" Module Name : %s\n",Info.ModuleName);
|
|
|
+ };
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// CP Info
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void CpInfo()
|
|
|
+{
|
|
|
+ TS7CpInfo Info;
|
|
|
+ int res=Cli_GetCpInfo(Client, &Info);
|
|
|
+ if (Check(res,"Communication processor Info"))
|
|
|
+ {
|
|
|
+ printf(" Max PDU Length : %d bytes\n",Info.MaxPduLengt);
|
|
|
+ printf(" Max Connections : %d \n",Info.MaxConnections);
|
|
|
+ printf(" Max MPI Rate : %d bps\n",Info.MaxMpiRate);
|
|
|
+ printf(" Max Bus Rate : %d bps\n",Info.MaxBusRate);
|
|
|
+ };
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// PLC Status
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void UnitStatus()
|
|
|
+{
|
|
|
+ int res=0;
|
|
|
+
|
|
|
+ int Status;
|
|
|
+ Cli_GetPlcStatus(Client, &Status);
|
|
|
+ if (Check(res,"CPU Status"))
|
|
|
+ {
|
|
|
+ switch (Status)
|
|
|
+ {
|
|
|
+ case S7CpuStatusRun : printf(" RUN\n"); break;
|
|
|
+ case S7CpuStatusStop: printf(" STOP\n"); break;
|
|
|
+ default : printf(" UNKNOWN\n"); break;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Upload DB0 (surely exists in AG)
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void UploadDB0()
|
|
|
+{
|
|
|
+ int Size = sizeof(Buffer); // Size is IN/OUT par
|
|
|
+ // In input it tells the client the size available
|
|
|
+ // In output it tells us how many bytes were uploaded.
|
|
|
+ int res=Cli_Upload(Client, Block_SDB, 0, &Buffer, &Size);
|
|
|
+ if (Check(res,"Block Upload (SDB 0)"))
|
|
|
+ {
|
|
|
+ printf("Dump (%d bytes) :\n",Size);
|
|
|
+ hexdump(&Buffer,Size);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Upload DB666 (surely exists in AG)
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void UploadDB666()
|
|
|
+{
|
|
|
+ unsigned char Buf666[406];
|
|
|
+ int Size = sizeof(Buf666); // Size is IN/OUT par
|
|
|
+ // In input it tells the client the size available
|
|
|
+ // In output it tells us how many bytes were uploaded.
|
|
|
+
|
|
|
+ int res = Cli_DBRead(Client, 666, 0, Size, &Buf666);
|
|
|
+
|
|
|
+ if (Check(res,"Block Upload (DB 666)"))
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+ int idx;
|
|
|
+ int ssize;
|
|
|
+ int slen;
|
|
|
+ char Hbuf[161];
|
|
|
+
|
|
|
+ printf("Dump (%d bytes) :\n",Size);
|
|
|
+
|
|
|
+ printf("Watchdog : %s\n", (Buf666[0] & 0x01)?"TRUE":"FALSE");
|
|
|
+ printf("Senden : %s\n", (Buf666[0] & 0x02)?"TRUE":"FALSE");
|
|
|
+ printf("Gesendet : %s\n", (Buf666[0] & 0x04)?"TRUE":"FALSE");
|
|
|
+ printf("Index # : %d\n", Buf666[1]);
|
|
|
+
|
|
|
+ for(i = 0; i < 10; i++) {
|
|
|
+ idx = (i * 22) + 2;
|
|
|
+ ssize = Buf666[idx];
|
|
|
+ slen = Buf666[idx + 1];
|
|
|
+
|
|
|
+ memset(Hbuf, 0, sizeof(Hbuf));
|
|
|
+ memcpy(Hbuf, Buf666 + idx + 2, slen < sizeof(Hbuf)?slen:sizeof(Hbuf) - 1);
|
|
|
+ printf("Tel#%2.2d : %s\n", i, Hbuf);
|
|
|
+ }
|
|
|
+
|
|
|
+ idx = 244;
|
|
|
+ ssize = Buf666[idx];
|
|
|
+ slen = Buf666[idx + 1];
|
|
|
+
|
|
|
+ memset(Hbuf, 0, sizeof(Hbuf));
|
|
|
+ memcpy(Hbuf, Buf666 + idx + 2, slen < sizeof(Hbuf)?slen:sizeof(Hbuf) - 1);
|
|
|
+ printf("SMS : %s\n", Hbuf);
|
|
|
+
|
|
|
+ //hexdump(&Buf666,Size);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Async Upload DB0 (using callback as completion trigger)
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void AsCBUploadDB0()
|
|
|
+{
|
|
|
+ int Size = sizeof(Buffer); // Size is IN/OUT par
|
|
|
+ // In input it tells the client the size available
|
|
|
+ // In output it tells us how many bytes were uploaded.
|
|
|
+ int res;
|
|
|
+ JobDone=false;
|
|
|
+
|
|
|
+ res=Cli_AsUpload(Client, Block_SDB, 0, &Buffer, &Size);
|
|
|
+
|
|
|
+ if (res==0)
|
|
|
+ {
|
|
|
+ while (!JobDone)
|
|
|
+ {
|
|
|
+ SysSleep(100);
|
|
|
+ }
|
|
|
+ res=JobResult;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Check(res,"Async (callback) Block Upload (SDB 0)"))
|
|
|
+ {
|
|
|
+ printf("Dump (%d bytes) :\n",Size);
|
|
|
+ hexdump(&Buffer,Size);
|
|
|
+ }
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Async Upload DB0 (using event wait as completion trigger)
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void AsEWUploadDB0()
|
|
|
+{
|
|
|
+ int Size = sizeof(Buffer); // Size is IN/OUT par
|
|
|
+ // In input it tells the client the size available
|
|
|
+ // In output it tells us how many bytes were uploaded.
|
|
|
+ int res;
|
|
|
+ JobDone=false;
|
|
|
+
|
|
|
+ res=Cli_AsUpload(Client, Block_SDB, 0, &Buffer, &Size);
|
|
|
+
|
|
|
+ if (res==0)
|
|
|
+ {
|
|
|
+ res=Cli_WaitAsCompletion(Client,3000);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Check(res,"Async (Wait event) Block Upload (SDB 0)"))
|
|
|
+ {
|
|
|
+ printf("Dump (%d bytes) :\n",Size);
|
|
|
+ hexdump(&Buffer,Size);
|
|
|
+ }
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Async Upload DB0 (using polling as completion trigger)
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void AsPOUploadDB0()
|
|
|
+{
|
|
|
+ int Size = sizeof(Buffer); // Size is IN/OUT par
|
|
|
+ // In input it tells the client the size available
|
|
|
+ // In output it tells us how many bytes were uploaded.
|
|
|
+ int res;
|
|
|
+ JobDone=false;
|
|
|
+
|
|
|
+ res=Cli_AsUpload(Client, Block_SDB, 0, &Buffer, &Size);
|
|
|
+
|
|
|
+ if (res==0)
|
|
|
+ {
|
|
|
+ while (Cli_CheckAsCompletion(Client,&res)!=JobComplete)
|
|
|
+ {
|
|
|
+ SysSleep(100);
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Check(res,"Async (polling) Block Upload (SDB 0)"))
|
|
|
+ {
|
|
|
+ printf("Dump (%d bytes) :\n",Size);
|
|
|
+ hexdump(&Buffer,Size);
|
|
|
+ }
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Read a sample SZL Block
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void ReadSzl_0011_0000()
|
|
|
+{
|
|
|
+ PS7SZL SZL = (PS7SZL)(&Buffer); // use our buffer casted as TS7SZL
|
|
|
+ int Size = sizeof(Buffer);
|
|
|
+ // Block ID 0x0011 IDX 0x0000 normally exists in every CPU
|
|
|
+ int res=Cli_ReadSZL(Client, 0x0011, 0x0000, SZL, &Size);
|
|
|
+ if (Check(res,"Read SZL - ID : 0x0011, IDX 0x0000"))
|
|
|
+ {
|
|
|
+ printf(" LENTHDR : %d\n",SZL->Header.LENTHDR);
|
|
|
+ printf(" N_DR : %d\n",SZL->Header.N_DR);
|
|
|
+ printf("Dump (%d bytes) :\n",Size);
|
|
|
+ hexdump(&Buffer,Size);
|
|
|
+ }
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Unit Connection
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+int CliConnect()
|
|
|
+{
|
|
|
+ int Requested, Negotiated, res;
|
|
|
+
|
|
|
+ res = Cli_ConnectTo(Client, Address,Rack,Slot);
|
|
|
+ if (Check(res,"UNIT Connection")) {
|
|
|
+ Cli_GetPduLength(Client, &Requested, &Negotiated);
|
|
|
+ printf(" Connected to : %s (Rack=%d, Slot=%d)\n",Address,Rack,Slot);
|
|
|
+ printf(" PDU Requested : %d bytes\n",Requested);
|
|
|
+ printf(" PDU Negotiated : %d bytes\n",Negotiated);
|
|
|
+ };
|
|
|
+ return !res;
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Unit Disconnection
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void CliDisconnect()
|
|
|
+{
|
|
|
+ Cli_Disconnect(Client);
|
|
|
+}
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+// Perform readonly tests, no cpu status modification
|
|
|
+//------------------------------------------------------------------------------
|
|
|
+void PerformTests()
|
|
|
+{
|
|
|
+ OrderCode();
|
|
|
+ CpuInfo();
|
|
|
+ CpInfo();
|
|
|
+ UnitStatus();
|
|
|
+ ReadSzl_0011_0000();
|
|
|
+ UploadDB666();
|
|
|
+// UploadDB0();
|
|
|
+// AsCBUploadDB0();
|
|
|
+// AsEWUploadDB0();
|
|
|
+// AsPOUploadDB0();
|
|
|
+// MultiRead();
|
|
|
+
|
|
|
+ while(1) {
|
|
|
+ usleep(200000);
|
|
|
+ UploadDB666();
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+void Summary()
|
|
|
+{
|
|
|
+ printf("\n");
|
|
|
+ printf("+-----------------------------------------------------\n");
|
|
|
+ printf("| Test Summary \n");
|
|
|
+ printf("+-----------------------------------------------------\n");
|
|
|
+ printf("| Performed : %d\n",(ok+ko));
|
|
|
+ printf("| Passed : %d\n",ok);
|
|
|
+ printf("| Failed : %d\n",ko);
|
|
|
+ printf("+----------------------------------------[press a key]\n");
|
|
|
+ getchar();
|
|
|
+}
|
|
|
+
|
|
|
+int main(int argc, char* argv[])
|
|
|
+{
|
|
|
+// Get Progran args
|
|
|
+ if (argc!=2 && argc!=4)
|
|
|
+ {
|
|
|
+ Usage();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ Address=argv[1];
|
|
|
+ if (argc==4)
|
|
|
+ {
|
|
|
+ Rack=atoi(argv[2]);
|
|
|
+ Slot=atoi(argv[3]);
|
|
|
+ }
|
|
|
+
|
|
|
+// Client Creation
|
|
|
+ Client=Cli_Create();
|
|
|
+ Cli_SetAsCallback(Client, CliCompletion,NULL);
|
|
|
+
|
|
|
+// Connection
|
|
|
+ if (CliConnect())
|
|
|
+ {
|
|
|
+ PerformTests();
|
|
|
+ CliDisconnect();
|
|
|
+ };
|
|
|
+
|
|
|
+// Deletion
|
|
|
+ Cli_Destroy(&Client);
|
|
|
+ Summary();
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
