commit f3f895df829ede423bce2505a2da35ba973886e6 Author: dtrentin Date: Sun May 17 22:10:30 2026 +0200 Initial commit: migrate from FanucProgramManager diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..ed23405 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +################################################################################ +# Il file gitignore è stato creato automaticamente da Microsoft(R) Visual Studio. +################################################################################ + +/obj +/bin +/.vs +/packages diff --git a/.paul/PROJECT.md b/.paul/PROJECT.md new file mode 100644 index 0000000..941f0c6 --- /dev/null +++ b/.paul/PROJECT.md @@ -0,0 +1,88 @@ +# FanucProgramManager + +## What This Is + +Console EXE (C# .NET 4.7.2) for upload/download of CNC programs to/from machine controllers. Targets any CN manufacturer, not Fanuc-only. Runs on Windows, distributed to licensed machine operators and integrators. + +## Core Value + +Machinists and operators transfer CNC programs to/from any controller without manual intervention or internet access. + +## Current State + +| Attribute | Value | +|-----------|-------| +| Type | Application | +| Version | 0.0.0 | +| Status | In development | +| Last Updated | 2026-05-13 | + +## Requirements + +### Core Features + +- Upload programs to CNC controller +- Download programs from CNC controller +- Local file management (organize/store programs on disk) +- Multi-CN brand support (Fanuc + others) + +### Validated (Shipped) +- [x] Fanuc FOCAS upload/download — initial +- [x] AES encryption for program files +- [x] CLI argument parsing +- [x] Machine-bound license check (hardcoded) + +### Active (In Progress) +- [ ] 3-file management mode — branch `3FilesManagement` + +### Planned (Next) +- To be defined during /paul:plan + +### Out of Scope +- Cloud sync +- Web UI +- Internet-dependent license validation + +## Constraints + +### Technical Constraints +- .NET Framework 4.7.2 — max compatibility, no upgrade +- Fanuc FOCAS via `fwlib32` (32-bit DLL, Windows-only) +- Must run offline — no internet dependency at runtime +- License validation must work without network + +### Business Constraints +- Software must be license-protected (offline, machine-bound) +- Current approach: hardcoded machine check — needs improvement +- Target: hardware fingerprint + encrypted license file + +## Key Decisions + +| Decision | Rationale | Date | Status | +|----------|-----------|------|--------| +| .NET 4.7.2 | Max compatibility with operator machines | 2026-05-13 | Active | +| Console EXE output | Simple deployment, scriptable | 2026-05-13 | Active | +| Offline license only | Operators may have no internet on shop floor | 2026-05-13 | Active | + +## Success Metrics + +| Metric | Target | Current | Status | +|--------|--------|---------|--------| +| Program transfer correctness | 100% (byte-verified) | Unknown | Not measured | +| License validation (offline) | Works without network | Hardcoded | At risk | +| Multi-CN support | ≥2 manufacturers | Fanuc only | In progress | + +## Tech Stack / Tools + +| Layer | Technology | Notes | +|-------|------------|-------| +| Language | C# | .NET Framework 4.7.2 | +| UI | Console EXE | CLI args via InputArgs.cs | +| CN Protocol (Fanuc) | FOCAS fwlib32 | 32-bit DLL | +| CN Protocol (others) | To be defined | Multi-CN expansion | +| Encryption | AES (AesCrypt.cs) | Program file protection | +| Licensing | Machine fingerprint | Hardcoded now, needs design | + +--- +*PROJECT.md — Updated when requirements or context change* +*Last updated: 2026-05-13* diff --git a/.paul/ROADMAP.md b/.paul/ROADMAP.md new file mode 100644 index 0000000..3d2c5fa --- /dev/null +++ b/.paul/ROADMAP.md @@ -0,0 +1,83 @@ +# Roadmap: FanucProgramManager + +## Overview + +Console tool for CNC program transfer and file management. Fanuc FOCAS base, expanding to multi-CN (Heidenhain LSV2, Siemens FTP) with robust offline licensing. + +## Current Milestone + +**v0.1 Multi-CN Release** (v0.1.0) +Status: In progress +Phases: 0 of 4 complete + +## Phases + +| Phase | Name | Plans | Status | Completed | +|-------|------|-------|--------|-----------| +| 1 | cnc-abstraction | 2 | In progress | - | +| 2 | heidenhain | 1 | Not started | - | +| 3 | siemens | 1 | Not started | - | +| 4 | program-wiring | 1 | Not started | - | + +## Phase Details + +### Phase 1: cnc-abstraction + +**Goal:** Fix namespace, add all Cnc/ files to csproj, complete ICncMachine + IFanucMachine with 3-file support +**Depends on:** Nothing +**Research:** Unlikely + +**Scope:** +- Fix namespace Fanuc_integration → FanucProgramManager.Cnc +- Add using FanucProgramManager to Fanuc-specific files +- Extend IFocasDialect to accept fileType for tool/work data +- Add IFanucMachine interface with tool offset + work zero ops +- Add CncManufacturer enum, CncMachineFactory stub +- Add all Cnc/ to csproj + +**Plans:** +- [ ] 01-01: Fix namespace, extend dialect interface, IFanucMachine +- [ ] 01-02: CncManufacturer, CncMachineFactory, add to csproj + +### Phase 2: heidenhain + +**Goal:** Implement ICncMachine for Heidenhain TNC via LSV2 protocol +**Depends on:** Phase 1 +**Research:** Likely (LSV2 binary protocol) + +**Scope:** +- HeidenhainConnectionConfig +- Lsv2Client (TCP framing, CRC16, commands) +- HeidenhainMachine : ICncMachine + +**Plans:** +- [ ] 02-01: Heidenhain LSV2 full implementation + +### Phase 3: siemens + +**Goal:** Implement ICncMachine for Siemens Sinumerik via FTP +**Depends on:** Phase 1 +**Research:** Unlikely (standard FTP) + +**Scope:** +- SiemensConnectionConfig +- SiemensMachine : ICncMachine via FtpWebRequest + +**Plans:** +- [ ] 03-01: Siemens FTP implementation + +### Phase 4: program-wiring + +**Goal:** Wire all 3 manufacturers into Program.cs + InputArgs, replace old FANUCMachine +**Depends on:** Phase 1, 2, 3 + +**Scope:** +- Update InputArgs with -manufacturer= param +- Refactor Program.cs to use ICncMachine factory +- Keep 3-file logic for Fanuc only + +**Plans:** +- [ ] 04-01: InputArgs + Program.cs refactor + +--- +*Roadmap created: 2026-05-13* diff --git a/.paul/STATE.md b/.paul/STATE.md new file mode 100644 index 0000000..4991bf2 --- /dev/null +++ b/.paul/STATE.md @@ -0,0 +1,111 @@ +# Project State + +## Project Reference + +See: .paul/PROJECT.md (updated 2026-05-13) + +**Core value:** Machinists transfer CNC programs to/from any controller without manual steps or internet +**Current focus:** 4-CN implementation complete — awaiting user verification and UNIFY + +## Current Position + +Milestone: v0.1 Multi-CN Release +Phase: 5 of 5 — Applied +Plan: All plans applied, awaiting user UNIFY +Status: APPLY complete, ready for UNIFY +Last activity: 2026-05-13 — Phase 5 NC Validator applied by agent + +Progress: +- Milestone: [█████████░] 90% + +## Loop Position + +Current loop state: +``` +PLAN ──▶ APPLY ──▶ UNIFY + ✓ ✓ ○ [Awaiting user verification + /paul:unify] +``` + +## What was built (all 4 phases) + +### Phase 1 — Cnc abstraction fixed +- Namespace: `Fanuc_integration.Cnc.*` → `FanucProgramManager.Cnc.*` across 29 files +- `using FanucProgramManager;` added to all FOCAS-using files +- `IFocasDialect` extended: `UploadStart`/`DownloadStart` now accept `short fileType` +- `IFanucMachine` created: extends `ICncMachine` with tool offset + work zero R/W +- `FanucMachine` now implements `IFanucMachine` +- `CncManufacturer` enum: Fanuc, Heidenhain, Siemens +- All 29 `Cnc/**/*.cs` files added to `.csproj` (36 total Compile entries) + +### Phase 2 — Heidenhain LSV2 +- `HeidenhainConnectionConfig` — IP, port 19000, credentials, timeout +- `Lsv2Client` — TCP framing, CRC-16/CCITT, login (SELECT+LOG_IN), ReceiveFile/SendFile +- `HeidenhainMachine : ICncMachine` — RunGuardedAsync pattern, state machine + +### Phase 3.1 — Mitsubishi M-series (added post-apply) +- `MitsubishiConnectionConfig` — port 21, dir `/PRG/` (no file extensions) +- `MitsubishiFtpClient` / `MitsubishiMachine : ICncMachine` — FTP, same pattern as Siemens +- `CncManufacturer.Mitsubishi` added to enum + factory + CLI parsing + +### Phase 3 — Siemens Sinumerik FTP +- `SiemensConnectionConfig` — IP, port 21, creds, program dir `/_N_MPF_DIR/` +- `SiemensFtpClient` — FtpWebRequest wrapper, ASCII mode, passive +- `SiemensMachine : ICncMachine` — same pattern as FanucMachine + +### Phase 4 — Wiring +- `CncMachineFactory` — creates right ICncMachine from InputArgs +- `InputArgs` — added `manufacturer`, `username`, `password` fields +- `Program.cs` — full rewrite using ICncMachine; Fanuc 3-file via IFanucMachine cast + +### Phase 5 — NC Validator +- `ValidationSeverity` enum (Error/Warning) +- `ValidationError` — Line, Message, Severity +- `ValidationResult` — Success + IReadOnlyList, static Ok()/Fail() +- `INcProgramValidator` interface +- `NcProgramValidator` — universal rules (block length ≤80, no lowercase, no tabs, no nested parens, comment ≤32); per-manufacturer name format + forbidden char rules; `#` in Fanuc/Mitsubishi is Warning not Error +- All 4 machines injected: public constructor creates `NcProgramValidator(manufacturer)`, internal constructor accepts `INcProgramValidator` for testing +- All 4 machines call validator in `WriteProgramAsync` before upload; fail on any Error-severity violation +- `NcProgramValidatorTests` — 30+ test cases covering all rules and all manufacturers +- Existing machine unit tests updated: inject always-ok mock validator to preserve existing behaviour tests +- Integration tests updated: content+names corrected to pass validation per manufacturer +- 5 new Compile entries in main csproj + 1 in tests csproj + +## New CLI args +- `-manufacturer=fanuc|heidenhain|siemens` (default: fanuc) +- `-username=` (Heidenhain/Siemens) +- `-password=` (Heidenhain/Siemens) + +## Accumulated Context + +### Decisions +- .NET 4.7.2 locked — max compatibility +- Offline-only license check (AES, unchanged) +- Heidenhain: LSV2 port 19000, needs real hardware testing +- Siemens: FTP /_N_MPF_DIR/, needs Sinumerik FTP option enabled on machine + +### Phase 5 — Test project (added post-apply) +- `FanucProgramManager.Tests/` — NUnit 3.13.3 + Moq 4.18.4, .NET 4.7.2 +- 7 unit test files (14+ tests on `FanucProgram`, `IsoProgramFormatter`, factory, all 4 machines) +- `FtpServerStub` — in-process TCP FTP (PASV); `Lsv2ServerStub` — in-process LSV2 TCP +- 3 integration test files — write→read round-trips against local stubs +- `InternalsVisibleTo("FanucProgramManager.Tests")` added to `AssemblyInfo.cs` +- Fanuc FOCAS tests that need Windows DLL are `[Ignore]`-d with explanation + +### Deferred Issues +- License system: still hardcoded AES key/IV — needs Phase 2.x redesign +- Heidenhain LSV2: ReadActiveProgramAsync / SelectMainProgram not supported +- Siemens FTP: ReadActiveProgramAsync / SelectMainProgram not supported +- Build not verifiable on Linux (fwlib32 is Windows-only DLL) + +### Blockers/Concerns +None — code complete, pending hardware testing. + +## Session Continuity + +Last session: 2026-05-13 +Stopped at: Phase 5 (NC Validator) applied — all 12 files created/modified +Next action: Build to verify compilation; run unit tests; /paul:unify when ready +Resume file: .paul/STATE.md + +--- +*STATE.md — Updated after every significant action* diff --git a/.paul/paul.json b/.paul/paul.json new file mode 100644 index 0000000..087b36b --- /dev/null +++ b/.paul/paul.json @@ -0,0 +1,25 @@ +{ + "name": "FanucProgramManager", + "version": "0.0.0", + "milestone": { + "name": "None", + "version": "0.0.0", + "status": "not_started" + }, + "phase": { + "number": 0, + "name": "None", + "status": "not_started" + }, + "loop": { + "plan": null, + "position": "IDLE" + }, + "timestamps": { + "created_at": "2026-05-13T00:00:00Z", + "updated_at": "2026-05-13T00:00:00Z" + }, + "satellite": { + "groom": true + } +} diff --git a/.paul/phases/05-nc-validator/PLAN.md b/.paul/phases/05-nc-validator/PLAN.md new file mode 100644 index 0000000..d584672 --- /dev/null +++ b/.paul/phases/05-nc-validator/PLAN.md @@ -0,0 +1,69 @@ +# Phase 05 — NC Program Validator + +**Status:** PLAN + +## Goal + +Per-manufacturer NC program validator runs inside `WriteProgramAsync` before upload. +Catches format errors before bytes hit the controller. + +## Acceptance Criteria + +- `NcProgramValidator` validates content for all 4 manufacturers +- All universal rules checked: block length ≤ 80, no lowercase, no tabs, no nested parens, comment ≤ 32 chars +- Per-manufacturer name format and forbidden chars checked +- Fanuc `#` char is Warning not Error +- All 4 machine classes call validator in `WriteProgramAsync` before upload +- Unit tests cover all rules + all manufacturers +- Old-style csproj Compile entries added for all new files + +## File List + +| # | File | Action | +|---|------|--------| +| 1 | `Cnc/Models/ValidationSeverity.cs` | Create | +| 2 | `Cnc/Models/ValidationError.cs` | Create | +| 3 | `Cnc/Models/ValidationResult.cs` | Create | +| 4 | `Cnc/INcProgramValidator.cs` | Create | +| 5 | `Cnc/NcProgramValidator.cs` | Create | +| 6 | `Cnc/Fanuc/FanucMachine.cs` | Edit — inject validator | +| 7 | `Cnc/Heidenhain/HeidenhainMachine.cs` | Edit — inject validator | +| 8 | `Cnc/Siemens/SiemensMachine.cs` | Edit — inject validator | +| 9 | `Cnc/Mitsubishi/MitsubishiMachine.cs` | Edit — inject validator | +| 10 | `FanucProgramManager.Tests/Unit/NcProgramValidatorTests.cs` | Create | +| 11 | `FanucProgramManager.csproj` | Edit — add 5 Compile entries | +| 12 | `FanucProgramManager.Tests/FanucProgramManager.Tests.csproj` | Edit — add test Compile entry | + +## Validation Rules + +### Universal +- Block length ≤ 80 chars per line +- No lowercase letters +- No tab characters +- No nested parentheses (depth > 1) +- Comment content inside `()` ≤ 32 chars + +### Fanuc +- Name must match `O\d{4}` +- First line of content must be `O####` +- Forbidden chars: `;`, `[`, `]` +- `#` → Warning (macro variable indicator) + +### Mitsubishi +- Same as Fanuc (O#### naming, same forbidden chars) + +### Siemens +- Name must end with `.MPF` (uppercase) +- Forbidden chars: `;` + +### Heidenhain +- Name must end with `.H` +- No O#### header required +- Forbidden chars: `%`, `;` + +## Constraints + +- .NET 4.7.2: no `Array.Empty()`, no C# 8+ features +- No LINQ unless already imported +- Namespace: `FanucProgramManager.Cnc` (validator), `FanucProgramManager.Cnc.Models` (result types) +- English code + comments only diff --git a/AesCrypt.cs b/AesCrypt.cs new file mode 100755 index 0000000..28e1894 --- /dev/null +++ b/AesCrypt.cs @@ -0,0 +1,93 @@ +using System; +using System.IO; +using System.Security.Cryptography; + +namespace FanucProgramManager +{ + class AesCrypt + { + + public static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV) + { + // Check arguments. + if (plainText == null || plainText.Length <= 0) + throw new ArgumentNullException("plainText"); + if (Key == null || Key.Length <= 0) + throw new ArgumentNullException("Key"); + if (IV == null || IV.Length <= 0) + throw new ArgumentNullException("IV"); + byte[] encrypted; + + // Create an Aes object + // with the specified key and IV. + using (Aes aesAlg = Aes.Create()) + { + aesAlg.Key = Key; + aesAlg.IV = IV; + + // Create an encryptor to perform the stream transform. + ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); + + // Create the streams used for encryption. + using (MemoryStream msEncrypt = new MemoryStream()) + { + using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) + { + using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) + { + //Write all data to the stream. + swEncrypt.Write(plainText); + } + encrypted = msEncrypt.ToArray(); + } + } + } + + // Return the encrypted bytes from the memory stream. + return encrypted; + } + + public static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV) + { + // Check arguments. + if (cipherText == null || cipherText.Length <= 0) + throw new ArgumentNullException("cipherText"); + if (Key == null || Key.Length <= 0) + throw new ArgumentNullException("Key"); + if (IV == null || IV.Length <= 0) + throw new ArgumentNullException("IV"); + + // Declare the string used to hold + // the decrypted text. + string plaintext = null; + + // Create an Aes object + // with the specified key and IV. + using (Aes aesAlg = Aes.Create()) + { + aesAlg.Key = Key; + aesAlg.IV = IV; + + // Create a decryptor to perform the stream transform. + ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); + + // Create the streams used for decryption. + using (MemoryStream msDecrypt = new MemoryStream(cipherText)) + { + using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) + { + using (StreamReader srDecrypt = new StreamReader(csDecrypt)) + { + + // Read the decrypted bytes from the decrypting stream + // and place them in a string. + plaintext = srDecrypt.ReadToEnd(); + } + } + } + } + + return plaintext; + } + } + } diff --git a/App.config b/App.config new file mode 100755 index 0000000..7d84477 --- /dev/null +++ b/App.config @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Cnc/CncMachineFactory.cs b/Cnc/CncMachineFactory.cs new file mode 100644 index 0000000..8299373 --- /dev/null +++ b/Cnc/CncMachineFactory.cs @@ -0,0 +1,60 @@ +using System; +using FanucProgramManager.Cnc.Fanuc; +using FanucProgramManager.Cnc.Heidenhain; +using FanucProgramManager.Cnc.Mitsubishi; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Siemens; + +namespace FanucProgramManager.Cnc +{ + internal static class CncMachineFactory + { + internal static ICncMachine Create(InputArgs args) + { + switch (args.manufacturer) + { + case CncManufacturer.Heidenhain: + return new HeidenhainMachine(new HeidenhainConnectionConfig + { + Name = "Heidenhain", + IpAddress = args.ip, + Port = string.IsNullOrEmpty(args.porta) ? 19000 : int.Parse(args.porta), + Username = args.username, + Password = args.password, + ConnectTimeout = TimeSpan.FromSeconds(5) + }); + + case CncManufacturer.Siemens: + return new SiemensMachine(new SiemensConnectionConfig + { + Name = "Siemens", + IpAddress = args.ip, + Port = string.IsNullOrEmpty(args.porta) ? 21 : int.Parse(args.porta), + Username = args.username, + Password = args.password + }); + + case CncManufacturer.Mitsubishi: + return new MitsubishiMachine(new MitsubishiConnectionConfig + { + Name = "Mitsubishi", + IpAddress = args.ip, + Port = string.IsNullOrEmpty(args.porta) ? 21 : int.Parse(args.porta), + Username = args.username, + Password = args.password + }); + + default: // Fanuc + return new FanucMachine(new FanucConnectionConfig + { + Name = "Fanuc", + Transport = args.nodoHssb >= 0 ? FanucTransport.Hssb : FanucTransport.Ethernet, + IpAddress = args.ip, + Port = string.IsNullOrEmpty(args.porta) ? (ushort)8193 : ushort.Parse(args.porta), + HssbNode = args.nodoHssb, + ConnectTimeout = TimeSpan.FromSeconds(4) + }); + } + } + } +} diff --git a/Cnc/Fanuc/FanucCapabilities.cs b/Cnc/Fanuc/FanucCapabilities.cs new file mode 100755 index 0000000..cd3e605 --- /dev/null +++ b/Cnc/Fanuc/FanucCapabilities.cs @@ -0,0 +1,26 @@ +namespace FanucProgramManager.Cnc.Fanuc +{ + public sealed class FanucCapabilities + { + public string CncType { get; set; } + public char ModelLetter { get; set; } + public bool IsISeries { get; set; } + public string Series { get; set; } + public string Version { get; set; } + public string MtType { get; set; } + public int MaxAxis { get; set; } + + public FanucDialect Dialect { get; set; } + + public bool SupportsPathBasedPrograms { get; set; } + public bool SupportsPdfProgramApi { get; set; } + public bool SupportsAlmMsg2 { get; set; } + public bool SupportsUpDownload4 { get; set; } + + public override string ToString() + { + return "Fanuc " + (CncType ?? "?").Trim() + "i-" + ModelLetter + + " (" + Dialect + ", " + (MtType ?? "?").Trim() + ", " + MaxAxis + " axes)"; + } + } +} diff --git a/Cnc/Fanuc/FanucConnectionConfig.cs b/Cnc/Fanuc/FanucConnectionConfig.cs new file mode 100755 index 0000000..86e20d2 --- /dev/null +++ b/Cnc/Fanuc/FanucConnectionConfig.cs @@ -0,0 +1,29 @@ +using System; + +namespace FanucProgramManager.Cnc.Fanuc +{ + public enum FanucTransport + { + Ethernet = 3, + Hssb = 2, + Library = 0 + } + + public sealed class FanucConnectionConfig + { + public string Name { get; set; } + public FanucTransport Transport { get; set; } + public string IpAddress { get; set; } + public ushort Port { get; set; } + public int HssbNode { get; set; } + public int PieceCounterMacro { get; set; } + public TimeSpan ConnectTimeout { get; set; } + + public FanucConnectionConfig() + { + HssbNode = -1; + PieceCounterMacro = -1; + ConnectTimeout = TimeSpan.FromSeconds(4); + } + } +} diff --git a/Cnc/Fanuc/FanucDialect.cs b/Cnc/Fanuc/FanucDialect.cs new file mode 100755 index 0000000..70c83ea --- /dev/null +++ b/Cnc/Fanuc/FanucDialect.cs @@ -0,0 +1,9 @@ +namespace FanucProgramManager.Cnc.Fanuc +{ + public enum FanucDialect + { + Unknown = 0, + Legacy = 1, + Modern = 2 + } +} diff --git a/Cnc/Fanuc/FanucDialectDetector.cs b/Cnc/Fanuc/FanucDialectDetector.cs new file mode 100755 index 0000000..c00ecd2 --- /dev/null +++ b/Cnc/Fanuc/FanucDialectDetector.cs @@ -0,0 +1,86 @@ +using FanucProgramManager; + +namespace FanucProgramManager.Cnc.Fanuc +{ + internal static class FanucDialectDetector + { + public static FanucCapabilities Detect(ushort hndl) + { + var sys = new Focas1.ODBSYS(); + short ret = Focas1.cnc_sysinfo(hndl, sys); + if (ret != Focas1.EW_OK) + { + return new FanucCapabilities + { + CncType = "??", + ModelLetter = '?', + Dialect = FanucDialect.Unknown + }; + } + + string cncType = new string(sys.cnc_type ?? new char[] { '?', '?' }); + char modelLetter = ModelLetterFrom(sys.addinfo); + bool isI = (sys.addinfo & 0x02) != 0; + FanucDialect dialect = DialectFor(cncType, modelLetter); + + bool modern = dialect == FanucDialect.Modern; + return new FanucCapabilities + { + CncType = cncType, + ModelLetter = modelLetter, + IsISeries = isI, + Series = sys.series != null ? new string(sys.series) : "", + Version = sys.version != null ? new string(sys.version) : "", + MtType = sys.mt_type != null ? new string(sys.mt_type) : "", + MaxAxis = sys.max_axis, + Dialect = dialect, + SupportsUpDownload4 = modern, + SupportsAlmMsg2 = modern, + SupportsPathBasedPrograms = modern, + SupportsPdfProgramApi = modern + }; + } + + private static char ModelLetterFrom(short addinfo) + { + int model = (addinfo >> 8) & 0xFF; + switch (model) + { + case 1: return 'A'; + case 2: return 'B'; + case 3: return 'C'; + case 4: return 'D'; + case 6: return 'F'; + default: return ' '; + } + } + + private static FanucDialect DialectFor(string cncType, char modelLetter) + { + if (string.IsNullOrEmpty(cncType)) return FanucDialect.Unknown; + + string t = cncType; + string trimmed = cncType.Trim(); + + if (trimmed == "30" || trimmed == "31" || trimmed == "32" || trimmed == "35") + return FanucDialect.Modern; + + if (trimmed == "PM") + return FanucDialect.Modern; + + if (trimmed == "0" || t == " 0") + { + if (modelLetter == 'D' || modelLetter == 'F') return FanucDialect.Modern; + return FanucDialect.Legacy; + } + + if (trimmed == "15" || trimmed == "16" || trimmed == "18" || trimmed == "21") + return FanucDialect.Legacy; + + if (trimmed == "PD" || trimmed == "PH") + return FanucDialect.Legacy; + + return FanucDialect.Unknown; + } + } +} diff --git a/Cnc/Fanuc/FanucErrorTranslator.cs b/Cnc/Fanuc/FanucErrorTranslator.cs new file mode 100755 index 0000000..00a7357 --- /dev/null +++ b/Cnc/Fanuc/FanucErrorTranslator.cs @@ -0,0 +1,60 @@ +using System.Collections.Generic; +using FanucProgramManager; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc.Fanuc +{ + internal static class FanucErrorTranslator + { + private static readonly Dictionary Messages = new Dictionary + { + { (short)Focas1.focas_ret.EW_PROTOCOL, "protocol error" }, + { (short)Focas1.focas_ret.EW_SOCKET, "windows socket error" }, + { (short)Focas1.focas_ret.EW_NODLL, "DLL not exist error" }, + { (short)Focas1.focas_ret.EW_BUS, "bus error" }, + { (short)Focas1.focas_ret.EW_SYSTEM2, "system error" }, + { (short)Focas1.focas_ret.EW_HSSB, "hssb communication error" }, + { (short)Focas1.focas_ret.EW_HANDLE, "Windows library handle error" }, + { (short)Focas1.focas_ret.EW_VERSION, "CNC/PMC version mismatch" }, + { (short)Focas1.focas_ret.EW_UNEXP, "abnormal error" }, + { (short)Focas1.focas_ret.EW_SYSTEM, "system error" }, + { (short)Focas1.focas_ret.EW_PARITY, "shared RAM parity error" }, + { (short)Focas1.focas_ret.EW_MMCSYS, "emm386 or mmcsys install error" }, + { (short)Focas1.focas_ret.EW_RESET, "reset or stop occurred" }, + { (short)Focas1.focas_ret.EW_BUSY, "busy" }, + { (short)Focas1.focas_ret.EW_FUNC, "command prepare error / pmc not exist" }, + { (short)Focas1.focas_ret.EW_LENGTH, "data block length error" }, + { (short)Focas1.focas_ret.EW_NUMBER, "data number / address range error" }, + { (short)Focas1.focas_ret.EW_ATTRIB, "data attribute / data type error" }, + { (short)Focas1.focas_ret.EW_DATA, "data error" }, + { (short)Focas1.focas_ret.EW_NOOPT, "no option" }, + { (short)Focas1.focas_ret.EW_PROT, "write protect" }, + { (short)Focas1.focas_ret.EW_OVRFLOW, "memory overflow" }, + { (short)Focas1.focas_ret.EW_PARAM, "CNC parameter not correct" }, + { (short)Focas1.focas_ret.EW_BUFFER, "buffer empty/full" }, + { (short)Focas1.focas_ret.EW_PATH, "path error" }, + { (short)Focas1.focas_ret.EW_MODE, "CNC mode error" }, + { (short)Focas1.focas_ret.EW_REJECT, "execution rejected" }, + { (short)Focas1.focas_ret.EW_DTSRVR, "data server error" }, + { (short)Focas1.focas_ret.EW_ALARM, "alarm has been occurred" }, + { (short)Focas1.focas_ret.EW_STOP, "CNC is not running" }, + { (short)Focas1.focas_ret.EW_PASSWD, "protection data error" } + }; + + public static CncError Translate(short code, string source) + { + string msg; + if (!Messages.TryGetValue(code, out msg)) + msg = "unknown FOCAS error"; + return new CncError(code, source, msg); + } + + public static bool IsDisconnectError(short code) + { + return code == (short)Focas1.focas_ret.EW_SOCKET + || code == (short)Focas1.focas_ret.EW_HANDLE + || code == (short)Focas1.focas_ret.EW_HSSB + || code == (short)Focas1.focas_ret.EW_PROTOCOL; + } + } +} diff --git a/Cnc/Fanuc/FanucMachine.cs b/Cnc/Fanuc/FanucMachine.cs new file mode 100755 index 0000000..e5c5ca7 --- /dev/null +++ b/Cnc/Fanuc/FanucMachine.cs @@ -0,0 +1,739 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using FanucProgramManager; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc.Fanuc +{ + public sealed class FanucMachine : IFanucMachine + { + private const int AlarmSlots = 17; + private const int OperatorMsgSlots = 17; + private const int TransferChunkSize = 1024; + private const int UploadBufferSize = 10240; + private const int Param_PiecesCount = 6711; + private const int Param_CycleTimeMs = 6757; + private const int Param_CycleTimeMin = 6758; + private const string DefaultDownloadFolder = "//CNC_MEM/USER/PATH1/"; + private const string SeedProgramName = "OSTD"; + private const string SeedProgramBody = "%\n\n%"; + + private readonly FanucConnectionConfig _config; + private readonly INcProgramValidator _validator; + private readonly List _currentErrors = new List(); + private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1); + + private ushort _hndl; + private FanucCapabilities _caps; + private IFocasDialect _dialect; + private ConnectionState _state = ConnectionState.Disconnected; + + public FanucMachine(FanucConnectionConfig config) + { + if (config == null) throw new ArgumentNullException("config"); + _config = config; + _validator = new NcProgramValidator(CncManufacturer.Fanuc); + } + + internal FanucMachine(FanucConnectionConfig config, INcProgramValidator validator) + { + if (config == null) throw new ArgumentNullException("config"); + _config = config; + _validator = validator ?? new NcProgramValidator(CncManufacturer.Fanuc); + } + + public string Name { get { return _config.Name; } } + public ConnectionState State { get { return _state; } } + public FanucCapabilities Capabilities { get { return _caps; } } + + public event EventHandler StateChanged; + + public Task> ConnectAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => ConnectCore(ct), ct); + } + + public Task DisconnectAsync() + { + return RunGuardedAsync(() => { DisconnectCore(); return true; }, CancellationToken.None); + } + + public Task> ReadAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => ReadCore(ct), ct); + } + + public Task> ReadActiveProgramAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => ReadActiveProgramCore(ct), ct); + } + + public Task> ReadProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => ReadProgramCore(path, ct), ct); + } + + public Task> WriteProgramAsync(string path, CncProgram program, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => WriteProgramCore(path, program, ct), ct); + } + + public Task> SelectMainProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => SelectMainProgramCore(path), ct); + } + + public Task> DeleteProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => DeleteProgramCore(path), ct); + } + + public Task> ReadToolDataAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => UploadFocasFile(1, path, ct), ct); + } + + public Task> ReadWorkZeroDataAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => UploadFocasFile(5, path, ct), ct); + } + + public Task> WriteToolDataAsync(string folderPath, string content, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => DownloadFocasFile(1, folderPath, content, ct), ct); + } + + public Task> WriteWorkZeroDataAsync(string folderPath, string content, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => DownloadFocasFile(5, folderPath, content, ct), ct); + } + + public void Dispose() + { + try { DisconnectAsync().GetAwaiter().GetResult(); } catch { } + try { _gate.Dispose(); } catch { } + } + + private async Task> RunGuardedAsync(Func body, CancellationToken ct) + { + await _gate.WaitAsync(ct).ConfigureAwait(false); + try + { + return await Task.Run(() => + { + _currentErrors.Clear(); + try + { + T value = body(); + if (_currentErrors.Count > 0) + return CncResult.Fail(_currentErrors.ToArray()); + return CncResult.Ok(value); + } + catch (OperationCanceledException) + { + return CncResult.Cancelled(); + } + catch (Exception ex) + { + _currentErrors.Add(new CncError(0, "FanucMachine", ex.Message)); + return CncResult.Fail(_currentErrors.ToArray()); + } + }, ct).ConfigureAwait(false); + } + finally + { + _gate.Release(); + } + } + + private bool ConnectCore(CancellationToken ct) + { + if (_state == ConnectionState.Connected) return true; + SetState(ConnectionState.Connecting); + ct.ThrowIfCancellationRequested(); + + short ret; + switch (_config.Transport) + { + case FanucTransport.Ethernet: + short timeoutSec = (short)Math.Max(1, (int)_config.ConnectTimeout.TotalSeconds); + ret = Focas1.cnc_allclibhndl3(_config.IpAddress, _config.Port, timeoutSec, out _hndl); + break; + case FanucTransport.Hssb: + ret = Focas1.cnc_allclibhndl2(_config.HssbNode, out _hndl); + break; + case FanucTransport.Library: + ret = Focas1.cnc_allclibhndl(out _hndl); + break; + default: + Record((short)Focas1.focas_ret.EW_ATTRIB, "Connect"); + SetState(ConnectionState.Faulted); + return false; + } + + if (ret != Focas1.EW_OK) + { + Record(ret, "cnc_allclibhndl"); + SetState(ConnectionState.Faulted); + return false; + } + + if (ct.IsCancellationRequested) + { + try { Focas1.cnc_freelibhndl(_hndl); } catch { } + SetState(ConnectionState.Disconnected); + ct.ThrowIfCancellationRequested(); + } + + _caps = FanucDialectDetector.Detect(_hndl); + _dialect = FocasDialectFactory.Create(_caps); + if (_caps.Dialect == FanucDialect.Unknown) + _currentErrors.Add(new CncError(0, "cnc_sysinfo", "Unknown CNC model, falling back to Legacy dialect")); + + SetState(ConnectionState.Connected); + return true; + } + + private void DisconnectCore() + { + if (_state == ConnectionState.Disconnected) return; + short ret = Focas1.cnc_freelibhndl(_hndl); + if (ret != Focas1.EW_OK) + Record(ret, "cnc_freelibhndl"); + SetState(ConnectionState.Disconnected); + } + + private MachineSnapshot ReadCore(CancellationToken ct) + { + EnsureConnected(); + ct.ThrowIfCancellationRequested(); + + Focas1.cnc_setpath(_hndl, 1); + + var snap = new MachineSnapshot + { + CapturedAt = DateTime.Now, + Alarms = new List(), + OperatorMessages = new List(), + Mode = MachineMode.Unknown, + Run = RunState.Unknown, + Motion = MotionState.Unknown + }; + + snap.CycleTime = ReadCycleTime(); + ct.ThrowIfCancellationRequested(); + snap.PieceCount = ReadPieceCount(); + ct.ThrowIfCancellationRequested(); + snap.Alarms = ReadAlarms(); + ct.ThrowIfCancellationRequested(); + snap.OperatorMessages = ReadOperatorMessages(); + ct.ThrowIfCancellationRequested(); + + var stateInfo = ReadMachineState(); + snap.Mode = stateInfo.Mode; + snap.Run = stateInfo.Run; + snap.Motion = stateInfo.Motion; + snap.Emergency = stateInfo.Emergency; + snap.AlarmActive = stateInfo.Alarm; + + if (snap.Mode != MachineMode.Edit) + { + ct.ThrowIfCancellationRequested(); + var prog = ReadProgramInfo(); + snap.MainProgram = prog.MainProgram; + snap.SubProgram = prog.SubProgram; + snap.ProgramComment = prog.Comment; + } + + return snap; + } + + private string ReadActiveProgramCore(CancellationToken ct) + { + EnsureConnected(); + short ret; + string identifier = _dialect.ReadMainProgramIdentifier(_hndl, out ret); + if (ret != Focas1.EW_OK) + { + Record(ret, "ReadMainProgramIdentifier"); + return null; + } + return UploadProgramByIdentifier(identifier, ct); + } + + private string ReadProgramCore(string path, CancellationToken ct) + { + EnsureConnected(); + if (string.IsNullOrEmpty(path)) + { + _currentErrors.Add(new CncError(0, "ReadProgram", "Path is empty")); + return null; + } + return UploadProgramByIdentifier(path, ct); + } + + private bool WriteProgramCore(string folderPath, CncProgram program, CancellationToken ct) + { + EnsureConnected(); + if (program == null || string.IsNullOrEmpty(program.Content)) + { + _currentErrors.Add(new CncError(0, "WriteProgram", "Program content is empty")); + return false; + } + var vr = _validator.Validate(program.Name ?? folderPath, program.Content); + if (!vr.Success) + { + string msg = string.Join("; ", vr.Errors + .Where(e => e.Severity == ValidationSeverity.Error) + .Select(e => e.Message)); + _currentErrors.Add(new CncError(0, "Validator", msg)); + return false; + } + if (!CanDownload()) return false; + if (string.IsNullOrEmpty(folderPath)) folderPath = DefaultDownloadFolder; + + string fileName = ExtractFileNameFromContent(program); + if (string.IsNullOrEmpty(fileName)) + { + _currentErrors.Add(new CncError(0, "WriteProgram", "Cannot extract program name from content")); + return false; + } + + EnsureSeedProgram(folderPath, ct); + ct.ThrowIfCancellationRequested(); + + if (_dialect.SupportsPathBasedPrograms) + Focas1.cnc_pdf_del(_hndl, folderPath + fileName); + + short ret = _dialect.DownloadStart(_hndl, folderPath); + if (ret != Focas1.EW_OK) + { + Record(ret, "DownloadStart"); + _dialect.DownloadEnd(_hndl); + return false; + } + + try + { + if (!TransferChunked(program.Content, ct)) return false; + } + finally + { + _dialect.DownloadEnd(_hndl); + } + + if (_dialect.SupportsPathBasedPrograms) + { + ret = Focas1.cnc_pdf_slctmain(_hndl, folderPath + fileName); + if (ret != Focas1.EW_OK) + { + Record(ret, "cnc_pdf_slctmain"); + return false; + } + } + return true; + } + + private bool SelectMainProgramCore(string path) + { + EnsureConnected(); + if (!_dialect.SupportsPathBasedPrograms) + { + _currentErrors.Add(new CncError((short)Focas1.focas_ret.EW_NOOPT, + "SelectMainProgram", "Path-based selection not supported on this CNC")); + return false; + } + short ret = Focas1.cnc_pdf_slctmain(_hndl, path); + if (ret != Focas1.EW_OK) { Record(ret, "cnc_pdf_slctmain"); return false; } + return true; + } + + private bool DeleteProgramCore(string path) + { + EnsureConnected(); + if (!_dialect.SupportsPathBasedPrograms) + { + _currentErrors.Add(new CncError((short)Focas1.focas_ret.EW_NOOPT, + "DeleteProgram", "Path-based delete not supported on this CNC")); + return false; + } + short ret = Focas1.cnc_pdf_del(_hndl, path); + if (ret != Focas1.EW_OK) { Record(ret, "cnc_pdf_del"); return false; } + return true; + } + + private string UploadFocasFile(short fileType, string path, CancellationToken ct) + { + EnsureConnected(); + if (string.IsNullOrEmpty(path)) + { + _currentErrors.Add(new CncError(0, "UploadFocasFile", "Path is empty")); + return null; + } + long programNumber = TryParseProgramNumber(path); + short ret = _dialect.UploadStart(_hndl, path, programNumber, fileType); + if (ret != Focas1.EW_OK) + { + Record(ret, "UploadStart"); + _dialect.UploadEnd(_hndl); + return null; + } + var output = new StringBuilder(); + char[] buffer = new char[UploadBufferSize + 1]; + try + { + while (true) + { + ct.ThrowIfCancellationRequested(); + int len = UploadBufferSize; + short r = _dialect.UploadData(_hndl, ref len, buffer); + if (r == (short)Focas1.focas_ret.EW_BUFFER) + { + if (ct.WaitHandle.WaitOne(100)) ct.ThrowIfCancellationRequested(); + continue; + } + if (r == Focas1.EW_OK && len > 0) + { + output.Append(buffer, 0, len); + if (buffer[len - 1] == '%') break; + } + else + { + if (r != Focas1.EW_OK) Record(r, "UploadData"); + break; + } + } + } + finally { _dialect.UploadEnd(_hndl); } + return output.ToString(); + } + + private bool DownloadFocasFile(short fileType, string folderPath, string content, CancellationToken ct) + { + EnsureConnected(); + if (string.IsNullOrEmpty(content)) + { + _currentErrors.Add(new CncError(0, "DownloadFocasFile", "Content is empty")); + return false; + } + if (string.IsNullOrEmpty(folderPath)) folderPath = DefaultDownloadFolder; + short ret = _dialect.DownloadStart(_hndl, folderPath, fileType); + if (ret != Focas1.EW_OK) + { + Record(ret, "DownloadStart"); + _dialect.DownloadEnd(_hndl); + return false; + } + try { return TransferChunked(content, ct); } + finally { _dialect.DownloadEnd(_hndl); } + } + + private TimeSpan ReadCycleTime() + { + var ms = new Focas1.IODBPSD(); + var min = new Focas1.IODBPSD(); + short r1 = Focas1.cnc_rdparam(_hndl, Param_CycleTimeMs, 0, 8, ms); + short r2 = Focas1.cnc_rdparam(_hndl, Param_CycleTimeMin, 0, 8, min); + if (r1 != Focas1.EW_OK) Record(r1, "cnc_rdparam(cycle ms)"); + if (r2 != Focas1.EW_OK) Record(r2, "cnc_rdparam(cycle min)"); + return TimeSpan.FromMinutes(min.u.ldata) + TimeSpan.FromMilliseconds(ms.u.ldata); + } + + private long ReadPieceCount() + { + try + { + if (_config.PieceCounterMacro == -1) + { + var p = new Focas1.IODBPSD(); + short ret = Focas1.cnc_rdparam(_hndl, Param_PiecesCount, 0, 8, p); + if (ret != Focas1.EW_OK) { Record(ret, "cnc_rdparam(pieces)"); return 0; } + return p.u.ldata; + } + var macro = new Focas1.ODBM(); + short macRet = Focas1.cnc_rdmacro(_hndl, (short)_config.PieceCounterMacro, 10, macro); + if (macRet != Focas1.EW_OK) { Record(macRet, "cnc_rdmacro(pieces)"); return 0; } + long val = Math.Abs(macro.mcr_val); + if (macro.dec_val > 0) val = val / (long)Math.Pow(10, macro.dec_val); + return macro.mcr_val < 0 ? -val : val; + } + catch (Exception ex) + { + _currentErrors.Add(new CncError(0, "ReadPieceCount", ex.Message)); + return 0; + } + } + + private IReadOnlyList ReadAlarms() + { + string[] buf = new string[AlarmSlots]; + short num = AlarmSlots; + short ret = _dialect.ReadAlarmMessages(_hndl, ref num, buf); + if (ret != Focas1.EW_OK) Record(ret, "ReadAlarmMessages"); + var list = new List(num); + for (int i = 0; i < num; i++) + if (!string.IsNullOrEmpty(buf[i])) list.Add(buf[i]); + return list; + } + + private IReadOnlyList ReadOperatorMessages() + { + string[] buf = new string[OperatorMsgSlots]; + short num = 1; + short ret = _dialect.ReadOperatorMessages(_hndl, ref num, buf); + if (ret != Focas1.EW_OK) Record(ret, "ReadOperatorMessages"); + var list = new List(num); + for (int i = 0; i < num; i++) + if (!string.IsNullOrEmpty(buf[i])) list.Add(buf[i]); + return list; + } + + private struct StateInfo + { + public MachineMode Mode; + public RunState Run; + public MotionState Motion; + public bool Emergency; + public bool Alarm; + } + + private StateInfo ReadMachineState() + { + var s = new StateInfo + { + Mode = MachineMode.Unknown, + Run = RunState.Unknown, + Motion = MotionState.Unknown + }; + var odbst = new Focas1.ODBST(); + short ret = Focas1.cnc_statinfo(_hndl, odbst); + if (ret != Focas1.EW_OK) { Record(ret, "cnc_statinfo"); return s; } + + switch (odbst.aut) + { + case 0: s.Mode = MachineMode.Mdi; break; + case 1: s.Mode = MachineMode.Auto; break; + case 3: s.Mode = MachineMode.Edit; break; + case 4: s.Mode = MachineMode.Handle; break; + case 5: s.Mode = MachineMode.Jog; break; + } + switch (odbst.run) + { + case 1: s.Run = RunState.Stop; break; + case 3: s.Run = RunState.ExecutingIso; break; + } + switch (odbst.motion) + { + case 0: s.Motion = MotionState.Idle; break; + case 1: s.Motion = MotionState.Moving; break; + case 2: s.Motion = MotionState.Hold; break; + } + s.Emergency = odbst.emergency == 1; + s.Alarm = odbst.alarm == 1; + return s; + } + + private struct ProgramInfo + { + public string MainProgram; + public string SubProgram; + public string Comment; + } + + private ProgramInfo ReadProgramInfo() + { + var info = new ProgramInfo { MainProgram = "", SubProgram = "", Comment = "" }; + + var prog = new Focas1.ODBPRO(); + short ret = Focas1.cnc_rdprgnum(_hndl, prog); + if (ret != Focas1.EW_OK) { Record(ret, "cnc_rdprgnum"); return info; } + info.SubProgram = "O" + prog.data.ToString(); + info.MainProgram = "O" + prog.mdata.ToString(); + + if (_dialect.SupportsPathBasedPrograms) + { + byte[] mainPath = new byte[242]; + short pathRet = Focas1.cnc_pdf_rdmain(_hndl, mainPath); + if (pathRet == Focas1.EW_OK) + { + string str = ASCIIEncoding.ASCII.GetString(mainPath).TrimEnd('\0'); + string[] parts = str.Split('/'); + if (parts.Length > 0) info.MainProgram = parts[parts.Length - 1]; + } + } + + byte[] commentBuf = new byte[100]; + int charsRead; + short cret = _dialect.ReadActiveProgramComment(_hndl, commentBuf, out charsRead); + if (cret != Focas1.EW_OK) { Record(cret, "ReadActiveProgramComment"); return info; } + + string raw = ASCIIEncoding.ASCII.GetString(commentBuf).TrimEnd('\0'); + int open = raw.IndexOf('('); + int close = raw.IndexOf(')'); + if (open >= 0 && close > open) + info.Comment = raw.Substring(open + 1, close - open - 1); + else + info.Comment = ""; + return info; + } + + private string UploadProgramByIdentifier(string identifier, CancellationToken ct) + { + long programNumber = TryParseProgramNumber(identifier); + short ret = _dialect.UploadStart(_hndl, identifier, programNumber); + if (ret != Focas1.EW_OK) + { + Record(ret, "UploadStart"); + _dialect.UploadEnd(_hndl); + return null; + } + + var output = new StringBuilder(); + char[] buffer = new char[UploadBufferSize + 1]; + try + { + while (true) + { + ct.ThrowIfCancellationRequested(); + int len = UploadBufferSize; + short r = _dialect.UploadData(_hndl, ref len, buffer); + if (r == (short)Focas1.focas_ret.EW_BUFFER) + { + if (ct.WaitHandle.WaitOne(100)) ct.ThrowIfCancellationRequested(); + continue; + } + if (r == Focas1.EW_OK && len > 0) + { + output.Append(buffer, 0, len); + if (len > 0 && buffer[len - 1] == '%') break; + } + else + { + if (r != Focas1.EW_OK) Record(r, "UploadData"); + break; + } + } + } + finally + { + _dialect.UploadEnd(_hndl); + } + return output.ToString(); + } + + private bool TransferChunked(string content, CancellationToken ct) + { + int len = content.Length; + int startPos = 0; + while (len > 0) + { + ct.ThrowIfCancellationRequested(); + int num = len >= TransferChunkSize ? TransferChunkSize : len; + char[] chunk = new char[num]; + content.CopyTo(startPos, chunk, 0, num); + + short ret = _dialect.DownloadData(_hndl, ref num, chunk); + if (ret == (short)Focas1.focas_ret.EW_BUFFER) + { + if (ct.WaitHandle.WaitOne(100)) ct.ThrowIfCancellationRequested(); + continue; + } + if (ret == Focas1.EW_OK) + { + startPos += num; + len -= num; + continue; + } + Record(ret, "DownloadData"); + var dtl = new Focas1.ODBERR(); + Focas1.cnc_getdtailerr(_hndl, dtl); + Debug.WriteLine("FOCAS detail err: " + dtl.err_no + " " + dtl.err_dtno); + return false; + } + return true; + } + + private bool CanDownload() + { + var odbst = new Focas1.ODBST(); + short ret = Focas1.cnc_statinfo(_hndl, odbst); + if (ret != Focas1.EW_OK) { Record(ret, "cnc_statinfo(canDownload)"); return false; } + if (odbst.aut != 0 && odbst.aut != 3) + { + Record((short)Focas1.focas_ret.EW_MODE, "CanDownload"); + return false; + } + return true; + } + + private void EnsureSeedProgram(string folderPath, CancellationToken ct) + { + if (!_dialect.SupportsPathBasedPrograms) return; + short selRet = Focas1.cnc_pdf_slctmain(_hndl, folderPath + SeedProgramName); + if (selRet == Focas1.EW_OK) return; + + Focas1.cnc_pdf_del(_hndl, folderPath + SeedProgramName); + short sStart = _dialect.DownloadStart(_hndl, folderPath); + if (sStart != Focas1.EW_OK) { _dialect.DownloadEnd(_hndl); return; } + TransferChunked(SeedProgramBody, ct); + _dialect.DownloadEnd(_hndl); + Focas1.cnc_pdf_slctmain(_hndl, folderPath + SeedProgramName); + } + + private static string ExtractFileNameFromContent(CncProgram program) + { + if (!string.IsNullOrEmpty(program.Name)) return program.Name; + string content = program.Content ?? ""; + int start = content.IndexOf('<'); + int end = content.IndexOf('>'); + if (start >= 0 && end > start) return content.Substring(start + 1, end - start - 1); + return null; + } + + private static long TryParseProgramNumber(string identifier) + { + if (string.IsNullOrEmpty(identifier)) return 0; + string s = identifier; + int slash = s.LastIndexOf('/'); + if (slash >= 0 && slash < s.Length - 1) s = s.Substring(slash + 1); + if (s.Length > 0 && (s[0] == 'O' || s[0] == 'o')) s = s.Substring(1); + long n; + return long.TryParse(s, out n) ? n : 0; + } + + private void EnsureConnected() + { + if (_state != ConnectionState.Connected || _dialect == null) + throw new InvalidOperationException("FanucMachine is not connected."); + } + + private void Record(short code, string source) + { + var err = FanucErrorTranslator.Translate(code, source); + _currentErrors.Add(err); + if (FanucErrorTranslator.IsDisconnectError(code)) + { + SetState(ConnectionState.Faulted); + try { Focas1.cnc_freelibhndl(_hndl); } catch { } + SetState(ConnectionState.Disconnected); + } + } + + private void SetState(ConnectionState next) + { + if (_state == next) return; + _state = next; + var h = StateChanged; + if (h != null) + { + try { h(this, next); } catch { } + } + } + } +} diff --git a/Cnc/Fanuc/FocasDialectFactory.cs b/Cnc/Fanuc/FocasDialectFactory.cs new file mode 100755 index 0000000..ee8b147 --- /dev/null +++ b/Cnc/Fanuc/FocasDialectFactory.cs @@ -0,0 +1,21 @@ +using System; + +namespace FanucProgramManager.Cnc.Fanuc +{ + internal static class FocasDialectFactory + { + public static IFocasDialect Create(FanucCapabilities caps) + { + if (caps == null) return new LegacyFocasDialect(); + switch (caps.Dialect) + { + case FanucDialect.Modern: return new ModernFocasDialect(); + case FanucDialect.Legacy: + case FanucDialect.Unknown: + return new LegacyFocasDialect(); + default: + throw new InvalidOperationException("Unsupported FanucDialect: " + caps.Dialect); + } + } + } +} diff --git a/Cnc/Fanuc/IFocasDialect.cs b/Cnc/Fanuc/IFocasDialect.cs new file mode 100755 index 0000000..1bfdc20 --- /dev/null +++ b/Cnc/Fanuc/IFocasDialect.cs @@ -0,0 +1,23 @@ +namespace FanucProgramManager.Cnc.Fanuc +{ + internal interface IFocasDialect + { + FanucDialect Dialect { get; } + bool SupportsPathBasedPrograms { get; } + bool SupportsAlmMsg2 { get; } + + short ReadAlarmMessages(ushort hndl, ref short num, string[] outBuffer); + short ReadOperatorMessages(ushort hndl, ref short num, string[] outBuffer); + + short DownloadStart(ushort hndl, string folderPath, short fileType = 0); + short DownloadData(ushort hndl, ref int len, char[] data); + short DownloadEnd(ushort hndl); + + short UploadStart(ushort hndl, string fileName, long programNumber, short fileType = 0); + short UploadData(ushort hndl, ref int len, char[] data); + short UploadEnd(ushort hndl); + + string ReadMainProgramIdentifier(ushort hndl, out short ret); + short ReadActiveProgramComment(ushort hndl, byte[] buffer, out int charsRead); + } +} diff --git a/Cnc/Fanuc/IsoProgramFormatter.cs b/Cnc/Fanuc/IsoProgramFormatter.cs new file mode 100755 index 0000000..6cdeb5a --- /dev/null +++ b/Cnc/Fanuc/IsoProgramFormatter.cs @@ -0,0 +1,95 @@ +namespace FanucProgramManager.Cnc.Fanuc +{ + public static class IsoProgramFormatter + { + public static string EnsureTitleBrackets(string program) + { + if (string.IsNullOrEmpty(program)) return program; + string head, body; + if (!SplitFirstNonEmptyLine(program, out head, out body)) return program; + + int openAngle = head.IndexOf('<'); + if (openAngle >= 0) return program; + + int openPar = head.IndexOf('('); + int closePar = head.IndexOf(')'); + + int titleStart = FindTitleStart(head); + head = head.Insert(titleStart, "<"); + if (closePar > 0) + { + openPar = head.IndexOf('('); + head = head.Insert(openPar, ">"); + } + else + { + head = head + ">"; + } + return head + body; + } + + public static string InsertOrReplaceComment(string program, string comment) + { + if (string.IsNullOrEmpty(program)) return program; + program = EnsureTitleBrackets(program); + + string head, body; + if (!SplitFirstNonEmptyLine(program, out head, out body)) return program; + + int openPar = head.IndexOf('('); + int closePar = head.IndexOf(')'); + if (openPar > 0 && closePar > openPar) + { + head = head.Remove(openPar + 1, closePar - openPar - 1); + head = head.Insert(openPar + 1, comment ?? ""); + } + else + { + head = head + "(" + (comment ?? "") + ")"; + } + return head + body; + } + + public static string RenameAndComment(string program, string name, string comment) + { + if (string.IsNullOrEmpty(program)) return program; + string head, body; + if (!SplitFirstNonEmptyLine(program, out head, out body)) return program; + + string newHead = "%\n<" + (name ?? "") + ">(" + (comment ?? "") + ")"; + return newHead + body; + } + + private static bool SplitFirstNonEmptyLine(string program, out string head, out string body) + { + head = program; + body = ""; + bool sawFirstLf = false; + int lastLf = -1; + for (int i = 0; i < program.Length; i++) + { + if (program[i] == '\n') + { + if (sawFirstLf) + { + head = program.Substring(0, i); + body = program.Substring(i); + return true; + } + sawFirstLf = true; + lastLf = i; + } + } + return false; + } + + private static int FindTitleStart(string head) + { + for (int i = 0; i < head.Length; i++) + { + if (head[i] == '\n') return i + 1; + } + return 0; + } + } +} diff --git a/Cnc/Fanuc/LegacyFocasDialect.cs b/Cnc/Fanuc/LegacyFocasDialect.cs new file mode 100755 index 0000000..5120c64 --- /dev/null +++ b/Cnc/Fanuc/LegacyFocasDialect.cs @@ -0,0 +1,76 @@ +using FanucProgramManager; + +namespace FanucProgramManager.Cnc.Fanuc +{ + internal sealed class LegacyFocasDialect : IFocasDialect + { + public FanucDialect Dialect { get { return FanucDialect.Legacy; } } + public bool SupportsPathBasedPrograms { get { return false; } } + public bool SupportsAlmMsg2 { get { return false; } } + + public short DownloadStart(ushort hndl, string folderPath, short fileType = 0) + { + return Focas1.cnc_dwnstart3(hndl, fileType); + } + + public short DownloadData(ushort hndl, ref int len, char[] data) + { + return Focas1.cnc_download3(hndl, ref len, data); + } + + public short DownloadEnd(ushort hndl) + { + return Focas1.cnc_dwnend3(hndl); + } + + public short UploadStart(ushort hndl, string fileName, long programNumber, short fileType = 0) + { + int pn = (int)programNumber; + return Focas1.cnc_upstart3(hndl, fileType, pn, pn); + } + + public short UploadData(ushort hndl, ref int len, char[] data) + { + return Focas1.cnc_upload3(hndl, ref len, data); + } + + public short UploadEnd(ushort hndl) + { + return Focas1.cnc_upend3(hndl); + } + + public short ReadAlarmMessages(ushort hndl, ref short num, string[] outBuffer) + { + var arr = new Focas1.ODBALMMSG_data_custom[outBuffer.Length]; + short ret = Focas1.cnc_rdalmmsg_custom(hndl, 0, ref num, arr); + for (int i = 0; i < num && i < outBuffer.Length; i++) + outBuffer[i] = arr[i].msg_len > 0 ? arr[i].alm_msg : ""; + return ret; + } + + public short ReadOperatorMessages(ushort hndl, ref short num, string[] outBuffer) + { + var arr = new Focas1.OPMSG3_data_custom[outBuffer.Length]; + short ret = Focas1.cnc_rdopmsg3_custom(hndl, 4, ref num, arr); + for (int i = 0; i < num && i < outBuffer.Length; i++) + outBuffer[i] = arr[i].char_num > 0 ? arr[i].data : ""; + return ret; + } + + public string ReadMainProgramIdentifier(ushort hndl, out short ret) + { + var prog = new Focas1.ODBPRO(); + ret = Focas1.cnc_rdprgnum(hndl, prog); + return "O" + prog.mdata.ToString(); + } + + public short ReadActiveProgramComment(ushort hndl, byte[] buffer, out int charsRead) + { + ushort len = (ushort)buffer.Length; + short blk; + short ret = Focas1.cnc_rdexecprog(hndl, ref len, out blk, buffer); + charsRead = len; + return ret; + } + } +} diff --git a/Cnc/Fanuc/ModernFocasDialect.cs b/Cnc/Fanuc/ModernFocasDialect.cs new file mode 100755 index 0000000..13dd273 --- /dev/null +++ b/Cnc/Fanuc/ModernFocasDialect.cs @@ -0,0 +1,79 @@ +using System.Text; +using FanucProgramManager; + +namespace FanucProgramManager.Cnc.Fanuc +{ + internal sealed class ModernFocasDialect : IFocasDialect + { + public FanucDialect Dialect { get { return FanucDialect.Modern; } } + public bool SupportsPathBasedPrograms { get { return true; } } + public bool SupportsAlmMsg2 { get { return true; } } + + public short DownloadStart(ushort hndl, string folderPath, short fileType = 0) + { + return Focas1.cnc_dwnstart4(hndl, fileType, folderPath); + } + + public short DownloadData(ushort hndl, ref int len, char[] data) + { + return Focas1.cnc_download4(hndl, ref len, data); + } + + public short DownloadEnd(ushort hndl) + { + return Focas1.cnc_dwnend4(hndl); + } + + public short UploadStart(ushort hndl, string fileName, long programNumber, short fileType = 0) + { + return Focas1.cnc_upstart4(hndl, fileType, fileName); + } + + public short UploadData(ushort hndl, ref int len, char[] data) + { + return Focas1.cnc_upload4(hndl, ref len, data); + } + + public short UploadEnd(ushort hndl) + { + return Focas1.cnc_upend4(hndl); + } + + public short ReadAlarmMessages(ushort hndl, ref short num, string[] outBuffer) + { + var arr = new Focas1.ODBALMMSG2_data_custom[outBuffer.Length]; + short ret = Focas1.cnc_rdalmmsg2_custom(hndl, -1, ref num, arr); + for (int i = 0; i < num && i < outBuffer.Length; i++) + outBuffer[i] = arr[i].msg_len > 0 ? arr[i].alm_msg : ""; + return ret; + } + + public short ReadOperatorMessages(ushort hndl, ref short num, string[] outBuffer) + { + var arr = new Focas1.OPMSG3_data_custom[outBuffer.Length]; + short ret = Focas1.cnc_rdopmsg3_custom(hndl, 4, ref num, arr); + for (int i = 0; i < num && i < outBuffer.Length; i++) + outBuffer[i] = arr[i].char_num > 0 ? arr[i].data : ""; + return ret; + } + + public string ReadMainProgramIdentifier(ushort hndl, out short ret) + { + byte[] buf = new byte[242]; + ret = Focas1.cnc_pdf_rdmain(hndl, buf); + return ASCIIEncoding.ASCII.GetString(buf).TrimEnd('\0'); + } + + public short ReadActiveProgramComment(ushort hndl, byte[] buffer, out int charsRead) + { + uint len = (uint)buffer.Length; + uint rows = 1; + byte[] main = new byte[242]; + Focas1.cnc_pdf_rdmain(hndl, main); + string mainPath = ASCIIEncoding.ASCII.GetString(main).TrimEnd('\0'); + short ret = Focas1.cnc_rdpdf_line(hndl, mainPath, 0, buffer, ref rows, ref len); + charsRead = (int)len; + return ret; + } + } +} diff --git a/Cnc/Fanuc/libs/Fwlib32.dll b/Cnc/Fanuc/libs/Fwlib32.dll new file mode 100755 index 0000000..4277c94 Binary files /dev/null and b/Cnc/Fanuc/libs/Fwlib32.dll differ diff --git a/Cnc/Fanuc/libs/fwlibNCG.dll b/Cnc/Fanuc/libs/fwlibNCG.dll new file mode 100755 index 0000000..608187f Binary files /dev/null and b/Cnc/Fanuc/libs/fwlibNCG.dll differ diff --git a/Cnc/Fanuc/libs/fwlibe1.dll b/Cnc/Fanuc/libs/fwlibe1.dll new file mode 100755 index 0000000..b6782bc Binary files /dev/null and b/Cnc/Fanuc/libs/fwlibe1.dll differ diff --git a/Cnc/Heidenhain/HeidenhainConnectionConfig.cs b/Cnc/Heidenhain/HeidenhainConnectionConfig.cs new file mode 100644 index 0000000..b4ffc9f --- /dev/null +++ b/Cnc/Heidenhain/HeidenhainConnectionConfig.cs @@ -0,0 +1,15 @@ +using System; + +namespace FanucProgramManager.Cnc.Heidenhain +{ + public sealed class HeidenhainConnectionConfig + { + public string Name { get; set; } + public string IpAddress { get; set; } + /// LSV2 data port — default 19000. + public int Port { get; set; } = 19000; + public string Username { get; set; } = string.Empty; + public string Password { get; set; } = string.Empty; + public TimeSpan ConnectTimeout { get; set; } = TimeSpan.FromSeconds(5); + } +} diff --git a/Cnc/Heidenhain/HeidenhainMachine.cs b/Cnc/Heidenhain/HeidenhainMachine.cs new file mode 100644 index 0000000..fb03314 --- /dev/null +++ b/Cnc/Heidenhain/HeidenhainMachine.cs @@ -0,0 +1,201 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc.Heidenhain +{ + public sealed class HeidenhainMachine : ICncMachine + { + private readonly HeidenhainConnectionConfig _config; + private readonly INcProgramValidator _validator; + private readonly List _errors = new List(); + private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1); + private ILsv2Client _client; + private ConnectionState _state = ConnectionState.Disconnected; + + public HeidenhainMachine(HeidenhainConnectionConfig config) + { + if (config == null) throw new ArgumentNullException("config"); + _config = config; + _validator = new NcProgramValidator(CncManufacturer.Heidenhain); + } + + internal HeidenhainMachine(HeidenhainConnectionConfig config, ILsv2Client client, + INcProgramValidator validator = null) + { + _config = config ?? throw new ArgumentNullException("config"); + _client = client ?? throw new ArgumentNullException("client"); + _validator = validator ?? new NcProgramValidator(CncManufacturer.Heidenhain); + _state = ConnectionState.Connected; + } + + public string Name => _config.Name; + public ConnectionState State => _state; + + public event EventHandler StateChanged; + + public Task> ConnectAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + SetState(ConnectionState.Connecting); + _client = new Lsv2Client(_config); + if (!_client.Connect()) + { + SetState(ConnectionState.Faulted); + _errors.Add(new CncError(0, "Connect", "LSV2 connection or login failed")); + return false; + } + SetState(ConnectionState.Connected); + return true; + }, ct); + } + + public Task DisconnectAsync() + { + return RunGuardedAsync(() => + { + if (_client != null) + { + _client.Disconnect(); + _client = null; + } + SetState(ConnectionState.Disconnected); + return true; + }, CancellationToken.None); + } + + public Task> ReadProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + string content = _client.ReceiveFile(path); + if (content == null) + _errors.Add(new CncError(0, "ReadProgram", "ReceiveFile returned null for: " + path)); + return content; + }, ct); + } + + public Task> WriteProgramAsync(string path, CncProgram program, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + if (program == null || string.IsNullOrEmpty(program.Content)) + { + _errors.Add(new CncError(0, "WriteProgram", "Program content is empty")); + return false; + } + var vr = _validator.Validate(program.Name ?? path, program.Content); + if (!vr.Success) + { + string msg = string.Join("; ", vr.Errors + .Where(e => e.Severity == ValidationSeverity.Error) + .Select(e => e.Message)); + _errors.Add(new CncError(0, "Validator", msg)); + return false; + } + string ncPath = BuildNcPath(path, program.Name); + bool ok = _client.SendFile(ncPath, program.Content); + if (!ok) _errors.Add(new CncError(0, "WriteProgram", "SendFile failed for: " + ncPath)); + return ok; + }, ct); + } + + public Task> ReadAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + return new MachineSnapshot + { + CapturedAt = DateTime.Now, + Mode = MachineMode.Unknown, + Run = RunState.Unknown, + Motion = MotionState.Unknown, + Alarms = new List(), + OperatorMessages = new List() + }; + }, ct); + } + + public Task> ReadActiveProgramAsync(CancellationToken ct = default(CancellationToken)) => + Task.FromResult(CncResult.Fail("ReadActiveProgram", "Not supported via basic LSV2")); + + public Task> SelectMainProgramAsync(string path, CancellationToken ct = default(CancellationToken)) => + Task.FromResult(CncResult.Fail("SelectMainProgram", "Not supported via basic LSV2")); + + public Task> DeleteProgramAsync(string path, CancellationToken ct = default(CancellationToken)) => + Task.FromResult(CncResult.Fail("DeleteProgram", "Not supported via basic LSV2")); + + public void Dispose() + { + try { DisconnectAsync().GetAwaiter().GetResult(); } catch { } + try { _gate.Dispose(); } catch { } + } + + // ── private ────────────────────────────────────────────────────────── + + private async Task> RunGuardedAsync(Func body, CancellationToken ct) + { + await _gate.WaitAsync(ct).ConfigureAwait(false); + try + { + return await Task.Run(() => + { + _errors.Clear(); + try + { + T value = body(); + return _errors.Count > 0 + ? CncResult.Fail(_errors.ToArray()) + : CncResult.Ok(value); + } + catch (OperationCanceledException) + { + return CncResult.Cancelled(); + } + catch (Exception ex) + { + _errors.Add(new CncError(0, "HeidenhainMachine", ex.Message)); + return CncResult.Fail(_errors.ToArray()); + } + }, ct).ConfigureAwait(false); + } + finally + { + _gate.Release(); + } + } + + private void EnsureConnected() + { + if (_state != ConnectionState.Connected || _client == null) + throw new InvalidOperationException("HeidenhainMachine is not connected."); + } + + private void SetState(ConnectionState next) + { + if (_state == next) return; + _state = next; + var h = StateChanged; + if (h != null) + { + try { h(this, next); } catch { } + } + } + + private static string BuildNcPath(string folder, string name) + { + if (string.IsNullOrEmpty(name)) return folder; + string sep = (folder.EndsWith("\\") || folder.EndsWith("/")) ? "" : "\\"; + string ext = name.Contains(".") ? "" : ".H"; + return folder + sep + name + ext; + } + } +} diff --git a/Cnc/Heidenhain/ILsv2Client.cs b/Cnc/Heidenhain/ILsv2Client.cs new file mode 100644 index 0000000..53a9519 --- /dev/null +++ b/Cnc/Heidenhain/ILsv2Client.cs @@ -0,0 +1,10 @@ +namespace FanucProgramManager.Cnc.Heidenhain +{ + internal interface ILsv2Client + { + bool Connect(); + void Disconnect(); + string ReceiveFile(string ncPath); + bool SendFile(string ncPath, string content); + } +} diff --git a/Cnc/Heidenhain/Lsv2Client.cs b/Cnc/Heidenhain/Lsv2Client.cs new file mode 100644 index 0000000..39b2ce7 --- /dev/null +++ b/Cnc/Heidenhain/Lsv2Client.cs @@ -0,0 +1,180 @@ +using System; +using System.Net.Sockets; +using System.Text; + +namespace FanucProgramManager.Cnc.Heidenhain +{ + /// LSV2 protocol client for Heidenhain TNC controls. + internal sealed class Lsv2Client : ILsv2Client, IDisposable + { + private TcpClient _tcp; + private NetworkStream _stream; + private readonly HeidenhainConnectionConfig _config; + + private const ushort T_OK = 0x0000; + private const ushort T_SE = 0x0001; + private const ushort T_LS_SELECT = 0x00A0; + private const ushort T_LS_LOG_IN = 0x00A1; + private const ushort T_LS_LOG_OUT = 0x00A2; + private const ushort T_R_FL = 0x0023; + private const ushort T_S_FL = 0x0024; + private const ushort T_FD = 0x0025; + + public Lsv2Client(HeidenhainConnectionConfig config) + { + _config = config; + } + + public bool Connect() + { + _tcp = new TcpClient(); + _tcp.SendTimeout = (int)_config.ConnectTimeout.TotalMilliseconds; + _tcp.ReceiveTimeout = (int)_config.ConnectTimeout.TotalMilliseconds; + if (!_tcp.ConnectAsync(_config.IpAddress, _config.Port).Wait(_config.ConnectTimeout)) + return false; + _stream = _tcp.GetStream(); + return Login(); + } + + public void Disconnect() + { + try { SendCommand(T_LS_LOG_OUT, new byte[0]); } catch { } + try { if (_stream != null) _stream.Close(); } catch { } + try { if (_tcp != null) _tcp.Close(); } catch { } + } + + /// Upload file from NC to PC. Returns file content or null on failure. + public string ReceiveFile(string ncPath) + { + byte[] pathBytes = Encoding.ASCII.GetBytes(ncPath + "\0"); + SendCommand(T_R_FL, pathBytes); + + var sb = new StringBuilder(); + while (true) + { + ushort cmd; + byte[] data = ReadFrame(out cmd); + if (cmd == T_SE || data == null) return null; + if (cmd == T_OK) break; + if (cmd == T_FD) sb.Append(Encoding.ASCII.GetString(data)); + } + return sb.ToString(); + } + + /// Download file from PC to NC. + public bool SendFile(string ncPath, string content) + { + byte[] pathBytes = Encoding.ASCII.GetBytes(ncPath + "\0"); + byte[] contentBytes = Encoding.ASCII.GetBytes(content); + byte[] payload = new byte[pathBytes.Length + contentBytes.Length]; + Buffer.BlockCopy(pathBytes, 0, payload, 0, pathBytes.Length); + Buffer.BlockCopy(contentBytes, 0, payload, pathBytes.Length, contentBytes.Length); + SendCommand(T_S_FL, payload); + + ushort cmd; + ReadFrame(out cmd); + return cmd == T_OK; + } + + public void Dispose() => Disconnect(); + + // ── private ────────────────────────────────────────────────────────── + + private bool Login() + { + // Select programming mode (3) + byte[] mode = { 0x03 }; + SendCommand(T_LS_SELECT, mode); + ushort cmd; + ReadFrame(out cmd); + if (cmd != T_OK) return false; + + // Authenticate + byte[] user = Encoding.ASCII.GetBytes(_config.Username + "\0"); + byte[] pass = Encoding.ASCII.GetBytes(_config.Password + "\0"); + byte[] cred = new byte[user.Length + pass.Length]; + Buffer.BlockCopy(user, 0, cred, 0, user.Length); + Buffer.BlockCopy(pass, 0, cred, user.Length, pass.Length); + SendCommand(T_LS_LOG_IN, cred); + ReadFrame(out cmd); + return cmd == T_OK; + } + + private void SendCommand(ushort cmdCode, byte[] data) + { + int dataLen = data.Length; + ushort size = (ushort)(2 + dataLen); + + byte sizeHi = (byte)(size >> 8); + byte sizeLo = (byte)(size & 0xFF); + byte cmdHi = (byte)(cmdCode >> 8); + byte cmdLo = (byte)(cmdCode & 0xFF); + + byte[] crcInput = new byte[4 + dataLen]; + crcInput[0] = sizeHi; crcInput[1] = sizeLo; + crcInput[2] = cmdHi; crcInput[3] = cmdLo; + Buffer.BlockCopy(data, 0, crcInput, 4, dataLen); + ushort crc = Crc16(crcInput); + + byte[] frame = new byte[1 + 4 + dataLen + 2]; + int i = 0; + frame[i++] = 0x02; + frame[i++] = sizeHi; + frame[i++] = sizeLo; + frame[i++] = cmdHi; + frame[i++] = cmdLo; + Buffer.BlockCopy(data, 0, frame, i, dataLen); + i += dataLen; + frame[i++] = (byte)(crc >> 8); + frame[i] = (byte)(crc & 0xFF); + + _stream.Write(frame, 0, frame.Length); + } + + private byte[] ReadFrame(out ushort cmd) + { + cmd = 0xFFFF; + int stx = _stream.ReadByte(); + if (stx != 0x02) return null; + + byte sizeHi = (byte)_stream.ReadByte(); + byte sizeLo = (byte)_stream.ReadByte(); + int size = (sizeHi << 8) | sizeLo; + if (size < 2) return null; + + byte cmdHi = (byte)_stream.ReadByte(); + byte cmdLo = (byte)_stream.ReadByte(); + cmd = (ushort)((cmdHi << 8) | cmdLo); + + int dataLen = size - 2; + byte[] data = new byte[dataLen]; + int read = 0; + while (read < dataLen) + { + int n = _stream.Read(data, read, dataLen - read); + if (n == 0) break; + read += n; + } + + // consume CRC bytes + _stream.ReadByte(); + _stream.ReadByte(); + + return data; + } + + private static ushort Crc16(byte[] data) + { + ushort crc = 0xFFFF; + foreach (byte b in data) + { + crc ^= (ushort)(b << 8); + for (int i = 0; i < 8; i++) + crc = (crc & 0x8000) != 0 + ? (ushort)((crc << 1) ^ 0x1021) + : (ushort)(crc << 1); + } + return crc; + } + } +} diff --git a/Cnc/ICncMachine.cs b/Cnc/ICncMachine.cs new file mode 100755 index 0000000..7620727 --- /dev/null +++ b/Cnc/ICncMachine.cs @@ -0,0 +1,26 @@ +using System; +using System.Threading; +using System.Threading.Tasks; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc +{ + public interface ICncMachine : IDisposable + { + string Name { get; } + ConnectionState State { get; } + + event EventHandler StateChanged; + + Task> ConnectAsync(CancellationToken ct = default); + Task DisconnectAsync(); + + Task> ReadAsync(CancellationToken ct = default); + + Task> ReadActiveProgramAsync(CancellationToken ct = default); + Task> ReadProgramAsync(string path, CancellationToken ct = default); + Task> WriteProgramAsync(string path, CncProgram program, CancellationToken ct = default); + Task> SelectMainProgramAsync(string path, CancellationToken ct = default); + Task> DeleteProgramAsync(string path, CancellationToken ct = default); + } +} diff --git a/Cnc/IFanucMachine.cs b/Cnc/IFanucMachine.cs new file mode 100644 index 0000000..f6bbe5b --- /dev/null +++ b/Cnc/IFanucMachine.cs @@ -0,0 +1,15 @@ +using System.Threading; +using System.Threading.Tasks; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc +{ + /// Fanuc-specific extensions: tool offset and work zero offset transfer. + public interface IFanucMachine : ICncMachine + { + Task> ReadToolDataAsync(string path, CancellationToken ct = default(CancellationToken)); + Task> ReadWorkZeroDataAsync(string path, CancellationToken ct = default(CancellationToken)); + Task> WriteToolDataAsync(string folderPath, string content, CancellationToken ct = default(CancellationToken)); + Task> WriteWorkZeroDataAsync(string folderPath, string content, CancellationToken ct = default(CancellationToken)); + } +} diff --git a/Cnc/INcProgramValidator.cs b/Cnc/INcProgramValidator.cs new file mode 100644 index 0000000..70de428 --- /dev/null +++ b/Cnc/INcProgramValidator.cs @@ -0,0 +1,12 @@ +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc +{ + /// Validates NC program content before upload to a CNC controller. + public interface INcProgramValidator + { + /// File name or program identifier (used for name-format checks). + /// Full program content string. + ValidationResult Validate(string programName, string content); + } +} diff --git a/Cnc/Mitsubishi/IMitsubishiFtpClient.cs b/Cnc/Mitsubishi/IMitsubishiFtpClient.cs new file mode 100644 index 0000000..4094af6 --- /dev/null +++ b/Cnc/Mitsubishi/IMitsubishiFtpClient.cs @@ -0,0 +1,10 @@ +namespace FanucProgramManager.Cnc.Mitsubishi +{ + internal interface IMitsubishiFtpClient + { + bool Ping(); + string DownloadFile(string ncPath); + void UploadFile(string ncPath, string content); + void DeleteFile(string ncPath); + } +} diff --git a/Cnc/Mitsubishi/MitsubishiConnectionConfig.cs b/Cnc/Mitsubishi/MitsubishiConnectionConfig.cs new file mode 100644 index 0000000..8f018ca --- /dev/null +++ b/Cnc/Mitsubishi/MitsubishiConnectionConfig.cs @@ -0,0 +1,16 @@ +using System; + +namespace FanucProgramManager.Cnc.Mitsubishi +{ + public sealed class MitsubishiConnectionConfig + { + public string Name { get; set; } + public string IpAddress { get; set; } + public int Port { get; set; } = 21; + public string Username { get; set; } = string.Empty; + public string Password { get; set; } = string.Empty; + /// NC directory for programs on the Mitsubishi FTP server. + public string ProgramDirectory { get; set; } = "/PRG/"; + public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(10); + } +} diff --git a/Cnc/Mitsubishi/MitsubishiFtpClient.cs b/Cnc/Mitsubishi/MitsubishiFtpClient.cs new file mode 100644 index 0000000..4df970e --- /dev/null +++ b/Cnc/Mitsubishi/MitsubishiFtpClient.cs @@ -0,0 +1,71 @@ +using System; +using System.IO; +using System.Net; +using System.Text; + +namespace FanucProgramManager.Cnc.Mitsubishi +{ + /// FTP client for Mitsubishi M-series CNC program transfer. + internal sealed class MitsubishiFtpClient : IMitsubishiFtpClient + { + private readonly MitsubishiConnectionConfig _config; + + public MitsubishiFtpClient(MitsubishiConnectionConfig config) + { + _config = config ?? throw new ArgumentNullException("config"); + } + + /// Verify FTP server is reachable by listing the program directory. + public bool Ping() + { + try + { + var req = CreateRequest(_config.ProgramDirectory, WebRequestMethods.Ftp.ListDirectory); + using (var resp = (FtpWebResponse)req.GetResponse()) + return resp.StatusCode == FtpStatusCode.DataAlreadyOpen + || resp.StatusCode == FtpStatusCode.OpeningData + || (int)resp.StatusCode / 100 == 2; + } + catch { return false; } + } + + /// Download file from Mitsubishi to string. + public string DownloadFile(string ncPath) + { + var req = CreateRequest(ncPath, WebRequestMethods.Ftp.DownloadFile); + using (var resp = (FtpWebResponse)req.GetResponse()) + using (var reader = new StreamReader(resp.GetResponseStream(), Encoding.ASCII)) + return reader.ReadToEnd(); + } + + /// Upload string content to Mitsubishi. + public void UploadFile(string ncPath, string content) + { + var req = CreateRequest(ncPath, WebRequestMethods.Ftp.UploadFile); + byte[] data = Encoding.ASCII.GetBytes(content); + req.ContentLength = data.Length; + using (var stream = req.GetRequestStream()) + stream.Write(data, 0, data.Length); + using ((FtpWebResponse)req.GetResponse()) { } + } + + public void DeleteFile(string ncPath) + { + var req = CreateRequest(ncPath, WebRequestMethods.Ftp.DeleteFile); + using ((FtpWebResponse)req.GetResponse()) { } + } + + private FtpWebRequest CreateRequest(string path, string method) + { + string uri = string.Format("ftp://{0}:{1}{2}", _config.IpAddress, _config.Port, path); + var req = (FtpWebRequest)WebRequest.Create(uri); + req.Method = method; + req.Credentials = new NetworkCredential(_config.Username, _config.Password); + req.Timeout = (int)_config.RequestTimeout.TotalMilliseconds; + req.KeepAlive = false; + req.UseBinary = false; + req.UsePassive = true; + return req; + } + } +} diff --git a/Cnc/Mitsubishi/MitsubishiMachine.cs b/Cnc/Mitsubishi/MitsubishiMachine.cs new file mode 100644 index 0000000..2c997dd --- /dev/null +++ b/Cnc/Mitsubishi/MitsubishiMachine.cs @@ -0,0 +1,210 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc.Mitsubishi +{ + public sealed class MitsubishiMachine : ICncMachine + { + private readonly MitsubishiConnectionConfig _config; + private readonly IMitsubishiFtpClient _ftp; + private readonly INcProgramValidator _validator; + private readonly List _errors = new List(); + private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1); + private ConnectionState _state = ConnectionState.Disconnected; + + public MitsubishiMachine(MitsubishiConnectionConfig config) + { + _config = config ?? throw new ArgumentNullException("config"); + _ftp = new MitsubishiFtpClient(config); + _validator = new NcProgramValidator(CncManufacturer.Mitsubishi); + } + + internal MitsubishiMachine(MitsubishiConnectionConfig config, IMitsubishiFtpClient ftpClient, + INcProgramValidator validator = null) + { + _config = config ?? throw new ArgumentNullException("config"); + _ftp = ftpClient ?? throw new ArgumentNullException("ftpClient"); + _validator = validator ?? new NcProgramValidator(CncManufacturer.Mitsubishi); + } + + public string Name { get { return _config.Name; } } + public ConnectionState State { get { return _state; } } + public event EventHandler StateChanged; + + public Task> ConnectAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + SetState(ConnectionState.Connecting); + if (!_ftp.Ping()) + { + SetState(ConnectionState.Faulted); + _errors.Add(new CncError(0, "Connect", + string.Format("FTP server unreachable at {0}:{1}", _config.IpAddress, _config.Port))); + return false; + } + SetState(ConnectionState.Connected); + return true; + }, ct); + } + + public Task DisconnectAsync() + { + return RunGuardedAsync(() => + { + SetState(ConnectionState.Disconnected); + return true; + }, CancellationToken.None); + } + + public Task> ReadProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + string ncPath = ResolvePath(path, null); + try { return _ftp.DownloadFile(ncPath); } + catch (Exception ex) + { + _errors.Add(new CncError(0, "ReadProgram", ex.Message)); + return null; + } + }, ct); + } + + public Task> WriteProgramAsync(string path, CncProgram program, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + if (program == null || string.IsNullOrEmpty(program.Content)) + { + _errors.Add(new CncError(0, "WriteProgram", "Content is empty")); + return false; + } + var vr = _validator.Validate(program.Name ?? path, program.Content); + if (!vr.Success) + { + string msg = string.Join("; ", vr.Errors + .Where(e => e.Severity == ValidationSeverity.Error) + .Select(e => e.Message)); + _errors.Add(new CncError(0, "Validator", msg)); + return false; + } + string ncPath = ResolvePath(path, program.Name); + try { _ftp.UploadFile(ncPath, program.Content); return true; } + catch (Exception ex) + { + _errors.Add(new CncError(0, "WriteProgram", ex.Message)); + return false; + } + }, ct); + } + + public Task> DeleteProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + try { _ftp.DeleteFile(path); return true; } + catch (Exception ex) + { + _errors.Add(new CncError(0, "DeleteProgram", ex.Message)); + return false; + } + }, ct); + } + + public Task> ReadAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + return new MachineSnapshot + { + CapturedAt = DateTime.Now, + Mode = MachineMode.Unknown, + Run = RunState.Unknown, + Motion = MotionState.Unknown, + Alarms = new List(), + OperatorMessages = new List() + }; + }, ct); + } + + public Task> ReadActiveProgramAsync(CancellationToken ct = default(CancellationToken)) + { + return Task.FromResult(CncResult.Fail("ReadActiveProgram", "Not supported via FTP")); + } + + public Task> SelectMainProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return Task.FromResult(CncResult.Fail("SelectMainProgram", "Not supported via FTP")); + } + + public void Dispose() + { + try { DisconnectAsync().GetAwaiter().GetResult(); } catch { } + try { _gate.Dispose(); } catch { } + } + + private async Task> RunGuardedAsync(Func body, CancellationToken ct) + { + await _gate.WaitAsync(ct).ConfigureAwait(false); + try + { + return await Task.Run(() => + { + _errors.Clear(); + try + { + T value = body(); + return _errors.Count > 0 + ? CncResult.Fail(_errors.ToArray()) + : CncResult.Ok(value); + } + catch (OperationCanceledException) { return CncResult.Cancelled(); } + catch (Exception ex) + { + _errors.Add(new CncError(0, "MitsubishiMachine", ex.Message)); + return CncResult.Fail(_errors.ToArray()); + } + }, ct).ConfigureAwait(false); + } + finally { _gate.Release(); } + } + + private void EnsureConnected() + { + if (_state != ConnectionState.Connected) + throw new InvalidOperationException("MitsubishiMachine is not connected."); + } + + private void SetState(ConnectionState next) + { + if (_state == next) return; + _state = next; + var h = StateChanged; + if (h != null) + { + try { h(this, next); } catch { } + } + } + + /// Build full FTP path. Mitsubishi programs have no extension. + private string ResolvePath(string folder, string name) + { + if (string.IsNullOrEmpty(name)) + return folder.Contains("/") ? folder : _config.ProgramDirectory + folder; + + string dir = folder ?? _config.ProgramDirectory; + if (!dir.EndsWith("/")) dir += "/"; + return dir + name; + } + } +} diff --git a/Cnc/Models/CncError.cs b/Cnc/Models/CncError.cs new file mode 100755 index 0000000..1a7270c --- /dev/null +++ b/Cnc/Models/CncError.cs @@ -0,0 +1,25 @@ +using System; + +namespace FanucProgramManager.Cnc.Models +{ + public sealed class CncError + { + public int Code { get; } + public string Source { get; } + public string Message { get; } + public DateTime At { get; } + + public CncError(int code, string source, string message) + { + Code = code; + Source = source ?? ""; + Message = message ?? ""; + At = DateTime.Now; + } + + public override string ToString() + { + return "[" + Code + "] " + Source + ": " + Message; + } + } +} diff --git a/Cnc/Models/CncManufacturer.cs b/Cnc/Models/CncManufacturer.cs new file mode 100644 index 0000000..d179a5f --- /dev/null +++ b/Cnc/Models/CncManufacturer.cs @@ -0,0 +1,4 @@ +namespace FanucProgramManager.Cnc.Models +{ + public enum CncManufacturer { Fanuc, Heidenhain, Siemens, Mitsubishi } +} diff --git a/Cnc/Models/CncProgram.cs b/Cnc/Models/CncProgram.cs new file mode 100755 index 0000000..0225e8c --- /dev/null +++ b/Cnc/Models/CncProgram.cs @@ -0,0 +1,10 @@ +namespace FanucProgramManager.Cnc.Models +{ + public sealed class CncProgram + { + public string Name { get; set; } + public string Comment { get; set; } + public string Content { get; set; } + public string Path { get; set; } + } +} diff --git a/Cnc/Models/CncResult.cs b/Cnc/Models/CncResult.cs new file mode 100755 index 0000000..e9ac3df --- /dev/null +++ b/Cnc/Models/CncResult.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; + +namespace FanucProgramManager.Cnc.Models +{ + /// Result wrapper for all CNC operations. + public sealed class CncResult + { + public bool Success { get; } + public T Value { get; } + public IReadOnlyList Errors { get; } + public bool WasCancelled { get; } + + private CncResult(bool success, T value, IReadOnlyList errors, bool cancelled) + { + Success = success; + Value = value; + Errors = errors ?? (IReadOnlyList)Array.Empty(); + WasCancelled = cancelled; + } + + public static CncResult Ok(T value) => + new CncResult(true, value, null, false); + + public static CncResult Fail(IReadOnlyList errors) => + new CncResult(false, default(T), errors, false); + + public static CncResult Fail(string source, string message) => + Fail(new[] { new CncError(0, source, message) }); + + public static CncResult Cancelled() => + new CncResult(false, default(T), null, true); + + public override string ToString() + { + if (WasCancelled) return $"CncResult<{typeof(T).Name}>: Cancelled"; + if (!Success) return $"CncResult<{typeof(T).Name}>: Fail ({Errors.Count} errors)"; + return $"CncResult<{typeof(T).Name}>: Ok"; + } + } +} diff --git a/Cnc/Models/ConnectionState.cs b/Cnc/Models/ConnectionState.cs new file mode 100755 index 0000000..460c0e6 --- /dev/null +++ b/Cnc/Models/ConnectionState.cs @@ -0,0 +1,10 @@ +namespace FanucProgramManager.Cnc.Models +{ + public enum ConnectionState + { + Disconnected, + Connecting, + Connected, + Faulted + } +} diff --git a/Cnc/Models/MachineMode.cs b/Cnc/Models/MachineMode.cs new file mode 100755 index 0000000..a901665 --- /dev/null +++ b/Cnc/Models/MachineMode.cs @@ -0,0 +1,12 @@ +namespace FanucProgramManager.Cnc.Models +{ + public enum MachineMode + { + Mdi = 0, + Auto = 1, + Edit = 3, + Handle = 4, + Jog = 5, + Unknown = 255 + } +} diff --git a/Cnc/Models/MachineSnapshot.cs b/Cnc/Models/MachineSnapshot.cs new file mode 100755 index 0000000..a94646f --- /dev/null +++ b/Cnc/Models/MachineSnapshot.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; + +namespace FanucProgramManager.Cnc.Models +{ + public sealed class MachineSnapshot + { + public string MainProgram { get; set; } + public string SubProgram { get; set; } + public string ProgramComment { get; set; } + public MachineMode Mode { get; set; } + public RunState Run { get; set; } + public MotionState Motion { get; set; } + public bool Emergency { get; set; } + public bool AlarmActive { get; set; } + public TimeSpan CycleTime { get; set; } + public long PieceCount { get; set; } + public IReadOnlyList Alarms { get; set; } + public IReadOnlyList OperatorMessages { get; set; } + public DateTime CapturedAt { get; set; } + } +} diff --git a/Cnc/Models/MotionState.cs b/Cnc/Models/MotionState.cs new file mode 100755 index 0000000..2c583d2 --- /dev/null +++ b/Cnc/Models/MotionState.cs @@ -0,0 +1,10 @@ +namespace FanucProgramManager.Cnc.Models +{ + public enum MotionState + { + Idle = 0, + Moving = 1, + Hold = 2, + Unknown = 255 + } +} diff --git a/Cnc/Models/RunState.cs b/Cnc/Models/RunState.cs new file mode 100755 index 0000000..961f987 --- /dev/null +++ b/Cnc/Models/RunState.cs @@ -0,0 +1,9 @@ +namespace FanucProgramManager.Cnc.Models +{ + public enum RunState + { + Stop = 1, + ExecutingIso = 3, + Unknown = 255 + } +} diff --git a/Cnc/Models/ValidationError.cs b/Cnc/Models/ValidationError.cs new file mode 100644 index 0000000..608b7df --- /dev/null +++ b/Cnc/Models/ValidationError.cs @@ -0,0 +1,21 @@ +namespace FanucProgramManager.Cnc.Models +{ + public sealed class ValidationError + { + public int Line { get; } + public string Message { get; } + public ValidationSeverity Severity { get; } + + public ValidationError(int line, string message, ValidationSeverity severity) + { + Line = line; + Message = message ?? ""; + Severity = severity; + } + + public override string ToString() + { + return string.Format("[{0}] Line {1}: {2}", Severity, Line, Message); + } + } +} diff --git a/Cnc/Models/ValidationResult.cs b/Cnc/Models/ValidationResult.cs new file mode 100644 index 0000000..d132474 --- /dev/null +++ b/Cnc/Models/ValidationResult.cs @@ -0,0 +1,32 @@ +using System.Collections.Generic; + +namespace FanucProgramManager.Cnc.Models +{ + public sealed class ValidationResult + { + public bool Success { get; } + public IReadOnlyList Errors { get; } + + private ValidationResult(bool success, IReadOnlyList errors) + { + Success = success; + Errors = errors ?? new ValidationError[0]; + } + + public static ValidationResult Ok() + { + return new ValidationResult(true, new ValidationError[0]); + } + + public static ValidationResult Fail(IReadOnlyList errors) + { + return new ValidationResult(false, errors); + } + + /// Success result that still carries warning-level entries. + public static ValidationResult OkWithWarnings(IReadOnlyList warnings) + { + return new ValidationResult(true, warnings); + } + } +} diff --git a/Cnc/Models/ValidationSeverity.cs b/Cnc/Models/ValidationSeverity.cs new file mode 100644 index 0000000..66e501a --- /dev/null +++ b/Cnc/Models/ValidationSeverity.cs @@ -0,0 +1,4 @@ +namespace FanucProgramManager.Cnc.Models +{ + public enum ValidationSeverity { Error, Warning } +} diff --git a/Cnc/NcProgramValidator.cs b/Cnc/NcProgramValidator.cs new file mode 100644 index 0000000..7709822 --- /dev/null +++ b/Cnc/NcProgramValidator.cs @@ -0,0 +1,215 @@ +using System; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc +{ + /// Validates NC program content per-manufacturer before upload. + public sealed class NcProgramValidator : INcProgramValidator + { + private const int MaxBlockLength = 80; + private const int MaxCommentLength = 32; + + private static readonly Regex FanucNamePattern = new Regex(@"^O\d{4}$", RegexOptions.Compiled); + private static readonly Regex FanucFirstLinePattern = new Regex(@"^O\d{4}", RegexOptions.Compiled); + + private readonly CncManufacturer _manufacturer; + + public NcProgramValidator(CncManufacturer manufacturer) + { + _manufacturer = manufacturer; + } + + public ValidationResult Validate(string programName, string content) + { + var errors = new List(); + + // Name-format check (uses just the bare filename without path) + string name = ExtractName(programName); + ValidateName(name, errors); + + if (string.IsNullOrEmpty(content)) + return errors.Count == 0 ? ValidationResult.Ok() : ValidationResult.Fail(errors); + + // Normalise: strip CR, split on LF + string normalized = content.Replace("\r", ""); + string[] lines = normalized.Split('\n'); + + // First-line check (Fanuc/Mitsubishi) + if ((_manufacturer == CncManufacturer.Fanuc || _manufacturer == CncManufacturer.Mitsubishi) + && lines.Length > 0) + { + string first = lines[0].Trim(); + if (!FanucFirstLinePattern.IsMatch(first)) + errors.Add(new ValidationError(1, "First line must be O#### program number", ValidationSeverity.Error)); + } + + for (int i = 0; i < lines.Length; i++) + { + int lineNum = i + 1; + string line = lines[i]; + + // Tab check + if (line.IndexOf('\t') >= 0) + errors.Add(new ValidationError(lineNum, "Tab character not allowed", ValidationSeverity.Error)); + + // Lowercase check + for (int ci = 0; ci < line.Length; ci++) + { + if (char.IsLower(line[ci])) + { + errors.Add(new ValidationError(lineNum, "Lowercase letters not allowed", ValidationSeverity.Error)); + break; + } + } + + // Block length + if (line.Length > MaxBlockLength) + errors.Add(new ValidationError(lineNum, + string.Format("Block length {0} exceeds 80 chars", line.Length), + ValidationSeverity.Error)); + + // Nested parens + comment length + ValidateParensAndComments(line, lineNum, errors); + + // Forbidden chars per manufacturer + ValidateForbiddenChars(line, lineNum, errors); + } + + bool hasErrors = false; + for (int i = 0; i < errors.Count; i++) + if (errors[i].Severity == ValidationSeverity.Error) { hasErrors = true; break; } + + if (hasErrors) + return ValidationResult.Fail(errors); + // Preserve warnings even when overall result is Success + return errors.Count == 0 ? ValidationResult.Ok() : ValidationResult.OkWithWarnings(errors); + } + + // ── private helpers ─────────────────────────────────────────────────── + + private void ValidateName(string name, List errors) + { + if (string.IsNullOrEmpty(name)) return; + + switch (_manufacturer) + { + case CncManufacturer.Fanuc: + case CncManufacturer.Mitsubishi: + if (!FanucNamePattern.IsMatch(name)) + errors.Add(new ValidationError(0, + string.Format("Program name '{0}' must match O####", name), + ValidationSeverity.Error)); + break; + + case CncManufacturer.Siemens: + if (!name.EndsWith(".MPF")) + errors.Add(new ValidationError(0, + string.Format("Program name '{0}' must end with .MPF", name), + ValidationSeverity.Error)); + break; + + case CncManufacturer.Heidenhain: + if (!name.EndsWith(".H")) + errors.Add(new ValidationError(0, + string.Format("Program name '{0}' must end with .H", name), + ValidationSeverity.Error)); + break; + } + } + + private void ValidateParensAndComments(string line, int lineNum, List errors) + { + int depth = 0; + int commentStart = -1; + + for (int i = 0; i < line.Length; i++) + { + char c = line[i]; + if (c == '(') + { + depth++; + if (depth > 1) + { + errors.Add(new ValidationError(lineNum, "Nested parentheses not allowed", ValidationSeverity.Error)); + // Don't keep adding the same error for this line + return; + } + commentStart = i; + } + else if (c == ')') + { + if (depth == 1 && commentStart >= 0) + { + // Extract comment content between the parens + int len = i - commentStart - 1; + if (len > MaxCommentLength) + errors.Add(new ValidationError(lineNum, + string.Format("Comment length {0} exceeds 32 chars", len), + ValidationSeverity.Error)); + } + if (depth > 0) depth--; + commentStart = -1; + } + } + } + + private void ValidateForbiddenChars(string line, int lineNum, List errors) + { + switch (_manufacturer) + { + case CncManufacturer.Fanuc: + case CncManufacturer.Mitsubishi: + for (int i = 0; i < line.Length; i++) + { + char c = line[i]; + if (c == ';' || c == '[' || c == ']') + { + errors.Add(new ValidationError(lineNum, + string.Format("Forbidden char '{0}' for Fanuc/Mitsubishi", c), + ValidationSeverity.Error)); + } + else if (c == '#') + { + errors.Add(new ValidationError(lineNum, + "Macro variable '#' detected — verify macro support on target CNC", + ValidationSeverity.Warning)); + } + } + break; + + case CncManufacturer.Siemens: + for (int i = 0; i < line.Length; i++) + { + if (line[i] == ';') + errors.Add(new ValidationError(lineNum, + "Forbidden char ';' for Siemens (use () for comments)", + ValidationSeverity.Error)); + } + break; + + case CncManufacturer.Heidenhain: + for (int i = 0; i < line.Length; i++) + { + char c = line[i]; + if (c == '%' || c == ';') + errors.Add(new ValidationError(lineNum, + string.Format("Forbidden char '{0}' for Heidenhain", c), + ValidationSeverity.Error)); + } + break; + } + } + + /// Extracts bare filename from a path (strips directory prefix). + private static string ExtractName(string programName) + { + if (string.IsNullOrEmpty(programName)) return programName; + int slash = programName.LastIndexOf('/'); + int backslash = programName.LastIndexOf('\\'); + int sep = slash > backslash ? slash : backslash; + return sep >= 0 ? programName.Substring(sep + 1) : programName; + } + } +} diff --git a/Cnc/Siemens/ISiemensFtpClient.cs b/Cnc/Siemens/ISiemensFtpClient.cs new file mode 100644 index 0000000..26fe945 --- /dev/null +++ b/Cnc/Siemens/ISiemensFtpClient.cs @@ -0,0 +1,10 @@ +namespace FanucProgramManager.Cnc.Siemens +{ + internal interface ISiemensFtpClient + { + bool Ping(); + string DownloadFile(string ncPath); + void UploadFile(string ncPath, string content); + void DeleteFile(string ncPath); + } +} diff --git a/Cnc/Siemens/SiemensConnectionConfig.cs b/Cnc/Siemens/SiemensConnectionConfig.cs new file mode 100644 index 0000000..762e2d5 --- /dev/null +++ b/Cnc/Siemens/SiemensConnectionConfig.cs @@ -0,0 +1,16 @@ +using System; + +namespace FanucProgramManager.Cnc.Siemens +{ + public sealed class SiemensConnectionConfig + { + public string Name { get; set; } + public string IpAddress { get; set; } + public int Port { get; set; } = 21; + public string Username { get; set; } = string.Empty; + public string Password { get; set; } = string.Empty; + /// NC directory for main programs on the CNC FTP server. + public string ProgramDirectory { get; set; } = "/_N_MPF_DIR/"; + public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(10); + } +} diff --git a/Cnc/Siemens/SiemensFtpClient.cs b/Cnc/Siemens/SiemensFtpClient.cs new file mode 100644 index 0000000..ab7d1ff --- /dev/null +++ b/Cnc/Siemens/SiemensFtpClient.cs @@ -0,0 +1,71 @@ +using System; +using System.IO; +using System.Net; +using System.Text; + +namespace FanucProgramManager.Cnc.Siemens +{ + /// FTP client for Siemens Sinumerik CNC program transfer. + internal sealed class SiemensFtpClient : ISiemensFtpClient + { + private readonly SiemensConnectionConfig _config; + + public SiemensFtpClient(SiemensConnectionConfig config) + { + _config = config ?? throw new ArgumentNullException("config"); + } + + /// Verify FTP server is reachable by listing the program directory. + public bool Ping() + { + try + { + var req = CreateRequest(_config.ProgramDirectory, WebRequestMethods.Ftp.ListDirectory); + using (var resp = (FtpWebResponse)req.GetResponse()) + return resp.StatusCode == FtpStatusCode.DataAlreadyOpen + || resp.StatusCode == FtpStatusCode.OpeningData + || (int)resp.StatusCode / 100 == 2; + } + catch { return false; } + } + + /// Download file from Sinumerik to string (upload from CNC perspective). + public string DownloadFile(string ncPath) + { + var req = CreateRequest(ncPath, WebRequestMethods.Ftp.DownloadFile); + using (var resp = (FtpWebResponse)req.GetResponse()) + using (var reader = new StreamReader(resp.GetResponseStream(), Encoding.ASCII)) + return reader.ReadToEnd(); + } + + /// Upload string content to Sinumerik (download from CNC perspective). + public void UploadFile(string ncPath, string content) + { + var req = CreateRequest(ncPath, WebRequestMethods.Ftp.UploadFile); + byte[] data = Encoding.ASCII.GetBytes(content); + req.ContentLength = data.Length; + using (var stream = req.GetRequestStream()) + stream.Write(data, 0, data.Length); + using ((FtpWebResponse)req.GetResponse()) { } + } + + public void DeleteFile(string ncPath) + { + var req = CreateRequest(ncPath, WebRequestMethods.Ftp.DeleteFile); + using ((FtpWebResponse)req.GetResponse()) { } + } + + private FtpWebRequest CreateRequest(string path, string method) + { + string uri = string.Format("ftp://{0}:{1}{2}", _config.IpAddress, _config.Port, path); + var req = (FtpWebRequest)WebRequest.Create(uri); + req.Method = method; + req.Credentials = new NetworkCredential(_config.Username, _config.Password); + req.Timeout = (int)_config.RequestTimeout.TotalMilliseconds; + req.KeepAlive = false; + req.UseBinary = false; + req.UsePassive = true; + return req; + } + } +} diff --git a/Cnc/Siemens/SiemensMachine.cs b/Cnc/Siemens/SiemensMachine.cs new file mode 100644 index 0000000..0c201a1 --- /dev/null +++ b/Cnc/Siemens/SiemensMachine.cs @@ -0,0 +1,211 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Cnc.Siemens +{ + public sealed class SiemensMachine : ICncMachine + { + private readonly SiemensConnectionConfig _config; + private readonly ISiemensFtpClient _ftp; + private readonly INcProgramValidator _validator; + private readonly List _errors = new List(); + private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1); + private ConnectionState _state = ConnectionState.Disconnected; + + public SiemensMachine(SiemensConnectionConfig config) + { + _config = config ?? throw new ArgumentNullException("config"); + _ftp = new SiemensFtpClient(config); + _validator = new NcProgramValidator(CncManufacturer.Siemens); + } + + internal SiemensMachine(SiemensConnectionConfig config, ISiemensFtpClient ftpClient, + INcProgramValidator validator = null) + { + _config = config ?? throw new ArgumentNullException("config"); + _ftp = ftpClient ?? throw new ArgumentNullException("ftpClient"); + _validator = validator ?? new NcProgramValidator(CncManufacturer.Siemens); + } + + public string Name { get { return _config.Name; } } + public ConnectionState State { get { return _state; } } + public event EventHandler StateChanged; + + public Task> ConnectAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + SetState(ConnectionState.Connecting); + if (!_ftp.Ping()) + { + SetState(ConnectionState.Faulted); + _errors.Add(new CncError(0, "Connect", + string.Format("FTP server unreachable at {0}:{1}", _config.IpAddress, _config.Port))); + return false; + } + SetState(ConnectionState.Connected); + return true; + }, ct); + } + + public Task DisconnectAsync() + { + return RunGuardedAsync(() => + { + SetState(ConnectionState.Disconnected); + return true; + }, CancellationToken.None); + } + + public Task> ReadProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + string ncPath = ResolvePath(path, null); + try { return _ftp.DownloadFile(ncPath); } + catch (Exception ex) + { + _errors.Add(new CncError(0, "ReadProgram", ex.Message)); + return null; + } + }, ct); + } + + public Task> WriteProgramAsync(string path, CncProgram program, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + if (program == null || string.IsNullOrEmpty(program.Content)) + { + _errors.Add(new CncError(0, "WriteProgram", "Content is empty")); + return false; + } + var vr = _validator.Validate(program.Name ?? path, program.Content); + if (!vr.Success) + { + string msg = string.Join("; ", vr.Errors + .Where(e => e.Severity == ValidationSeverity.Error) + .Select(e => e.Message)); + _errors.Add(new CncError(0, "Validator", msg)); + return false; + } + string ncPath = ResolvePath(path, program.Name); + try { _ftp.UploadFile(ncPath, program.Content); return true; } + catch (Exception ex) + { + _errors.Add(new CncError(0, "WriteProgram", ex.Message)); + return false; + } + }, ct); + } + + public Task> DeleteProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + try { _ftp.DeleteFile(path); return true; } + catch (Exception ex) + { + _errors.Add(new CncError(0, "DeleteProgram", ex.Message)); + return false; + } + }, ct); + } + + public Task> ReadAsync(CancellationToken ct = default(CancellationToken)) + { + return RunGuardedAsync(() => + { + EnsureConnected(); + return new MachineSnapshot + { + CapturedAt = DateTime.Now, + Mode = MachineMode.Unknown, + Run = RunState.Unknown, + Motion = MotionState.Unknown, + Alarms = new List(), + OperatorMessages = new List() + }; + }, ct); + } + + public Task> ReadActiveProgramAsync(CancellationToken ct = default(CancellationToken)) + { + return Task.FromResult(CncResult.Fail("ReadActiveProgram", "Not supported via FTP")); + } + + public Task> SelectMainProgramAsync(string path, CancellationToken ct = default(CancellationToken)) + { + return Task.FromResult(CncResult.Fail("SelectMainProgram", "Not supported via FTP")); + } + + public void Dispose() + { + try { DisconnectAsync().GetAwaiter().GetResult(); } catch { } + try { _gate.Dispose(); } catch { } + } + + private async Task> RunGuardedAsync(Func body, CancellationToken ct) + { + await _gate.WaitAsync(ct).ConfigureAwait(false); + try + { + return await Task.Run(() => + { + _errors.Clear(); + try + { + T value = body(); + return _errors.Count > 0 + ? CncResult.Fail(_errors.ToArray()) + : CncResult.Ok(value); + } + catch (OperationCanceledException) { return CncResult.Cancelled(); } + catch (Exception ex) + { + _errors.Add(new CncError(0, "SiemensMachine", ex.Message)); + return CncResult.Fail(_errors.ToArray()); + } + }, ct).ConfigureAwait(false); + } + finally { _gate.Release(); } + } + + private void EnsureConnected() + { + if (_state != ConnectionState.Connected) + throw new InvalidOperationException("SiemensMachine is not connected."); + } + + private void SetState(ConnectionState next) + { + if (_state == next) return; + _state = next; + var h = StateChanged; + if (h != null) + { + try { h(this, next); } catch { } + } + } + + /// Build full FTP path. If name given, appends it with .MPF extension. + private string ResolvePath(string folder, string name) + { + if (string.IsNullOrEmpty(name)) + return folder.Contains("/") ? folder : _config.ProgramDirectory + folder + ".MPF"; + + string dir = folder ?? _config.ProgramDirectory; + if (!dir.EndsWith("/")) dir += "/"; + string ext = name.Contains(".") ? "" : ".MPF"; + return dir + name + ext; + } + } +} diff --git a/Dockerfile.test b/Dockerfile.test new file mode 100644 index 0000000..85b1c56 --- /dev/null +++ b/Dockerfile.test @@ -0,0 +1,37 @@ +FROM mono:6.12 + +WORKDIR /build + +# Sync Mozilla root certs into Mono trust store — required for NuGet HTTPS on Buster +RUN cert-sync /etc/ssl/certs/ca-certificates.crt + +# Copy solution + projects first for layer caching +COPY FanucProgramManager.csproj ./ +COPY packages.config ./ +COPY FanucProgramManager.Tests/FanucProgramManager.Tests.csproj ./FanucProgramManager.Tests/ +COPY FanucProgramManager.Tests/packages.config ./FanucProgramManager.Tests/ +COPY FanucProgramManager.sln ./ + +# Restore all packages (sln now includes test project) +RUN nuget restore FanucProgramManager.sln -NonInteractive +# Explicit fallback: restore test packages.config directly to same packages dir +RUN nuget restore FanucProgramManager.Tests/packages.config \ + -OutputDirectory packages -NonInteractive +# Grab NUnit console runner +RUN nuget install NUnit.ConsoleRunner -Version 3.16.3 -OutputDirectory packages -NonInteractive + +# Copy source +COPY . . + +# Make libs dir explicit (native Win32 DLLs — needed by csproj Content entries, not executed on Linux) +RUN ls Cnc/Fanuc/libs/ || true + +# Build test project (Debug) +RUN msbuild FanucProgramManager.Tests/FanucProgramManager.Tests.csproj \ + /p:Configuration=Debug /p:Platform=AnyCPU \ + /v:minimal /nologo + +# Run tests — skip Fanuc FOCAS tests (marked [Ignore] — need fwlib32.dll) +CMD mono packages/NUnit.ConsoleRunner.3.16.3/tools/nunit3-console.exe \ + FanucProgramManager.Tests/bin/Debug/FanucProgramManager.Tests.dll \ + --labels=All diff --git a/FANUCMachine.cs b/FANUCMachine.cs new file mode 100755 index 0000000..f00d241 --- /dev/null +++ b/FANUCMachine.cs @@ -0,0 +1,1094 @@ +using System; +using System.Text; +using System.Threading; +using System.Diagnostics; +using System.Text.RegularExpressions; + +namespace FanucProgramManager +{ + class FANUCMachine + { + private static string get_cnc_path(int path = 1) + { + return "//CNC_MEM/USER/PATH" + path.ToString() + "/"; + } + /// + /// Parametri connessione + /// + + private string Name; + private string IPAddress; //IP ethernet + private string Port; //Port ethernet + private int Node; //nodo HSSB per connessione si tipo allclibhndl2 + private int ReadTime; + private int ConnectionType; + private Boolean compatibiltyMode; + + + + public bool CONNECTED; + private string ConnectionStatus { get; set; } + + public bool ConnectionRequest; + short[] ret_array = new short[11] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + // valore di ritorno della funzioni richiamate dalle librerie FOCAS, in generale se ret == 0 + // la funzione e' terminata senza errori + // in ordine nell'array: + // 0 -> connect + // 1 -> disconnect + // 2 -> cicle time + // 3 -> pieces counter + // 4 -> alarm messages + // 5 -> operator messages + // 6 -> machine state + // 7 -> main program + // 8 -> comment program + // 9 -> download + // 10 -> upload + + ushort hndl; // handle di comunicazione: questo valore viene scritto una volta eseguita la connessione + // questo valore si passa come riferimento ad ogni funzione focas e rappresenta i + // parametri di connessione + + private string FOCAS_ERRORS = ""; + private string machine_status = ""; + + /// + /// Strutture per la lettura dati da controlli FANUC. + /// + + // Strutture per tempo ciclo e contapezzi + Focas1.IODBPSD cicloMSp1 = new Focas1.IODBPSD(); + Focas1.IODBPSD ciclo2MINp1 = new Focas1.IODBPSD(); + Focas1.IODBPSD ContaPezzip1 = new Focas1.IODBPSD(); // struttura dati per memorizzazione contapezzi path 1 + private string StrContaPezzip1; + private string StrTempoCiclop1; + // Strutture per nome programma + Focas1.PRGDIR3 info_prg = new Focas1.PRGDIR3(); + Focas1.ODBPRO prognum = new Focas1.ODBPRO(); + private string NomeProgrammaISO; + private string NomeSubProgrammaISO; + private string CommentoProgrammaISO; + // Strutture per allarmi + private string[] AlarmMessage = new string[17]; + // Strutture per messaggi operatore + private string[] OperatorMessage = new string[17]; + // Strutture per stati + Focas1.ODBST odbst = new Focas1.ODBST(); + + + //Strutture per letture range di dati pmc + Focas1.IODBPMC0 iodbpmcByte = new Focas1.IODBPMC0(); // 8 Bit + Focas1.IODBPMC1 iodbpmcShort = new Focas1.IODBPMC1(); // 16 Bit + Focas1.IODBPMC2 iodbpmcInt = new Focas1.IODBPMC2(); //32bit + //relative al contapezzi + + short CPMacroPiecesCounter = -1; //Variabile macro dove viene aggiornato il contapezzi #500 a #999 memria ritentiva + short CPMacroLength = 1; //quante variabili macro leggere + short CPlength = 4; //numero di byte scelto in CPdata_type (X) + //short CPdata_type = 2; // 0 Byte (1), 1 Short(2), 2 int (4) + //ushort CPStart; + + + + + public string GetFocasErrorsBuffer() + { + string errorBuffer = FOCAS_ERRORS; + FOCAS_ERRORS = ""; + return errorBuffer; + } + + + public string GetStatus() + { + return machine_status; + } + + public string GetNomeProgramma() + { + if (NomeProgrammaISO == null) + { + return "null"; + } + else + return NomeProgrammaISO; + } + + public string GetSubProgramma() + { + if (NomeSubProgrammaISO == null) + { + return "null"; + } + else + return NomeSubProgrammaISO; + } + + public string GetCommentoProgramma() + { + if (CommentoProgrammaISO == null) + { + return "Commento Assente"; + } + else + return CommentoProgrammaISO; + } + + public string[] GetAlarmMessage() + { + return AlarmMessage; + } + + public string[] GetOperatorMessage() + { + return OperatorMessage; + } + + public string GetStrContaPezzip1() + { + if (StrContaPezzip1 == null) + { + return "0"; + } + else + return StrContaPezzip1; + } + + public string GetStrTempoCiclop1() + { + if (StrTempoCiclop1 == null) + { + return "null"; + } + else + return StrTempoCiclop1; + } + + public string GetName() + { + if (Name == null) + { + return "null"; + } + else + return Name; + } + + public ushort GetHandle() + { + return hndl; + } + + private string getFocasFunctionName(short index) + { + string functionName = ""; + switch (index) + { + case 0: + functionName = "connect"; + break; + case 1: + functionName = "disconnect"; + break; + case 2: + functionName = "cicle time"; + break; + case 3: + functionName = "pieces counter"; + break; + case 4: + functionName = "alarm messages"; + break; + case 5: + functionName = "operator messages"; + break; + case 6: + functionName = "machine state"; + break; + case 7: + functionName = "main program and comment"; + break; + case 8: + functionName = "download"; + break; + case 9: + functionName = "upload"; + break; + } + return functionName; + } + + public FANUCMachine(string name, string ipaddress, string port, Boolean compatibiltyMode, int readtime, int connectiontype, int MacroPiecesCounter) + { + this.Name = name; + this.IPAddress = ipaddress; + this.Port = port; + this.compatibiltyMode = compatibiltyMode; + this.Node = -1; + this.ConnectionStatus = "Not Connected"; + this.ConnectionRequest = false; + this.NomeProgrammaISO = ""; + this.NomeSubProgrammaISO = ""; + this.ReadTime = readtime; + this.ConnectionType = connectiontype; + this.ConnectionRequest = true; + this.CONNECTED = false; + this.CPMacroPiecesCounter = (short)MacroPiecesCounter; + } + + public FANUCMachine(string name, int node, Boolean compatibiltyMode, int readtime, int connectiontype, int MacroPiecesCounter) //Per controlli HSSB + { + this.Name = name; + this.IPAddress = null; + this.Port = null; + this.compatibiltyMode = compatibiltyMode; + this.Node = node; //il paramatro node serve solo nel caso connectiontype = 2 altrimenti puo essere messo a 0 + this.ConnectionStatus = "Not Connected"; + this.ConnectionRequest = false; + this.NomeProgrammaISO = ""; + this.NomeSubProgrammaISO = ""; + this.ReadTime = readtime; + this.ConnectionType = connectiontype; + this.ConnectionRequest = true; + this.CONNECTED = false; + this.CPMacroPiecesCounter = (short)MacroPiecesCounter; + } + + private short readCicleTime() + { + // read cycle time + short time_ret = 0; + //millisecondi + time_ret = Focas1.cnc_rdparam(hndl, 6757, 0, 8, cicloMSp1); + //minuti + time_ret = (short)(time_ret + Focas1.cnc_rdparam(hndl, 6758, 0, 8, ciclo2MINp1)); + StrTempoCiclop1 = ciclo2MINp1.u.ldata.ToString() + " minuti : " + (cicloMSp1.u.ldata / 1000).ToString() + " secondi"; + return time_ret; + } + private short readAlarmMessages() + { + // Dati di stato macchina + // Allarmi + short num_alm = 17; + short almmsg_ret = -1; + + if (compatibiltyMode) + { + Focas1.ODBALMMSG_data_custom[] alm = new Focas1.ODBALMMSG_data_custom[17]; + almmsg_ret = Focas1.cnc_rdalmmsg_custom(hndl, 0, ref num_alm, alm); + for (int i = 0; i < num_alm; i++) + { + AlarmMessage[i] = ""; + if (alm[i].msg_len > 0) + AlarmMessage[i] = alm[i].alm_msg; + } + } + else + { + //Plese use cnc_rdalmmsg2 fucntion for Series 30i/31i/32i, 0i-D/F and PMi-A. + Focas1.ODBALMMSG2_data_custom[] alm = new Focas1.ODBALMMSG2_data_custom[17]; + almmsg_ret = Focas1.cnc_rdalmmsg2_custom(hndl, -1, ref num_alm, alm); + for (int i = 0; i < num_alm; i++) + { + AlarmMessage[i] = ""; + if (alm[i].msg_len > 0) + AlarmMessage[i] = alm[i].alm_msg; + } + } + return almmsg_ret; + } + + private short readOperatorMessages() + { + // Messaggi operatore + short num_alm = 1; + short opmsg_ret = 0; + Focas1.OPMSG3_data_custom[] opmsg = new Focas1.OPMSG3_data_custom[17]; + opmsg_ret = Focas1.cnc_rdopmsg3_custom(hndl, 4, ref num_alm, opmsg); + for (int i = 0; i < num_alm; i++) + { + OperatorMessage[i] = ""; + if (opmsg[i].char_num > 0) + OperatorMessage[i] = opmsg[i].data; + } + return opmsg_ret; + } + + private short readMachineState() + { + // Stati macchina + short state_ret = Focas1.cnc_statinfo(hndl, odbst); + if (state_ret == Focas1.EW_OK) + { + machine_status = ""; + + switch (odbst.aut) + { + case 0: + machine_status += "MDI -"; + break; + case 1: + machine_status += "AUTO -"; + break; + case 3: + machine_status += "EDIT -"; + break; + case 4: + machine_status += "HNDL -"; + break; + case 5: + machine_status += "JOG -"; + break; + default: + machine_status += "**** -"; + break; + } + + if (odbst.aut != 3) + { + ret_array[7] = readMainProgram(); + ret_array[8] = readMainProgramComment(); + } + + machine_status += " "; + + switch (odbst.run) + { + case 1: + machine_status += "STOP - "; + break; + case 3: + machine_status += "ESEC ISO - "; + break; + + default: + machine_status += " **** - "; + break; + } + + machine_status += " "; + + switch (odbst.motion) + { + case 1: + machine_status += "IN MOVIMENTO - "; + break; + case 2: + machine_status += "PAUSA - "; + break; + + default: + machine_status += "*** - "; + break; + } + + machine_status += " "; + + switch (odbst.mstb) + { + case 1: + machine_status += "FIN - "; + break; + default: + machine_status += "*** - "; + break; + } + + machine_status += " "; + + switch (odbst.emergency) + { + case 1: + machine_status += "EMERGENZA -"; + break; + case 2: + machine_status += "RST -"; + break; + default: + machine_status += "*** -"; + break; + } + + machine_status += " "; + + switch (odbst.alarm) + { + case 1: + machine_status += "ALM"; + break; + default: + machine_status += "***"; + break; + } + } + return state_ret; + } + + public short readMainProgram() + { + short program_ret = 0; + Focas1.ODBPRO prog_num = new Focas1.ODBPRO(); + // nome programma + program_ret = Focas1.cnc_rdprgnum(hndl, prog_num); + NomeSubProgrammaISO = "O" + prog_num.data.ToString(); + NomeProgrammaISO = "O" + prog_num.mdata.ToString(); + if (!compatibiltyMode) + { + byte[] nome_main = new byte[242]; + // nome programma + program_ret = Focas1.cnc_pdf_rdmain(hndl, nome_main); + string str_main = ASCIIEncoding.ASCII.GetString(nome_main).TrimEnd('\0'); + string[] words = str_main.Split('/'); + int indiceUltimoElemento = words.Length - 1; + if (NomeProgrammaISO != words[indiceUltimoElemento]) + NomeProgrammaISO = words[indiceUltimoElemento]; + } + return program_ret; + } + + public short readMainProgramComment() + { + short program_ret = 0; + string[] words; + byte[] alpha_comment = new byte[100]; + if (compatibiltyMode) + { + ushort caratteriDaLeggere = 100; + program_ret = Focas1.cnc_rdexecprog(hndl, ref caratteriDaLeggere, out short blknumber, alpha_comment); + } + else + { + uint lunghezza = 100; //va lasciato qui perche' viene riscritto ogni volta da "cnc_rdpdf_line" + uint numero_righe = 1; //va lasciato qui perche' viene riscritto ogni volta da "cnc_rdpdf_line" + byte[] nome_main = new byte[242]; + program_ret = Focas1.cnc_pdf_rdmain(hndl, nome_main); + string str_main = ASCIIEncoding.ASCII.GetString(nome_main).TrimEnd('\0'); + program_ret = Focas1.cnc_rdpdf_line(hndl, str_main, 0, alpha_comment, ref numero_righe, ref lunghezza); + } + string str_alpha_comment = ASCIIEncoding.ASCII.GetString(alpha_comment).TrimEnd('\0'); + // caso commento presente + if (str_alpha_comment.Contains("(")) + { + words = str_alpha_comment.Split('(', ')'); + int indiceUltimoElemento = words.Length - 2; + //CommentoProgrammaISO = '(' + words[indiceUltimoElemento] + ')'; + int open_index = str_alpha_comment.IndexOf('('); + int close_index = str_alpha_comment.IndexOf(')'); + if (open_index > 0) + { + CommentoProgrammaISO = str_alpha_comment.Substring(open_index + 1, close_index - open_index - 1); + } + } + // caso di programma senza commento + else + { + // CommentoProgrammaISO = '(' + NomeProgrammaISO + ')'; + CommentoProgrammaISO = "Commento Assente"; + } + return program_ret; + } + + public void Read() + { + // leggo i dati + + // Dati di produzione + // path 1 + Focas1.cnc_setpath(hndl, 1); + short a, b; + Focas1.cnc_getpath(hndl, out a, out b); + + ret_array[2] = readCicleTime(); + ret_array[3] = readContaPezzi(); + ret_array[4] = readAlarmMessages(); + ret_array[5] = readOperatorMessages(); + ret_array[6] = readMachineState(); + + CheckErrors(ret_array); + + } + + public void Connect() + { + //Thread.Sleep(500); + if (ConnectionRequest) + { + if (!CONNECTED && ConnectionType == 3) + { + // apro il canale di comunicazione verso la macchina + short timeout = 4; //sec + ret_array[0] = Focas1.cnc_allclibhndl3(IPAddress, Convert.ToUInt16(Port), timeout, out hndl); + } + else if (!CONNECTED && ConnectionType == 0) + { + ret_array[0] = Focas1.cnc_allclibhndl(out hndl); + } + else if (!CONNECTED && ConnectionType == 2) + { + ret_array[0] = Focas1.cnc_allclibhndl2(Node, out hndl); + } + if (ret_array[0] == 0) + { + // abilito il timer: comincio a fare il refresh dei dati su Cn e Robot + CONNECTED = true; + machine_status = "CONNECTED"; + ConnectionRequest = false; + } + else + { + ConnectionRequest = true; + CONNECTED = false; + machine_status = "DISCONNECTED"; + CheckErrors(ret_array); + } + } + } + + public void Disconnect() + { + ret_array[1] = Focas1.cnc_freelibhndl(hndl); + if (ret_array[1] == 0) + { + ConnectionRequest = true; + CONNECTED = false; + machine_status = "DISCONNECTED"; + } + resetMachineRet(); + } + + private void resetMachineRet() + { + for (short index = 0; index < ret_array.Length; index++) + { + ret_array[index] = 0; + } + } + + private void CheckErrors(short[] error) + { + FOCAS_ERRORS = ""; + bool disconnect = false; + for (short index = 0; index < error.Length; index++) + { + string focas_function = getFocasFunctionName(index); + switch (error[index]) + { + case (short)Focas1.focas_ret.EW_PROTOCOL: /* protocol error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "protocol error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_SOCKET: /* Windows socket error */ + disconnect = CONNECTED; + FOCAS_ERRORS += "Error " + error[index] + ": " + "windows socket error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_NODLL: /* DLL not exist error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "DLL not exist error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_BUS: /* bus error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "bus error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_SYSTEM2: /* system error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "system error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_HSSB: /* hssb communication error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " hssb communication error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_HANDLE: /* Windows library handle error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " Windows library handle error" + " in " + focas_function + "\n"; + disconnect = CONNECTED; + break; + case (short)Focas1.focas_ret.EW_VERSION: /* CNC/PMC version missmatch */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " CNC/PMC version missmatch" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_UNEXP: /* abnormal error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "abnormal error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_SYSTEM: /* system error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " system error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_PARITY: /* shared RAM parity error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "shared RAM parity error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_MMCSYS: /* emm386 or mmcsys install error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "emm386 or mmcsys install error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_RESET: /* reset or stop occured error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "reset or stop occured error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_BUSY: /* busy error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "busy error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_OK: /* no problem */ + break; + case (short)Focas1.focas_ret.EW_FUNC: /* command prepare error --or-- pmc not exist */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "command prepare error --or-- pmc not exist" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_LENGTH: /* data block length error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "data block length error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_NUMBER: /* data number error --or-- address range error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "data number error --or-- address range error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_ATTRIB: /* data attribute error --or-- data type error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "data attribute error --or-- data type error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_DATA: /* data error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "data error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_NOOPT: /* no option error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "no option error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_PROT: /* write protect error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "write protect error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_OVRFLOW: /* memory overflow error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "memory overflow error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_PARAM: /* cnc parameter not correct error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "cnc parameter not correct error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_BUFFER: /* buffer error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " buffer error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_PATH: /* path error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "path error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_MODE: /* cnc mode error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "cnc mode error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_REJECT: /* execution rejected error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "execution rejected error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_DTSRVR: /* data server error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " data server error" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_ALARM: /* alarm has been occurred */ + FOCAS_ERRORS += "Error " + error[index] + ": " + "alarm has been occurred" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_STOP: /* CNC is not running */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " CNC is not running" + " in " + focas_function + "\n"; + break; + case (short)Focas1.focas_ret.EW_PASSWD: /* protection data error */ + FOCAS_ERRORS += "Error " + error[index] + ": " + " protection data error" + " in " + focas_function + "\n"; + break; + default: + break; + } + if (FOCAS_ERRORS == "") + { + FOCAS_ERRORS = "OK"; + } + if (disconnect) + { + Disconnect(); + } + } + } + + + private short readContaPezzi() + { + short pieces_ret = 0; + try + { + if (CPMacroPiecesCounter == -1) + { + // Conta pezzi + pieces_ret = Focas1.cnc_rdparam(hndl, 6711, 0, 8, ContaPezzip1); + StrContaPezzip1 = ContaPezzip1.u.ldata.ToString(); + } + else + { + CPlength = (short)(8 + 8 * 1); + Focas1.ODBM macro = new Focas1.ODBM(); + pieces_ret = Focas1.cnc_rdmacro(hndl, CPMacroPiecesCounter, 10, macro); + if (pieces_ret == Focas1.EW_OK) + { + StrContaPezzip1 = string.Format("{0:d9}", Math.Abs(macro.mcr_val)); + if (0 < macro.dec_val) StrContaPezzip1 = StrContaPezzip1.Insert(9 - macro.dec_val, "."); + if (macro.mcr_val < 0) StrContaPezzip1 = "-" + StrContaPezzip1; + int index = StrContaPezzip1.IndexOf("."); + if (index >= 0) + StrContaPezzip1 = StrContaPezzip1.Substring(0, index); + Console.WriteLine("{0}", StrContaPezzip1); + } + else + { + Console.WriteLine("ERR-READ-MACRO**********"); + } + + } + } + catch + { + StrContaPezzip1 = "Errore Contapezzi"; + } + return pieces_ret; + } + + private void DownloadStd(short cnc_path = 1) + { + var PROG_MEMORY_PATH = get_cnc_path(cnc_path); + int num; + int len; + string program = "%\n\n%"; + + if (CONNECTED) + { + ret_array[9] = Focas1.cnc_pdf_del(hndl, PROG_MEMORY_PATH + "OSTD"); + + try + { + + + ret_array[9] = Focas_StartNCFileDownload(PROG_MEMORY_PATH, FanucProgram.FILE_TYPE.CNC_PROGRAM); + if (ret_array[9] != Focas1.EW_OK) + { + Focas_EndNCFileDownload(); + ret_array[9] = ret_array[9]; + CheckErrors(ret_array); + return; + } + + len = program.Length; + int startPos = 0; + + while (len > 0) + { + if (len >= 1024) + { + num = 1024; + } + else + { + num = len; + } + char[] prg_temp = new char[num]; + program.CopyTo(startPos, prg_temp, 0, num); + + ret_array[9] = Focas_NCFileDownload(ref num, prg_temp); + if (ret_array[9] == (short)Focas1.focas_ret.EW_BUFFER) + { + Thread.Sleep(100); + continue; + } + if (ret_array[9] == Focas1.EW_OK) + { + startPos += num; + len -= num; + } + if (ret_array[9] != Focas1.EW_OK) + { + Focas1.ODBERR odd = new Focas1.ODBERR(); + Focas1.cnc_getdtailerr(hndl, odd); + Debug.WriteLine(odd.err_no + " " + odd.err_dtno); + break; + } + } + + if (ret_array[9] != Focas1.EW_OK) + { + Focas_EndNCFileDownload(); + CheckErrors(ret_array); + return; + } + + Focas_EndNCFileDownload(); + Focas1.ODBERR odd2 = new Focas1.ODBERR(); + Focas1.cnc_getdtailerr(hndl, odd2); + Debug.WriteLine(odd2.err_no + " " + odd2.err_dtno); + } + catch + { + CheckErrors(ret_array); + return; + } + + ret_array[9] = Focas1.cnc_pdf_slctmain(hndl, PROG_MEMORY_PATH + "OSTD"); + CheckErrors(ret_array); + } + } + + + private bool canDownloadNC() + { + ret_array[9] = Focas1.cnc_statinfo(hndl, odbst); + if (ret_array[9] != Focas1.EW_OK) + { + CheckErrors(ret_array); + return false; + } + else if (odbst.aut != 0 //MDI STATE + && odbst.aut != 3) //EDIT STATE + { + ret_array[9] = (short)Focas1.focas_ret.EW_MODE; + CheckErrors(ret_array); + return false; + } + return true; + } + + /** + * SEND PROGRAM TO CNC MEMORY + */ + public short Download(string file, FanucProgram.FILE_TYPE type, short cnc_path = 1) + { + if (!canDownloadNC()) return ret_array[9]; + Focas1.cnc_setpath(hndl, cnc_path); + var PROG_MEMORY_PATH = get_cnc_path(cnc_path); + int num; + int len; + string prog_name = ""; + if (CONNECTED) + { + if (type == FanucProgram.FILE_TYPE.CNC_PROGRAM) + { + try + { + prog_name = FanucProgram.GetProgramTitle(file); + } + catch (Exception e) + { + FOCAS_ERRORS = "tentativo Download fallito nome file in formato errato\n" + e.StackTrace; + return (short)Focas1.focas_ret.EW_DATA; + } + + if (!compatibiltyMode) + { + ret_array[9] = Focas1.cnc_pdf_slctmain(hndl, PROG_MEMORY_PATH + "OSTD"); + if (ret_array[9] != Focas1.EW_OK) + DownloadStd(); + } + ret_array[9] = Focas_DeleteNCProgram(prog_name, PROG_MEMORY_PATH); + if (ret_array[9] != Focas1.EW_OK && ret_array[9] != (short)Focas1.focas_ret.EW_BUSY && ret_array[9] != (short)Focas1.focas_ret.EW_DATA) + { + CheckErrors(ret_array); + } + } + + try + { + ret_array[9] = Focas_StartNCFileDownload(PROG_MEMORY_PATH, type); + if (ret_array[9] != Focas1.EW_OK) + { + Focas_EndNCFileDownload(); + CheckErrors(ret_array); + return ret_array[9]; + } + + len = file.Length; + int startPos = 0; + + while (len > 0) + { + if (len >= 1024) + { + num = 1024; + } + else + { + num = len; + } + char[] prg_temp = new char[num]; + file.CopyTo(startPos, prg_temp, 0, num); + string a = file.Substring(startPos); + + ret_array[9] = Focas_NCFileDownload(ref num, prg_temp); + if (ret_array[9] == (short)Focas1.focas_ret.EW_BUFFER) + { + Thread.Sleep(100); + continue; + } + if (ret_array[9] == Focas1.EW_OK) + { + startPos += num; + len -= num; + } + if (ret_array[9] != Focas1.EW_OK) + { + Focas1.ODBERR odd = new Focas1.ODBERR(); + Focas1.cnc_getdtailerr(hndl, odd); + Debug.WriteLine(odd.err_no + " " + odd.err_dtno); + break; + } + } + + if (ret_array[9] != Focas1.EW_OK) + { + CheckErrors(ret_array); + Focas_EndNCFileDownload(); + return ret_array[9]; + } + + Focas_EndNCFileDownload(); + } + catch + { + CheckErrors(ret_array); + Focas_EndNCFileDownload(); + return ret_array[9]; + } + + if (!compatibiltyMode && type == FanucProgram.FILE_TYPE.CNC_PROGRAM) + ret_array[9] = Focas1.cnc_pdf_slctmain(hndl, PROG_MEMORY_PATH + prog_name); + + if (ret_array[9] != Focas1.EW_OK) + { + CheckErrors(ret_array); + return 18; + } + return Focas1.EW_OK; + } + return (short)Focas1.focas_ret.EW_BUSY; + } + + private short Focas_DeleteNCProgram(string prog_name, string prog_path) + { + Regex rx = new Regex(@"(\b[O]+\d{4}\b)|(\b\d{4}\b)"); //cerca per O#### o #### dove # è un carattere numerico + // Find matches. + MatchCollection matches = rx.Matches(prog_name); + if (matches.Count > 0) + { + prog_name = prog_name.Trim(new Char[] { 'O' }); + return Focas1.cnc_delete(hndl, (short)Convert.ToUInt32(prog_name)); + } + else + { + return Focas1.cnc_pdf_del(hndl, prog_path + prog_name); + } + } + + private short Focas_StartNCFileDownload(string file_path, FanucProgram.FILE_TYPE type) + { + //il path del file non può essere selezionato se compatibilityMode = true + if (compatibiltyMode) return Focas1.cnc_dwnstart3(hndl, (short)type); else return Focas1.cnc_dwnstart4(hndl, (short)type, file_path); + } + + private short Focas_NCFileDownload(ref int program_lenght, char[] program) + { + if (compatibiltyMode) return Focas1.cnc_download3(hndl, ref program_lenght, program); else return Focas1.cnc_download4(hndl, ref program_lenght, program); + } + + private short Focas_EndNCFileDownload() + { + if (compatibiltyMode) return Focas1.cnc_dwnend3(hndl); else return Focas1.cnc_dwnend4(hndl); + } + + private short Focas_StartNCFileUpload(string file_path, FanucProgram.FILE_TYPE type) + { + //il file_path cambia a seconda di compatibilityMode + if (compatibiltyMode) + { + try + { + //file_path deve essere il codice del programma e.g. O1234 --> file_path = 1234 + int file_code = Convert.ToInt32(file_path); + return Focas1.cnc_upstart3(hndl, (short)type, file_code, file_code); + } + catch + { + return (short)Focas1.focas_ret.EW_DATA; + } + } + else + //file_path deve essere il path del programma compreso il nome file e.g. "//CNC_MEM/USER/PATH1/SAMPLE" dove SAMPLE è il nome del programma + return Focas1.cnc_upstart4(hndl, (short)type, file_path); + } + + private short Focas_NCFileUpload(int program_lenght, char[] program) + { + //il path del file non può essere selezionato se compatibilityMode = true + if (compatibiltyMode) return Focas1.cnc_upload4(hndl, ref program_lenght, program); else return Focas1.cnc_upload4(hndl, ref program_lenght, program); + } + + private short Focas_EndNCFileUpload() + { + //il path del file non può essere selezionato se compatibilityMode = true + if (compatibiltyMode) return Focas1.cnc_upend3(hndl); else return Focas1.cnc_upend4(hndl); + } + + private string Focas_GetMainForNCDownloadUpload() + { + if (compatibiltyMode) + { + Focas1.ODBPRO buf = new Focas1.ODBPRO(); + ret_array[10] = Focas1.cnc_rdprgnum(hndl, buf); + CheckErrors(ret_array); + //buf.data->programma in esecuzione + //buf.mdata-> main program + return buf.mdata.ToString(); + } + else + { + byte[] nome_main = new byte[242]; + // nome programma + ret_array[10] = Focas1.cnc_pdf_rdmain(hndl, nome_main); + string path = ASCIIEncoding.ASCII.GetString(nome_main).TrimEnd('\0'); + CheckErrors(ret_array); + return path; + } + } + + /** + * GET MAIN PROGRAM FROM CNC MEMORY + */ + public string Upload(FanucProgram.FILE_TYPE type, short cnc_path = 1) + { + Focas1.cnc_setpath(hndl, cnc_path); + //file_path = PROG_MEMORY_PATH + //file_name = "SAMPLE"; + int BUFFER_SIZE = 10000;//dimensione del buffer di caratteri. Solitamente scarica meno di 1000 caratteri al ciclo + char[] buffer = new char[BUFFER_SIZE + 1]; + string buf; + int len; + string output = ""; + char[] path = new char[244]; + + if (CONNECTED == false) + return ""; + else + { + ret_array[10] = Focas_StartNCFileUpload(Focas_GetMainForNCDownloadUpload(), type); + + if (ret_array[10] != Focas1.EW_OK) + { + Focas_EndNCFileUpload(); + CheckErrors(ret_array); + return ""; + } + + do + { + len = BUFFER_SIZE; + ret_array[10] = Focas_NCFileUpload(len, buffer); + + if (ret_array[10] == (short)Focas1.focas_ret.EW_BUFFER) + { + Thread.Sleep(100); + continue; + } + + if (ret_array[10] == Focas1.EW_OK) + { + buffer[len] = '\0'; ; + buf = new string(buffer).TrimEnd('\0'); + output = output + buf; + } + + if (buffer[len - 1] == '%') + { + break; + } + } + while ((ret_array[10] == Focas1.EW_OK) || (ret_array[10] == (short)Focas1.focas_ret.EW_BUFFER)); + + + ret_array[10] = Focas_EndNCFileUpload(); + + return output; + } + } + + + } +} diff --git a/FanucProgram.cs b/FanucProgram.cs new file mode 100755 index 0000000..1e14dd7 --- /dev/null +++ b/FanucProgram.cs @@ -0,0 +1,192 @@ +using System; +using System.Text.RegularExpressions; + +namespace FanucProgramManager +{ + internal class FanucProgram + { + + private static Regex titleRegex = new Regex(@"(\b[O]+\d{4}\b)|(\b\d{4}\b)"); //cerca per O#### o #### dove # è un carattere numerico + private static Regex oldTitleRegex = new Regex(@"\<((\b[O]+\d{4}\b)|(\b\d{4}\b))\>");//cerca per o #### dove # è un carattere numerico + private static Regex titleAndCommentRegex = new Regex(@"((\b[O]+\d{4}\b)|(\b\d{4}\b))+(\n|(\s*\((.*?)\)))"); + private static Regex commentRegex = new Regex(@"\((.*?)\)"); + + private const string programStringName = "program:"; + private const string toolOffsetDataName = "tooloffsetdata:"; + private const string workZeroOffsetDataName = "workzerooffset:"; + + private static Regex programRegex = new Regex(@"program:\{\n((?:.*?|\n)*?)\}"); + private static Regex toolOffsetDataRegex = new Regex(@"tooloffsetdata:\{\n((?:.*?|\n)*?)\}"); + private static Regex workZeroOffsetDataRegex = new Regex(@"workzerooffset:\{\n((?:.*?|\n)*?)\}"); + + + public String Program; + public String ToolOffsetData; + public String WorkZeroOffsetData; + + public void setValue(String value, FILE_TYPE type) + { + switch (type) + { + case FILE_TYPE.CNC_PROGRAM: Program = value; break; + case FILE_TYPE.TOOL_OFFEST_DATA: ToolOffsetData = value; break; + case FILE_TYPE.WORK_ZERO_OFFSET: WorkZeroOffsetData = value; break; + } + Standardize(); + } + public enum FILE_TYPE : short + { + CNC_PROGRAM = 0, + TOOL_OFFEST_DATA = 1, + WORK_ZERO_OFFSET = 5 + } + + public FanucProgram(string _program) + { + var programMatch = programRegex.Match(_program); + if (programMatch.Success) + { + Program = programMatch.Value.Substring(9); + Program = Program.Trim('}'); + } + else Program = null; + + var toolOffsetDataMatch = toolOffsetDataRegex.Match(_program); + if (toolOffsetDataMatch.Success) + { + ToolOffsetData = toolOffsetDataMatch.Value.Substring(16); + ToolOffsetData = ToolOffsetData.Trim('}'); + } + else ToolOffsetData = null; + + var workZeroOffsetDataMatch = workZeroOffsetDataRegex.Match(_program); + if (workZeroOffsetDataMatch.Success) + { + WorkZeroOffsetData = workZeroOffsetDataMatch.Value.Substring(16); + WorkZeroOffsetData = WorkZeroOffsetData.Trim('}'); + } + else WorkZeroOffsetData = null; + + //Old program format with ONLY the program outside of brachets + if (!programMatch.Success && !toolOffsetDataMatch.Success && !workZeroOffsetDataMatch.Success) + { + Program = _program; + } + + Standardize(); + } + + public string GetProgramTitle() + { + var match = titleRegex.Match(Program); + if (match.Success) + { + return match.Value; + } + throw new InvalidOperationException("Regex could not match any program title in the file, check program formatting for a O#### patern"); + } + + public static string GetProgramTitle(string program) + { + var match = titleRegex.Match(program); + if (match.Success) + { + return match.Value; + } + throw new InvalidOperationException("Regex could not match any program title in the file, check program formatting for a O#### patern"); + } + + public string GetProgramComment() + { + var groupMatch = titleAndCommentRegex.Match(Program); + if (groupMatch.Success) + { + Match match = commentRegex.Match(groupMatch.Value); + if (match.Success) + { + return match.Value.Trim(new Char[] { '(', ')' }); + } + } + return ""; + } + + private void Standardize() + { + //removes % from start of file + int percent_index = Program.IndexOf('%'); + if (percent_index == 0) + { + Program = Program.Remove(percent_index, 1); + } + //removes % from start of file + if (ToolOffsetData != null) + { + percent_index = ToolOffsetData.IndexOf('%'); + if (percent_index == 0) + { + ToolOffsetData = ToolOffsetData.Remove(percent_index, 1); + } + } + //removes % from start of file + if (WorkZeroOffsetData != null) + { + percent_index = WorkZeroOffsetData.IndexOf('%'); + if (percent_index == 0) + { + WorkZeroOffsetData = WorkZeroOffsetData.Remove(percent_index, 1); + } + } + + //replace with O#### + var oldTitleMatch = oldTitleRegex.Match(Program); + if (oldTitleMatch.Success) + { + Program = Program.Replace(oldTitleMatch.Value, GetProgramTitle()); + } + + //adds \n to file beginning if missing + int new_line_index = Program.IndexOf('\n'); + if (new_line_index != 0) + { + Program = Program.Substring(Program.IndexOf(GetProgramTitle())); + Program = Program.Insert(0, "\n"); + } + } + + //fornendo un programma CNC e un commento in INPUT restituisce un output nel formato corretto per il caricamento con la funzione download + public void ChangeComment(string comment) + { + string previousComment = GetProgramComment(); + if (previousComment != "") + Program = Program.Replace(previousComment, "(" + comment + ")"); + else + { + Program = Program.Replace(GetProgramTitle(), GetProgramTitle() + "(" + comment + ")"); + } + + } + + public void ChangeProgName(string progName) + { + var match = titleRegex.Match(progName); + if (!match.Success) + { + throw new InvalidOperationException("New Program Name does Not respect the proper formattings O#### patern"); + } + Program.Replace(GetProgramTitle(), progName); + } + + public void ChangeNameAndComment(string progName, string comment) + { + ChangeProgName(progName); + ChangeComment(comment); + } + + public override string ToString() + { + return programStringName + "{\n" + Program + "\n}\n" + + toolOffsetDataName + "{\n" + ToolOffsetData + "\n}\n" + + workZeroOffsetDataName + "{\n" + WorkZeroOffsetData + "\n}\n"; + } + } +} diff --git a/FanucProgramManager.Tests/FanucProgramManager.Tests.csproj b/FanucProgramManager.Tests/FanucProgramManager.Tests.csproj new file mode 100644 index 0000000..c798d9c --- /dev/null +++ b/FanucProgramManager.Tests/FanucProgramManager.Tests.csproj @@ -0,0 +1,70 @@ + + + + + Debug + AnyCPU + {A1B2C3D4-E5F6-7890-ABCD-EF1234567890} + Library + FanucProgramManager.Tests + FanucProgramManager.Tests + v4.7.2 + 512 + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + ..\packages\NUnit.3.13.3\lib\net45\nunit.framework.dll + + + ..\packages\Moq.4.18.4\lib\net462\Moq.dll + + + ..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll + + + + + {1032188B-3321-42B2-87ED-343BF718CAF5} + FanucProgramManager + + + + + + + + + + + + + + + + + + + diff --git a/FanucProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs b/FanucProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs new file mode 100644 index 0000000..173217f --- /dev/null +++ b/FanucProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs @@ -0,0 +1,80 @@ +using System; +using NUnit.Framework; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Heidenhain; +using FanucProgramManager.Tests.Integration.Stubs; + +namespace FanucProgramManager.Tests.Integration +{ + [TestFixture] + [Category("Integration")] + public class HeidenhainMachineIntegrationTests + { + private Lsv2ServerStub _stub; + private HeidenhainMachine _machine; + + [SetUp] + public void SetUp() + { + _stub = new Lsv2ServerStub(); + var config = new HeidenhainConnectionConfig + { + Name = "HeidenhainIntegration", + IpAddress = "127.0.0.1", + Port = _stub.Port, + Username = "user", + Password = "pass", + ConnectTimeout = TimeSpan.FromSeconds(5) + }; + _machine = new HeidenhainMachine(config); + } + + [TearDown] + public void TearDown() + { + _machine?.Dispose(); + _stub?.Dispose(); + } + + [Test] + public void ConnectAsync_StubHandlesLoginHandshake_ResultOk() + { + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Connected)); + } + + [Test] + public void WriteThenRead_ProgramRoundTrips() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + // Heidenhain: name must end with .H; no % or ; forbidden chars; no lowercase; no O#### required + string content = "L X+0 Y+0 R0 FMAX\nM30"; + var prog = new CncProgram { Name = "O1234.H", Content = content }; + string folder = "TNC:/nc_prog/"; + + var writeResult = _machine.WriteProgramAsync(folder, prog).GetAwaiter().GetResult(); + Assert.That(writeResult.Success, Is.True); + + // HeidenhainMachine appends .H only if name has no extension — name already has .H + string storedPath = folder + "O1234.H"; + Assert.That(_stub.Files.ContainsKey(storedPath), Is.True, + "File should be in stub at " + storedPath); + + var readResult = _machine.ReadProgramAsync(storedPath).GetAwaiter().GetResult(); + Assert.That(readResult.Success, Is.True); + Assert.That(readResult.Value, Is.EqualTo(content)); + } + + [Test] + public void ReadProgramAsync_UnknownPath_ResultIsFail() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.ReadProgramAsync("TNC:/nc_prog/DOESNOTEXIST.H").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } +} diff --git a/FanucProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs b/FanucProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs new file mode 100644 index 0000000..b937b5f --- /dev/null +++ b/FanucProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs @@ -0,0 +1,96 @@ +using System; +using NUnit.Framework; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Mitsubishi; +using FanucProgramManager.Tests.Integration.Stubs; + +namespace FanucProgramManager.Tests.Integration +{ + [TestFixture] + [Category("Integration")] + public class MitsubishiMachineIntegrationTests + { + private FtpServerStub _stub; + private MitsubishiMachine _machine; + private const string ProgramDir = "/PRG/"; + + [SetUp] + public void SetUp() + { + _stub = new FtpServerStub(); + var config = new MitsubishiConnectionConfig + { + Name = "MitsubishiIntegration", + IpAddress = "127.0.0.1", + Port = _stub.Port, + Username = "user", + Password = "pass", + ProgramDirectory = ProgramDir, + RequestTimeout = TimeSpan.FromSeconds(5) + }; + _machine = new MitsubishiMachine(config); + } + + [TearDown] + public void TearDown() + { + _machine?.Dispose(); + _stub?.Dispose(); + } + + [Test] + public void ConnectAsync_StubListens_ResultOk() + { + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Connected)); + } + + [Test] + public void WriteThenRead_ProgramRoundTripsNoExtension() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + // Mitsubishi: name O\d{4}; first line must be O####; no semicolons/brackets; no lowercase + string content = "O1234\nG0 X0 Y0\nM30"; + var prog = new CncProgram { Name = "O1234", Content = content }; + + var writeResult = _machine.WriteProgramAsync(ProgramDir, prog).GetAwaiter().GetResult(); + Assert.That(writeResult.Success, Is.True); + + // Mitsubishi: no extension + string storedPath = ProgramDir + "O1234"; + Assert.That(_stub.Files.ContainsKey(storedPath), Is.True, + "File should be stored without extension at " + storedPath); + Assert.That(_stub.Files.ContainsKey(storedPath + ".MPF"), Is.False, + "File must NOT be stored with .MPF extension"); + + var readResult = _machine.ReadProgramAsync(storedPath).GetAwaiter().GetResult(); + Assert.That(readResult.Success, Is.True); + Assert.That(readResult.Value, Is.EqualTo(content)); + } + + [Test] + public void DeleteProgramAsync_FileExistsInStub_RemovedFromStub() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + string path = ProgramDir + "O5678"; + _stub.Files[path] = "SOME_CONTENT"; + + var result = _machine.DeleteProgramAsync(path).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(_stub.Files.ContainsKey(path), Is.False); + } + + [Test] + public void ReadProgramAsync_FileNotInStub_ResultFail() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.ReadProgramAsync(ProgramDir + "O9999").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } +} diff --git a/FanucProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs b/FanucProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs new file mode 100644 index 0000000..13f9494 --- /dev/null +++ b/FanucProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs @@ -0,0 +1,104 @@ +using System; +using NUnit.Framework; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Siemens; +using FanucProgramManager.Tests.Integration.Stubs; + +namespace FanucProgramManager.Tests.Integration +{ + [TestFixture] + [Category("Integration")] + public class SiemensMachineIntegrationTests + { + private FtpServerStub _stub; + private SiemensMachine _machine; + private const string ProgramDir = "/_N_MPF_DIR/"; + + [SetUp] + public void SetUp() + { + _stub = new FtpServerStub(); + var config = new SiemensConnectionConfig + { + Name = "SiemensIntegration", + IpAddress = "127.0.0.1", + Port = _stub.Port, + Username = "user", + Password = "pass", + ProgramDirectory = ProgramDir, + RequestTimeout = TimeSpan.FromSeconds(5) + }; + _machine = new SiemensMachine(config); + } + + [TearDown] + public void TearDown() + { + _machine?.Dispose(); + _stub?.Dispose(); + } + + [Test] + public void ConnectAsync_StubListens_ResultOk() + { + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Connected)); + } + + [Test] + public void WriteThenRead_ProgramRoundTrips() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + // Siemens: name must end with .MPF; no semicolons; no lowercase + string content = "G0 X0 Y0\nM30"; + var prog = new CncProgram { Name = "O1234.MPF", Content = content }; + + var writeResult = _machine.WriteProgramAsync(ProgramDir, prog).GetAwaiter().GetResult(); + Assert.That(writeResult.Success, Is.True); + + // Determine where SiemensMachine stored the file + string storedPath = ProgramDir + "O1234.MPF"; + var readResult = _machine.ReadProgramAsync(storedPath).GetAwaiter().GetResult(); + + Assert.That(readResult.Success, Is.True); + Assert.That(readResult.Value, Is.EqualTo(content)); + } + + [Test] + public void DeleteProgramAsync_FileExistsInStub_RemovedFromStub() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + string path = ProgramDir + "O5678.MPF"; + _stub.Files[path] = "SOME_CONTENT"; + + var result = _machine.DeleteProgramAsync(path).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(_stub.Files.ContainsKey(path), Is.False); + } + + [Test] + public void ReadProgramAsync_FileNotInStub_ResultFail() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.ReadProgramAsync(ProgramDir + "DOESNOTEXIST.MPF").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + + [Test] + public void WriteProgramAsync_InvalidName_ValidationFails() + { + _machine.ConnectAsync().GetAwaiter().GetResult(); + // Siemens requires .MPF extension — validator rejects before any FTP call + var prog = new CncProgram { Name = "INVALID", Content = "G00 X10\nM30" }; + + var result = _machine.WriteProgramAsync(ProgramDir, prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } +} diff --git a/FanucProgramManager.Tests/Integration/Stubs/FtpServerStub.cs b/FanucProgramManager.Tests/Integration/Stubs/FtpServerStub.cs new file mode 100644 index 0000000..08f8397 --- /dev/null +++ b/FanucProgramManager.Tests/Integration/Stubs/FtpServerStub.cs @@ -0,0 +1,255 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Threading; + +namespace FanucProgramManager.Tests.Integration.Stubs +{ + /// + /// Minimal in-process FTP server using passive mode. + /// Supports USER, PASS, SYST, PWD, CWD, TYPE, PASV, LIST, NLST, RETR, STOR, DELE, QUIT. + /// Also accepts OPTS, FEAT, NOOP, CLNT, MODE, STRU as no-ops. + /// All replies use CRLF (per RFC 959), independent of host platform. + /// + public sealed class FtpServerStub : IDisposable + { + private const string CRLF = "\r\n"; + + private readonly TcpListener _listener; + private readonly Thread _acceptThread; + private volatile bool _running; + + public int Port { get; } + + /// In-memory file store: full path → content. + public Dictionary Files { get; } = new Dictionary(StringComparer.OrdinalIgnoreCase); + + public FtpServerStub() + { + _listener = new TcpListener(IPAddress.Loopback, 0); + _listener.Start(); + Port = ((IPEndPoint)_listener.LocalEndpoint).Port; + _running = true; + _acceptThread = new Thread(AcceptLoop) { IsBackground = true, Name = "FtpStub-Accept" }; + _acceptThread.Start(); + } + + public void Dispose() + { + _running = false; + try { _listener.Stop(); } catch { } + } + + private void AcceptLoop() + { + while (_running) + { + TcpClient client; + try { client = _listener.AcceptTcpClient(); } + catch { break; } + var t = new Thread(() => HandleClient(client)) { IsBackground = true, Name = "FtpStub-Client" }; + t.Start(); + } + } + + private static void SendLine(Stream stream, string line) + { + byte[] bytes = Encoding.ASCII.GetBytes(line + CRLF); + stream.Write(bytes, 0, bytes.Length); + stream.Flush(); + } + + private static string ReadLine(Stream stream) + { + var sb = new StringBuilder(); + int prev = -1; + while (true) + { + int b = stream.ReadByte(); + if (b < 0) return sb.Length == 0 ? null : sb.ToString(); + if (b == '\n') + { + if (prev == '\r') + sb.Length = sb.Length - 1; // strip CR + return sb.ToString(); + } + sb.Append((char)b); + prev = b; + } + } + + private void HandleClient(TcpClient client) + { + using (client) + using (var stream = client.GetStream()) + { + string cwd = "/"; + TcpListener dataListener = null; + + SendLine(stream, "220 FtpServerStub ready"); + + string line; + while ((line = ReadLine(stream)) != null) + { + line = line.Trim(); + if (string.IsNullOrEmpty(line)) continue; + + string cmd, arg; + int sp = line.IndexOf(' '); + if (sp >= 0) + { + cmd = line.Substring(0, sp).ToUpperInvariant(); + arg = line.Substring(sp + 1).Trim(); + } + else + { + cmd = line.ToUpperInvariant(); + arg = ""; + } + + switch (cmd) + { + case "USER": + SendLine(stream, "331 Password required"); + break; + + case "PASS": + SendLine(stream, "230 Logged in"); + break; + + case "SYST": + SendLine(stream, "215 UNIX Type: L8"); + break; + + case "FEAT": + SendLine(stream, "211-Features:"); + SendLine(stream, " UTF8"); + SendLine(stream, "211 End"); + break; + + case "OPTS": + case "CLNT": + case "NOOP": + case "MODE": + case "STRU": + case "ALLO": + SendLine(stream, "200 OK"); + break; + + case "PWD": + SendLine(stream, "257 \"" + cwd + "\""); + break; + + case "CWD": + cwd = arg.StartsWith("/") ? arg : cwd.TrimEnd('/') + "/" + arg; + if (!cwd.EndsWith("/")) cwd += "/"; + SendLine(stream, "250 CWD successful"); + break; + + case "TYPE": + SendLine(stream, "200 Type set"); + break; + + case "PASV": + dataListener = new TcpListener(IPAddress.Loopback, 0); + dataListener.Start(); + int dataPort = ((IPEndPoint)dataListener.LocalEndpoint).Port; + int p1 = dataPort >> 8; + int p2 = dataPort & 0xFF; + SendLine(stream, "227 Entering Passive Mode (127,0,0,1," + p1 + "," + p2 + ")"); + break; + + case "LIST": + case "NLST": + if (dataListener == null) { SendLine(stream, "425 No data connection"); break; } + SendLine(stream, "150 Opening data connection"); + try + { + using (var dc = dataListener.AcceptTcpClient()) + using (var ds = dc.GetStream()) + { + // Empty listing — enough for Ping() + } + } + catch { } + try { dataListener.Stop(); } catch { } + dataListener = null; + SendLine(stream, "226 Transfer complete"); + break; + + case "RETR": + if (dataListener == null) { SendLine(stream, "425 No data connection"); break; } + string retrPath = NormalizePath(cwd, arg); + string retrContent; + if (!Files.TryGetValue(retrPath, out retrContent)) + { + try { dataListener.Stop(); } catch { } + dataListener = null; + SendLine(stream, "550 File not found"); + break; + } + SendLine(stream, "150 Opening data connection"); + try + { + using (var dc = dataListener.AcceptTcpClient()) + using (var ds = dc.GetStream()) + { + byte[] bytes = Encoding.ASCII.GetBytes(retrContent); + ds.Write(bytes, 0, bytes.Length); + } + } + catch { } + try { dataListener.Stop(); } catch { } + dataListener = null; + SendLine(stream, "226 Transfer complete"); + break; + + case "STOR": + if (dataListener == null) { SendLine(stream, "425 No data connection"); break; } + string storPath = NormalizePath(cwd, arg); + SendLine(stream, "150 Opening data connection"); + var sb = new StringBuilder(); + try + { + using (var dc = dataListener.AcceptTcpClient()) + using (var ds = dc.GetStream()) + using (var dr = new StreamReader(ds, Encoding.ASCII)) + { + sb.Append(dr.ReadToEnd()); + } + } + catch { } + Files[storPath] = sb.ToString(); + try { dataListener.Stop(); } catch { } + dataListener = null; + SendLine(stream, "226 Transfer complete"); + break; + + case "DELE": + string delePath = NormalizePath(cwd, arg); + Files.Remove(delePath); + SendLine(stream, "250 DELE successful"); + break; + + case "QUIT": + SendLine(stream, "221 Goodbye"); + return; + + default: + SendLine(stream, "500 Unknown command"); + break; + } + } + } + } + + private static string NormalizePath(string cwd, string arg) + { + if (arg.StartsWith("/")) return arg; + return cwd.TrimEnd('/') + "/" + arg; + } + } +} diff --git a/FanucProgramManager.Tests/Integration/Stubs/Lsv2ServerStub.cs b/FanucProgramManager.Tests/Integration/Stubs/Lsv2ServerStub.cs new file mode 100644 index 0000000..3e25868 --- /dev/null +++ b/FanucProgramManager.Tests/Integration/Stubs/Lsv2ServerStub.cs @@ -0,0 +1,212 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Threading; + +namespace FanucProgramManager.Tests.Integration.Stubs +{ + /// + /// Minimal in-process LSV2 server. + /// Frame format: [0x02][SIZE_HI][SIZE_LO][CMD_HI][CMD_LO][data...][CRC_HI][CRC_LO] + /// SIZE = len(CMD) + len(data) = 2 + dataLen + /// + public sealed class Lsv2ServerStub : IDisposable + { + private const ushort T_OK = 0x0000; + private const ushort T_SE = 0x0001; + private const ushort T_LS_SELECT = 0x00A0; + private const ushort T_LS_LOG_IN = 0x00A1; + private const ushort T_LS_LOG_OUT = 0x00A2; + private const ushort T_R_FL = 0x0023; + private const ushort T_S_FL = 0x0024; + private const ushort T_FD = 0x0025; + + private readonly TcpListener _listener; + private readonly Thread _acceptThread; + private volatile bool _running; + + public int Port { get; } + + /// In-memory file store: full path → content. + public Dictionary Files { get; } = new Dictionary(StringComparer.Ordinal); + + public Lsv2ServerStub() + { + _listener = new TcpListener(IPAddress.Loopback, 0); + _listener.Start(); + Port = ((IPEndPoint)_listener.LocalEndpoint).Port; + _running = true; + _acceptThread = new Thread(AcceptLoop) { IsBackground = true, Name = "Lsv2Stub-Accept" }; + _acceptThread.Start(); + } + + public void Dispose() + { + _running = false; + try { _listener.Stop(); } catch { } + } + + private void AcceptLoop() + { + while (_running) + { + TcpClient client; + try { client = _listener.AcceptTcpClient(); } + catch { break; } + var t = new Thread(() => HandleClient(client)) { IsBackground = true, Name = "Lsv2Stub-Client" }; + t.Start(); + } + } + + private void HandleClient(TcpClient client) + { + using (client) + using (var stream = client.GetStream()) + { + while (true) + { + ushort cmd; + byte[] data = ReadFrame(stream, out cmd); + if (data == null) break; + + switch (cmd) + { + case T_LS_SELECT: + case T_LS_LOG_IN: + SendFrame(stream, T_OK, new byte[0]); + break; + + case T_LS_LOG_OUT: + SendFrame(stream, T_OK, new byte[0]); + return; + + case T_R_FL: + { + // data = path\0 + string path = ExtractString(data, 0); + string content; + if (!Files.TryGetValue(path, out content)) + { + SendFrame(stream, T_SE, new byte[0]); + break; + } + byte[] contentBytes = Encoding.ASCII.GetBytes(content); + SendFrame(stream, T_FD, contentBytes); + SendFrame(stream, T_OK, new byte[0]); + break; + } + + case T_S_FL: + { + // data = path\0 + content + string path = ExtractString(data, 0); + int pathLen = Encoding.ASCII.GetByteCount(path) + 1; // +1 for \0 + int contentLen = data.Length - pathLen; + string content = contentLen > 0 + ? Encoding.ASCII.GetString(data, pathLen, contentLen) + : ""; + Files[path] = content; + SendFrame(stream, T_OK, new byte[0]); + break; + } + + default: + SendFrame(stream, T_SE, new byte[0]); + break; + } + } + } + } + + private static byte[] ReadFrame(Stream stream, out ushort cmd) + { + cmd = 0xFFFF; + int stx = stream.ReadByte(); + if (stx != 0x02) return null; + + int sizeHi = stream.ReadByte(); + int sizeLo = stream.ReadByte(); + if (sizeHi < 0 || sizeLo < 0) return null; + int size = (sizeHi << 8) | sizeLo; + if (size < 2) return null; + + int cmdHi = stream.ReadByte(); + int cmdLo = stream.ReadByte(); + if (cmdHi < 0 || cmdLo < 0) return null; + cmd = (ushort)((cmdHi << 8) | cmdLo); + + int dataLen = size - 2; + byte[] data = new byte[dataLen]; + int read = 0; + while (read < dataLen) + { + int n = stream.Read(data, read, dataLen - read); + if (n == 0) return null; + read += n; + } + + // consume CRC + stream.ReadByte(); + stream.ReadByte(); + + return data; + } + + private static void SendFrame(Stream stream, ushort cmdCode, byte[] data) + { + int dataLen = data.Length; + ushort size = (ushort)(2 + dataLen); + + byte sizeHi = (byte)(size >> 8); + byte sizeLo = (byte)(size & 0xFF); + byte cmdHi = (byte)(cmdCode >> 8); + byte cmdLo = (byte)(cmdCode & 0xFF); + + byte[] crcInput = new byte[4 + dataLen]; + crcInput[0] = sizeHi; crcInput[1] = sizeLo; + crcInput[2] = cmdHi; crcInput[3] = cmdLo; + Buffer.BlockCopy(data, 0, crcInput, 4, dataLen); + ushort crc = Crc16(crcInput); + + byte[] frame = new byte[1 + 4 + dataLen + 2]; + int i = 0; + frame[i++] = 0x02; + frame[i++] = sizeHi; + frame[i++] = sizeLo; + frame[i++] = cmdHi; + frame[i++] = cmdLo; + Buffer.BlockCopy(data, 0, frame, i, dataLen); + i += dataLen; + frame[i++] = (byte)(crc >> 8); + frame[i] = (byte)(crc & 0xFF); + + stream.Write(frame, 0, frame.Length); + stream.Flush(); + } + + private static string ExtractString(byte[] data, int offset) + { + int end = offset; + while (end < data.Length && data[end] != 0) end++; + return Encoding.ASCII.GetString(data, offset, end - offset); + } + + // CRC16 CCITT — same poly/init as Lsv2Client + private static ushort Crc16(byte[] data) + { + ushort crc = 0xFFFF; + foreach (byte b in data) + { + crc ^= (ushort)(b << 8); + for (int i = 0; i < 8; i++) + crc = (crc & 0x8000) != 0 + ? (ushort)((crc << 1) ^ 0x1021) + : (ushort)(crc << 1); + } + return crc; + } + } +} diff --git a/FanucProgramManager.Tests/Unit/CncMachineFactoryTests.cs b/FanucProgramManager.Tests/Unit/CncMachineFactoryTests.cs new file mode 100644 index 0000000..4b342bb --- /dev/null +++ b/FanucProgramManager.Tests/Unit/CncMachineFactoryTests.cs @@ -0,0 +1,113 @@ +using NUnit.Framework; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Fanuc; +using FanucProgramManager.Cnc.Heidenhain; +using FanucProgramManager.Cnc.Mitsubishi; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Siemens; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class CncMachineFactoryTests + { + private static T GetRequiredField(object target, string name) + { + var f = target.GetType().GetField(name, + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance) + ?? throw new InvalidOperationException( + string.Format("Field '{0}' not found on {1}. Field may have been renamed.", name, target.GetType().Name)); + return (T)f.GetValue(target); + } + + private InputArgs BaseArgs() + { + return new InputArgs + { + ip = "192.168.1.1", + porta = "", + username = "user", + password = "pass", + nodoHssb = -1 + }; + } + + [Test] + public void Create_Fanuc_ReturnsFanucMachine() + { + var args = BaseArgs(); + args.manufacturer = CncManufacturer.Fanuc; + + using (var m = CncMachineFactory.Create(args)) + { + Assert.That(m, Is.InstanceOf()); + } + } + + [Test] + public void Create_Heidenhain_ReturnsHeidenhainMachine() + { + var args = BaseArgs(); + args.manufacturer = CncManufacturer.Heidenhain; + + using (var m = CncMachineFactory.Create(args)) + { + Assert.That(m, Is.InstanceOf()); + } + } + + [Test] + public void Create_Siemens_ReturnsSiemensMachine() + { + var args = BaseArgs(); + args.manufacturer = CncManufacturer.Siemens; + + using (var m = CncMachineFactory.Create(args)) + { + Assert.That(m, Is.InstanceOf()); + } + } + + [Test] + public void Create_Mitsubishi_ReturnsMitsubishiMachine() + { + var args = BaseArgs(); + args.manufacturer = CncManufacturer.Mitsubishi; + + using (var m = CncMachineFactory.Create(args)) + { + Assert.That(m, Is.InstanceOf()); + } + } + + [Test] + public void Create_FanucHssbNode_TransportIsHssb() + { + var args = BaseArgs(); + args.manufacturer = CncManufacturer.Fanuc; + args.nodoHssb = 0; + + using (var m = CncMachineFactory.Create(args) as FanucMachine) + { + var config = GetRequiredField(m, "_config"); + + Assert.That(config.Transport, Is.EqualTo(FanucTransport.Hssb)); + } + } + + [Test] + public void Create_FanucNoHssb_TransportIsEthernet() + { + var args = BaseArgs(); + args.manufacturer = CncManufacturer.Fanuc; + args.nodoHssb = -1; + + using (var m = CncMachineFactory.Create(args) as FanucMachine) + { + var config = GetRequiredField(m, "_config"); + + Assert.That(config.Transport, Is.EqualTo(FanucTransport.Ethernet)); + } + } + } +} diff --git a/FanucProgramManager.Tests/Unit/FanucMachineTests.cs b/FanucProgramManager.Tests/Unit/FanucMachineTests.cs new file mode 100644 index 0000000..51af1bf --- /dev/null +++ b/FanucProgramManager.Tests/Unit/FanucMachineTests.cs @@ -0,0 +1,221 @@ +using System; +using NUnit.Framework; +using Moq; +using FanucProgramManager.Cnc.Fanuc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Tests.Unit +{ + /// + /// FanucMachine calls real FOCAS DLL in ConnectCore and most methods guard + /// via EnsureConnected. Tests that require an active FOCAS handle are marked Ignore. + /// The tests here verify dialect call patterns by setting machine state via + /// reflection (bypass EnsureConnected) after injecting a mock dialect. + /// + [TestFixture] + public class FanucMachineTests + { + // Used in Returns() to modify the ref int len parameter — lambdas cannot have ref params. + private delegate short UploadDataDelegate(ushort hndl, ref int len, char[] data); + + private FanucConnectionConfig EthernetConfig() + { + return new FanucConnectionConfig + { + Name = "TestFanuc", + Transport = FanucTransport.Ethernet, + IpAddress = "127.0.0.1", + Port = 8193, + ConnectTimeout = TimeSpan.FromSeconds(1) + }; + } + + private static T GetRequiredField(object target, string name) + { + var f = target.GetType().GetField(name, + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance) + ?? throw new InvalidOperationException( + string.Format("Field '{0}' not found on {1}. Field may have been renamed.", name, target.GetType().Name)); + return (T)f.GetValue(target); + } + + private static void SetRequiredField(object target, string name, T value) + { + var f = target.GetType().GetField(name, + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance) + ?? throw new InvalidOperationException( + string.Format("Field '{0}' not found on {1}. Field may have been renamed.", name, target.GetType().Name)); + f.SetValue(target, value); + } + + private FanucMachine CreateConnectedWithMockDialect(Mock dialectMock) + { + var machine = new FanucMachine(EthernetConfig()); + SetRequiredField(machine, "_state", ConnectionState.Connected); + SetRequiredField(machine, "_dialect", dialectMock.Object); + return machine; + } + + [Test] + [Ignore("Requires Fanuc FOCAS DLL — no mock injection path for ConnectCore")] + public void ConnectAsync_FocasReturnsOk_ResultSuccess() + { + // Would need real FOCAS DLL or a way to intercept Focas1.cnc_allclibhndl3 + } + + [Test] + [Ignore("Requires Fanuc FOCAS DLL")] + public void ConnectAsync_FocasReturnsError_ResultFail() + { + // Same — Focas1 static calls cannot be intercepted without DLL + } + + [Test] + // Moq default: ref int len stays 0 after UploadData call, loop exits via else-branch (len == 0). + // This test verifies call sequence only, not data content. + // See ReadProgramAsync_UploadDataReturnsContent_ContentInResult for data-reading coverage. + public void ReadProgramAsync_CallsUploadStartThenDataThenEnd() + { + var dialect = new Mock(); + dialect.Setup(d => d.UploadStart(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadData(It.IsAny(), ref It.Ref.IsAny, It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadEnd(It.IsAny())).Returns(Focas1.EW_OK); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + machine.ReadProgramAsync("O1234").GetAwaiter().GetResult(); + } + + dialect.Verify(d => d.UploadStart(It.IsAny(), "O1234", It.IsAny(), 0), Times.Once); + dialect.Verify(d => d.UploadEnd(It.IsAny()), Times.Once); + } + + [Test] + public void ReadProgramAsync_UploadDataReturnsContent_ContentInResult() + { + var programContent = "O1234\nG0 X0\nM30\n%"; + var chars = programContent.ToCharArray(); + + var dialect = new Mock(); + dialect.Setup(d => d.UploadStart(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadData(It.IsAny(), ref It.Ref.IsAny, It.IsAny())) + .Returns(new UploadDataDelegate(delegate(ushort h, ref int len, char[] buf) + { + Array.Copy(chars, buf, chars.Length); + len = chars.Length; + return Focas1.EW_OK; + })); + dialect.Setup(d => d.UploadEnd(It.IsAny())).Returns(Focas1.EW_OK); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + var result = machine.ReadProgramAsync("O1234").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(result.Value, Is.EqualTo(programContent)); + } + } + + [Test] + public void ReadToolDataAsync_CallsUploadStartWithFileType1() + { + var dialect = new Mock(); + dialect.Setup(d => d.UploadStart(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadData(It.IsAny(), ref It.Ref.IsAny, It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadEnd(It.IsAny())).Returns(Focas1.EW_OK); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + machine.ReadToolDataAsync("O1234").GetAwaiter().GetResult(); + } + + dialect.Verify(d => d.UploadStart(It.IsAny(), "O1234", It.IsAny(), (short)1), Times.Once); + } + + [Test] + public void ReadWorkZeroDataAsync_CallsUploadStartWithFileType5() + { + var dialect = new Mock(); + dialect.Setup(d => d.UploadStart(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadData(It.IsAny(), ref It.Ref.IsAny, It.IsAny())) + .Returns(Focas1.EW_OK); + dialect.Setup(d => d.UploadEnd(It.IsAny())).Returns(Focas1.EW_OK); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + machine.ReadWorkZeroDataAsync("O1234").GetAwaiter().GetResult(); + } + + dialect.Verify(d => d.UploadStart(It.IsAny(), "O1234", It.IsAny(), (short)5), Times.Once); + } + + [Test] + public void ReadProgramAsync_UploadStartFails_ResultIsFail() + { + var dialect = new Mock(); + dialect.Setup(d => d.UploadStart(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(-3); // EW_SOCKET or any error + dialect.Setup(d => d.UploadEnd(It.IsAny())).Returns(Focas1.EW_OK); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + var result = machine.ReadProgramAsync("O1234").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } + + [Test] + public void WriteProgramAsync_NullContent_ResultFail() + { + var dialect = new Mock(); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + var prog = new CncProgram { Name = "O1234", Content = null }; + var result = machine.WriteProgramAsync("//CNC_MEM/USER/PATH1/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } + + [Test] + public void WriteProgramAsync_InvalidProgramName_ValidationFails() + { + var dialect = new Mock(); + + using (var machine = CreateConnectedWithMockDialect(dialect)) + { + // "PROG" does not match Fanuc O#### name rule — validator rejects before any FOCAS call + var prog = new CncProgram { Name = "PROG", Content = "O1234\nG00 X0\nM30" }; + var result = machine.WriteProgramAsync("//CNC_MEM/USER/PATH1/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } + + [Test] + public void State_InitialState_IsDisconnected() + { + using (var machine = new FanucMachine(EthernetConfig())) + { + Assert.That(machine.State, Is.EqualTo(ConnectionState.Disconnected)); + } + } + + [Test] + public void Name_ReturnsConfigName() + { + using (var machine = new FanucMachine(EthernetConfig())) + { + Assert.That(machine.Name, Is.EqualTo("TestFanuc")); + } + } + } +} diff --git a/FanucProgramManager.Tests/Unit/FanucProgramParsingTests.cs b/FanucProgramManager.Tests/Unit/FanucProgramParsingTests.cs new file mode 100644 index 0000000..0f3f61d --- /dev/null +++ b/FanucProgramManager.Tests/Unit/FanucProgramParsingTests.cs @@ -0,0 +1,185 @@ +using NUnit.Framework; +using FanucProgramManager; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class FanucProgramParsingTests + { + private const string SimpleProgram = + "\nO1234(COMMENT)\n" + + "G0 X0 Y0\n" + + "M30\n" + + "%"; + + private const string ThreeFileInput = + "program:{\n" + + "\nO1234(COMMENT)\n" + + "G0 X0 Y0\n" + + "M30\n" + + "%\n" + + "}\n" + + "tooloffsetdata:{\n" + + "TOOL_DATA_LINE1\n" + + "}\n" + + "workzerooffset:{\n" + + "WORK_ZERO_LINE1\n" + + "}\n"; + + [Test] + public void Constructor_OldFormat_ProgramFieldSet() + { + var p = new FanucProgram(SimpleProgram); + + Assert.That(p.Program, Is.Not.Null); + Assert.That(p.ToolOffsetData, Is.Null); + Assert.That(p.WorkZeroOffsetData, Is.Null); + } + + [Test] + public void Constructor_ThreeFileFormat_AllSectionsSet() + { + var p = new FanucProgram(ThreeFileInput); + + Assert.That(p.Program, Is.Not.Null); + Assert.That(p.ToolOffsetData, Is.Not.Null); + Assert.That(p.WorkZeroOffsetData, Is.Not.Null); + } + + [Test] + public void Constructor_ThreeFileFormat_ToolOffsetDataContent() + { + var p = new FanucProgram(ThreeFileInput); + + Assert.That(p.ToolOffsetData, Does.Contain("TOOL_DATA_LINE1")); + } + + [Test] + public void Constructor_ThreeFileFormat_WorkZeroOffsetDataContent() + { + var p = new FanucProgram(ThreeFileInput); + + Assert.That(p.WorkZeroOffsetData, Does.Contain("WORK_ZERO_LINE1")); + } + + [Test] + public void GetProgramTitle_StandardProgram_ReturnsO1234() + { + var p = new FanucProgram(SimpleProgram); + + string title = p.GetProgramTitle(); + + Assert.That(title, Is.EqualTo("O1234")); + } + + [Test] + public void GetProgramTitle_Static_ReturnsTitle() + { + string title = FanucProgram.GetProgramTitle("\nO5678\nG0\n%"); + + Assert.That(title, Is.EqualTo("O5678")); + } + + [Test] + public void GetProgramComment_ProgramWithComment_ReturnsComment() + { + var p = new FanucProgram(SimpleProgram); + + string comment = p.GetProgramComment(); + + Assert.That(comment, Is.EqualTo("COMMENT")); + } + + [Test] + public void GetProgramComment_ProgramWithoutComment_ReturnsEmpty() + { + var p = new FanucProgram("\nO1234\nG0 X0\nM30\n%"); + + string comment = p.GetProgramComment(); + + Assert.That(comment, Is.EqualTo("")); + } + + [Test] + public void ChangeComment_ReplaceExistingComment_CommentUpdated() + { + var p = new FanucProgram(SimpleProgram); + + p.ChangeComment("NEW_COMMENT"); + + Assert.That(p.GetProgramComment(), Is.EqualTo("NEW_COMMENT")); + } + + [Test] + public void ChangeComment_NoExistingComment_CommentInserted() + { + var p = new FanucProgram("\nO1234\nG0 X0\nM30\n%"); + + p.ChangeComment("INSERTED"); + + Assert.That(p.GetProgramComment(), Is.EqualTo("INSERTED")); + } + + [Test] + public void Standardize_LeadingPercent_Removed() + { + var p = new FanucProgram("%\nO1234\nG0\n%"); + + Assert.That(p.Program, Does.Not.StartWith("%")); + } + + [Test] + public void Standardize_AngleBracketTitle_ConvertedToPlain() + { + var p = new FanucProgram("\n\nG0\n%"); + + Assert.That(p.Program, Does.Contain("O1234")); + Assert.That(p.Program, Does.Not.Contain("")); + } + + [Test] + public void ToString_ThreeFileFormat_ContainsAllSections() + { + var p = new FanucProgram(ThreeFileInput); + + string output = p.ToString(); + + Assert.That(output, Does.Contain("program:{")); + Assert.That(output, Does.Contain("tooloffsetdata:{")); + Assert.That(output, Does.Contain("workzerooffset:{")); + } + + [Test] + public void ToString_ProgramContent_RoundTrips() + { + var p = new FanucProgram(ThreeFileInput); + + string output = p.ToString(); + var p2 = new FanucProgram(output); + + Assert.That(p2.GetProgramTitle(), Is.EqualTo(p.GetProgramTitle())); + Assert.That(p2.ToolOffsetData, Does.Contain("TOOL_DATA_LINE1")); + Assert.That(p2.WorkZeroOffsetData, Does.Contain("WORK_ZERO_LINE1")); + } + + [Test] + public void SetValue_ToolOffsetData_ValueStored() + { + var p = new FanucProgram(SimpleProgram); + + p.setValue("TOOL_DATA\n%", FanucProgram.FILE_TYPE.TOOL_OFFEST_DATA); + + Assert.That(p.ToolOffsetData, Does.Contain("TOOL_DATA")); + } + + [Test] + public void SetValue_WorkZeroOffset_ValueStored() + { + var p = new FanucProgram(SimpleProgram); + + p.setValue("WORK_DATA\n%", FanucProgram.FILE_TYPE.WORK_ZERO_OFFSET); + + Assert.That(p.WorkZeroOffsetData, Does.Contain("WORK_DATA")); + } + } +} diff --git a/FanucProgramManager.Tests/Unit/HeidenhainMachineTests.cs b/FanucProgramManager.Tests/Unit/HeidenhainMachineTests.cs new file mode 100644 index 0000000..2d79129 --- /dev/null +++ b/FanucProgramManager.Tests/Unit/HeidenhainMachineTests.cs @@ -0,0 +1,141 @@ +using System; +using NUnit.Framework; +using Moq; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Heidenhain; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class HeidenhainMachineTests + { + private HeidenhainConnectionConfig _config; + private Mock _clientMock; + private Mock _validatorMock; + private HeidenhainMachine _machine; + + [SetUp] + public void SetUp() + { + _config = new HeidenhainConnectionConfig + { + Name = "TestHeidenhain", + IpAddress = "192.168.1.4", + Port = 19000 + }; + _clientMock = new Mock(MockBehavior.Strict); + // Always-ok validator so existing write tests are not affected by validation rules + _validatorMock = new Mock(); + _validatorMock.Setup(v => v.Validate(It.IsAny(), It.IsAny())) + .Returns(ValidationResult.Ok()); + // Internal constructor sets state = Connected immediately + _machine = new HeidenhainMachine(_config, _clientMock.Object, _validatorMock.Object); + } + + [TearDown] + public void TearDown() + { + _clientMock.Setup(c => c.Disconnect()); + _machine?.Dispose(); + } + + // State on construction + + [Test] + public void Constructor_WithInjectedClient_StateIsConnected() + { + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Connected)); + } + + // ReadProgramAsync + + [Test] + public void ReadProgramAsync_ReceiveFileReturnsContent_ResultOk() + { + _clientMock.Setup(c => c.ReceiveFile("TNC:/nc_prog/O1234.H")).Returns("NC_CONTENT"); + + var result = _machine.ReadProgramAsync("TNC:/nc_prog/O1234.H").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(result.Value, Is.EqualTo("NC_CONTENT")); + _clientMock.Verify(c => c.ReceiveFile("TNC:/nc_prog/O1234.H"), Times.Once); + } + + [Test] + public void ReadProgramAsync_ReceiveFileReturnsNull_ResultIsFail() + { + _clientMock.Setup(c => c.ReceiveFile(It.IsAny())).Returns((string)null); + + var result = _machine.ReadProgramAsync("TNC:/nc_prog/MISSING.H").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + + // WriteProgramAsync + + [Test] + public void WriteProgramAsync_WithName_AppendsDotHExtension() + { + _clientMock.Setup(c => c.SendFile("TNC:/nc_prog/O1234.H", "CONTENT")).Returns(true); + + var prog = new CncProgram { Name = "O1234", Content = "CONTENT" }; + var result = _machine.WriteProgramAsync("TNC:/nc_prog/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + _clientMock.Verify(c => c.SendFile("TNC:/nc_prog/O1234.H", "CONTENT"), Times.Once); + } + + [Test] + public void WriteProgramAsync_NameAlreadyHasExtension_NoDoubleExtension() + { + _clientMock.Setup(c => c.SendFile("TNC:/nc_prog/O1234.H", "CONTENT")).Returns(true); + + var prog = new CncProgram { Name = "O1234.H", Content = "CONTENT" }; + _machine.WriteProgramAsync("TNC:/nc_prog/", prog).GetAwaiter().GetResult(); + + _clientMock.Verify(c => c.SendFile("TNC:/nc_prog/O1234.H", "CONTENT"), Times.Once); + _clientMock.Verify(c => c.SendFile(It.Is(s => s.EndsWith(".H.H")), It.IsAny()), Times.Never); + } + + [Test] + public void WriteProgramAsync_EmptyContent_FailsWithoutCallingSendFile() + { + var prog = new CncProgram { Name = "O1234", Content = "" }; + var result = _machine.WriteProgramAsync("TNC:/nc_prog/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + _clientMock.Verify(c => c.SendFile(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void WriteProgramAsync_NullProgram_FailsWithoutCallingSendFile() + { + var result = _machine.WriteProgramAsync("TNC:/nc_prog/", null).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + _clientMock.Verify(c => c.SendFile(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void WriteProgramAsync_SendFileFails_ResultIsFail() + { + _clientMock.Setup(c => c.SendFile(It.IsAny(), It.IsAny())).Returns(false); + + var prog = new CncProgram { Name = "O1234", Content = "DATA" }; + var result = _machine.WriteProgramAsync("TNC:/nc_prog/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + + // ReadActiveProgramAsync + + [Test] + public void ReadActiveProgramAsync_ReturnsFailNotSupported() + { + var result = _machine.ReadActiveProgramAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } +} diff --git a/FanucProgramManager.Tests/Unit/IsoProgramFormatterTests.cs b/FanucProgramManager.Tests/Unit/IsoProgramFormatterTests.cs new file mode 100644 index 0000000..8b580db --- /dev/null +++ b/FanucProgramManager.Tests/Unit/IsoProgramFormatterTests.cs @@ -0,0 +1,105 @@ +using NUnit.Framework; +using FanucProgramManager.Cnc.Fanuc; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class IsoProgramFormatterTests + { + // EnsureTitleBrackets + // The formatter works on programs with a leading blank line then a title line. + // e.g. "%\nO1234(COMMENT)\nG0...\n" + // SplitFirstNonEmptyLine splits after the SECOND newline, so we need at least 2 newlines. + + private const string ProgramWithBrackets = + "%\n(COMMENT)\nG0 X0\nM30\n"; + + private const string ProgramNoBrackets = + "%\nO1234(COMMENT)\nG0 X0\nM30\n"; + + private const string ProgramNoComment = + "%\nO1234\nG0 X0\nM30\n"; + + [Test] + public void EnsureTitleBrackets_NoBrackets_AddsBrackets() + { + string result = IsoProgramFormatter.EnsureTitleBrackets(ProgramNoBrackets); + + Assert.That(result, Does.Contain("")); + } + + [Test] + public void EnsureTitleBrackets_AlreadyHasBrackets_NoChange() + { + string result = IsoProgramFormatter.EnsureTitleBrackets(ProgramWithBrackets); + + Assert.That(result, Is.EqualTo(ProgramWithBrackets)); + } + + [Test] + public void EnsureTitleBrackets_NullOrEmpty_ReturnsInput() + { + Assert.That(IsoProgramFormatter.EnsureTitleBrackets(null), Is.Null); + Assert.That(IsoProgramFormatter.EnsureTitleBrackets(""), Is.EqualTo("")); + } + + // InsertOrReplaceComment + + [Test] + public void InsertOrReplaceComment_NoComment_InsertsComment() + { + string result = IsoProgramFormatter.InsertOrReplaceComment(ProgramNoComment, "TEST"); + + Assert.That(result, Does.Contain("(TEST)")); + } + + [Test] + public void InsertOrReplaceComment_ExistingComment_ReplacesComment() + { + string result = IsoProgramFormatter.InsertOrReplaceComment(ProgramNoBrackets, "NEW"); + + Assert.That(result, Does.Contain("(NEW)")); + Assert.That(result, Does.Not.Contain("(COMMENT)")); + } + + [Test] + public void InsertOrReplaceComment_EmptyComment_InsertsEmptyParens() + { + string result = IsoProgramFormatter.InsertOrReplaceComment(ProgramNoComment, ""); + + Assert.That(result, Does.Contain("()")); + } + + [Test] + public void InsertOrReplaceComment_NullOrEmpty_ReturnsInput() + { + Assert.That(IsoProgramFormatter.InsertOrReplaceComment(null, "X"), Is.Null); + Assert.That(IsoProgramFormatter.InsertOrReplaceComment("", "X"), Is.EqualTo("")); + } + + // RenameAndComment + + [Test] + public void RenameAndComment_ProducesCorrectHeader() + { + string result = IsoProgramFormatter.RenameAndComment(ProgramNoBrackets, "O9999", "DESC"); + + Assert.That(result, Does.StartWith("%\n(DESC)")); + } + + [Test] + public void RenameAndComment_BodyAppendedAfterHeader() + { + string result = IsoProgramFormatter.RenameAndComment(ProgramNoBrackets, "O9999", "DESC"); + + Assert.That(result, Does.Contain("G0 X0")); + } + + [Test] + public void RenameAndComment_NullOrEmpty_ReturnsInput() + { + Assert.That(IsoProgramFormatter.RenameAndComment(null, "X", "Y"), Is.Null); + Assert.That(IsoProgramFormatter.RenameAndComment("", "X", "Y"), Is.EqualTo("")); + } + } +} diff --git a/FanucProgramManager.Tests/Unit/MitsubishiMachineTests.cs b/FanucProgramManager.Tests/Unit/MitsubishiMachineTests.cs new file mode 100644 index 0000000..379bb6d --- /dev/null +++ b/FanucProgramManager.Tests/Unit/MitsubishiMachineTests.cs @@ -0,0 +1,163 @@ +using System; +using NUnit.Framework; +using Moq; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Mitsubishi; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class MitsubishiMachineTests + { + private MitsubishiConnectionConfig _config; + private Mock _ftpMock; + private Mock _validatorMock; + private MitsubishiMachine _machine; + + [SetUp] + public void SetUp() + { + _config = new MitsubishiConnectionConfig + { + Name = "TestMitsubishi", + IpAddress = "192.168.1.3", + Port = 21, + ProgramDirectory = "/PRG/" + }; + _ftpMock = new Mock(MockBehavior.Strict); + // Always-ok validator so existing write tests are not affected by validation rules + _validatorMock = new Mock(); + _validatorMock.Setup(v => v.Validate(It.IsAny(), It.IsAny())) + .Returns(ValidationResult.Ok()); + _machine = new MitsubishiMachine(_config, _ftpMock.Object, _validatorMock.Object); + } + + [TearDown] + public void TearDown() + { + _machine?.Dispose(); + } + + // ConnectAsync + + [Test] + public void ConnectAsync_PingTrue_StateConnectedAndResultOk() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Connected)); + } + + [Test] + public void ConnectAsync_PingFalse_StateFaultedAndResultFail() + { + _ftpMock.Setup(f => f.Ping()).Returns(false); + + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Faulted)); + } + + // ReadProgramAsync — no .MPF extension for Mitsubishi + + [Test] + public void ReadProgramAsync_FullPath_CallsDownloadFileNoExtension() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.DownloadFile("/PRG/O1234")).Returns("NC_DATA"); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.ReadProgramAsync("/PRG/O1234").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(result.Value, Is.EqualTo("NC_DATA")); + _ftpMock.Verify(f => f.DownloadFile("/PRG/O1234"), Times.Once); + } + + [Test] + public void ReadProgramAsync_ShortName_ResolvesWithDirectoryNoExtension() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.DownloadFile("/PRG/O1234")).Returns("DATA"); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + _machine.ReadProgramAsync("O1234").GetAwaiter().GetResult(); + + // Must NOT append .MPF + _ftpMock.Verify(f => f.DownloadFile("/PRG/O1234"), Times.Once); + _ftpMock.Verify(f => f.DownloadFile(It.Is(s => s.EndsWith(".MPF"))), Times.Never); + } + + // WriteProgramAsync + + [Test] + public void WriteProgramAsync_ValidContent_CallsUploadFileNoExtension() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.UploadFile("/PRG/O1234", "CONTENT")); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var prog = new CncProgram { Name = "O1234", Content = "CONTENT" }; + var result = _machine.WriteProgramAsync("/PRG/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + _ftpMock.Verify(f => f.UploadFile("/PRG/O1234", "CONTENT"), Times.Once); + _ftpMock.Verify(f => f.UploadFile(It.Is(s => s.EndsWith(".MPF")), It.IsAny()), Times.Never); + } + + [Test] + public void WriteProgramAsync_EmptyContent_FailsWithoutCallingUploadFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var prog = new CncProgram { Name = "O1234", Content = "" }; + var result = _machine.WriteProgramAsync("/PRG/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + _ftpMock.Verify(f => f.UploadFile(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void WriteProgramAsync_NullProgram_FailsWithoutCallingUploadFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.WriteProgramAsync("/PRG/", null).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + _ftpMock.Verify(f => f.UploadFile(It.IsAny(), It.IsAny()), Times.Never); + } + + // DeleteProgramAsync + + [Test] + public void DeleteProgramAsync_ValidPath_CallsDeleteFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.DeleteFile("/PRG/O1234")); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.DeleteProgramAsync("/PRG/O1234").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + _ftpMock.Verify(f => f.DeleteFile("/PRG/O1234"), Times.Once); + } + + // ReadActiveProgramAsync + + [Test] + public void ReadActiveProgramAsync_ReturnsFailNotSupported() + { + var result = _machine.ReadActiveProgramAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } +} diff --git a/FanucProgramManager.Tests/Unit/NcProgramValidatorTests.cs b/FanucProgramManager.Tests/Unit/NcProgramValidatorTests.cs new file mode 100644 index 0000000..991248b --- /dev/null +++ b/FanucProgramManager.Tests/Unit/NcProgramValidatorTests.cs @@ -0,0 +1,280 @@ +using NUnit.Framework; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class NcProgramValidatorTests + { + // ── Universal rules ─────────────────────────────────────────────────── + + [Test] + public void Validate_BlockTooLong_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + string longLine = "O1234\n" + new string('X', 81); + var r = v.Validate("O1234", longLine); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "80"), Is.True); + } + + [Test] + public void Validate_BlockExactly80_NoLengthError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + string line80 = new string('G', 80); + var r = v.Validate("O1234", "O1234\n" + line80); + // Should not have a block-length error (may still have other errors) + Assert.That(HasErrorContaining(r, "Block length"), Is.False); + } + + [Test] + public void Validate_LowercaseLetter_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("PROG.MPF", "PROG.MPF\ng00 X10"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "Lowercase"), Is.True); + } + + [Test] + public void Validate_NoLowercase_NoLowercaseError() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("PROG.MPF", "G00 X10 Y20"); + Assert.That(HasErrorContaining(r, "Lowercase"), Is.False); + } + + [Test] + public void Validate_TabCharacter_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("PROG.MPF", "G00\tX10"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "Tab"), Is.True); + } + + [Test] + public void Validate_NestedParentheses_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("O1234", "O1234\nG00 ((NESTED))"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "Nested"), Is.True); + } + + [Test] + public void Validate_SingleParenComment_NoNestedError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("O1234", "O1234\nG00 (COMMENT) X10"); + Assert.That(HasErrorContaining(r, "Nested"), Is.False); + } + + [Test] + public void Validate_CommentExceeds32Chars_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + string longComment = "(" + new string('A', 33) + ")"; + var r = v.Validate("O1234", "O1234\n" + longComment); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "Comment length"), Is.True); + } + + [Test] + public void Validate_CommentExactly32Chars_NoCommentLengthError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + string comment = "(" + new string('A', 32) + ")"; + var r = v.Validate("O1234", "O1234\n" + comment); + Assert.That(HasErrorContaining(r, "Comment length"), Is.False); + } + + // ── Fanuc rules ─────────────────────────────────────────────────────── + + [Test] + public void Validate_Fanuc_ValidNameAndContent_Succeeds() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("O1234", "O1234\nG00 X10 Y20\nM30"); + Assert.That(r.Success, Is.True); + } + + [Test] + public void Validate_Fanuc_NameNotOFourDigits_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("PROG", "O1234\nG00"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "O####"), Is.True); + } + + [Test] + public void Validate_Fanuc_NameO12345_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + // 5 digits — invalid for Fanuc + var r = v.Validate("O12345", "O1234\nG00"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "O####"), Is.True); + } + + [Test] + public void Validate_Fanuc_FirstLineNotONumber_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("O1234", "G00 X10\nM30"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "First line"), Is.True); + } + + [TestCase(CncManufacturer.Fanuc, "O1234", "O1234\nG00 X10;")] + [TestCase(CncManufacturer.Mitsubishi, "O1234", "O1234\nG00 X10;")] + [TestCase(CncManufacturer.Siemens, "PROG.MPF", "G00 X10;")] + [TestCase(CncManufacturer.Heidenhain, "PROG.H", "L X+10;")] + public void Validate_SemicolonForbidden_ReturnsError(CncManufacturer m, string name, string content) + { + var r = new NcProgramValidator(m).Validate(name, content); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, ";"), Is.True); + } + + [Test] + public void Validate_Fanuc_BracketForbidden_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("O1234", "O1234\nG00 [X10]"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "["), Is.True); + } + + [Test] + public void Validate_Fanuc_MacroHash_ReturnsWarningNotError() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + var r = v.Validate("O1234", "O1234\n#100=10"); + // Warnings alone do not cause failure + Assert.That(r.Success, Is.True); + Assert.That(HasWarningContaining(r, "#"), Is.True); + } + + [Test] + public void Validate_Fanuc_NameFromPathStripped() + { + var v = new NcProgramValidator(CncManufacturer.Fanuc); + // Full path — name part is O1234 + var r = v.Validate("//CNC_MEM/USER/PATH1/O1234", "O1234\nG00 X10"); + Assert.That(HasErrorContaining(r, "O####"), Is.False); + } + + // ── Mitsubishi rules ────────────────────────────────────────────────── + + [Test] + public void Validate_Mitsubishi_ValidNameAndContent_Succeeds() + { + var v = new NcProgramValidator(CncManufacturer.Mitsubishi); + var r = v.Validate("O1234", "O1234\nG00 X10\nM30"); + Assert.That(r.Success, Is.True); + } + + [Test] + public void Validate_Mitsubishi_BadName_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Mitsubishi); + var r = v.Validate("PROG", "O1234\nG00"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "O####"), Is.True); + } + + // ── Siemens rules ───────────────────────────────────────────────────── + + [Test] + public void Validate_Siemens_ValidNameAndContent_Succeeds() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("PROG.MPF", "G00 X10 Y20\nM30"); + Assert.That(r.Success, Is.True); + } + + [Test] + public void Validate_Siemens_NameNoDotMpf_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("PROG", "G00 X10"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, ".MPF"), Is.True); + } + + [Test] + public void Validate_Siemens_LowercaseMpf_ReturnsNameError() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("prog.mpf", "G00 X10"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, ".MPF"), Is.True); + } + + [Test] + public void Validate_Siemens_NoFirstLineRequired() + { + var v = new NcProgramValidator(CncManufacturer.Siemens); + var r = v.Validate("PROG.MPF", "G00 X10\nM30"); + Assert.That(HasErrorContaining(r, "First line"), Is.False); + } + + // ── Heidenhain rules ────────────────────────────────────────────────── + + [Test] + public void Validate_Heidenhain_ValidNameAndContent_Succeeds() + { + var v = new NcProgramValidator(CncManufacturer.Heidenhain); + var r = v.Validate("PROG.H", "L X+10 Y+20 R0 FMAX\nL Z-5 F500"); + Assert.That(r.Success, Is.True); + } + + [Test] + public void Validate_Heidenhain_NameNoDotH_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Heidenhain); + var r = v.Validate("PROG", "L X+10"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, ".H"), Is.True); + } + + [Test] + public void Validate_Heidenhain_PercentForbidden_ReturnsError() + { + var v = new NcProgramValidator(CncManufacturer.Heidenhain); + var r = v.Validate("PROG.H", "L X+10 % COMMENT"); + Assert.That(r.Success, Is.False); + Assert.That(HasErrorContaining(r, "%"), Is.True); + } + + [Test] + public void Validate_Heidenhain_NoFirstLineRequired() + { + var v = new NcProgramValidator(CncManufacturer.Heidenhain); + var r = v.Validate("PROG.H", "L X+10\nM30"); + Assert.That(HasErrorContaining(r, "First line"), Is.False); + } + + // ── Helpers ─────────────────────────────────────────────────────────── + + private static bool HasErrorContaining(ValidationResult r, string fragment) + { + foreach (var e in r.Errors) + if (e.Severity == ValidationSeverity.Error && e.Message.Contains(fragment)) + return true; + return false; + } + + private static bool HasWarningContaining(ValidationResult r, string fragment) + { + foreach (var e in r.Errors) + if (e.Severity == ValidationSeverity.Warning && e.Message.Contains(fragment)) + return true; + return false; + } + } +} diff --git a/FanucProgramManager.Tests/Unit/SiemensMachineTests.cs b/FanucProgramManager.Tests/Unit/SiemensMachineTests.cs new file mode 100644 index 0000000..033f8d5 --- /dev/null +++ b/FanucProgramManager.Tests/Unit/SiemensMachineTests.cs @@ -0,0 +1,161 @@ +using System; +using NUnit.Framework; +using Moq; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; +using FanucProgramManager.Cnc.Siemens; + +namespace FanucProgramManager.Tests.Unit +{ + [TestFixture] + public class SiemensMachineTests + { + private SiemensConnectionConfig _config; + private Mock _ftpMock; + private Mock _validatorMock; + private SiemensMachine _machine; + + [SetUp] + public void SetUp() + { + _config = new SiemensConnectionConfig + { + Name = "TestSiemens", + IpAddress = "192.168.1.2", + Port = 21, + ProgramDirectory = "/_N_MPF_DIR/" + }; + _ftpMock = new Mock(MockBehavior.Strict); + // Always-ok validator so existing write tests are not affected by validation rules + _validatorMock = new Mock(); + _validatorMock.Setup(v => v.Validate(It.IsAny(), It.IsAny())) + .Returns(ValidationResult.Ok()); + _machine = new SiemensMachine(_config, _ftpMock.Object, _validatorMock.Object); + } + + [TearDown] + public void TearDown() + { + _machine?.Dispose(); + } + + // ConnectAsync + + [Test] + public void ConnectAsync_PingTrue_StateConnectedAndResultOk() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(result.Value, Is.True); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Connected)); + } + + [Test] + public void ConnectAsync_PingFalse_StateFaultedAndResultFail() + { + _ftpMock.Setup(f => f.Ping()).Returns(false); + + var result = _machine.ConnectAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + Assert.That(_machine.State, Is.EqualTo(ConnectionState.Faulted)); + } + + // ReadProgramAsync + + [Test] + public void ReadProgramAsync_FullPath_CallsDownloadFileWithPath() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.DownloadFile("/_N_MPF_DIR/O1234.MPF")).Returns("PROGRAM_CONTENT"); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.ReadProgramAsync("/_N_MPF_DIR/O1234.MPF").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + Assert.That(result.Value, Is.EqualTo("PROGRAM_CONTENT")); + _ftpMock.Verify(f => f.DownloadFile("/_N_MPF_DIR/O1234.MPF"), Times.Once); + } + + [Test] + public void ReadProgramAsync_ShortName_ResolvesWithDirectoryAndMpfExtension() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.DownloadFile("/_N_MPF_DIR/O1234.MPF")).Returns("DATA"); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + _machine.ReadProgramAsync("O1234").GetAwaiter().GetResult(); + + _ftpMock.Verify(f => f.DownloadFile("/_N_MPF_DIR/O1234.MPF"), Times.Once); + } + + // WriteProgramAsync + + [Test] + public void WriteProgramAsync_ValidContent_CallsUploadFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.UploadFile(It.IsAny(), "CONTENT")); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var prog = new CncProgram { Name = "O1234", Content = "CONTENT" }; + var result = _machine.WriteProgramAsync("/_N_MPF_DIR/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + _ftpMock.Verify(f => f.UploadFile(It.IsAny(), "CONTENT"), Times.Once); + } + + [Test] + public void WriteProgramAsync_EmptyContent_FailsWithoutCallingUploadFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var prog = new CncProgram { Name = "O1234", Content = "" }; + var result = _machine.WriteProgramAsync("/_N_MPF_DIR/", prog).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + _ftpMock.Verify(f => f.UploadFile(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void WriteProgramAsync_NullProgram_FailsWithoutCallingUploadFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.WriteProgramAsync("/_N_MPF_DIR/", null).GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + _ftpMock.Verify(f => f.UploadFile(It.IsAny(), It.IsAny()), Times.Never); + } + + // DeleteProgramAsync + + [Test] + public void DeleteProgramAsync_ValidPath_CallsDeleteFile() + { + _ftpMock.Setup(f => f.Ping()).Returns(true); + _ftpMock.Setup(f => f.DeleteFile("/_N_MPF_DIR/O1234.MPF")); + _machine.ConnectAsync().GetAwaiter().GetResult(); + + var result = _machine.DeleteProgramAsync("/_N_MPF_DIR/O1234.MPF").GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.True); + _ftpMock.Verify(f => f.DeleteFile("/_N_MPF_DIR/O1234.MPF"), Times.Once); + } + + // ReadActiveProgramAsync + + [Test] + public void ReadActiveProgramAsync_ReturnsFailNotSupported() + { + var result = _machine.ReadActiveProgramAsync().GetAwaiter().GetResult(); + + Assert.That(result.Success, Is.False); + } + } +} diff --git a/FanucProgramManager.Tests/packages.config b/FanucProgramManager.Tests/packages.config new file mode 100644 index 0000000..fd5acb3 --- /dev/null +++ b/FanucProgramManager.Tests/packages.config @@ -0,0 +1,7 @@ + + + + + + + diff --git a/FanucProgramManager.csproj b/FanucProgramManager.csproj new file mode 100755 index 0000000..2a89fb0 --- /dev/null +++ b/FanucProgramManager.csproj @@ -0,0 +1,151 @@ + + + + + Debug + AnyCPU + {1032188B-3321-42B2-87ED-343BF718CAF5} + Exe + FanucProgramManager + FanucProgramManager + v4.7.2 + 512 + true + true + false + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + false + + + + packages\Microsoft.Bcl.AsyncInterfaces.7.0.0\lib\net462\Microsoft.Bcl.AsyncInterfaces.dll + False + + + + + + packages\System.Memory.4.5.5\lib\net461\System.Memory.dll + False + + + packages\System.Runtime.CompilerServices.Unsafe.6.0.0\lib\net461\System.Runtime.CompilerServices.Unsafe.dll + False + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + + False + Microsoft .NET Framework 4.7.2 %28x86 e x64%29 + true + + + False + .NET Framework 3.5 SP1 + false + + + + \ No newline at end of file diff --git a/FanucProgramManager.csproj.user b/FanucProgramManager.csproj.user new file mode 100755 index 0000000..091fd47 --- /dev/null +++ b/FanucProgramManager.csproj.user @@ -0,0 +1,20 @@ + + + + -chiave=YQXnxVoz6MjuH18d9/XDHzfTyxd/prRciP3C8bwMYb1vv3oUDjR250JKBh1X84f9 -azione=invia -pathprogramma=c:\temp\FanucProgrammiSalvati\M0108.txt -nodo=9 -tipo=2 -tooloffset -workzero -debug + + + -chiave=YQXnxVoz6MjuH18d9/XDHzfTyxd/prRciP3C8bwMYb1vv3oUDjR250JKBh1X84f9 -azione=invia -tipo=2 -nodo=9 -porta=8193 -path=2 -pathprogramma\temp\FanucProgrammiSalvati\programma.txt -debug + + + publish\ + + + + + + it-IT + false + ShowAllFiles + + \ No newline at end of file diff --git a/FanucProgramManager.sln b/FanucProgramManager.sln new file mode 100755 index 0000000..3875041 --- /dev/null +++ b/FanucProgramManager.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.5.33414.496 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FanucProgramManager", "FanucProgramManager.csproj", "{1032188B-3321-42B2-87ED-343BF718CAF5}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FanucProgramManager.Tests", "FanucProgramManager.Tests\FanucProgramManager.Tests.csproj", "{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {1032188B-3321-42B2-87ED-343BF718CAF5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1032188B-3321-42B2-87ED-343BF718CAF5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1032188B-3321-42B2-87ED-343BF718CAF5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1032188B-3321-42B2-87ED-343BF718CAF5}.Release|Any CPU.Build.0 = Release|Any CPU + {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.ActiveCfg = Debug|AnyCPU + {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.Build.0 = Debug|AnyCPU + {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.ActiveCfg = Release|AnyCPU + {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.Build.0 = Release|AnyCPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {79CE0E5A-A8EA-4EAD-B78D-EE8E0E9BADAB} + EndGlobalSection +EndGlobal diff --git a/InputArgs.cs b/InputArgs.cs new file mode 100755 index 0000000..878dfb9 --- /dev/null +++ b/InputArgs.cs @@ -0,0 +1,25 @@ +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager +{ + internal class InputArgs + { + public CncManufacturer manufacturer = CncManufacturer.Fanuc; + public int tipo = 0; // kept for legacy parsing only + public string azione = ""; + public string ip = ""; + public string porta = ""; + public short pathCNC = 1; + public int nodoHssb = -1; + public string chiave = ""; + public string username = ""; + public string password = ""; + public string commentoProgramma = ""; + public string pathLocaleProgramma = ""; + public bool compatibilityMode = false; + public bool hasToolOffsetData = false; + public bool hasWorkZeroOffsetData = false; + public bool mostraHelp = false; + public bool debugMode = false; + } +} diff --git a/Program.cs b/Program.cs new file mode 100755 index 0000000..ba1176a --- /dev/null +++ b/Program.cs @@ -0,0 +1,447 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Management; +using System.Security.Cryptography; +using System.Text.RegularExpressions; +using FanucProgramManager.Cnc; +using FanucProgramManager.Cnc.Models; + +namespace FanucProgramManager +{ + internal class Program + { + private static InputArgs inputArgs = new InputArgs(); + + public static int Main(string[] args) + { + try + { + parseArgomenti(args); + } + catch (Exception e) + { + Console.Write("Gestore Programmi FANUC: "); + Console.WriteLine(e.Message); + Console.WriteLine("Errore parametri input. Consulta `-help' per maggiori informazioni."); + vediErrore(-101); + return -101; + } + + if (inputArgs.mostraHelp) + { + MostraAiuto(); + vediErrore(0); + return 0; + } + + if (!checkLicense(inputArgs.chiave)) + { + Console.WriteLine("Licenza ERRATA"); + vediErrore(-100); + return -1; + } + + // Validate required params + bool needsIp = inputArgs.manufacturer != CncManufacturer.Fanuc || inputArgs.nodoHssb == -1; + if (inputArgs.azione == "" || (needsIp && string.IsNullOrEmpty(inputArgs.ip)) || inputArgs.pathLocaleProgramma == "") + { + vediErrore(-102); + return -102; + } + + Console.WriteLine( + "manufacturer: " + inputArgs.manufacturer + "\n" + + "IndirizzoIP: " + inputArgs.ip + "\n" + + "Porta: " + inputArgs.porta + "\n" + + "Compatibility: " + inputArgs.compatibilityMode + "\n" + + "commentoProgramma: " + inputArgs.commentoProgramma + "\n" + + "pathCNC: " + inputArgs.pathCNC + "\n" + + "pathLocaleProgramma: " + inputArgs.pathLocaleProgramma + "\n" + ); + + ICncMachine machine = null; + try + { + machine = CncMachineFactory.Create(inputArgs); + + switch (inputArgs.azione.ToUpperInvariant()) + { + case "SCARICA": return Scarica(machine); + case "INVIA": return Invia(machine); + default: + vediErrore(-103); + return -103; + } + } + finally + { + if (machine != null) + machine.Dispose(); + } + } + + static int Scarica(ICncMachine macchina) + { + Console.WriteLine("RICEVI DA CNC-->"); + try + { + var connResult = macchina.ConnectAsync().GetAwaiter().GetResult(); + if (!connResult.Success) + { + Console.WriteLine("Macchina non connessa"); + vediErrore(-201); + return -201; + } + + Console.WriteLine("Inizio RICEZIONE NCProgram"); + var progResult = macchina.ReadProgramAsync(inputArgs.pathCNC.ToString()).GetAwaiter().GetResult(); + Console.WriteLine("Fine RICEZIONE NCProgram"); + if (!progResult.Success || string.IsNullOrEmpty(progResult.Value)) + { + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-204); + return -204; + } + + FanucProgram programma = new FanucProgram(progResult.Value); + + IFanucMachine fanuc = macchina as IFanucMachine; + + if (inputArgs.hasToolOffsetData) + { + if (fanuc == null) + { + Console.WriteLine("ToolOffset non supportato per questo produttore"); + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-205); + return -205; + } + Console.WriteLine("Inizio RICEZIONE ToolOffsetData"); + var toolResult = fanuc.ReadToolDataAsync(inputArgs.pathCNC.ToString()).GetAwaiter().GetResult(); + Console.WriteLine("Fine RICEZIONE ToolOffsetData"); + if (!toolResult.Success || string.IsNullOrEmpty(toolResult.Value)) + { + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-205); + return -205; + } + programma.setValue(toolResult.Value, FanucProgram.FILE_TYPE.TOOL_OFFEST_DATA); + } + + if (inputArgs.hasWorkZeroOffsetData) + { + if (fanuc == null) + { + Console.WriteLine("WorkZeroOffset non supportato per questo produttore"); + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-206); + return -206; + } + Console.WriteLine("Inizio RICEZIONE WorkZeroOffsetData"); + var workResult = fanuc.ReadWorkZeroDataAsync(inputArgs.pathCNC.ToString()).GetAwaiter().GetResult(); + Console.WriteLine("Fine RICEZIONE WorkZeroOffsetData"); + if (!workResult.Success || string.IsNullOrEmpty(workResult.Value)) + { + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-206); + return -206; + } + programma.setValue(workResult.Value, FanucProgram.FILE_TYPE.WORK_ZERO_OFFSET); + } + + macchina.DisconnectAsync().GetAwaiter().GetResult(); + File.WriteAllText(inputArgs.pathLocaleProgramma, programma.ToString()); + vediErrore(0); + return 0; + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + vediErrore(-202); + return -202; + } + } + + static int Invia(ICncMachine macchina) + { + Console.WriteLine("INVIA A CNC-->"); + try + { + var connResult = macchina.ConnectAsync().GetAwaiter().GetResult(); + if (!connResult.Success) + { + Console.WriteLine("Macchina non connessa"); + vediErrore(-201); + return -201; + } + + FanucProgram programma = new FanucProgram(File.ReadAllText(inputArgs.pathLocaleProgramma)); + if (!string.IsNullOrEmpty(inputArgs.commentoProgramma)) + programma.ChangeComment(inputArgs.commentoProgramma); + + if (programma.Program != null) + { + Console.WriteLine("Inizio INVIO NCProgram"); + var cncProg = new CncProgram + { + Name = programma.GetProgramTitle(), + Comment = programma.GetProgramComment(), + Content = programma.Program, + Path = inputArgs.pathCNC.ToString() + }; + var writeResult = macchina.WriteProgramAsync(inputArgs.pathCNC.ToString(), cncProg).GetAwaiter().GetResult(); + Console.WriteLine("Fine INVIO NCProgram"); + if (!writeResult.Success) + { + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-204); + return -204; + } + } + + IFanucMachine fanuc = macchina as IFanucMachine; + + if (programma.ToolOffsetData != null && inputArgs.hasToolOffsetData) + { + if (fanuc == null) + { + Console.WriteLine("ToolOffset non supportato per questo produttore"); + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-205); + return -205; + } + Console.WriteLine("Inizio INVIO ToolOffsetData"); + var toolResult = fanuc.WriteToolDataAsync(inputArgs.pathCNC.ToString(), programma.ToolOffsetData).GetAwaiter().GetResult(); + Console.WriteLine("Fine INVIO ToolOffsetData"); + if (!toolResult.Success) + { + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-205); + return -205; + } + } + + if (programma.WorkZeroOffsetData != null && inputArgs.hasWorkZeroOffsetData) + { + if (fanuc == null) + { + Console.WriteLine("WorkZeroOffset non supportato per questo produttore"); + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-206); + return -206; + } + Console.WriteLine("Inizio INVIO WorkZeroOffsetData"); + var workResult = fanuc.WriteWorkZeroDataAsync(inputArgs.pathCNC.ToString(), programma.WorkZeroOffsetData).GetAwaiter().GetResult(); + Console.WriteLine("Fine INVIO WorkZeroOffsetData"); + if (!workResult.Success) + { + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(-206); + return -206; + } + } + + macchina.DisconnectAsync().GetAwaiter().GetResult(); + vediErrore(0); + return 0; + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + vediErrore(-202); + return -202; + } + } + + static void vediErrore(int errore) + { + Console.WriteLine("Errore:" + errore); + Console.WriteLine(); + Console.WriteLine("Codici Errori:"); + Console.WriteLine("-100 : Licenza Errata/non valida."); + Console.WriteLine("-101 : Impossibile parsare i parametri."); + Console.WriteLine("-102 : Parametri mancanti. "); + Console.WriteLine("-103 : Codice connessione errato: 3->Ethernet 2->HSSB. "); + Console.WriteLine("-201 : Macchina non connessa. "); + Console.WriteLine("-202 : Eccezione nell'esecuzione dell'AZIONE. "); + Console.WriteLine("-203 : L'azione è fallita. "); + Console.WriteLine("-204 : Errore in fase invio/ricezione Programma CN. "); + Console.WriteLine("-205 : Errore in fase invio/ricezione tool offset data "); + Console.WriteLine("-206 : Errore in fase invio/ricezione work zero offest data"); + Console.WriteLine("-207 : Posizionare il CN in MDI o EDIT per eseguire l'invio di un programma"); + Console.WriteLine("-208 : Programma CN Caricato ma non settato a main."); + if (inputArgs.debugMode) + Console.ReadLine(); + } + + static Boolean checkLicense(string chiave) + { + string pcInfo = string.Empty; + ManagementClass mc = new ManagementClass("win32_processor"); + ManagementObjectCollection moc = mc.GetInstances(); + + foreach (ManagementObject mo in moc) + { + //Get only the first CPU's ID + pcInfo = mo.Properties["processorID"].Value.ToString(); + } + + ManagementObjectSearcher baseboardSearcher = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_BaseBoard"); + foreach (ManagementObject queryObj in baseboardSearcher.Get()) + { + //Get motherboardSerialNumber + pcInfo += queryObj["SerialNumber"].ToString(); + break; + } + + using (Aes myAes = Aes.Create()) + { + if (chiave == "") + return false; + myAes.IV = Convert.FromBase64String("qqxNM8Li99Cwx61VX/QoWA=="); + myAes.Key = Convert.FromBase64String("7/12mP3dFLGqPGjujlwBCVblURxBaBcGGQ2c2FatfP4="); + byte[] encrypted = AesCrypt.EncryptStringToBytes_Aes(pcInfo, myAes.Key, myAes.IV); + string roundtrip = AesCrypt.DecryptStringFromBytes_Aes(encrypted, myAes.Key, myAes.IV); + string decoded = ""; + try + { + decoded = AesCrypt.DecryptStringFromBytes_Aes(Convert.FromBase64String(chiave), myAes.Key, myAes.IV); + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + } + return pcInfo == decoded; + } + } + + static void MostraAiuto() + { + Console.WriteLine("Utilizzo del Software gestore Programmi FANUC"); + Console.WriteLine("Le funzioni pricipali sono due."); + Console.WriteLine("INVIA: caricamento di programma su CNC."); + Console.WriteLine("SCARICA: scaricamento di programma su CNC."); + Console.WriteLine(); + Console.WriteLine(); + Console.WriteLine("Lista dei parametri da fornire all'eseguibile\nDevono essere separati da uno spazio tra l'uno e l'altro,\nnon andare a capo e non lasciare spazi dopo l'= "); + Console.WriteLine(); + Console.WriteLine("-chiave="); + Console.WriteLine(" la stringa chiave per eseguire il software."); + Console.WriteLine("-azione="); + Console.WriteLine(" l'{AZIONE} da eseguire."); + Console.WriteLine("-manufacturer="); + Console.WriteLine(" Il produttore del CNC: fanuc (default), heidenhain, siemens, mitsubishi"); + Console.WriteLine("-tipo="); + Console.WriteLine(" Il tipo di connessione utilizzato dalla macchina: 3 per ethernet\n 2 per HSSB (solo Fanuc, legacy)"); + Console.WriteLine("-ip="); + Console.WriteLine(" Dato per Ethernet indirizzo IP della macchina"); + Console.WriteLine("-porta="); + Console.WriteLine(" Dato per Ethernet PORTA di connessione"); + Console.WriteLine("-nodo="); + Console.WriteLine(" Dato per HSSB Nodo di connesione (solo Fanuc)"); + Console.WriteLine("-username="); + Console.WriteLine(" Username per autenticazione (Heidenhain/Siemens)"); + Console.WriteLine("-password="); + Console.WriteLine(" Password per autenticazione (Heidenhain/Siemens)"); + Console.WriteLine("-compatibility"); + Console.WriteLine(" Attivazione modalità compatibilità"); + Console.WriteLine("-commento="); + Console.WriteLine(" Commento da applicare al programma scelto"); + Console.WriteLine("-path="); + Console.WriteLine(" Path dei programmi del CNC dove vengono salvati i programmi, se non definito è impostato a 1 cioè //CNC_MEM/USER/PATH1/"); + Console.WriteLine("-pathprogramma="); + Console.WriteLine(" Necessario per INVIO: Path del programma locale da caricare sul CNC"); + Console.WriteLine("-workzero="); + Console.WriteLine(" Invia/Scarica anche i dati relativi al workzero offset"); + Console.WriteLine("-tooloffset="); + Console.WriteLine(" Invia/Scarica anche i dati relativi al tool offset"); + Console.WriteLine("-debug="); + Console.WriteLine(" Mantiene il terminale aperto alla fine delle operazioni"); + Console.WriteLine("-help"); + Console.WriteLine(" Mostra questo messaggio e termina"); + Console.WriteLine(); + Console.WriteLine("Codici Errori:"); + Console.WriteLine("-100 : Licenza Errata/non valida."); + Console.WriteLine("-101 : Impossibile parsare i parametri."); + Console.WriteLine("-102 : Parametri mancanti. "); + Console.WriteLine("-103 : Codice connessione errato: 3->Ethernet 2->HSSB. "); + Console.WriteLine("-201 : Macchina non connessa. "); + Console.WriteLine("-202 : Eccezione nell'esecuzione dell'AZIONE. "); + Console.WriteLine("-203 : L'azione è fallita. "); + Console.WriteLine("-204 : Errore in fase invio/ricezione Programma CN. "); + Console.WriteLine("-205 : Errore in fase invio/ricezione tool offset data "); + Console.WriteLine("-206 : Errore in fase invio/ricezione work zero offest data"); + Console.WriteLine("-207 : Posizionare il CN in MDI o EDIT per eseguire l'invio di un programma"); + Console.WriteLine("-208 : Programma CN Caricato ma non settato a main."); + } + + private static void parseArgomenti(string[] args) + { + List arguments = new List(args); + var help = arguments.Find(it => new Regex("-help.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(help)) + { + inputArgs.mostraHelp = true; + return; + } + var chiave = arguments.Find(it => new Regex("-chiave=.*", RegexOptions.IgnoreCase).IsMatch(it)); + inputArgs.chiave = chiave.Substring(8); + var azione = arguments.Find(it => new Regex("-azione=.*", RegexOptions.IgnoreCase).IsMatch(it)); + inputArgs.azione = azione.Substring(8); + var manufacturer = arguments.Find(it => new Regex("-manufacturer=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(manufacturer)) + { + string mfgVal = manufacturer.Substring(14).Trim().ToLowerInvariant(); + switch (mfgVal) + { + case "heidenhain": inputArgs.manufacturer = CncManufacturer.Heidenhain; break; + case "siemens": inputArgs.manufacturer = CncManufacturer.Siemens; break; + case "mitsubishi": inputArgs.manufacturer = CncManufacturer.Mitsubishi; break; + default: inputArgs.manufacturer = CncManufacturer.Fanuc; break; + } + } + string tipo = arguments.Find(it => new Regex("-tipo=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(tipo)) + inputArgs.tipo = Int32.Parse(tipo.Substring(6)); + else inputArgs.tipo = 3; + var ip = arguments.Find(it => new Regex("-ip=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(ip)) + inputArgs.ip = ip.Substring(4); + var porta = arguments.Find(it => new Regex("-porta=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(porta)) + inputArgs.porta = porta.Substring(7); + var nodo = arguments.Find(it => new Regex("-nodo=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(nodo)) + inputArgs.nodoHssb = Int32.Parse(nodo.Substring(6)); + else inputArgs.nodoHssb = -1; + var username = arguments.Find(it => new Regex("-username=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(username)) + inputArgs.username = username.Substring(10); + var password = arguments.Find(it => new Regex("-password=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(password)) + inputArgs.password = password.Substring(10); + var compatibility = arguments.Find(it => new Regex("-compatibility.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(compatibility)) + inputArgs.compatibilityMode = true; + var commento = arguments.Find(it => new Regex("-commento=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(commento)) + inputArgs.commentoProgramma = commento.Substring(10); + var path = arguments.Find(it => new Regex("-path=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(path)) + inputArgs.pathCNC = Int16.Parse(path.Substring(6)); + var pathprogramma = arguments.Find(it => new Regex("-pathprogramma=.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(pathprogramma)) + inputArgs.pathLocaleProgramma = pathprogramma.Substring(15); + var hasToolOffestData = arguments.Find(it => new Regex("-tooloffset.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(hasToolOffestData)) + inputArgs.hasToolOffsetData = true; + var hasWorkZeroOffsetData = arguments.Find(it => new Regex("-workzero.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(hasWorkZeroOffsetData)) + inputArgs.hasWorkZeroOffsetData = true; + var debugMode = arguments.Find(it => new Regex("-debug.*", RegexOptions.IgnoreCase).IsMatch(it)); + if (!string.IsNullOrEmpty(debugMode)) + inputArgs.debugMode = true; + } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100755 index 0000000..f400efd --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,39 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: InternalsVisibleTo("FanucProgramManager.Tests")] +[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] + +// Le informazioni generali relative a un assembly sono controllate dal seguente +// set di attributi. Modificare i valori di questi attributi per modificare le informazioni +// associate a un assembly. +[assembly: AssemblyTitle("FanucProgramManager")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("FanucProgramManager")] +[assembly: AssemblyCopyright("Copyright © 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Se si imposta ComVisible su false, i tipi in questo assembly non saranno visibili +// ai componenti COM. Se è necessario accedere a un tipo in questo assembly da +// COM, impostare su true l'attributo ComVisible per tale tipo. +[assembly: ComVisible(false)] + +// Se il progetto viene esposto a COM, il GUID seguente verrà utilizzato come ID della libreria dei tipi +[assembly: Guid("1032188b-3321-42b2-87ed-343bf718caf5")] + +// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori: +// +// Versione principale +// Versione secondaria +// Numero di build +// Revisione +// +// È possibile specificare tutti i valori oppure impostare valori predefiniti per i numeri relativi alla revisione e alla build +// usando l'asterisco '*' come illustrato di seguito: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.1.0.0")] +[assembly: AssemblyFileVersion("1.1.0.0")] diff --git a/fwlib32.cs b/fwlib32.cs new file mode 100755 index 0000000..db679b0 --- /dev/null +++ b/fwlib32.cs @@ -0,0 +1,11569 @@ +/*-------------------------------------------------------------------*/ +/* FWLIB32.cs */ +/* */ +/* CNC/PMC Data Window Library for FOCAS1/Ethernet */ +/* */ +/* Copyright (C) 2002-2014 by FANUC CORPORATION All rights reserved. */ +/* */ +/*-------------------------------------------------------------------*/ + +#define LEAVE_OLD_STYLE + +using System; +using System.Runtime.InteropServices; + +public class Focas1 +{ + /* Axis define */ +#if FS30D + public const short MAX_AXIS = 32; +#elif M_AXIS2 + public const short MAX_AXIS = 24; +#elif FS15D + public const short MAX_AXIS = 10; +#else + public const short MAX_AXIS = 8; +#endif + + public const short ALL_AXES = (-1); + public const short ALL_SPINDLES = (-1); + public const short EW_OK = (short)focas_ret.EW_OK; + + /* Error Codes */ + public enum focas_ret { + EW_PROTOCOL = (-17), /* protocol error */ + EW_SOCKET = (-16), /* Windows socket error */ + EW_NODLL = (-15), /* DLL not exist error */ + EW_BUS = (-11), /* bus error */ + EW_SYSTEM2 = (-10), /* system error */ + EW_HSSB = (-9) , /* hssb communication error */ + EW_HANDLE = (-8) , /* Windows library handle error */ + EW_VERSION = (-7) , /* CNC/PMC version missmatch */ + EW_UNEXP = (-6) , /* abnormal error */ + EW_SYSTEM = (-5) , /* system error */ + EW_PARITY = (-4) , /* shared RAM parity error */ + EW_MMCSYS = (-3) , /* emm386 or mmcsys install error */ + EW_RESET = (-2) , /* reset or stop occured error */ + EW_BUSY = (-1) , /* busy error */ + EW_OK = 0 , /* no problem */ + EW_FUNC = 1 , /* command prepare error */ + EW_NOPMC = 1 , /* pmc not exist */ + EW_LENGTH = 2 , /* data block length error */ + EW_NUMBER = 3 , /* data number error */ + EW_RANGE = 3 , /* address range error */ + EW_ATTRIB = 4 , /* data attribute error */ + EW_TYPE = 4 , /* data type error */ + EW_DATA = 5 , /* data error */ + EW_NOOPT = 6 , /* no option error */ + EW_PROT = 7 , /* write protect error */ + EW_OVRFLOW = 8 , /* memory overflow error */ + EW_PARAM = 9 , /* cnc parameter not correct error */ + EW_BUFFER = 10 , /* buffer error */ + EW_PATH = 11 , /* path error */ + EW_MODE = 12 , /* cnc mode error */ + EW_REJECT = 13 , /* execution rejected error */ + EW_DTSRVR = 14 , /* data server error */ + EW_ALARM = 15 , /* alarm has been occurred */ + EW_STOP = 16 , /* CNC is not running */ + EW_PASSWD = 17 , /* protection data error */ + /* + Result codes of DNC operation + */ + DNC_NORMAL = (-1) , /* normal completed */ + DNC_CANCEL = (-32768), /* DNC operation was canceled by CNC */ + DNC_OPENERR = (-514) , /* file open error */ + DNC_NOFILE = (-516) , /* file not found */ + DNC_READERR = (-517) /* read error */ + }; + +/*--------------------*/ +/* */ +/* Structure Template */ +/* */ +/*--------------------*/ +/*-------------------------------------*/ +/* CNC: Control axis / spindle related */ +/*-------------------------------------*/ + + /* cnc_actf:read actual axis feedrate(F) */ + /* cnc_acts:read actual spindle speed(S) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBACT + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* dummy */ + public int data ; /* actual feed / actual spindle */ + } + + /* cnc_acts2:read actual spindle speed(S) */ + /* (All or specified ) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBACT2 + { + public short datano; /* spindle number */ + public short type; /* dummy */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public int[] data; /* spindle data */ + } + + /* cnc_absolute:read absolute axis position */ + /* cnc_machine:read machine axis position */ + /* cnc_relative:read relative axis position */ + /* cnc_distance:read distance to go */ + /* cnc_skip:read skip position */ + /* cnc_srvdelay:read servo delay value */ + /* cnc_accdecdly:read acceleration/deceleration delay value */ + /* cnc_absolute2:read absolute axis position 2 */ + /* cnc_relative2:read relative axis position 2 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXIS + { + public short dummy ; /* dummy */ + public short type ; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] data; /* data value */ + } + + /* cnc_rddynamic:read all dynamic data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class FAXIS + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] absolute; /* absolute position */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] machine; /* machine position */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] relative; /* relative position */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] distance; /* distance to go */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OAXIS + { + public int absolute ; /* absolute position */ + public int machine ; /* machine position */ + public int relative ; /* relative position */ + public int distance ; /* distance to go */ + } +#if (!ONO8D) + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBDY_1 + { + public short dummy ; + public short axis ; /* axis number */ + public short alarm ; /* alarm status */ + public short prgnum ; /* current program number */ + public short prgmnum ; /* main program number */ + public int seqnum ; /* current sequence number */ + public int actf ; /* actual feedrate */ + public int acts ; /* actual spindle speed */ + public FAXIS pos = new FAXIS(); + } + + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBDY_2 + { + public short dummy ; + public short axis ; /* axis number */ + public short alarm ; /* alarm status */ + public short prgnum ; /* current program number */ + public short prgmnum ; /* main program number */ + public int seqnum ; /* current sequence number */ + public int actf ; /* actual feedrate */ + public int acts ; /* actual spindle speed */ + public OAXIS pos = new OAXIS(); + } +#else + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBDY_1 + { + public short dummy ; + public short axis ; /* axis number */ + public short alarm ; /* alarm status */ + public int prgnum ; /* current program number */ + public int prgmnum ; /* main program number */ + public int seqnum ; /* current sequence number */ + public int actf ; /* actual feedrate */ + public int acts ; /* actual spindle speed */ + public FAXIS pos = new FAXIS(); + } + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBDY_2 + { + public short dummy ; + public short axis ; /* axis number */ + public short alarm ; /* alarm status */ + public int prgnum ; /* current program number */ + public int prgmnum ; /* main program number */ + public int seqnum ; /* current sequence number */ + public int actf ; /* actual feedrate */ + public int acts ; /* actual spindle speed */ + public OAXIS pos = new OAXIS(); + } +#endif + + /* cnc_rddynamic2:read all dynamic data */ + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBDY2_1 + { + public short dummy ; + public short axis ; /* axis number */ + public int alarm ; /* alarm status */ + public int prgnum ; /* current program number */ + public int prgmnum ; /* main program number */ + public int seqnum ; /* current sequence number */ + public int actf ; /* actual feedrate */ + public int acts ; /* actual spindle speed */ + public FAXIS pos = new FAXIS(); + } + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBDY2_2 + { + public short dummy; + public short axis; /* axis number */ + public int alarm; /* alarm status */ + public int prgnum; /* current program number */ + public int prgmnum; /* main program number */ + public int seqnum; /* current sequence number */ + public int actf; /* actual feedrate */ + public int acts; /* actual spindle speed */ + public OAXIS pos = new OAXIS(); /* In case of 1 axis */ + } + + /* cnc_wrrelpos:set origin / preset relative axis position */ + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class IDBWRR + { + public short datano; /* dummy */ + public short type; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] data = new int[MAX_AXIS]; /* preset data */ + } + + /* cnc_prstwkcd:preset work coordinate */ + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class IDBWRA + { + public short datano; /* dummy */ + public short type; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] data = new int[MAX_AXIS]; /* preset data */ + } + + /* cnc_rdmovrlap:read manual overlapped motion value */ + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class IODBOVL + { + public short datano; /* dummy */ + public short type; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2*MAX_AXIS)] + public int[] data; /* data value:[2][MAX_AXIS] */ + } + + /* cnc_rdspload:read load information of serial spindle */ + /* cnc_rdspmaxrpm:read maximum r.p.m. ratio of serial spindle */ + /* cnc_rdspgear:read gear ratio of serial spindle */ + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBSPN + { + public short datano; /* dummy */ + public short type; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public short[] data; /* preset data */ + } + + /* cnc_rdposition:read tool position */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class POSELM + { + public int data; /* position data */ + public short dec; /* place of decimal point of position data */ + public short unit; /* unit of position data */ + public short disp; /* status of display */ + public char name; /* axis name */ + public char suff; /* axis name preffix */ + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class POSELMALL + { + public POSELM abs=new POSELM(); + public POSELM mach=new POSELM(); + public POSELM rel=new POSELM(); + public POSELM dist=new POSELM(); + } + +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPOS + { + public POSELMALL p1=new POSELMALL(); + public POSELMALL p2=new POSELMALL(); + public POSELMALL p3=new POSELMALL(); + public POSELMALL p4=new POSELMALL(); + public POSELMALL p5=new POSELMALL(); + public POSELMALL p6=new POSELMALL(); + public POSELMALL p7=new POSELMALL(); + public POSELMALL p8=new POSELMALL(); + public POSELMALL p9=new POSELMALL(); + public POSELMALL p10=new POSELMALL(); + public POSELMALL p11=new POSELMALL(); + public POSELMALL p12=new POSELMALL(); + public POSELMALL p13=new POSELMALL(); + public POSELMALL p14=new POSELMALL(); + public POSELMALL p15=new POSELMALL(); + public POSELMALL p16=new POSELMALL(); + public POSELMALL p17=new POSELMALL(); + public POSELMALL p18=new POSELMALL(); + public POSELMALL p19=new POSELMALL(); + public POSELMALL p20=new POSELMALL(); + public POSELMALL p21=new POSELMALL(); + public POSELMALL p22=new POSELMALL(); + public POSELMALL p23=new POSELMALL(); + public POSELMALL p24=new POSELMALL(); + // In case of 24 axes. + // if you need the more information, you must be add the member. + } +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPOS + { + public POSELMALL p1=new POSELMALL(); + public POSELMALL p2=new POSELMALL(); + public POSELMALL p3=new POSELMALL(); + public POSELMALL p4=new POSELMALL(); + public POSELMALL p5=new POSELMALL(); + public POSELMALL p6=new POSELMALL(); + public POSELMALL p7=new POSELMALL(); + public POSELMALL p8=new POSELMALL(); + public POSELMALL p9=new POSELMALL(); + public POSELMALL p10=new POSELMALL(); + // In case of 10 axes. + // if you need the more information, you must be add the member. + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPOS + { + public POSELMALL p1=new POSELMALL(); + public POSELMALL p2=new POSELMALL(); + public POSELMALL p3=new POSELMALL(); + public POSELMALL p4=new POSELMALL(); + public POSELMALL p5=new POSELMALL(); + public POSELMALL p6=new POSELMALL(); + public POSELMALL p7=new POSELMALL(); + public POSELMALL p8=new POSELMALL(); + // In case of 8 axes. + // if you need the more information, you must be add the member. + } +#endif + + /* cnc_rdhndintrpt:read handle interruption */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHND_data + { + public POSELM input=new POSELM(); /* input unit */ + public POSELM output=new POSELM(); /* output unit */ + } +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHND + { + public ODBHND_data p1=new ODBHND_data(); + public ODBHND_data p2=new ODBHND_data(); + public ODBHND_data p3=new ODBHND_data(); + public ODBHND_data p4=new ODBHND_data(); + public ODBHND_data p5=new ODBHND_data(); + public ODBHND_data p6=new ODBHND_data(); + public ODBHND_data p7=new ODBHND_data(); + public ODBHND_data p8=new ODBHND_data(); + public ODBHND_data p9=new ODBHND_data(); + public ODBHND_data p10=new ODBHND_data(); + public ODBHND_data p11=new ODBHND_data(); + public ODBHND_data p12=new ODBHND_data(); + public ODBHND_data p13=new ODBHND_data(); + public ODBHND_data p14=new ODBHND_data(); + public ODBHND_data p15=new ODBHND_data(); + public ODBHND_data p16=new ODBHND_data(); + public ODBHND_data p17=new ODBHND_data(); + public ODBHND_data p18=new ODBHND_data(); + public ODBHND_data p19=new ODBHND_data(); + public ODBHND_data p20=new ODBHND_data(); + public ODBHND_data p21=new ODBHND_data(); + public ODBHND_data p22=new ODBHND_data(); + public ODBHND_data p23=new ODBHND_data(); + public ODBHND_data p24=new ODBHND_data(); + // In case of 24 axes. + // if you need the more information, you must be add the member. + } +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHND + { + public ODBHND_data p1=new ODBHND_data(); + public ODBHND_data p2=new ODBHND_data(); + public ODBHND_data p3=new ODBHND_data(); + public ODBHND_data p4=new ODBHND_data(); + public ODBHND_data p5=new ODBHND_data(); + public ODBHND_data p6=new ODBHND_data(); + public ODBHND_data p7=new ODBHND_data(); + public ODBHND_data p8=new ODBHND_data(); + public ODBHND_data p9=new ODBHND_data(); + public ODBHND_data p10=new ODBHND_data(); + // In case of 10 axes. + // if you need the more information, you must be add the member. + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHND + { + public ODBHND_data p1=new ODBHND_data(); + public ODBHND_data p2=new ODBHND_data(); + public ODBHND_data p3=new ODBHND_data(); + public ODBHND_data p4=new ODBHND_data(); + public ODBHND_data p5=new ODBHND_data(); + public ODBHND_data p6=new ODBHND_data(); + public ODBHND_data p7=new ODBHND_data(); + public ODBHND_data p8=new ODBHND_data(); + // In case of 8 axes. + // if you need the more information, you must be add the member. + } +#endif + + /* cnc_rdspeed:read current speed */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class SPEEDELM + { + public int data; /* speed data */ + public short dec; /* decimal position */ + public short unit; /* data unit */ + public short disp; /* display flag */ + public byte name; /* name of data */ + public byte suff; /* suffix */ + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPEED + { + public SPEEDELM actf=new SPEEDELM(); /* actual feed rate */ + public SPEEDELM acts=new SPEEDELM(); /* actual spindle speed */ + } + + /* cnc_rdsvmeter:read servo load meter */ + /* cnc_rdspmeter:read spindle load meter */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class LOADELM + { + public int data; /* load meter */ + public short dec; /* decimal position */ + public short unit; /* unit */ + public byte name; /* name of data */ + public byte suff1; /* suffix */ + public byte suff2; /* suffix */ + public byte reserve; /* reserve */ + } + +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSVLOAD + { + public LOADELM svload1 = new LOADELM(); /* servo load meter */ + public LOADELM svload2 = new LOADELM(); /* servo load meter */ + public LOADELM svload3 = new LOADELM(); /* servo load meter */ + public LOADELM svload4 = new LOADELM(); /* servo load meter */ + public LOADELM svload5 = new LOADELM(); /* servo load meter */ + public LOADELM svload6 = new LOADELM(); /* servo load meter */ + public LOADELM svload7 = new LOADELM(); /* servo load meter */ + public LOADELM svload8 = new LOADELM(); /* servo load meter */ + public LOADELM svload9 = new LOADELM(); /* servo load meter */ + public LOADELM svload10= new LOADELM(); /* servo load meter */ + public LOADELM svload11= new LOADELM(); /* servo load meter */ + public LOADELM svload12= new LOADELM(); /* servo load meter */ + public LOADELM svload13= new LOADELM(); /* servo load meter */ + public LOADELM svload14= new LOADELM(); /* servo load meter */ + public LOADELM svload15= new LOADELM(); /* servo load meter */ + public LOADELM svload16= new LOADELM(); /* servo load meter */ + public LOADELM svload17= new LOADELM(); /* servo load meter */ + public LOADELM svload18= new LOADELM(); /* servo load meter */ + public LOADELM svload19= new LOADELM(); /* servo load meter */ + public LOADELM svload20= new LOADELM(); /* servo load meter */ + public LOADELM svload21= new LOADELM(); /* servo load meter */ + public LOADELM svload22= new LOADELM(); /* servo load meter */ + public LOADELM svload23= new LOADELM(); /* servo load meter */ + public LOADELM svload24= new LOADELM(); /* servo load meter */ + } +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSVLOAD + { + public LOADELM svload1 = new LOADELM(); /* servo load meter */ + public LOADELM svload2 = new LOADELM(); /* servo load meter */ + public LOADELM svload3 = new LOADELM(); /* servo load meter */ + public LOADELM svload4 = new LOADELM(); /* servo load meter */ + public LOADELM svload5 = new LOADELM(); /* servo load meter */ + public LOADELM svload6 = new LOADELM(); /* servo load meter */ + public LOADELM svload7 = new LOADELM(); /* servo load meter */ + public LOADELM svload8 = new LOADELM(); /* servo load meter */ + public LOADELM svload9 = new LOADELM(); /* servo load meter */ + public LOADELM svload10= new LOADELM(); /* servo load meter */ + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSVLOAD + { + public LOADELM svload1 = new LOADELM(); /* servo load meter */ + public LOADELM svload2 = new LOADELM(); /* servo load meter */ + public LOADELM svload3 = new LOADELM(); /* servo load meter */ + public LOADELM svload4 = new LOADELM(); /* servo load meter */ + public LOADELM svload5 = new LOADELM(); /* servo load meter */ + public LOADELM svload6 = new LOADELM(); /* servo load meter */ + public LOADELM svload7 = new LOADELM(); /* servo load meter */ + public LOADELM svload8 = new LOADELM(); /* servo load meter */ + } +#endif + + /* cnc_rdexecpt:read execution program pointer */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class PRGPNT + { + public int prog_no; /* program number */ + public int blk_no; /* block number */ + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPLOAD_data + { + public LOADELM spload=new LOADELM(); /* spindle load meter */ + public LOADELM spspeed=new LOADELM(); /* spindle speed */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPLOAD + { + public ODBSPLOAD_data spload1 = new ODBSPLOAD_data(); /* spindle load */ + public ODBSPLOAD_data spload2 = new ODBSPLOAD_data(); /* spindle load */ + public ODBSPLOAD_data spload3 = new ODBSPLOAD_data(); /* spindle load */ + public ODBSPLOAD_data spload4 = new ODBSPLOAD_data(); /* spindle load */ + } + + /* cnc_rd5axmandt:read manual feed for 5-axis machining */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB5AXMAN + { + public short type1; + public short type2; + public short type3; + public int data1; + public int data2; + public int data3; + public int c1; + public int c2; + public int dummy; + public int td; + public int r1; + public int r2; + public int vr; + public int h1; + public int h2; + } + +/*----------------------*/ +/* CNC: Program related */ +/*----------------------*/ + + /* cnc_rddncdgndt:read the diagnosis data of DNC operation */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDNCDGN + { + public short ctrl_word; + public short can_word; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public char[] nc_file; + public ushort read_ptr; + public ushort write_ptr; + public ushort empty_cnt; + public uint total_size; + } + + /* cnc_upload:upload NC program */ + /* cnc_cupload:upload NC program(conditional) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBUP + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* dummy */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=256)] + public char[] data ; /* data */ + } /* In case that the number of data is 256 */ + + /* cnc_buff:read buffer status for downloading/verification NC program */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBBUF + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* dummy */ + public short data ; /* buffer status */ + } + + /* cnc_rdprogdir:read program directory */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class PRGDIR + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=256)] + public char[] prg_data ; /* directory data */ + } /* In case that the number of data is 256 */ + + /* cnc_rdproginfo:read program information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBNC_1 + { + public short reg_prg ; /* registered program number */ + public short unreg_prg ; /* unregistered program number */ + public int used_mem ; /* used memory area */ + public int unused_mem ; /* unused memory area */ + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBNC_2 + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=31)] + public char[] asc; /* ASCII string type */ + } + + /* cnc_rdprgnum:read program number under execution */ +#if (!ONO8D) + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPRO + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy ; /* dummy */ + public short data ; /* running program number */ + public short mdata ; /* main program number */ + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPRO + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy ; /* dummy */ + public int data ; /* running program number */ + public int mdata ; /* main program number */ + } +#endif + + /* cnc_exeprgname:read program name under execution */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBEXEPRG + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=36)] + public char[] name; /* running program name */ + public int o_num; /* running program number */ + } + + /* cnc_rdseqnum:read sequence number under execution */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSEQ + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* dummy */ + public int data; /* sequence number */ + } + + /* cnc_rdmdipntr:read execution pointer for MDI operation */ +#if (!ONO8D) + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMDIP + { + public short mdiprog; /* exec. program number */ + public int mdipntr; /* exec. pointer */ + public short crntprog; /* prepare program number */ + public int crntpntr; /* prepare pointer */ + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMDIP + { + public int mdiprog; /* exec. program number */ + public int mdipntr; /* exec. pointer */ + public int crntprog; /* prepare program number */ + public int crntpntr; /* prepare pointer */ + } +#endif + + /* cnc_rdaxisdata:read various axis data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXDT_data + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string name = new string(' ',4); /* axis name */ + public int data; /* position data */ + public short dec; /* decimal position */ + public short unit; /* data unit */ + public short flag; /* flags */ + public short reserve; /* reserve */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXDT + { + public ODBAXDT_data data1 =new ODBAXDT_data(); + public ODBAXDT_data data2 =new ODBAXDT_data(); + public ODBAXDT_data data3 =new ODBAXDT_data(); + public ODBAXDT_data data4 =new ODBAXDT_data(); + public ODBAXDT_data data5 =new ODBAXDT_data(); + public ODBAXDT_data data6 =new ODBAXDT_data(); + public ODBAXDT_data data7 =new ODBAXDT_data(); + public ODBAXDT_data data8 =new ODBAXDT_data(); + public ODBAXDT_data data9 =new ODBAXDT_data(); + public ODBAXDT_data data10 =new ODBAXDT_data(); + public ODBAXDT_data data11 =new ODBAXDT_data(); + public ODBAXDT_data data12 =new ODBAXDT_data(); + public ODBAXDT_data data13 =new ODBAXDT_data(); + public ODBAXDT_data data14 =new ODBAXDT_data(); + public ODBAXDT_data data15 =new ODBAXDT_data(); + public ODBAXDT_data data16 =new ODBAXDT_data(); + public ODBAXDT_data data17 =new ODBAXDT_data(); + public ODBAXDT_data data18 =new ODBAXDT_data(); + public ODBAXDT_data data19 =new ODBAXDT_data(); + public ODBAXDT_data data20 =new ODBAXDT_data(); + public ODBAXDT_data data21 =new ODBAXDT_data(); + public ODBAXDT_data data22 =new ODBAXDT_data(); + public ODBAXDT_data data23 =new ODBAXDT_data(); + public ODBAXDT_data data24 =new ODBAXDT_data(); + public ODBAXDT_data data25 =new ODBAXDT_data(); + public ODBAXDT_data data26 =new ODBAXDT_data(); + public ODBAXDT_data data27 =new ODBAXDT_data(); + public ODBAXDT_data data28 =new ODBAXDT_data(); + public ODBAXDT_data data29 =new ODBAXDT_data(); + public ODBAXDT_data data30 =new ODBAXDT_data(); + public ODBAXDT_data data31 =new ODBAXDT_data(); + public ODBAXDT_data data32 =new ODBAXDT_data(); + public ODBAXDT_data data33 =new ODBAXDT_data(); + public ODBAXDT_data data34 =new ODBAXDT_data(); + public ODBAXDT_data data35 =new ODBAXDT_data(); + public ODBAXDT_data data36 =new ODBAXDT_data(); + public ODBAXDT_data data37 =new ODBAXDT_data(); + public ODBAXDT_data data38 =new ODBAXDT_data(); + public ODBAXDT_data data39 =new ODBAXDT_data(); + public ODBAXDT_data data40 =new ODBAXDT_data(); + public ODBAXDT_data data41 =new ODBAXDT_data(); + public ODBAXDT_data data42 =new ODBAXDT_data(); + public ODBAXDT_data data43 =new ODBAXDT_data(); + public ODBAXDT_data data44 =new ODBAXDT_data(); + public ODBAXDT_data data45 =new ODBAXDT_data(); + public ODBAXDT_data data46 =new ODBAXDT_data(); + public ODBAXDT_data data47 =new ODBAXDT_data(); + public ODBAXDT_data data48 =new ODBAXDT_data(); + public ODBAXDT_data data49 =new ODBAXDT_data(); + public ODBAXDT_data data50 =new ODBAXDT_data(); + public ODBAXDT_data data51 =new ODBAXDT_data(); + public ODBAXDT_data data52 =new ODBAXDT_data(); + public ODBAXDT_data data53 =new ODBAXDT_data(); + public ODBAXDT_data data54 =new ODBAXDT_data(); + public ODBAXDT_data data55 =new ODBAXDT_data(); + public ODBAXDT_data data56 =new ODBAXDT_data(); + public ODBAXDT_data data57 =new ODBAXDT_data(); + public ODBAXDT_data data58 =new ODBAXDT_data(); + public ODBAXDT_data data59 =new ODBAXDT_data(); + public ODBAXDT_data data60 =new ODBAXDT_data(); + public ODBAXDT_data data61 =new ODBAXDT_data(); + public ODBAXDT_data data62 =new ODBAXDT_data(); + public ODBAXDT_data data63 =new ODBAXDT_data(); + public ODBAXDT_data data64 =new ODBAXDT_data(); + public ODBAXDT_data data65 =new ODBAXDT_data(); + public ODBAXDT_data data66 =new ODBAXDT_data(); + public ODBAXDT_data data67 =new ODBAXDT_data(); + public ODBAXDT_data data68 =new ODBAXDT_data(); + public ODBAXDT_data data69 =new ODBAXDT_data(); + public ODBAXDT_data data70 =new ODBAXDT_data(); + public ODBAXDT_data data71 =new ODBAXDT_data(); + public ODBAXDT_data data72 =new ODBAXDT_data(); + public ODBAXDT_data data73 =new ODBAXDT_data(); + public ODBAXDT_data data74 =new ODBAXDT_data(); + public ODBAXDT_data data75 =new ODBAXDT_data(); + public ODBAXDT_data data76 =new ODBAXDT_data(); + public ODBAXDT_data data77 =new ODBAXDT_data(); + public ODBAXDT_data data78 =new ODBAXDT_data(); + public ODBAXDT_data data79 =new ODBAXDT_data(); + public ODBAXDT_data data80 =new ODBAXDT_data(); + public ODBAXDT_data data81 =new ODBAXDT_data(); + public ODBAXDT_data data82 =new ODBAXDT_data(); + public ODBAXDT_data data83 =new ODBAXDT_data(); + public ODBAXDT_data data84 =new ODBAXDT_data(); + public ODBAXDT_data data85 =new ODBAXDT_data(); + public ODBAXDT_data data86 =new ODBAXDT_data(); + public ODBAXDT_data data87 =new ODBAXDT_data(); + public ODBAXDT_data data88 =new ODBAXDT_data(); + public ODBAXDT_data data89 =new ODBAXDT_data(); + public ODBAXDT_data data90 =new ODBAXDT_data(); + public ODBAXDT_data data91 =new ODBAXDT_data(); + public ODBAXDT_data data92 =new ODBAXDT_data(); + public ODBAXDT_data data93 =new ODBAXDT_data(); + public ODBAXDT_data data94 =new ODBAXDT_data(); + public ODBAXDT_data data95 =new ODBAXDT_data(); + public ODBAXDT_data data96 =new ODBAXDT_data(); + public ODBAXDT_data data97 =new ODBAXDT_data(); + public ODBAXDT_data data98 =new ODBAXDT_data(); + public ODBAXDT_data data99 =new ODBAXDT_data(); + public ODBAXDT_data data100 =new ODBAXDT_data(); + public ODBAXDT_data data101 =new ODBAXDT_data(); + public ODBAXDT_data data102 =new ODBAXDT_data(); + public ODBAXDT_data data103 =new ODBAXDT_data(); + public ODBAXDT_data data104 =new ODBAXDT_data(); + public ODBAXDT_data data105 =new ODBAXDT_data(); + public ODBAXDT_data data106 =new ODBAXDT_data(); + public ODBAXDT_data data107 =new ODBAXDT_data(); + public ODBAXDT_data data108 =new ODBAXDT_data(); + public ODBAXDT_data data109 =new ODBAXDT_data(); + public ODBAXDT_data data110 =new ODBAXDT_data(); + public ODBAXDT_data data111 =new ODBAXDT_data(); + public ODBAXDT_data data112 =new ODBAXDT_data(); + public ODBAXDT_data data113 =new ODBAXDT_data(); + public ODBAXDT_data data114 =new ODBAXDT_data(); + public ODBAXDT_data data115 =new ODBAXDT_data(); + public ODBAXDT_data data116 =new ODBAXDT_data(); + public ODBAXDT_data data117 =new ODBAXDT_data(); + public ODBAXDT_data data118 =new ODBAXDT_data(); + public ODBAXDT_data data119 =new ODBAXDT_data(); + public ODBAXDT_data data120 =new ODBAXDT_data(); + public ODBAXDT_data data121 =new ODBAXDT_data(); + public ODBAXDT_data data122 =new ODBAXDT_data(); + public ODBAXDT_data data123 =new ODBAXDT_data(); + public ODBAXDT_data data124 =new ODBAXDT_data(); + public ODBAXDT_data data125 =new ODBAXDT_data(); + public ODBAXDT_data data126 =new ODBAXDT_data(); + public ODBAXDT_data data127 =new ODBAXDT_data(); + public ODBAXDT_data data128 =new ODBAXDT_data(); + } + + /* cnc_rdspcss:read constant surface speed data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBCSS + { + public int srpm; /* order spindle speed */ + public int sspm; /* order constant spindle speed */ + public int smax; /* order maximum spindle speed */ + } + + /* cnc_rdpdf_drive:read program drive directory */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPDFDRV + { + public short max_num; /* maximum drive number */ + public short dummy; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive1 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive2 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive3 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive4 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive5 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive6 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive7 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive8 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive9 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive10 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive11 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive12 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive13 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive14 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive15 = new string(' ',12) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string drive16 = new string(' ',12) ; + } + + /* cnc_rdpdf_inf:read program drive information */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBPDFINF + { + public int used_page; /* used capacity */ + public int all_page; /* all capacity */ + public int used_dir; /* used directory number */ + public int all_dir; /* all directory number */ + } + + /* cnc_rdpdf_subdir:read directory (sub directories) */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IDBPDFSDIR + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=212)] + public string path = new string(' ',212) ; /* path name */ + public short req_num; /* entry number */ + public short dummy; + } + + /* cnc_rdpdf_subdir:read directory (sub directories) */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBPDFSDIR + { + public short sub_exist; /* existence of sub directory */ + public short dummy; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=36)] + public string d_f = new string(' ',36) ; /* path name */ + } + + /* cnc_rdpdf_alldir:read directory (all files) */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IDBPDFADIR + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=212)] + public string path = new string(' ',212) ; /* path name */ + public short req_num; /* entry number */ + public short size_kind; /* kind of size */ + public short type; /* kind of format */ + public short dummy; + } + + /* cnc_rdpdf_alldir:read directory (all files) */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBPDFADIR + { + public short data_kind; /* kinf of data */ + public short year; /* last date and time */ + public short mon; /* last date and time */ + public short day; /* last date and time */ + public short hour; /* last date and time */ + public short min; /* last date and time */ + public short sec; /* last date and time */ + public short dummy; + public int dummy2; + public int size; /* size */ + public int attr; /* attribute */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=36)] + public string d_f = new string(' ',36) ; /* path name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=52)] + public string comment = new string(' ',52) ; /* comment */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string o_time = new string(' ',12) ; /* machining time stamp */ + } + + /* cnc_rdpdf_subdirn:read file count the directory has */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPDFNFIL + { + public short dir_num; /* directory */ + public short file_num; /* file */ + } + + /* cnc_wrpdf_attr:change attribute of program file and directory */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBPDFTDIR + { + public uint slct; /* selection */ + public uint attr; /* data */ + } + +/*---------------------------*/ +/* CNC: NC file data related */ +/*---------------------------*/ + + /* cnc_rdtofs:read tool offset value */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTOFS + { + public short datano; /* data number */ + public short type; /* data type */ + public int data; /* data */ + } + + /* cnc_rdtofsr:read tool offset value(area specified) */ + /* cnc_wrtofsr:write tool offset value(area specified) */ + [StructLayout(LayoutKind.Explicit)] + public class OFS_1 + { + [ FieldOffset( 0 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] m_ofs = new int[5]; /* M Each */ + [ FieldOffset( 0 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] m_ofs_a = new int[5] ; /* M-A All */ + [ FieldOffset( 0 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] t_tip = new short[5] ; /* T Each, 2-byte */ + [ FieldOffset( 0 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] t_ofs = new int[5]; /* T Each, 4-byte */ + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OFS_2 + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2*5)] + public int[] m_ofs_b = new int[10] ; /* M-B All */ + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OFS_3 + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4*5)] + public int[] m_ofs_c = new int[20]; /* M-C All */ + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class T_OFS_A + { + public short tip ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public int[] data ; + } /* T-A All */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class T_OFS_A_data + { + public T_OFS_A data1 = new T_OFS_A(); + public T_OFS_A data2 = new T_OFS_A(); + public T_OFS_A data3 = new T_OFS_A(); + public T_OFS_A data4 = new T_OFS_A(); + public T_OFS_A data5 = new T_OFS_A(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class T_OFS_B + { + public short tip ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] data ; + } /* T-B All */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class T_OFS_B_data + { + public T_OFS_B data1 = new T_OFS_B(); + public T_OFS_B data2 = new T_OFS_B(); + public T_OFS_B data3 = new T_OFS_B(); + public T_OFS_B data4 = new T_OFS_B(); + public T_OFS_B data5 = new T_OFS_B(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTO_1_1 + { + public short datano_s ; /* start offset number */ + public short type ; /* offset type */ + public short datano_e ; /* end offset number */ + public OFS_1 ofs = new OFS_1(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTO_1_2 + { + public short datano_s ; /* start offset number */ + public short type ; /* offset type */ + public short datano_e ; /* end offset number */ + public OFS_2 ofs = new OFS_2(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTO_1_3 + { + public short datano_s ; /* start offset number */ + public short type ; /* offset type */ + public short datano_e ; /* end offset number */ + public OFS_3 ofs = new OFS_3(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTO_2 + { + public short datano_s ; /* start offset number */ + public short type ; /* offset type */ + public short datano_e ; /* end offset number */ + public T_OFS_A_data tofsa = new T_OFS_A_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTO_3 + { + public short datano_s ; /* start offset number */ + public short type ; /* offset type */ + public short datano_e ; /* end offset number */ + public T_OFS_B_data tofsb = new T_OFS_B_data(); + } + + /* cnc_rdzofs:read work zero offset value */ + /* cnc_wrzofs:write work zero offset value */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBZOFS + { + public short datano ; /* offset NO. */ + public short type ; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] data = new int[MAX_AXIS]; /* data value */ + } + + /* cnc_rdzofsr:read work zero offset value(area specified) */ + /* cnc_wrzofsr:write work zero offset value(area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBZOR + { + public short datano_s ; /* start offset number */ + public short type ; /* axis number */ + public short datano_e ; /* end offset number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=7*MAX_AXIS)] + public int[] data = new int[7*MAX_AXIS] ; /* offset value */ + } /* In case that the number of axes is MAX_AXIS, the number of data is 7 */ + + /* cnc_rdmsptype:read mesured point value */ + /* cnc_wrmsptype:write mesured point value */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMSTP + { + public short datano_s ; /* start offset number */ + public short dummy ; /* dummy */ + public short datano_e ; /* end offset number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=7)] + public sbyte[] data = new sbyte[7]; /* mesured point value */ + } + + /* cnc_rdparam:read parameter */ + /* cnc_wrparam:write parameter */ + /* cnc_rdset:read setting data */ + /* cnc_wrset:write setting data */ + /* cnc_rdparar:read parameter(area specified) */ + /* cnc_wrparas:write parameter(plural specified) */ + /* cnc_rdsetr:read setting data(area specified) */ + /* cnc_wrsets:write setting data(plural specified) */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class IODBPSD + { + public short datano; /* data number */ + public short type; /* axis number */ + public IODBPSD_U u = new IODBPSD_U(); + + [StructLayout(LayoutKind.Explicit)] + public class IODBPSD_U + { + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public byte[] cdatas; + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public short[] idatas; + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public int[] ldatas; + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public REALPRM[] rdatas = new REALPRM[MAX_AXIS]; + + public byte cdata { get { return cdatas[0]; } set { cdatas[0] = value; } } + public short idata { get { return idatas[0]; } set { idatas[0] = value; } } + public int ldata { get { return ldatas[0]; } set { ldatas[0] = value; } } + public REALPRM rdata { get { return rdatas[0]; } set { rdatas[0] = value; } } + } + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public struct REALPRM + { + public int prm_val; /* data of real parameter */ + public int dec_val; /* decimal point of real parameter */ + } +#if LEAVE_OLD_STYLE +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REALPRMS + { + public REALPRM rdata1=new REALPRM(); + public REALPRM rdata2=new REALPRM(); + public REALPRM rdata3=new REALPRM(); + public REALPRM rdata4=new REALPRM(); + public REALPRM rdata5=new REALPRM(); + public REALPRM rdata6=new REALPRM(); + public REALPRM rdata7=new REALPRM(); + public REALPRM rdata8=new REALPRM(); + public REALPRM rdata9=new REALPRM(); + public REALPRM rdata10=new REALPRM(); + public REALPRM rdata11=new REALPRM(); + public REALPRM rdata12=new REALPRM(); + public REALPRM rdata13=new REALPRM(); + public REALPRM rdata14=new REALPRM(); + public REALPRM rdata15=new REALPRM(); + public REALPRM rdata16=new REALPRM(); + public REALPRM rdata17=new REALPRM(); + public REALPRM rdata18=new REALPRM(); + public REALPRM rdata19=new REALPRM(); + public REALPRM rdata20=new REALPRM(); + public REALPRM rdata21=new REALPRM(); + public REALPRM rdata22=new REALPRM(); + public REALPRM rdata23=new REALPRM(); + public REALPRM rdata24=new REALPRM(); + } /* In case that the number of alarm is 24 */ +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REALPRMS + { + public REALPRM rdata1=new REALPRM(); + public REALPRM rdata2=new REALPRM(); + public REALPRM rdata3=new REALPRM(); + public REALPRM rdata4=new REALPRM(); + public REALPRM rdata5=new REALPRM(); + public REALPRM rdata6=new REALPRM(); + public REALPRM rdata7=new REALPRM(); + public REALPRM rdata8=new REALPRM(); + public REALPRM rdata9=new REALPRM(); + public REALPRM rdata10=new REALPRM(); + } /* In case that the number of alarm is 10 */ +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REALPRMS + { + public REALPRM rdata1=new REALPRM(); + public REALPRM rdata2=new REALPRM(); + public REALPRM rdata3=new REALPRM(); + public REALPRM rdata4=new REALPRM(); + public REALPRM rdata5=new REALPRM(); + public REALPRM rdata6=new REALPRM(); + public REALPRM rdata7=new REALPRM(); + public REALPRM rdata8=new REALPRM(); + } /* In case that the number of alarm is 8 */ +#endif + + [StructLayout(LayoutKind.Explicit)] + public class IODBPSD_1 + { + [ FieldOffset( 0 )] + public short datano ; /* data number */ + [ FieldOffset( 2 )] + public short type ; /* axis number */ + [ FieldOffset( 4 )] + public byte cdata; /* parameter / setting data */ + [ FieldOffset( 4 )] + public short idata; + [ FieldOffset( 4 )] + public int ldata; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSD_2 + { + public short datano ; /* data number */ + public short type ; /* axis number */ + public REALPRM rdata=new REALPRM(); + } + [StructLayout(LayoutKind.Explicit)] + public class IODBPSD_3 + { + [ FieldOffset( 0 )] + public short datano ; /* data number */ + [ FieldOffset( 2 )] + public short type ; /* axis number */ + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas = new byte[MAX_AXIS]; + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas = new short[MAX_AXIS]; + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas = new int[MAX_AXIS]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSD_4 + { + public short datano ; /* data number */ + public short type ; /* axis number */ + public REALPRMS rdatas=new REALPRMS(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSD_A + { + public IODBPSD_1 data1=new IODBPSD_1(); + public IODBPSD_1 data2=new IODBPSD_1(); + public IODBPSD_1 data3=new IODBPSD_1(); + public IODBPSD_1 data4=new IODBPSD_1(); + public IODBPSD_1 data5=new IODBPSD_1(); + public IODBPSD_1 data6=new IODBPSD_1(); + public IODBPSD_1 data7=new IODBPSD_1(); + } /* (sample) must be modified */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSD_B + { + public IODBPSD_2 data1=new IODBPSD_2(); + public IODBPSD_2 data2=new IODBPSD_2(); + public IODBPSD_2 data3=new IODBPSD_2(); + public IODBPSD_2 data4=new IODBPSD_2(); + public IODBPSD_2 data5=new IODBPSD_2(); + public IODBPSD_2 data6=new IODBPSD_2(); + public IODBPSD_2 data7=new IODBPSD_2(); + } /* (sample) must be modified */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSD_C + { + public IODBPSD_3 data1=new IODBPSD_3(); + public IODBPSD_3 data2=new IODBPSD_3(); + public IODBPSD_3 data3=new IODBPSD_3(); + public IODBPSD_3 data4=new IODBPSD_3(); + public IODBPSD_3 data5=new IODBPSD_3(); + public IODBPSD_3 data6=new IODBPSD_3(); + public IODBPSD_3 data7=new IODBPSD_3(); + } /* (sample) must be modified */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSD_D + { + public IODBPSD_4 data1=new IODBPSD_4(); + public IODBPSD_4 data2=new IODBPSD_4(); + public IODBPSD_4 data3=new IODBPSD_4(); + public IODBPSD_4 data4=new IODBPSD_4(); + public IODBPSD_4 data5=new IODBPSD_4(); + public IODBPSD_4 data6=new IODBPSD_4(); + public IODBPSD_4 data7=new IODBPSD_4(); + } /* (sample) must be modified */ +#endif + + /* cnc_rdparam_ext:read parameters */ + /* cnc_rddiag_ext:read diagnosis data */ + /* cnc_start_async_wrparam:async parameter write start */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPRMNO + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] prm = new int[10]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPRM_data + { + public int prm_val ; /* parameter / setting data */ + public int dec_val ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPRM1 + { + public IODBPRM_data data1=new IODBPRM_data(); + public IODBPRM_data data2=new IODBPRM_data(); + public IODBPRM_data data3=new IODBPRM_data(); + public IODBPRM_data data4=new IODBPRM_data(); + public IODBPRM_data data5=new IODBPRM_data(); + public IODBPRM_data data6=new IODBPRM_data(); + public IODBPRM_data data7=new IODBPRM_data(); + public IODBPRM_data data8=new IODBPRM_data(); + public IODBPRM_data data9=new IODBPRM_data(); + public IODBPRM_data data10=new IODBPRM_data(); + public IODBPRM_data data11=new IODBPRM_data(); + public IODBPRM_data data12=new IODBPRM_data(); + public IODBPRM_data data13=new IODBPRM_data(); + public IODBPRM_data data14=new IODBPRM_data(); + public IODBPRM_data data15=new IODBPRM_data(); + public IODBPRM_data data16=new IODBPRM_data(); + public IODBPRM_data data17=new IODBPRM_data(); + public IODBPRM_data data18=new IODBPRM_data(); + public IODBPRM_data data19=new IODBPRM_data(); + public IODBPRM_data data20=new IODBPRM_data(); + public IODBPRM_data data21=new IODBPRM_data(); + public IODBPRM_data data22=new IODBPRM_data(); + public IODBPRM_data data23=new IODBPRM_data(); + public IODBPRM_data data24=new IODBPRM_data(); + public IODBPRM_data data25=new IODBPRM_data(); + public IODBPRM_data data26=new IODBPRM_data(); + public IODBPRM_data data27=new IODBPRM_data(); + public IODBPRM_data data28=new IODBPRM_data(); + public IODBPRM_data data29=new IODBPRM_data(); + public IODBPRM_data data30=new IODBPRM_data(); + public IODBPRM_data data31=new IODBPRM_data(); + public IODBPRM_data data32=new IODBPRM_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPRM2 + { + public int datano ; /* data number */ + public short type ; /* data type */ + public short axis ; /* axis information */ + public short info ; /* misc information */ + public short unit ; /* unit information */ + public IODBPRM1 data = new IODBPRM1(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPRM + { + public IODBPRM2 prm1 = new IODBPRM2(); + public IODBPRM2 prm2 = new IODBPRM2(); + public IODBPRM2 prm3 = new IODBPRM2(); + public IODBPRM2 prm4 = new IODBPRM2(); + public IODBPRM2 prm5 = new IODBPRM2(); + public IODBPRM2 prm6 = new IODBPRM2(); + public IODBPRM2 prm7 = new IODBPRM2(); + public IODBPRM2 prm8 = new IODBPRM2(); + public IODBPRM2 prm9 = new IODBPRM2(); + public IODBPRM2 prm10= new IODBPRM2(); + } /* In case that the number of alarm is 10 */ + + /* cnc_rdpitchr:read pitch error compensation data(area specified) */ + /* cnc_wrpitchr:write pitch error compensation data(area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPI + { + public short datano_s ; /* start pitch number */ + public short dummy ; /* dummy */ + public short datano_e ; /* end pitch number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public sbyte[] data = new sbyte[5]; /* offset value */ + } /* In case that the number of data is 5 */ + + /* cnc_rdmacro:read custom macro variable */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBM + { + public short datano ; /* variable number */ + public short dummy ; /* dummy */ + public int mcr_val ; /* macro variable */ + public short dec_val ; /* decimal point */ + } + + /* cnc_rdmacror:read custom macro variables(area specified) */ + /* cnc_wrmacror:write custom macro variables(area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMR_data + { + public int mcr_val ; /* macro variable */ + public short dec_val ; /* decimal point */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMR1 + { + public IODBMR_data data1=new IODBMR_data(); + public IODBMR_data data2=new IODBMR_data(); + public IODBMR_data data3=new IODBMR_data(); + public IODBMR_data data4=new IODBMR_data(); + public IODBMR_data data5=new IODBMR_data(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMR + { + public short datano_s ; /* start macro number */ + public short dummy ; /* dummy */ + public short datano_e ; /* end macro number */ + public IODBMR1 data = new IODBMR1(); + } + + /* cnc_rdpmacro:read P code macro variable */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPM + { + public int datano ; /* variable number */ + public short dummy ; /* dummy */ + public int mcr_val ; /* macro variable */ + public short dec_val ; /* decimal point */ + } + + /* cnc_rdpmacror:read P code macro variables(area specified) */ + /* cnc_wrpmacror:write P code macro variables(area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPR_data + { + public int mcr_val ; /* macro variable */ + public short dec_val ; /* decimal point */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPR1 + { + public IODBPR_data data1=new IODBPR_data(); + public IODBPR_data data2=new IODBPR_data(); + public IODBPR_data data3=new IODBPR_data(); + public IODBPR_data data4=new IODBPR_data(); + public IODBPR_data data5=new IODBPR_data(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPR + { + public int datano_s ; /* start macro number */ + public short dummy ; /* dummy */ + public int datano_e ; /* end macro number */ + public IODBPR1 data = new IODBPR1(); + } + + /* cnc_rdtofsinfo:read tool offset information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLINF + { + public short ofs_type; + public short use_no; + } + + /* cnc_rdtofsinfo2:read tool offset information(2) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLINF2 + { + public short ofs_type; + public short use_no; + public short ofs_enable; + } + + /* cnc_rdmacroinfo:read custom macro variable information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMVINF + { + public short use_no1; + public short use_no2; + } + + /* cnc_rdpmacroinfo:read P code macro variable information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMINF + { + public short use_no1; +#if PCD_UWORD + public ushort use_no2; +#else + public short use_no2; +#endif + public short v2_type; + } + + /* cnc_tofs_rnge:read validity of tool offset */ + /* cnc_zofs_rnge:read validity of work zero offset */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDATRNG + { + public int data_min; /* lower limit */ + public int data_max; /* upper limit */ + public int status; /* status of setting */ + } + + /* cnc_rdhsprminfo:read the information for function cnc_rdhsparam() */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class HSPINFO_data + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data1 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data2 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data3 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data4 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data5 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data6 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data7 = new byte[16]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] data8 = new byte[16]; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class HSPINFO + { + public HSPINFO_data prminfo1 = new HSPINFO_data(); + public HSPINFO_data prminfo2 = new HSPINFO_data(); + public HSPINFO_data prminfo3 = new HSPINFO_data(); + public HSPINFO_data prminfo4 = new HSPINFO_data(); + public HSPINFO_data prminfo5 = new HSPINFO_data(); + public HSPINFO_data prminfo6 = new HSPINFO_data(); + public HSPINFO_data prminfo7 = new HSPINFO_data(); + public HSPINFO_data prminfo8 = new HSPINFO_data(); + public HSPINFO_data prminfo9 = new HSPINFO_data(); + public HSPINFO_data prminfo10 = new HSPINFO_data(); + } + + /* cnc_rdhsparam:read parameters at the high speed */ + [StructLayout(LayoutKind.Explicit)] + public class HSPDATA_1 + { + [ FieldOffset( 0 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas1 = new byte[MAX_AXIS]; + [ FieldOffset( 4*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas2 = new byte[MAX_AXIS]; + [ FieldOffset( 4*2*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas3 = new byte[MAX_AXIS]; + [ FieldOffset( 4*3*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas4 = new byte[MAX_AXIS]; + [ FieldOffset( 4*4*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas5 = new byte[MAX_AXIS]; + [ FieldOffset( 4*5*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas6 = new byte[MAX_AXIS]; + [ FieldOffset( 4*6*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas7 = new byte[MAX_AXIS]; + [ FieldOffset( 4*7*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas8 = new byte[MAX_AXIS]; + [ FieldOffset( 4*8*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas9 = new byte[MAX_AXIS]; + [ FieldOffset( 4*9*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas10 = new byte[MAX_AXIS]; + } + + [StructLayout(LayoutKind.Explicit)] + public class HSPDATA_2 + { + [ FieldOffset( 0 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas1 = new short[MAX_AXIS]; + [ FieldOffset( 2*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas2 = new short[MAX_AXIS]; + [ FieldOffset( 2*2*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas3 = new short[MAX_AXIS]; + [ FieldOffset( 2*3*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas4 = new short[MAX_AXIS]; + [ FieldOffset( 2*4*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas5 = new short[MAX_AXIS]; + [ FieldOffset( 2*5*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas6 = new short[MAX_AXIS]; + [ FieldOffset( 2*6*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas7 = new short[MAX_AXIS]; + [ FieldOffset( 2*7*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas8 = new short[MAX_AXIS]; + [ FieldOffset( 2*8*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas9 = new short[MAX_AXIS]; + [ FieldOffset( 2*9*MAX_AXIS ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas10 = new short[MAX_AXIS]; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class HSPDATA_3 + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas1 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas2 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas3 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas4 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas5 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas6 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas7 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas8 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas9 = new int[MAX_AXIS]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas10 = new int[MAX_AXIS]; + } + +/*----------------------------------------*/ +/* CNC: Tool life management data related */ +/*----------------------------------------*/ + + /* cnc_rdgrpid:read tool life management data(tool group number) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLIFE1 + { + public short dummy ; /* dummy */ + public short type ; /* data type */ + public int data ; /* data */ + } + + /* cnc_rdngrp:read tool life management data(number of tool groups) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLIFE2 + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* dummy */ + public int data; /* data */ + } + + /* cnc_rdntool:read tool life management data(number of tools) */ + /* cnc_rdlife:read tool life management data(tool life) */ + /* cnc_rdcount:read tool life management data(tool lift counter) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLIFE3 + { + public short datano ; /* data number */ + public short dummy ; /* dummy */ + public int data ; /* data */ + } + + /* cnc_rd1length:read tool life management data(tool length number-1) */ + /* cnc_rd2length:read tool life management data(tool length number-2) */ + /* cnc_rd1radius:read tool life management data(cutter compensation no.-1) */ + /* cnc_rd2radius:read tool life management data(cutter compensation no.-2) */ + /* cnc_t1info:read tool life management data(tool information-1) */ + /* cnc_t2info:read tool life management data(tool information-2) */ + /* cnc_toolnum:read tool life management data(tool number) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLIFE4 + { + public short datano ; /* data number */ + public short type ; /* data type */ + public int data ; /* data */ + } + + /* cnc_rdgrpid2:read tool life management data(tool group number) 2 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLIFE5 + { + public int dummy ; /* dummy */ + public int type ; /* data type */ + public int data ; /* data */ + } + + /* cnc_rdtoolrng:read tool life management data(tool number, tool life, tool life counter)(area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTR_data + { + public int ntool ; /* tool number */ + public int life ; /* tool life */ + public int count ; /* tool life counter */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTR1 + { + public IODBTR_data data1 = new IODBTR_data(); + public IODBTR_data data2 = new IODBTR_data(); + public IODBTR_data data3 = new IODBTR_data(); + public IODBTR_data data4 = new IODBTR_data(); + public IODBTR_data data5 = new IODBTR_data(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTR + { + public short datano_s ; /* start group number */ + public short dummy ; /* dummy */ + public short datano_e ; /* end group number */ + public IODBTR1 data = new IODBTR1(); + } + + /* cnc_rdtoolgrp:read tool life management data(all data within group) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTG_data + { + public int tuse_num ; /* tool number */ + public int tool_num ; /* tool life */ + public int length_num ; /* tool life counter */ + public int radius_num ; /* tool life counter */ + public int tinfo ; /* tool life counter */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTG1 + { + public ODBTG_data data1 = new ODBTG_data(); + public ODBTG_data data2 = new ODBTG_data(); + public ODBTG_data data3 = new ODBTG_data(); + public ODBTG_data data4 = new ODBTG_data(); + public ODBTG_data data5 = new ODBTG_data(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTG + { + public short grp_num ; /* start group number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy ; /* dummy */ + public int ntool ; /* tool number */ + public int life ; /* tool life */ + public int count ; /* tool life counter */ + public ODBTG1 data = new ODBTG1(); + } + + /* cnc_wrcountr:write tool life management data(tool life counter) (area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBWRC_data + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] dummy ; /* dummy */ + public int count ; /* tool life counter */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBWRC1 + { + public IDBWRC_data data1 = new IDBWRC_data(); + public IDBWRC_data data2 = new IDBWRC_data(); + public IDBWRC_data data3 = new IDBWRC_data(); + public IDBWRC_data data4 = new IDBWRC_data(); + public IDBWRC_data data5 = new IDBWRC_data(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBWRC + { + public short datano_s ; /* start group number */ + public short dummy ; /* dummy */ + public short datano_e ; /* end group number */ + public IDBWRC1 data = new IDBWRC1(); + } + + /* cnc_rdusegrpid:read tool life management data(used tool group number) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBUSEGR + { + public short datano; /* dummy */ + public short type; /* dummy */ + public int next; /* next use group number */ + public int use; /* using group number */ + public int slct; /* selecting group number */ + } + + /* cnc_rdmaxgrp:read tool life management data(max. number of tool groups) */ + /* cnc_rdmaxtool:read tool life management data(maximum number of tool within group) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBLFNO + { + public short datano; /* dummy */ + public short type; /* dummy */ + public short data; /* number of data */ + } + + /* cnc_rdusetlno:read tool life management data(used tool no within group) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLUSE + { + public short s_grp; /* start group number */ + public short dummy; /* dummy */ + public short e_grp; /* end group number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] data; /* tool using number */ + } /* In case that the number of group is 5 */ + + /* cnc_rd1tlifedata:read tool life management data(tool data1) */ + /* cnc_rd2tlifedata:read tool life management data(tool data2) */ + /* cnc_wr1tlifedata:write tool life management data(tool data1) */ + /* cnc_wr2tlifedata:write tool life management data(tool data2) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTD + { + public short datano; /* tool group number */ + public short type; /* tool using number */ + public int tool_num; /* tool number */ + public int h_code; /* H code */ + public int d_code; /* D code */ + public int tool_inf; /* tool information */ + } + + /* cnc_rd1tlifedat2:read tool life management data(tool data1) 2 */ + /* cnc_wr1tlifedat2:write tool life management data(tool data1) 2 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTD2 + { + public short datano; /* tool group number */ + public short dummy; /* dummy */ + public int type; /* tool using number */ + public int tool_num; /* tool number */ + public int h_code; /* H code */ + public int d_code; /* D code */ + public int tool_inf; /* tool information */ + } + + /* cnc_rdgrpinfo:read tool life management data(tool group information) */ + /* cnc_wrgrpinfo:write tool life management data(tool group information) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTGI_data + { + public int n_tool; /* number of tool */ + public int count_value; /* tool life */ + public int counter; /* tool life counter */ + public int count_type; /* tool life counter type */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTGI1 + { + public IODBTGI_data data1 = new IODBTGI_data(); + public IODBTGI_data data2 = new IODBTGI_data(); + public IODBTGI_data data3 = new IODBTGI_data(); + public IODBTGI_data data4 = new IODBTGI_data(); + public IODBTGI_data data5 = new IODBTGI_data(); + } /* In case that the number of data is 5 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTGI + { + public short s_grp; /* start group number */ + public short dummy; /* dummy */ + public short e_grp; /* end group number */ + public IODBTGI1 data = new IODBTGI1(); + } + + /* cnc_rdgrpinfo2:read tool life management data(tool group information 2) */ + /* cnc_wrgrpinfo2:write tool life management data(tool group information 2) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTGI2 + { + public short s_grp; /* start group number */ + public short dummy; /* dummy */ + public short e_grp; /* end group number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] opt_grpno = new int[5]; /* optional group number of tool */ + } /* In case that the number of group is 5 */ + + /* cnc_rdgrpinfo3:read tool life management data(tool group information 3) */ + /* cnc_wrgrpinfo3:write tool life management data(tool group information 3) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTGI3 + { + public short s_grp; /* start group number */ + public short dummy; /* dummy */ + public short e_grp; /* end group number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] life_rest = new int[5]; /* tool life rest count */ + } /* In case that the number of group is 5 */ + + /* cnc_rdgrpinfo4:read tool life management data(tool group information 4) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTGI4 + { + public short grp_no; + public int n_tool; + public int count_value; + public int counter; + public int count_type; + public int opt_grpno; + public int life_rest; + } + + /* cnc_instlifedt:insert tool life management data(tool data) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBITD + { + public short datano; /* tool group number */ + public short type; /* tool using number */ + public int data; /* tool number */ + } + + /* cnc_rdtlinfo:read tool life management data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBTLINFO + { + public int max_group; /* maximum number of tool groups */ + public int max_tool; /* maximum number of tool within group */ + public int max_minute; /* maximum number of life count (minutes) */ + public int max_cycle; /* maximum number of life count (cycles) */ + } + + /* cnc_rdtlusegrp:read tool life management data(used tool group number) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBUSEGRP + { + public int next; /* next use group number */ + public int use; /* using group number */ + public int slct; /* selecting group number */ + public int opt_next; /* next use optional group number */ + public int opt_use; /* using optional group number */ + public int opt_slct; /* selecting optional group number */ + } + + /* cnc_rdtlgrp:read tool life management data(tool group information 2) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLGRP_data + { + public int ntool; /* number of all tool */ + public int nfree; /* number of free tool */ + public int life; /* tool life */ + public int count; /* tool life counter */ + public int use_tool; /* using tool number */ + public int opt_grpno; /* optional group number */ + public int life_rest; /* tool life rest count */ + public short rest_sig; /* tool life rest signal */ + public short count_type; /* tool life counter type */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLGRP + { + public IODBTLGRP_data data1 = new IODBTLGRP_data(); + public IODBTLGRP_data data2 = new IODBTLGRP_data(); + public IODBTLGRP_data data3 = new IODBTLGRP_data(); + public IODBTLGRP_data data4 = new IODBTLGRP_data(); + public IODBTLGRP_data data5 = new IODBTLGRP_data(); + } /* In case that the number of group is 5 */ + + /* cnc_rdtltool:read tool life management data (tool data1) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLTOOL_data + { + public int tool_num; /* tool number */ + public int h_code; /* H code */ + public int d_code; /* D code */ + public int tool_inf; /* tool information */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLTOOL + { + public IODBTLTOOL_data data1 = new IODBTLTOOL_data(); + public IODBTLTOOL_data data2 = new IODBTLTOOL_data(); + public IODBTLTOOL_data data3 = new IODBTLTOOL_data(); + public IODBTLTOOL_data data4 = new IODBTLTOOL_data(); + public IODBTLTOOL_data data5 = new IODBTLTOOL_data(); + } /* In case that the number of group is 5 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBEXGP_data + { + public int grp_no; /* group number */ + public int opt_grpno; /* optional group number */ + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBEXGP + { + public ODBEXGP_data data1 = new ODBEXGP_data(); + public ODBEXGP_data data2 = new ODBEXGP_data(); + public ODBEXGP_data data3 = new ODBEXGP_data(); + public ODBEXGP_data data4 = new ODBEXGP_data(); + public ODBEXGP_data data5 = new ODBEXGP_data(); + public ODBEXGP_data data6 = new ODBEXGP_data(); + public ODBEXGP_data data7 = new ODBEXGP_data(); + public ODBEXGP_data data8 = new ODBEXGP_data(); + public ODBEXGP_data data9 = new ODBEXGP_data(); + public ODBEXGP_data data10 = new ODBEXGP_data(); + public ODBEXGP_data data11 = new ODBEXGP_data(); + public ODBEXGP_data data12 = new ODBEXGP_data(); + public ODBEXGP_data data13 = new ODBEXGP_data(); + public ODBEXGP_data data14 = new ODBEXGP_data(); + public ODBEXGP_data data15 = new ODBEXGP_data(); + public ODBEXGP_data data16 = new ODBEXGP_data(); + public ODBEXGP_data data17 = new ODBEXGP_data(); + public ODBEXGP_data data18 = new ODBEXGP_data(); + public ODBEXGP_data data19 = new ODBEXGP_data(); + public ODBEXGP_data data20 = new ODBEXGP_data(); + public ODBEXGP_data data21 = new ODBEXGP_data(); + public ODBEXGP_data data22 = new ODBEXGP_data(); + public ODBEXGP_data data23 = new ODBEXGP_data(); + public ODBEXGP_data data24 = new ODBEXGP_data(); + public ODBEXGP_data data25 = new ODBEXGP_data(); + public ODBEXGP_data data26 = new ODBEXGP_data(); + public ODBEXGP_data data27 = new ODBEXGP_data(); + public ODBEXGP_data data28 = new ODBEXGP_data(); + public ODBEXGP_data data29 = new ODBEXGP_data(); + public ODBEXGP_data data30 = new ODBEXGP_data(); + public ODBEXGP_data data31 = new ODBEXGP_data(); + public ODBEXGP_data data32 = new ODBEXGP_data(); + } + +/*-----------------------------------*/ +/* CNC: Tool management data related */ +/*-----------------------------------*/ + + /* cnc_regtool:new registration of tool management data */ + /* cnc_rdtool:lead of tool management data */ + /* cnc_wrtool:write of tool management data */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class IODBTLMNG_data + { + public int T_code; + public int life_count; + public int max_life; + public int rest_life; + public byte life_stat; + public byte cust_bits; + public ushort tool_info; + public short H_code; + public short D_code; + public int spindle_speed; + public int feedrate; + public short magazine; + public short pot; + public short G_code; + public short W_code; + public short gno; + public short grp; + public short edge; + public short org_magazine; + public short org_pot; + public byte edge_num; + private byte reserve_c; + private int reserved_1; + private int reserved_2; + public int custom1; + public int custom2; + public int custom3; + public int custom4; + public int custom5; + public int custom6; + public int custom7; + public int custom8; + public int custom9; + public int custom10; + public int custom11; + public int custom12; + public int custom13; + public int custom14; + public int custom15; + public int custom16; + public int custom17; + public int custom18; + public int custom19; + public int custom20; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLMNG + { + public IODBTLMNG_data data1 = new IODBTLMNG_data(); + public IODBTLMNG_data data2 = new IODBTLMNG_data(); + public IODBTLMNG_data data3 = new IODBTLMNG_data(); + public IODBTLMNG_data data4 = new IODBTLMNG_data(); + public IODBTLMNG_data data5 = new IODBTLMNG_data(); + } /* In case that the number of group is 5 */ + + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class IODBTLMNG_F2_data + { + public int T_code; + public int life_count; + public int max_life; + public int rest_life; + public byte life_stat; + public byte cust_bits; + public ushort tool_info; + public short H_code; + public short D_code; + public int spindle_speed; + public int feedrate; + public short magazine; + public short pot; + public short G_code; + public short W_code; + public short gno; + public short grp; + public short edge; + public short org_magazine; + public short org_pot; + public byte edge_num; + private byte reserve_c; + private long reserved_1; + private long reserved_2; + public int custom1; + public int custom2; + public int custom3; + public int custom4; + public int custom5; + public int custom6; + public int custom7; + public int custom8; + public int custom9; + public int custom10; + public int custom11; + public int custom12; + public int custom13; + public int custom14; + public int custom15; + public int custom16; + public int custom17; + public int custom18; + public int custom19; + public int custom20; + public int custom21; + public int custom22; + public int custom23; + public int custom24; + public int custom25; + public int custom26; + public int custom27; + public int custom28; + public int custom29; + public int custom30; + public int custom31; + public int custom32; + public int custom33; + public int custom34; + public int custom35; + public int custom36; + public int custom37; + public int custom38; + public int custom39; + public int custom40; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLMNG_F2 + { + public IODBTLMNG_F2_data data1 = new IODBTLMNG_F2_data(); + public IODBTLMNG_F2_data data2 = new IODBTLMNG_F2_data(); + public IODBTLMNG_F2_data data3 = new IODBTLMNG_F2_data(); + public IODBTLMNG_F2_data data4 = new IODBTLMNG_F2_data(); + public IODBTLMNG_F2_data data5 = new IODBTLMNG_F2_data(); + } /* In case that the number of group is 5 */ + + /* cnc_wrtool2:write of individual data of tool management data */ + [StructLayout(LayoutKind.Explicit)] + public class IDBTLM_item + { + [ FieldOffset( 0 )] + public sbyte data1; + [ FieldOffset( 0 )] + public short data2; + [ FieldOffset( 0 )] + public int data4; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBTLM + { + public short data_id; + public IDBTLM_item item = new IDBTLM_item(); + } + + /* cnc_regmagazine:new registration of magazine management data */ + /* cnc_rdmagazine:lead of magazine management data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLMAG_data + { + public short magazine; + public short pot; + public short tool_index; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLMAG + { + public IODBTLMAG_data data1 = new IODBTLMAG_data(); + public IODBTLMAG_data data2 = new IODBTLMAG_data(); + public IODBTLMAG_data data3 = new IODBTLMAG_data(); + public IODBTLMAG_data data4 = new IODBTLMAG_data(); + public IODBTLMAG_data data5 = new IODBTLMAG_data(); + } /* In case that the number of group is 5 */ + + /* cnc_delmagazine:deletion of magazine management data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLMAG2_data + { + public short magazine; + public short pot; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLMAG2 + { + public IODBTLMAG2_data data1 = new IODBTLMAG2_data(); + public IODBTLMAG2_data data2 = new IODBTLMAG2_data(); + public IODBTLMAG2_data data3 = new IODBTLMAG2_data(); + public IODBTLMAG2_data data4 = new IODBTLMAG2_data(); + public IODBTLMAG2_data data5 = new IODBTLMAG2_data(); + } /* In case that the number of group is 5 */ + + +/*-------------------------------------*/ +/* CNC: Operation history data related */ +/*-------------------------------------*/ + + /* cnc_rdophistry:read operation history data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_ALM + { + public short rec_type; /* record type */ + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public sbyte axis_no; /* axis number */ + public sbyte dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MDI + { + public short rec_type; /* record type */ + public byte key_code; /* key code */ + public byte pw_flag; /* power on flag */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public sbyte[] dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_SGN + { + public short rec_type; /* record type */ + public sbyte sig_name; /* signal name */ + public byte sig_old; /* old signal bit pattern */ + public byte sig_new; /* new signal bit pattern */ + public sbyte dummy; + public short sig_no; /* signal number */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_DATE + { + public short rec_type; /* record type */ + public sbyte year; /* year */ + public sbyte month; /* month */ + public sbyte day; /* day */ + public sbyte pw_flag; /* power on flag */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public sbyte[] dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_TIME + { + public short rec_type; /* record flag */ + public sbyte hour; /* hour */ + public sbyte minute; /* minute */ + public sbyte second; /* second */ + public sbyte pw_flag; /* power on flag */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public sbyte[] dummy; + } + [StructLayout(LayoutKind.Explicit,Size=8)] + public class ODBHIS_data + { + // record type + [ FieldOffset( 0 )] + public short rec_type; /* record type */ + + // alarm record + [ FieldOffset( 0 )] + public short alm_rec_type; /* record type */ + [ FieldOffset( 2 )] + public short alm_alm_grp; /* alarm group */ + [ FieldOffset( 4 )] + public short alm_alm_no; /* alarm number */ + [ FieldOffset( 6 )] + public sbyte alm_axis_no; /* axis number */ + [ FieldOffset( 7 )] + public sbyte alm_dummy; + + // mdi record + [ FieldOffset( 0 )] + public short mdi_rec_type; /* record type */ + [ FieldOffset( 2 )] + public byte mdi_key_code; /* key code */ + [ FieldOffset( 3 )] + public byte mdi_pw_flag; /* power on flag */ + [ FieldOffset( 4 )] + public sbyte mdi_dummy1; + [ FieldOffset( 5 )] + public sbyte mdi_dummy2; + [ FieldOffset( 6 )] + public sbyte mdi_dummy3; + [ FieldOffset( 7 )] + public sbyte mdi_dummy4; + + // sign record + [ FieldOffset( 0 )] + public short sgn_rec_type; /* record type */ + [ FieldOffset( 2 )] + public sbyte sgn_sig_name; /* signal name */ + [ FieldOffset( 3 )] + public byte sgn_sig_old; /* old signal bit pattern */ + [ FieldOffset( 4 )] + public byte sgn_sig_new; /* new signal bit pattern */ + [ FieldOffset( 5 )] + public sbyte sgn_dummy; + [ FieldOffset( 6 )] + public short sgn_sig_no; /* signal number */ + + // date record + [ FieldOffset( 0 )] + public short date_rec_type; /* record type */ + [ FieldOffset( 2 )] + public sbyte date_year; /* year */ + [ FieldOffset( 3 )] + public sbyte date_month; /* month */ + [ FieldOffset( 4 )] + public sbyte date_day; /* day */ + [ FieldOffset( 5 )] + public sbyte date_pw_flag; /* power on flag */ + [ FieldOffset( 6 )] + public sbyte date_dummy1; + [ FieldOffset( 7 )] + public sbyte date_dummy2; + + // time record + [ FieldOffset( 0 )] + public short time_rec_type; /* record flag */ + [ FieldOffset( 2 )] + public sbyte time_hour; /* hour */ + [ FieldOffset( 3 )] + public sbyte time_minute; /* minute */ + [ FieldOffset( 4 )] + public sbyte time_second; /* second */ + [ FieldOffset( 5 )] + public sbyte time_pw_flag; /* power on flag */ + [ FieldOffset( 6 )] + public sbyte time_dummy1; + [ FieldOffset( 7 )] + public sbyte time_dummy2; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHIS1 + { + public ODBHIS_data data1 = new ODBHIS_data(); + public ODBHIS_data data2 = new ODBHIS_data(); + public ODBHIS_data data3 = new ODBHIS_data(); + public ODBHIS_data data4 = new ODBHIS_data(); + public ODBHIS_data data5 = new ODBHIS_data(); + public ODBHIS_data data6 = new ODBHIS_data(); + public ODBHIS_data data7 = new ODBHIS_data(); + public ODBHIS_data data8 = new ODBHIS_data(); + public ODBHIS_data data9 = new ODBHIS_data(); + public ODBHIS_data data10= new ODBHIS_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHIS + { + public ushort s_no; /* start number */ + public short type; /* dummy */ + public ushort e_no; /* end number */ + public ODBHIS1 data = new ODBHIS1(); + } + + /* cnc_rdophistry2:read operation history data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MDI2 + { + public byte key_code; /* key code */ + public byte pw_flag; /* power on flag */ + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MDI2_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_MDI2 data = new REC_MDI2(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_SGN2 + { + public short sig_name; /* signal name */ + public short sig_no; /* signal number */ + public byte sig_old; /* old signal bit pattern */ + public byte sig_new; /* new signal bit pattern */ + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_SGN2_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_SGN2 data = new REC_SGN2(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_ALM2 + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_ALM2_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_ALM2 data = new REC_ALM2(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_DATE2 + { + public short evnt_type; /* event type */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_DATE2_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_DATE2 data = new REC_DATE2(); + } + [StructLayout(LayoutKind.Explicit)] + public class ODBOPHIS + { + [ FieldOffset( 0 )] + public REC_MDI2_data rec_mdi = new REC_MDI2_data(); + [ FieldOffset( 0 )] + public REC_SGN2_data rec_sgn = new REC_SGN2_data(); + [ FieldOffset( 0 )] + public REC_ALM2_data rec_alm = new REC_ALM2_data(); + [ FieldOffset( 0 )] + public REC_DATE2_data rec_date = new REC_DATE2_data(); + } + + /* cnc_rdophistry4:read operation history data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MDI4 + { + public char key_code; /* key code */ + public char pw_flag; /* power on flag */ + public short pth_no; /* path index */ + public short ex_flag; /* kxternal key flag */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MDI4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_MDI4 data = new REC_MDI4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_SGN4 + { + public short sig_name; /* signal name */ + public short sig_no; /* signal number */ + public char sig_old; /* old signal bit pattern */ + public char sig_new; /* new signal bit pattern */ + public short pmc_no; /* pmc index */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_SGN4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_SGN4 data = new REC_SGN4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_ALM4 + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short pth_no; /* path index */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_ALM4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_ALM4 data = new REC_ALM4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_DATE4 + { + public short evnt_type; /* event type */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_DATE4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_DATE4 data = new REC_DATE4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_IAL4 + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short pth_no; /* path index */ + public short sys_alm; /* sys alarm */ + public short dsp_flg; /* message dsp flag */ + public short axis_num; /* axis num */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] g_modal; /* G code Modal */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public char[] g_dp; /* #7:1 Block */ + /* #6`#0 dp*/ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] a_modal; /* B,D,E,F,H,M,N,O,S,T code Modal */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public char[] a_dp; /* #7:1 Block */ + /* 6`#0 dp*/ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public int[] abs_pos; /* Abs pos */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public char[] abs_dp; /* Abs dp */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public int[] mcn_pos; /* Mcn pos */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public char[] mcn_dp; /* Mcn dp */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_IAL4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_IAL4 data = new REC_IAL4(); + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class REC_MAL4 + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short pth_no; /* path index */ + public short sys_alm; /* sys alarm */ + public short dsp_flg; /* message dsp flag */ + public short axis_num; /* axis num */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=64)] + public string alm_msg = new string(' ',64) ; /* alarm message */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] g_modal; /* G code Modal */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public char[] g_dp; /* #7:1 Block */ + /* #6`#0 dp*/ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] a_modal; /* B,D,E,F,H,M,N,O,S,T code Modal */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public char[] a_dp; /* #7:1 Block */ + /* 6`#0 dp*/ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public int[] abs_pos; /* Abs pos */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public char[] abs_dp; /* Abs dp */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public int[] mcn_pos; /* Mcn pos */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public char[] mcn_dp; /* Mcn dp */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MAL4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_MAL4 data = new REC_MAL4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_OPM4 + { + public short dsp_flg; /* Dysplay flag(ON/OFF) */ + public short om_no; /* message number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* Hour */ + public short minute; /* Minute */ + public short second; /* Second */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=256)] + public string ope_msg = new string(' ',256) ; /* Messege */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_OPM4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_OPM4 data = new REC_OPM4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_OFS4 + { + public short ofs_grp; /* Tool offset group */ + public short ofs_no; /* Tool offset number */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short pth_no; /* path index */ + public int ofs_old; /* old data */ + public int ofs_new; /* new data */ + public short old_dp; /* old data decimal point */ + public short new_dp; /* new data decimal point */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_OFS4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_OFS4 data = new REC_OFS4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_PRM4 + { + public short prm_grp; /* paramater group */ + public short prm_num; /* paramater number */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short prm_len; /* paramater data length */ + public int prm_no; /* paramater no */ + public int prm_old; /* old data */ + public int prm_new; /* new data */ + public short old_dp; /* old data decimal point */ + public short new_dp; /* new data decimal point */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_PRM4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_PRM4 data = new REC_PRM4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_WOF4 + { + public short ofs_grp; /* Work offset group */ + public short ofs_no; /* Work offset number */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short pth_no; /* path index */ + public short axis_no; /* path axis num $*/ + public short dummy; + public int ofs_old; /* old data */ + public int ofs_new; /* new data */ + public short old_dp; /* old data decimal point */ + public short new_dp; /* new data decimal point */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_WOF4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_WOF4 data = new REC_WOF4(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MAC4 + { + public short mac_no; /* macro val number */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short pth_no; /* path index */ + public int mac_old; /* old data */ + public int mac_new; /* new data */ + public short old_dp; /* old data decimal point */ + public short new_dp; /* old data decimal point */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REC_MAC4_data + { + public short rec_len; /* length */ + public short rec_type; /* record type */ + public REC_MAC4 data = new REC_MAC4(); + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_1 + { + public REC_MDI4_data rec_mdi1 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi2 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi3 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi4 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi5 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi6 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi7 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi8 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi9 = new REC_MDI4_data(); + public REC_MDI4_data rec_mdi10 = new REC_MDI4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_2 + { + public REC_SGN4_data rec_sgn1 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn2 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn3 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn4 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn5 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn6 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn7 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn8 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn9 = new REC_SGN4_data(); + public REC_SGN4_data rec_sgn10 = new REC_SGN4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_3 + { + public REC_ALM4_data rec_alm1 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm2 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm3 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm4 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm5 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm6 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm7 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm8 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm9 = new REC_ALM4_data(); + public REC_ALM4_data rec_alm10 = new REC_ALM4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_4 + { + public REC_DATE4_data rec_date1 = new REC_DATE4_data(); + public REC_DATE4_data rec_date2 = new REC_DATE4_data(); + public REC_DATE4_data rec_date3 = new REC_DATE4_data(); + public REC_DATE4_data rec_date4 = new REC_DATE4_data(); + public REC_DATE4_data rec_date5 = new REC_DATE4_data(); + public REC_DATE4_data rec_date6 = new REC_DATE4_data(); + public REC_DATE4_data rec_date7 = new REC_DATE4_data(); + public REC_DATE4_data rec_date8 = new REC_DATE4_data(); + public REC_DATE4_data rec_date9 = new REC_DATE4_data(); + public REC_DATE4_data rec_date10 = new REC_DATE4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_5 + { + public REC_IAL4_data rec_ial1 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial2 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial3 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial4 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial5 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial6 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial7 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial8 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial9 = new REC_IAL4_data(); + public REC_IAL4_data rec_ial10 = new REC_IAL4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_6 + { + public REC_MAL4_data rec_mal1 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal2 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal3 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal4 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal5 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal6 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal7 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal8 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal9 = new REC_MAL4_data(); + public REC_MAL4_data rec_mal10 = new REC_MAL4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_7 + { + public REC_OPM4_data rec_opm1 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm2 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm3 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm4 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm5 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm6 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm7 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm8 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm9 = new REC_OPM4_data(); + public REC_OPM4_data rec_opm10 = new REC_OPM4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_8 + { + public REC_OFS4_data rec_ofs1 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs2 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs3 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs4 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs5 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs6 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs7 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs8 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs9 = new REC_OFS4_data(); + public REC_OFS4_data rec_ofs10 = new REC_OFS4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_9 + { + public REC_PRM4_data rec_prm1 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm2 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm3 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm4 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm5 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm6 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm7 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm8 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm9 = new REC_PRM4_data(); + public REC_PRM4_data rec_prm10 = new REC_PRM4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_10 + { + public REC_WOF4_data rec_wof1 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof2 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof3 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof4 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof5 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof6 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof7 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof8 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof9 = new REC_WOF4_data(); + public REC_WOF4_data rec_wof10 = new REC_WOF4_data(); + } /* In case that the number of data is 10 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOPHIS4_11 + { + public REC_MAC4_data rec_mac1 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac2 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac3 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac4 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac5 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac6 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac7 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac8 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac9 = new REC_MAC4_data(); + public REC_MAC4_data rec_mac10 = new REC_MAC4_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdalmhistry:read alarm history data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ALM_HIS_data + { + public short dummy; + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public byte axis_no; /* axis number */ + public byte year; /* year */ + public byte month; /* month */ + public byte day; /* day */ + public byte hour; /* hour */ + public byte minute; /* minute */ + public byte second; /* second */ + public byte dummy2; + public short len_msg; /* alarm message length */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string alm_msg = new string(' ',32) ; /* alarm message */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALM_HIS1 + { + public ALM_HIS_data data1 = new ALM_HIS_data(); + public ALM_HIS_data data2 = new ALM_HIS_data(); + public ALM_HIS_data data3 = new ALM_HIS_data(); + public ALM_HIS_data data4 = new ALM_HIS_data(); + public ALM_HIS_data data5 = new ALM_HIS_data(); + public ALM_HIS_data data6 = new ALM_HIS_data(); + public ALM_HIS_data data7 = new ALM_HIS_data(); + public ALM_HIS_data data8 = new ALM_HIS_data(); + public ALM_HIS_data data9 = new ALM_HIS_data(); + public ALM_HIS_data data10= new ALM_HIS_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAHIS + { + public ushort s_no; /* start number */ + public short type; /* dummy */ + public ushort e_no; /* end number */ + public ALM_HIS1 alm_his = new ALM_HIS1(); + } + + /* cnc_rdalmhistry2:read alarm history data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ALM_HIS2_data + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short len_msg; /* alarm message length */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string alm_msg = new string(' ',32) ; /* alarm message */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALM_HIS2 + { + public ALM_HIS2_data data1 = new ALM_HIS2_data(); + public ALM_HIS2_data data2 = new ALM_HIS2_data(); + public ALM_HIS2_data data3 = new ALM_HIS2_data(); + public ALM_HIS2_data data4 = new ALM_HIS2_data(); + public ALM_HIS2_data data5 = new ALM_HIS2_data(); + public ALM_HIS2_data data6 = new ALM_HIS2_data(); + public ALM_HIS2_data data7 = new ALM_HIS2_data(); + public ALM_HIS2_data data8 = new ALM_HIS2_data(); + public ALM_HIS2_data data9 = new ALM_HIS2_data(); + public ALM_HIS2_data data10= new ALM_HIS2_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAHIS2 + { + public ushort s_no; /* start number */ + public ushort e_no; /* end number */ + public ALM_HIS2 alm_his = new ALM_HIS2(); + } + + /* cnc_rdalmhistry3:read alarm history data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ALM_HIS3_data + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short len_msg; /* alarm message length */ + public short pth_no; /* path index */ + public short dummy; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string alm_msg = new string(' ',32) ; /* alarm message */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALM_HIS3 + { + public ALM_HIS3_data data1 = new ALM_HIS3_data(); + public ALM_HIS3_data data2 = new ALM_HIS3_data(); + public ALM_HIS3_data data3 = new ALM_HIS3_data(); + public ALM_HIS3_data data4 = new ALM_HIS3_data(); + public ALM_HIS3_data data5 = new ALM_HIS3_data(); + public ALM_HIS3_data data6 = new ALM_HIS3_data(); + public ALM_HIS3_data data7 = new ALM_HIS3_data(); + public ALM_HIS3_data data8 = new ALM_HIS3_data(); + public ALM_HIS3_data data9 = new ALM_HIS3_data(); + public ALM_HIS3_data data10= new ALM_HIS3_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAHIS3 + { + public ushort s_no; /* start number */ + public ushort e_no; /* end number */ + public ALM_HIS3 alm_his = new ALM_HIS3(); + } + + /* cnc_rdalmhistry5:read alarm history data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ALM_HIS5_data + { + public short alm_grp; /* alarm group */ + public short alm_no; /* alarm number */ + public short axis_no; /* axis number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* minute */ + public short second; /* second */ + public short len_msg; /* alarm message length */ + public short pth_no; /* path index */ + public short dummy; /* dummy */ + public short dsp_flg; /* Flag for displaying */ + public short axis_num; /* Total axis number */ + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] + public string alm_msg = new string(' ', 64); /* alarm message */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] g_modal; /* G code Modal */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public byte[] g_dp; /* #7:1 Block #6`#0 dp */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public int[] a_modal; /* B,D,E,F,H,M,N,O,S,T code Modal */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public byte[] a_dp; /* #7:1 Block #6`#0 dp */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public int[] abs_pos; /* Abs pos */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public byte[] abs_dp; /* Abs dp */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public int[] mcn_pos; /* Mcn pos */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public byte[] mcn_dp; /* Mcn dp */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALM_HIS5 + { + public ALM_HIS5_data data1 = new ALM_HIS5_data(); + public ALM_HIS5_data data2 = new ALM_HIS5_data(); + public ALM_HIS5_data data3 = new ALM_HIS5_data(); + public ALM_HIS5_data data4 = new ALM_HIS5_data(); + public ALM_HIS5_data data5 = new ALM_HIS5_data(); + public ALM_HIS5_data data6 = new ALM_HIS5_data(); + public ALM_HIS5_data data7 = new ALM_HIS5_data(); + public ALM_HIS5_data data8 = new ALM_HIS5_data(); + public ALM_HIS5_data data9 = new ALM_HIS5_data(); + public ALM_HIS5_data data10= new ALM_HIS5_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAHIS5 + { + public ushort s_no; /* start number */ + public ushort e_no; /* end number */ + public ALM_HIS5 alm_his = new ALM_HIS5(); + } + + /* cnc_rdomhistry2:read operater message history data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBOMHIS2_data + { + public short dsp_flg; /* Dysplay flag(ON/OFF) */ + public short om_no; /* operater message number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* Hour */ + public short minute; /* Minute */ + public short second; /* Second */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=256)] + public string alm_msg = new string(' ',256) ; /* alarm message */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OPM_HIS + { + public ODBOMHIS2_data data1 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data2 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data3 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data4 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data5 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data6 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data7 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data8 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data9 = new ODBOMHIS2_data(); + public ODBOMHIS2_data data10 = new ODBOMHIS2_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOMHIS2 + { + public ushort s_no; /* start number */ + public ushort e_no; /* end number */ + public OPM_HIS opm_his = new OPM_HIS(); + } + + /* cnc_rdhissgnl:read signals related operation history */ + /* cnc_wrhissgnl:write signals related operation history */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBSIG_data + { + public short ent_no; /* entry number */ + public short sig_no; /* signal number */ + public byte sig_name; /* signal name */ + public byte mask_pat; /* signal mask pattern */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIG1 + { + public IODBSIG_data data1 = new IODBSIG_data(); + public IODBSIG_data data2 = new IODBSIG_data(); + public IODBSIG_data data3 = new IODBSIG_data(); + public IODBSIG_data data4 = new IODBSIG_data(); + public IODBSIG_data data5 = new IODBSIG_data(); + public IODBSIG_data data6 = new IODBSIG_data(); + public IODBSIG_data data7 = new IODBSIG_data(); + public IODBSIG_data data8 = new IODBSIG_data(); + public IODBSIG_data data9 = new IODBSIG_data(); + public IODBSIG_data data10= new IODBSIG_data(); + public IODBSIG_data data11= new IODBSIG_data(); + public IODBSIG_data data12= new IODBSIG_data(); + public IODBSIG_data data13= new IODBSIG_data(); + public IODBSIG_data data14= new IODBSIG_data(); + public IODBSIG_data data15= new IODBSIG_data(); + public IODBSIG_data data16= new IODBSIG_data(); + public IODBSIG_data data17= new IODBSIG_data(); + public IODBSIG_data data18= new IODBSIG_data(); + public IODBSIG_data data19= new IODBSIG_data(); + public IODBSIG_data data20= new IODBSIG_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIG + { + public short datano; /* dummy */ + public short type; /* dummy */ + public IODBSIG1 data = new IODBSIG1(); + } + + /* cnc_rdhissgnl2:read signals related operation history 2 */ + /* cnc_wrhissgnl2:write signals related operation history 2 */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class _IODBSIG2_data + { + public short ent_no; /* entry number */ + public short sig_no; /* signal number */ + public byte sig_name; /* signal name */ + public byte mask_pat; /* signal mask pattern */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIG2_data + { + public _IODBSIG2_data data1 = new _IODBSIG2_data(); + public _IODBSIG2_data data2 = new _IODBSIG2_data(); + public _IODBSIG2_data data3 = new _IODBSIG2_data(); + public _IODBSIG2_data data4 = new _IODBSIG2_data(); + public _IODBSIG2_data data5 = new _IODBSIG2_data(); + public _IODBSIG2_data data6 = new _IODBSIG2_data(); + public _IODBSIG2_data data7 = new _IODBSIG2_data(); + public _IODBSIG2_data data8 = new _IODBSIG2_data(); + public _IODBSIG2_data data9 = new _IODBSIG2_data(); + public _IODBSIG2_data data10= new _IODBSIG2_data(); + public _IODBSIG2_data data11= new _IODBSIG2_data(); + public _IODBSIG2_data data12= new _IODBSIG2_data(); + public _IODBSIG2_data data13= new _IODBSIG2_data(); + public _IODBSIG2_data data14= new _IODBSIG2_data(); + public _IODBSIG2_data data15= new _IODBSIG2_data(); + public _IODBSIG2_data data16= new _IODBSIG2_data(); + public _IODBSIG2_data data17= new _IODBSIG2_data(); + public _IODBSIG2_data data18= new _IODBSIG2_data(); + public _IODBSIG2_data data19= new _IODBSIG2_data(); + public _IODBSIG2_data data20= new _IODBSIG2_data(); + public _IODBSIG2_data data31= new _IODBSIG2_data(); + public _IODBSIG2_data data32= new _IODBSIG2_data(); + public _IODBSIG2_data data33= new _IODBSIG2_data(); + public _IODBSIG2_data data34= new _IODBSIG2_data(); + public _IODBSIG2_data data35= new _IODBSIG2_data(); + public _IODBSIG2_data data36= new _IODBSIG2_data(); + public _IODBSIG2_data data37= new _IODBSIG2_data(); + public _IODBSIG2_data data38= new _IODBSIG2_data(); + public _IODBSIG2_data data39= new _IODBSIG2_data(); + public _IODBSIG2_data data40= new _IODBSIG2_data(); + public _IODBSIG2_data data41= new _IODBSIG2_data(); + public _IODBSIG2_data data42= new _IODBSIG2_data(); + public _IODBSIG2_data data43= new _IODBSIG2_data(); + public _IODBSIG2_data data44= new _IODBSIG2_data(); + public _IODBSIG2_data data45= new _IODBSIG2_data(); + + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIG2 + { + public short datano; /* dummy */ + public short type; /* dummy */ + public IODBSIG2_data data = new IODBSIG2_data(); + } + + /* cnc_rdhissgnl3:read signals related operation history */ + /* cnc_wrhissgnl3:write signals related operation history */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class _IODBSIG3_data + { + public short ent_no; /* entry number */ + public short pmc_no; /* pmc number */ + public short sig_no; /* signal number */ + public byte sig_name; /* signal name */ + public byte mask_pat; /* signal mask pattern */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIG3_data + { + public _IODBSIG3_data data1 = new _IODBSIG3_data(); + public _IODBSIG3_data data2 = new _IODBSIG3_data(); + public _IODBSIG3_data data3 = new _IODBSIG3_data(); + public _IODBSIG3_data data4 = new _IODBSIG3_data(); + public _IODBSIG3_data data5 = new _IODBSIG3_data(); + public _IODBSIG3_data data6 = new _IODBSIG3_data(); + public _IODBSIG3_data data7 = new _IODBSIG3_data(); + public _IODBSIG3_data data8 = new _IODBSIG3_data(); + public _IODBSIG3_data data9 = new _IODBSIG3_data(); + public _IODBSIG3_data data10= new _IODBSIG3_data(); + public _IODBSIG3_data data11= new _IODBSIG3_data(); + public _IODBSIG3_data data12= new _IODBSIG3_data(); + public _IODBSIG3_data data13= new _IODBSIG3_data(); + public _IODBSIG3_data data14= new _IODBSIG3_data(); + public _IODBSIG3_data data15= new _IODBSIG3_data(); + public _IODBSIG3_data data16= new _IODBSIG3_data(); + public _IODBSIG3_data data17= new _IODBSIG3_data(); + public _IODBSIG3_data data18= new _IODBSIG3_data(); + public _IODBSIG3_data data19= new _IODBSIG3_data(); + public _IODBSIG3_data data20= new _IODBSIG3_data(); + public _IODBSIG3_data data21= new _IODBSIG3_data(); + public _IODBSIG3_data data22= new _IODBSIG3_data(); + public _IODBSIG3_data data23= new _IODBSIG3_data(); + public _IODBSIG3_data data24= new _IODBSIG3_data(); + public _IODBSIG3_data data25= new _IODBSIG3_data(); + public _IODBSIG3_data data26= new _IODBSIG3_data(); + public _IODBSIG3_data data27= new _IODBSIG3_data(); + public _IODBSIG3_data data28= new _IODBSIG3_data(); + public _IODBSIG3_data data29= new _IODBSIG3_data(); + public _IODBSIG3_data data30= new _IODBSIG3_data(); + public _IODBSIG3_data data31= new _IODBSIG3_data(); + public _IODBSIG3_data data32= new _IODBSIG3_data(); + public _IODBSIG3_data data33= new _IODBSIG3_data(); + public _IODBSIG3_data data34= new _IODBSIG3_data(); + public _IODBSIG3_data data35= new _IODBSIG3_data(); + public _IODBSIG3_data data36= new _IODBSIG3_data(); + public _IODBSIG3_data data37= new _IODBSIG3_data(); + public _IODBSIG3_data data38= new _IODBSIG3_data(); + public _IODBSIG3_data data39= new _IODBSIG3_data(); + public _IODBSIG3_data data40= new _IODBSIG3_data(); + public _IODBSIG3_data data41= new _IODBSIG3_data(); + public _IODBSIG3_data data42= new _IODBSIG3_data(); + public _IODBSIG3_data data43= new _IODBSIG3_data(); + public _IODBSIG3_data data44= new _IODBSIG3_data(); + public _IODBSIG3_data data45= new _IODBSIG3_data(); + public _IODBSIG3_data data46= new _IODBSIG3_data(); + public _IODBSIG3_data data47= new _IODBSIG3_data(); + public _IODBSIG3_data data48= new _IODBSIG3_data(); + public _IODBSIG3_data data49= new _IODBSIG3_data(); + public _IODBSIG3_data data50= new _IODBSIG3_data(); + public _IODBSIG3_data data51= new _IODBSIG3_data(); + public _IODBSIG3_data data52= new _IODBSIG3_data(); + public _IODBSIG3_data data53= new _IODBSIG3_data(); + public _IODBSIG3_data data54= new _IODBSIG3_data(); + public _IODBSIG3_data data55= new _IODBSIG3_data(); + public _IODBSIG3_data data56= new _IODBSIG3_data(); + public _IODBSIG3_data data57= new _IODBSIG3_data(); + public _IODBSIG3_data data58= new _IODBSIG3_data(); + public _IODBSIG3_data data59= new _IODBSIG3_data(); + public _IODBSIG3_data data60= new _IODBSIG3_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIG3 + { + public short datano; /* dummy */ + public short type; /* dummy */ + public IODBSIG3_data data = new IODBSIG3_data(); + } + +/*-------------*/ +/* CNC: Others */ +/*-------------*/ + + /* cnc_sysinfo:read CNC system information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYS + { + public short addinfo; + public short max_axis; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public char[] cnc_type; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public char[] mt_type; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public char[] series; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public char[] version; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public char[] axes; + } + +#if FS15D + /* cnc_statinfo:read CNC status information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBST + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* dummy */ + public short aut; /* selected automatic mode */ + public short manual; /* selected manual mode */ + public short run; /* running status */ + public short edit; /* editting status */ + public short motion; /* axis, dwell status */ + public short mstb; /* m, s, t, b status */ + public short emergency; /* emergency stop status */ + public short write; /* writting status */ + public short labelskip; /* label skip status */ + public short alarm; /* alarm status */ + public short warning; /* warning status */ + public short battery; /* battery status */ + } +#else + /* cnc_statinfo:read CNC status information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBST + { + public short dummy ; /* dummy */ + public short tmmode ; /* T/M mode */ + public short aut ; /* selected automatic mode */ + public short run ; /* running status */ + public short motion ; /* axis, dwell status */ + public short mstb ; /* m, s, t, b status */ + public short emergency ; /* emergency stop status */ + public short alarm ; /* alarm status */ + public short edit ; /* editting status */ + } +#endif + + /* cnc_alarm:read alarm status */ + [StructLayout(LayoutKind.Sequential, Pack=4)] + public class ODBALM + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy={0,0}; + public ushort data=0; + } + + /* cnc_rdalminfo:read alarm information */ +#if (M_AXIS2 || FS30D) + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALMINFO1_data + { + public int axis; + public short alm_no; + } + + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ALMINFO2_data + { + public int axis=0 ; + public short alm_no=0 ; + public short msg_len=0 ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string alm_msg= new string(' ',32) ; + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALMINFO1_data + { + public short axis; + public short alm_no; + } + + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ALMINFO2_data + { + public short axis=0 ; + public short alm_no=0 ; + public short msg_len=0 ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string alm_msg= new string(' ',32) ; + } +#endif + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALMINFO_1 + { + public ALMINFO1_data msg1=new ALMINFO1_data(); + public ALMINFO1_data msg2=new ALMINFO1_data(); + public ALMINFO1_data msg3=new ALMINFO1_data(); + public ALMINFO1_data msg4=new ALMINFO1_data(); + public ALMINFO1_data msg5=new ALMINFO1_data(); + public short data_end ; + } /* In case that the number of alarm is 5 */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ALMINFO_2 + { + public ALMINFO2_data msg1=new ALMINFO2_data(); + public ALMINFO2_data msg2=new ALMINFO2_data(); + public ALMINFO2_data msg3=new ALMINFO2_data(); + public ALMINFO2_data msg4=new ALMINFO2_data(); + public ALMINFO2_data msg5=new ALMINFO2_data(); + public short dataend=0; + } /* In case that the number of alarm is 5 */ + + /* cnc_rdalmmsg:read alarm messages */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBALMMSG_data + { + public int alm_no; + public short type; + public short axis; + public short dummy; + public short msg_len; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string alm_msg= new string(' ',32) ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBALMMSG + { + public ODBALMMSG_data msg1 = new ODBALMMSG_data(); + public ODBALMMSG_data msg2 = new ODBALMMSG_data(); + public ODBALMMSG_data msg3 = new ODBALMMSG_data(); + public ODBALMMSG_data msg4 = new ODBALMMSG_data(); + public ODBALMMSG_data msg5 = new ODBALMMSG_data(); + public ODBALMMSG_data msg6 = new ODBALMMSG_data(); + public ODBALMMSG_data msg7 = new ODBALMMSG_data(); + public ODBALMMSG_data msg8 = new ODBALMMSG_data(); + public ODBALMMSG_data msg9 = new ODBALMMSG_data(); + public ODBALMMSG_data msg10= new ODBALMMSG_data(); + } /* In case that the number of alarm is 10 */ + + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBALMMSG2_data + { + public int alm_no; + public short type; + public short axis; + public short dummy; + public short msg_len; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=64)] + public string alm_msg= new string(' ',64) ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBALMMSG2 + { + public ODBALMMSG2_data msg1 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg2 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg3 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg4 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg5 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg6 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg7 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg8 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg9 = new ODBALMMSG2_data(); + public ODBALMMSG2_data msg10= new ODBALMMSG2_data(); + } /* In case that the number of alarm is 10 */ + + /* cnc_modal:read modal data */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class ODBMDL + { + public short datano; + public short type; + public ODBMDL_U modal; + + [StructLayout(LayoutKind.Explicit)] + public struct ODBMDL_U + { + [FieldOffset(0), + MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public byte[] g_1shot; + [FieldOffset(0), + MarshalAs(UnmanagedType.ByValArray, SizeConst = 35)] + public byte[] g_rdata; + [FieldOffset(0), + MarshalAs(UnmanagedType.ByValArray, SizeConst = 27)] + public MODAL_AUX_data[] raux1; + [FieldOffset(0), + MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public MODAL_AUX_data[] raux2; + + public byte g_data { get { return g_1shot[0]; } } + public MODAL_AUX_data aux { get { return raux1[0]; } } + } + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public struct MODAL_AUX_data + { + public int aux_data; + public byte flag1; + public byte flag2; + } +#if LEAVE_OLD_STYLE + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class MODAL_RAUX1_data + { + public MODAL_AUX_data data1 = new MODAL_AUX_data(); + public MODAL_AUX_data data2 = new MODAL_AUX_data(); + public MODAL_AUX_data data3 = new MODAL_AUX_data(); + public MODAL_AUX_data data4 = new MODAL_AUX_data(); + public MODAL_AUX_data data5 = new MODAL_AUX_data(); + public MODAL_AUX_data data6 = new MODAL_AUX_data(); + public MODAL_AUX_data data7 = new MODAL_AUX_data(); + public MODAL_AUX_data data8 = new MODAL_AUX_data(); + public MODAL_AUX_data data9 = new MODAL_AUX_data(); + public MODAL_AUX_data data10= new MODAL_AUX_data(); + public MODAL_AUX_data data11= new MODAL_AUX_data(); + public MODAL_AUX_data data12= new MODAL_AUX_data(); + public MODAL_AUX_data data13= new MODAL_AUX_data(); + public MODAL_AUX_data data14= new MODAL_AUX_data(); + public MODAL_AUX_data data15= new MODAL_AUX_data(); + public MODAL_AUX_data data16= new MODAL_AUX_data(); + public MODAL_AUX_data data17= new MODAL_AUX_data(); + public MODAL_AUX_data data18= new MODAL_AUX_data(); + public MODAL_AUX_data data19= new MODAL_AUX_data(); + public MODAL_AUX_data data20= new MODAL_AUX_data(); + public MODAL_AUX_data data21= new MODAL_AUX_data(); + public MODAL_AUX_data data22= new MODAL_AUX_data(); + public MODAL_AUX_data data23= new MODAL_AUX_data(); + public MODAL_AUX_data data24= new MODAL_AUX_data(); + public MODAL_AUX_data data25= new MODAL_AUX_data(); + public MODAL_AUX_data data26= new MODAL_AUX_data(); + public MODAL_AUX_data data27= new MODAL_AUX_data(); + } +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class MODAL_RAUX2_data + { + public MODAL_AUX_data data1 = new MODAL_AUX_data(); + public MODAL_AUX_data data2 = new MODAL_AUX_data(); + public MODAL_AUX_data data3 = new MODAL_AUX_data(); + public MODAL_AUX_data data4 = new MODAL_AUX_data(); + public MODAL_AUX_data data5 = new MODAL_AUX_data(); + public MODAL_AUX_data data6 = new MODAL_AUX_data(); + public MODAL_AUX_data data7 = new MODAL_AUX_data(); + public MODAL_AUX_data data8 = new MODAL_AUX_data(); + public MODAL_AUX_data data9 = new MODAL_AUX_data(); + public MODAL_AUX_data data10= new MODAL_AUX_data(); + public MODAL_AUX_data data11= new MODAL_AUX_data(); + public MODAL_AUX_data data12= new MODAL_AUX_data(); + public MODAL_AUX_data data13= new MODAL_AUX_data(); + public MODAL_AUX_data data14= new MODAL_AUX_data(); + public MODAL_AUX_data data15= new MODAL_AUX_data(); + public MODAL_AUX_data data16= new MODAL_AUX_data(); + public MODAL_AUX_data data17= new MODAL_AUX_data(); + public MODAL_AUX_data data18= new MODAL_AUX_data(); + public MODAL_AUX_data data19= new MODAL_AUX_data(); + public MODAL_AUX_data data20= new MODAL_AUX_data(); + public MODAL_AUX_data data21= new MODAL_AUX_data(); + public MODAL_AUX_data data22= new MODAL_AUX_data(); + public MODAL_AUX_data data23= new MODAL_AUX_data(); + public MODAL_AUX_data data24= new MODAL_AUX_data(); + } +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class MODAL_RAUX2_data + { + public MODAL_AUX_data data1 = new MODAL_AUX_data(); + public MODAL_AUX_data data2 = new MODAL_AUX_data(); + public MODAL_AUX_data data3 = new MODAL_AUX_data(); + public MODAL_AUX_data data4 = new MODAL_AUX_data(); + public MODAL_AUX_data data5 = new MODAL_AUX_data(); + public MODAL_AUX_data data6 = new MODAL_AUX_data(); + public MODAL_AUX_data data7 = new MODAL_AUX_data(); + public MODAL_AUX_data data8 = new MODAL_AUX_data(); + public MODAL_AUX_data data9 = new MODAL_AUX_data(); + public MODAL_AUX_data data10= new MODAL_AUX_data(); + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class MODAL_RAUX2_data + { + public MODAL_AUX_data data1 = new MODAL_AUX_data(); + public MODAL_AUX_data data2 = new MODAL_AUX_data(); + public MODAL_AUX_data data3 = new MODAL_AUX_data(); + public MODAL_AUX_data data4 = new MODAL_AUX_data(); + public MODAL_AUX_data data5 = new MODAL_AUX_data(); + public MODAL_AUX_data data6 = new MODAL_AUX_data(); + public MODAL_AUX_data data7 = new MODAL_AUX_data(); + public MODAL_AUX_data data8 = new MODAL_AUX_data(); + } +#endif + + [StructLayout(LayoutKind.Explicit)] + public class ODBMDL_1 + { + [ FieldOffset( 0 )] + public short datano; + [ FieldOffset( 2 )] + public short type; + [ FieldOffset( 4 )] + public byte g_data; + } + [StructLayout(LayoutKind.Explicit)] + public class ODBMDL_2 + { + [ FieldOffset( 0 )] + public short datano; + [ FieldOffset( 2 )] + public short type; + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public byte[] g_1shot = new byte[4]; + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=35)] + public byte[] g_rdata = new byte[35]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMDL_3 + { + public short datano; + public short type; + public MODAL_AUX_data aux = new MODAL_AUX_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMDL_4 + { + public short datano; + public short type; + public MODAL_RAUX1_data raux1 = new MODAL_RAUX1_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMDL_5 + { + public short datano; + public short type; + public MODAL_RAUX2_data raux2 = new MODAL_RAUX2_data(); + } +#endif + + /* cnc_rdgcode: read G code */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBGCD_data + { + public short group ; + public short flag ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=8)] + public string code= new string(' ',8) ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBGCD + { + public ODBGCD_data gcd0 =new ODBGCD_data(); + public ODBGCD_data gcd1 =new ODBGCD_data(); + public ODBGCD_data gcd2 =new ODBGCD_data(); + public ODBGCD_data gcd3 =new ODBGCD_data(); + public ODBGCD_data gcd4 =new ODBGCD_data(); + public ODBGCD_data gcd5 =new ODBGCD_data(); + public ODBGCD_data gcd6 =new ODBGCD_data(); + public ODBGCD_data gcd7 =new ODBGCD_data(); + public ODBGCD_data gcd8 =new ODBGCD_data(); + public ODBGCD_data gcd9 =new ODBGCD_data(); + public ODBGCD_data gcd10=new ODBGCD_data(); + public ODBGCD_data gcd11=new ODBGCD_data(); + public ODBGCD_data gcd12=new ODBGCD_data(); + public ODBGCD_data gcd13=new ODBGCD_data(); + public ODBGCD_data gcd14=new ODBGCD_data(); + public ODBGCD_data gcd15=new ODBGCD_data(); + public ODBGCD_data gcd16=new ODBGCD_data(); + public ODBGCD_data gcd17=new ODBGCD_data(); + public ODBGCD_data gcd18=new ODBGCD_data(); + public ODBGCD_data gcd19=new ODBGCD_data(); + public ODBGCD_data gcd20=new ODBGCD_data(); + public ODBGCD_data gcd21=new ODBGCD_data(); + public ODBGCD_data gcd22=new ODBGCD_data(); + public ODBGCD_data gcd23=new ODBGCD_data(); + public ODBGCD_data gcd24=new ODBGCD_data(); + public ODBGCD_data gcd25=new ODBGCD_data(); + public ODBGCD_data gcd26=new ODBGCD_data(); + public ODBGCD_data gcd27=new ODBGCD_data(); + } + + /* cnc_rdcommand: read command value */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBCMD_data + { + public byte adrs ; + public byte num ; + public short flag ; + public int cmd_val ; + public int dec_val ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBCMD + { + public ODBCMD_data cmd0 =new ODBCMD_data(); + public ODBCMD_data cmd1 =new ODBCMD_data(); + public ODBCMD_data cmd2 =new ODBCMD_data(); + public ODBCMD_data cmd3 =new ODBCMD_data(); + public ODBCMD_data cmd4 =new ODBCMD_data(); + public ODBCMD_data cmd5 =new ODBCMD_data(); + public ODBCMD_data cmd6 =new ODBCMD_data(); + public ODBCMD_data cmd7 =new ODBCMD_data(); + public ODBCMD_data cmd8 =new ODBCMD_data(); + public ODBCMD_data cmd9 =new ODBCMD_data(); + public ODBCMD_data cmd10=new ODBCMD_data(); + public ODBCMD_data cmd11=new ODBCMD_data(); + public ODBCMD_data cmd12=new ODBCMD_data(); + public ODBCMD_data cmd13=new ODBCMD_data(); + public ODBCMD_data cmd14=new ODBCMD_data(); + public ODBCMD_data cmd15=new ODBCMD_data(); + public ODBCMD_data cmd16=new ODBCMD_data(); + public ODBCMD_data cmd17=new ODBCMD_data(); + public ODBCMD_data cmd18=new ODBCMD_data(); + public ODBCMD_data cmd19=new ODBCMD_data(); + public ODBCMD_data cmd20=new ODBCMD_data(); + public ODBCMD_data cmd21=new ODBCMD_data(); + public ODBCMD_data cmd22=new ODBCMD_data(); + public ODBCMD_data cmd23=new ODBCMD_data(); + public ODBCMD_data cmd24=new ODBCMD_data(); + public ODBCMD_data cmd25=new ODBCMD_data(); + public ODBCMD_data cmd26=new ODBCMD_data(); + public ODBCMD_data cmd27=new ODBCMD_data(); + public ODBCMD_data cmd28=new ODBCMD_data(); + public ODBCMD_data cmd29=new ODBCMD_data(); + } + + /* cnc_diagnoss:read diagnosis data */ + /* cnc_diagnosr:read diagnosis data(area specified) */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class ODBDGN + { + public short datano; /* data number */ + public short type; /* axis number */ + public ODBDGN_U u; + + [StructLayout(LayoutKind.Explicit)] + public struct ODBDGN_U + { + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public byte[] cdatas; + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public short[] idatas; + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public int[] ldatas; + [FieldOffset(0), MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_AXIS)] + public REALDGN[] rdatas; + + public byte cdata { get { return cdatas[0]; } } + public short idata { get { return idatas[0]; } } + public int ldata { get { return ldatas[0]; } } + public REALDGN rdata { get { return rdatas[0]; } } + } + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public struct REALDGN + { + public int dgn_val; /* data of real diagnoss */ + public int dec_val; /* decimal point of real diagnoss */ + } +#if LEAVE_OLD_STYLE +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REALDGNS + { + public REALDGN rdata1=new REALDGN(); + public REALDGN rdata2=new REALDGN(); + public REALDGN rdata3=new REALDGN(); + public REALDGN rdata4=new REALDGN(); + public REALDGN rdata5=new REALDGN(); + public REALDGN rdata6=new REALDGN(); + public REALDGN rdata7=new REALDGN(); + public REALDGN rdata8=new REALDGN(); + public REALDGN rdata9=new REALDGN(); + public REALDGN rdata10=new REALDGN(); + public REALDGN rdata11=new REALDGN(); + public REALDGN rdata12=new REALDGN(); + public REALDGN rdata13=new REALDGN(); + public REALDGN rdata14=new REALDGN(); + public REALDGN rdata15=new REALDGN(); + public REALDGN rdata16=new REALDGN(); + public REALDGN rdata17=new REALDGN(); + public REALDGN rdata18=new REALDGN(); + public REALDGN rdata19=new REALDGN(); + public REALDGN rdata20=new REALDGN(); + public REALDGN rdata21=new REALDGN(); + public REALDGN rdata22=new REALDGN(); + public REALDGN rdata23=new REALDGN(); + public REALDGN rdata24=new REALDGN(); + } /* In case that the number of alarm is 24 */ +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REALDGNS + { + public REALDGN rdata1=new REALDGN(); + public REALDGN rdata2=new REALDGN(); + public REALDGN rdata3=new REALDGN(); + public REALDGN rdata4=new REALDGN(); + public REALDGN rdata5=new REALDGN(); + public REALDGN rdata6=new REALDGN(); + public REALDGN rdata7=new REALDGN(); + public REALDGN rdata8=new REALDGN(); + public REALDGN rdata9=new REALDGN(); + public REALDGN rdata10=new REALDGN(); + } /* In case that the number of alarm is 10 */ +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class REALDGNS + { + public REALDGN rdata1=new REALDGN(); + public REALDGN rdata2=new REALDGN(); + public REALDGN rdata3=new REALDGN(); + public REALDGN rdata4=new REALDGN(); + public REALDGN rdata5=new REALDGN(); + public REALDGN rdata6=new REALDGN(); + public REALDGN rdata7=new REALDGN(); + public REALDGN rdata8=new REALDGN(); + } /* In case that the number of alarm is 8 */ +#endif + + [StructLayout(LayoutKind.Explicit)] + public class ODBDGN_1 + { + [ FieldOffset( 0 )] + public short datano ; /* data number */ + [ FieldOffset( 2 )] + public short type ; /* axis number */ + [ FieldOffset( 4 )] + public byte cdata; /* parameter / setting data */ + [ FieldOffset( 4 )] + public short idata; + [ FieldOffset( 4 )] + public int ldata; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDGN_2 + { + public short datano ; /* data number */ + public short type ; /* axis number */ + public REALDGN rdata=new REALDGN(); + } + [StructLayout(LayoutKind.Explicit)] + public class ODBDGN_3 + { + [ FieldOffset( 0 )] + public short datano ; /* data number */ + [ FieldOffset( 2 )] + public short type ; /* axis number */ + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public byte[] cdatas; + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public short[] idatas; + [ FieldOffset( 4 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ldatas; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDGN_4 + { + public short datano ; /* data number */ + public short type ; /* axis number */ + public REALDGNS rdatas=new REALDGNS(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDGN_A + { + public ODBDGN_1 data1=new ODBDGN_1(); + public ODBDGN_1 data2=new ODBDGN_1(); + public ODBDGN_1 data3=new ODBDGN_1(); + public ODBDGN_1 data4=new ODBDGN_1(); + public ODBDGN_1 data5=new ODBDGN_1(); + public ODBDGN_1 data6=new ODBDGN_1(); + public ODBDGN_1 data7=new ODBDGN_1(); + } /* (sample) must be modified */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDGN_B + { + public ODBDGN_2 data1=new ODBDGN_2(); + public ODBDGN_2 data2=new ODBDGN_2(); + public ODBDGN_2 data3=new ODBDGN_2(); + public ODBDGN_2 data4=new ODBDGN_2(); + public ODBDGN_2 data5=new ODBDGN_2(); + public ODBDGN_2 data6=new ODBDGN_2(); + public ODBDGN_2 data7=new ODBDGN_2(); + } /* (sample) must be modified */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDGN_C + { + public ODBDGN_3 data1=new ODBDGN_3(); + public ODBDGN_3 data2=new ODBDGN_3(); + public ODBDGN_3 data3=new ODBDGN_3(); + public ODBDGN_3 data4=new ODBDGN_3(); + public ODBDGN_3 data5=new ODBDGN_3(); + public ODBDGN_3 data6=new ODBDGN_3(); + public ODBDGN_3 data7=new ODBDGN_3(); + } /* (sample) must be modified */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDGN_D + { + public ODBDGN_4 data1=new ODBDGN_4(); + public ODBDGN_4 data2=new ODBDGN_4(); + public ODBDGN_4 data3=new ODBDGN_4(); + public ODBDGN_4 data4=new ODBDGN_4(); + public ODBDGN_4 data5=new ODBDGN_4(); + public ODBDGN_4 data6=new ODBDGN_4(); + public ODBDGN_4 data7=new ODBDGN_4(); + } /* (sample) must be modified */ +#endif + + /* cnc_adcnv:read A/D conversion data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAD + { + public short datano ; /* input analog voltage type */ + public short type ; /* analog voltage type */ + public short data ; /* digital voltage data */ + } + +#if FS15D + /* cnc_rdopmsg:read operator's message */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class OPMSG_data + { + public short datano ; /* operator's message number */ + public short type ; /* operator's message type */ + public short char_num ; /* message string length */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=129)] + public string data= new string(' ',129) ; /* operator's message string */ + } /* In case that the data length is 129 */ +#else + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class OPMSG_data + { + public short datano ; /* operator's message number */ + public short type ; /* operator's message type */ + public short char_num ; /* message string length */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=256)] + public string data= new string(' ',256) ; /* operator's message string */ + } /* In case that the data length is 256 */ +#endif + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OPMSG + { + public OPMSG_data msg1 =new OPMSG_data(); + public OPMSG_data msg2 =new OPMSG_data(); + public OPMSG_data msg3 =new OPMSG_data(); + public OPMSG_data msg4 =new OPMSG_data(); + public OPMSG_data msg5 =new OPMSG_data(); + } + + /* cnc_rdopmsg2:read operator's message */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class OPMSG2_data + { + public short datano ; /* operator's message number */ + public short type ; /* operator's message type */ + public short char_num ; /* message string length */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=64)] + public string data= new string(' ',64) ; /* operator's message string */ + } /* In case that the data length is 64 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OPMSG2 + { + public OPMSG2_data msg1 =new OPMSG2_data(); + public OPMSG2_data msg2 =new OPMSG2_data(); + public OPMSG2_data msg3 =new OPMSG2_data(); + public OPMSG2_data msg4 =new OPMSG2_data(); + public OPMSG2_data msg5 =new OPMSG2_data(); + } + + /* cnc_rdopmsg3:read operator's message */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class OPMSG3_data + { + public short datano ; /* operator's message number */ + public short type ; /* operator's message type */ + public short char_num ; /* message string length */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=256)] + public string data= new string(' ',256) ; /* operator's message string */ + } /* In case that the data length is 256 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class OPMSG3 + { + public OPMSG3_data msg1 =new OPMSG3_data(); + public OPMSG3_data msg2 =new OPMSG3_data(); + public OPMSG3_data msg3 =new OPMSG3_data(); + public OPMSG3_data msg4 =new OPMSG3_data(); + public OPMSG3_data msg5 =new OPMSG3_data(); + } + + /* cnc_sysconfig:read CNC configuration information */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBSYSC + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] slot_no_p; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] slot_no_l; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] mod_id; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] soft_id; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series1 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series2 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series3 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series4 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series5 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series6 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series7 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series8 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series9 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series10= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series11= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series12= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series13= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series14= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series15= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_series16= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version1 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version2 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version3 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version4 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version5 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version6 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version7 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version8 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version9 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version10= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version11= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version12= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version13= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version14= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version15= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string s_version16= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] dummy; + public short m_rom; + public short s_rom; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public char[] svo_soft; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public char[] pmc_soft; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public char[] lad_soft; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public char[] mcr_soft; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public char[] spl1_soft; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public char[] spl2_soft; + public short frmmin; + public short drmmin; + public short srmmin; + public short pmcmin; + public short crtmin; + public short sv1min; + public short sv3min; + public short sicmin; + public short posmin; + public short drmmrc; + public short drmarc; + public short pmcmrc; + public short dmaarc; + public short iopt; + public short hdiio; + public short frmsub; + public short drmsub; + public short srmsub; + public short sv5sub; + public short sv7sub; + public short sicsub; + public short possub; + public short hamsub; + public short gm2gr1; + public short crtgr2; + public short gm1gr2; + public short gm2gr2; + public short cmmrb; + public short sv5axs; + public short sv7axs; + public short sicaxs; + public short posaxs; + public short hanaxs; + public short romr64; + public short srmr64; + public short dr1r64; + public short dr2r64; + public short iopio2; + public short hdiio2; + public short cmmrb2; + public short romfap; + public short srmfap; + public short drmfap; + } + + /* cnc_rdprstrinfo:read program restart information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPRS + { + public short datano; /* dummy */ + public short type; /* dummy */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] data_info; /* data setting information */ + public int rstr_bc; /* block counter */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=35)] + public int[] rstr_m; /* M code value */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] rstr_t; /* T code value */ + public int rstr_s; /* S code value */ + public int rstr_b; /* B code value */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] dest; /* program re-start position */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] dist; /* program re-start distance */ + } + +#if FS15D + /* cnc_rdopnlsgnl:read output signal image of software operator's panel */ + /* cnc_wropnlsgnl:write output signal of software operator's panel */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSGNL + { + public short datano; /* dummy */ + public short type; /* data select flag */ + public short mode; /* mode signal */ + public short hndl_ax; /* Manual handle feed axis selection signal */ + public short hndl_mv; /* Manual handle feed travel distance selection signal */ + public short rpd_ovrd; /* rapid traverse override signal */ + public short jog_ovrd; /* manual feedrate override signal */ + public short feed_ovrd; /* feedrate override signal */ + public short spdl_ovrd; /* spindle override signal */ + public short blck_del; /* optional block skip signal */ + public short sngl_blck; /* single block signal */ + public short machn_lock; /* machine lock signal */ + public short dry_run; /* dry run signal */ + public short mem_prtct; /* memory protection signal */ + public short feed_hold; /* automatic operation halt signal */ + public short manual_rpd; /* (not used) */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] dummy; /* (not used) */ + } +#else + /* cnc_rdopnlsgnl:read output signal image of software operator's panel */ + /* cnc_wropnlsgnl:write output signal of software operator's panel */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSGNL + { + public short datano; /* dummy */ + public short type; /* data select flag */ + public short mode; /* mode signal */ + public short hndl_ax; /* Manual handle feed axis selection signal */ + public short hndl_mv; /* Manual handle feed travel distance selection signal */ + public short rpd_ovrd; /* rapid traverse override signal */ + public short jog_ovrd; /* manual feedrate override signal */ + public short feed_ovrd; /* feedrate override signal */ + public short spdl_ovrd; /* (not used) */ + public short blck_del; /* optional block skip signal */ + public short sngl_blck; /* single block signal */ + public short machn_lock; /* machine lock signal */ + public short dry_run; /* dry run signal */ + public short mem_prtct; /* memory protection signal */ + public short feed_hold; /* automatic operation halt signal */ + } +#endif + + /* cnc_rdopnlgnrl:read general signal image of software operator's panel */ + /* cnc_wropnlgnrl:write general signal image of software operator's panel */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBGNRL + { + public short datano; /* dummy */ + public short type; /* data select flag */ + public byte sgnal; /* general signal */ + } + + /* cnc_rdopnlgsname:read general signal name of software operator's panel */ + /* cnc_wropnlgsname:write general signal name of software operator's panel*/ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBRDNA + { + public short datano; /* dummy */ + public short type; /* data select flag */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl1_name= new string(' ',9) ; /* general signal 1 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl2_name= new string(' ',9) ; /* general signal 2 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl3_name= new string(' ',9) ; /* general signal 3 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl4_name= new string(' ',9) ; /* general signal 4 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl5_name= new string(' ',9) ; /* general signal 5 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl6_name= new string(' ',9) ; /* general signal 6 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl7_name= new string(' ',9) ; /* general signal 7 name */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=9)] + public string sgnl8_name= new string(' ',9) ; /* general signal 8 name */ + } + + /* cnc_getdtailerr:get detail error */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBERR + { + public short err_no ; + public short err_dtno ; + } + + + /* cnc_rdparainfo:read informations of CNC parameter */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPARAIF_info + { + public short prm_no ; + public short prm_type ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPARAIF1 + { + public ODBPARAIF_info info1 = new ODBPARAIF_info(); + public ODBPARAIF_info info2 = new ODBPARAIF_info(); + public ODBPARAIF_info info3 = new ODBPARAIF_info(); + public ODBPARAIF_info info4 = new ODBPARAIF_info(); + public ODBPARAIF_info info5 = new ODBPARAIF_info(); + public ODBPARAIF_info info6 = new ODBPARAIF_info(); + public ODBPARAIF_info info7 = new ODBPARAIF_info(); + public ODBPARAIF_info info8 = new ODBPARAIF_info(); + public ODBPARAIF_info info9 = new ODBPARAIF_info(); + public ODBPARAIF_info info10= new ODBPARAIF_info(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPARAIF + { + public ushort info_no ; + public short prev_no ; + public short next_no ; + public ODBPARAIF1 info = new ODBPARAIF1(); + } + + /* cnc_rdsetinfo:read informations of CNC setting data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSETIF_info + { + public short set_no ; + public short set_type ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSETIF1 + { + public ODBSETIF_info info1 = new ODBSETIF_info(); + public ODBSETIF_info info2 = new ODBSETIF_info(); + public ODBSETIF_info info3 = new ODBSETIF_info(); + public ODBSETIF_info info4 = new ODBSETIF_info(); + public ODBSETIF_info info5 = new ODBSETIF_info(); + public ODBSETIF_info info6 = new ODBSETIF_info(); + public ODBSETIF_info info7 = new ODBSETIF_info(); + public ODBSETIF_info info8 = new ODBSETIF_info(); + public ODBSETIF_info info9 = new ODBSETIF_info(); + public ODBSETIF_info info10= new ODBSETIF_info(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSETIF + { + public ushort info_no ; + public short prev_no ; + public short next_no ; + public ODBSETIF1 info = new ODBSETIF1(); + } + + /* cnc_rddiaginfo:read informations of CNC diagnose data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDIAGIF_info + { + public short diag_no ; + public short diag_type ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDIAGIF1 + { + public ODBDIAGIF_info info1 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info2 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info3 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info4 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info5 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info6 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info7 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info8 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info9 = new ODBDIAGIF_info(); + public ODBDIAGIF_info info10= new ODBDIAGIF_info(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDIAGIF + { + public ushort info_no ; + public short prev_no ; + public short next_no ; + public ODBDIAGIF1 info = new ODBDIAGIF1(); + } + + /* cnc_rdparanum:read maximum, minimum and total number of CNC parameter */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPARANUM + { + public ushort para_min ; + public ushort para_max ; + public ushort total_no ; + } + + /* cnc_rdsetnum:read maximum, minimum and total number of CNC setting data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSETNUM + { + public ushort set_min ; + public ushort set_max ; + public ushort total_no ; + } + + /* cnc_rddiagnum:read maximum, minimum and total number of CNC diagnose data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDIAGNUM + { + public ushort diag_min ; + public ushort diag_max ; + public ushort total_no ; + } + + /* cnc_rdfrominfo:read F-ROM information on CNC */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBFINFO_info + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string sysname= new string(' ',12) ; /* F-ROM SYSTEM data Name */ + public int fromsize; /* F-ROM Size */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBFINFO1 + { + public ODBFINFO_info info1 = new ODBFINFO_info(); + public ODBFINFO_info info2 = new ODBFINFO_info(); + public ODBFINFO_info info3 = new ODBFINFO_info(); + public ODBFINFO_info info4 = new ODBFINFO_info(); + public ODBFINFO_info info5 = new ODBFINFO_info(); + public ODBFINFO_info info6 = new ODBFINFO_info(); + public ODBFINFO_info info7 = new ODBFINFO_info(); + public ODBFINFO_info info8 = new ODBFINFO_info(); + public ODBFINFO_info info9 = new ODBFINFO_info(); + public ODBFINFO_info info10= new ODBFINFO_info(); + public ODBFINFO_info info11= new ODBFINFO_info(); + public ODBFINFO_info info12= new ODBFINFO_info(); + public ODBFINFO_info info13= new ODBFINFO_info(); + public ODBFINFO_info info14= new ODBFINFO_info(); + public ODBFINFO_info info15= new ODBFINFO_info(); + public ODBFINFO_info info16= new ODBFINFO_info(); + public ODBFINFO_info info17= new ODBFINFO_info(); + public ODBFINFO_info info18= new ODBFINFO_info(); + public ODBFINFO_info info19= new ODBFINFO_info(); + public ODBFINFO_info info20= new ODBFINFO_info(); + public ODBFINFO_info info21= new ODBFINFO_info(); + public ODBFINFO_info info22= new ODBFINFO_info(); + public ODBFINFO_info info23= new ODBFINFO_info(); + public ODBFINFO_info info24= new ODBFINFO_info(); + public ODBFINFO_info info25= new ODBFINFO_info(); + public ODBFINFO_info info26= new ODBFINFO_info(); + public ODBFINFO_info info27= new ODBFINFO_info(); + public ODBFINFO_info info28= new ODBFINFO_info(); + public ODBFINFO_info info29= new ODBFINFO_info(); + public ODBFINFO_info info30= new ODBFINFO_info(); + public ODBFINFO_info info31= new ODBFINFO_info(); + public ODBFINFO_info info32= new ODBFINFO_info(); + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBFINFO + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string slotname= new string(' ',12) ; /* Slot Name */ + public int fromnum; /* Number of F-ROM SYSTEM data */ + public ODBFINFO1 info = new ODBFINFO1(); + } + + /* cnc_getfrominfo:read F-ROM information on CNC */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBFINFORM_info + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string sysname= new string(' ',12) ; /* F-ROM SYSTEM data Name */ + public int fromsize; /* F-ROM Size */ + public int fromattrib; /* F-ROM data attribute */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBFINFORM1 + { + public ODBFINFORM_info info1 = new ODBFINFORM_info(); + public ODBFINFORM_info info2 = new ODBFINFORM_info(); + public ODBFINFORM_info info3 = new ODBFINFORM_info(); + public ODBFINFORM_info info4 = new ODBFINFORM_info(); + public ODBFINFORM_info info5 = new ODBFINFORM_info(); + public ODBFINFORM_info info6 = new ODBFINFORM_info(); + public ODBFINFORM_info info7 = new ODBFINFORM_info(); + public ODBFINFORM_info info8 = new ODBFINFORM_info(); + public ODBFINFORM_info info9 = new ODBFINFORM_info(); + public ODBFINFORM_info info10= new ODBFINFORM_info(); + public ODBFINFORM_info info11= new ODBFINFORM_info(); + public ODBFINFORM_info info12= new ODBFINFORM_info(); + public ODBFINFORM_info info13= new ODBFINFORM_info(); + public ODBFINFORM_info info14= new ODBFINFORM_info(); + public ODBFINFORM_info info15= new ODBFINFORM_info(); + public ODBFINFORM_info info16= new ODBFINFORM_info(); + public ODBFINFORM_info info17= new ODBFINFORM_info(); + public ODBFINFORM_info info18= new ODBFINFORM_info(); + public ODBFINFORM_info info19= new ODBFINFORM_info(); + public ODBFINFORM_info info20= new ODBFINFORM_info(); + public ODBFINFORM_info info21= new ODBFINFORM_info(); + public ODBFINFORM_info info22= new ODBFINFORM_info(); + public ODBFINFORM_info info23= new ODBFINFORM_info(); + public ODBFINFORM_info info24= new ODBFINFORM_info(); + public ODBFINFORM_info info25= new ODBFINFORM_info(); + public ODBFINFORM_info info26= new ODBFINFORM_info(); + public ODBFINFORM_info info27= new ODBFINFORM_info(); + public ODBFINFORM_info info28= new ODBFINFORM_info(); + public ODBFINFORM_info info29= new ODBFINFORM_info(); + public ODBFINFORM_info info30= new ODBFINFORM_info(); + public ODBFINFORM_info info31= new ODBFINFORM_info(); + public ODBFINFORM_info info32= new ODBFINFORM_info(); + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBFINFORM + { + public int slotno; /* Slot Number */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string slotname= new string(' ',12) ; /* Slot Name */ + public int fromnum; /* Number of F-ROM SYSTEM data */ + public ODBFINFORM1 info = new ODBFINFORM1(); + } + + /* cnc_rdsraminfo:read S-RAM information on CNC */ + /* cnc_getsraminfo:read S-RAM information on CNC */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBSINFO_info + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string sramname= new string(' ',12) ; /* S-RAM data Name */ + public int sramsize; /* S-RAM data Size */ + public short divnumber; /* Division number of S-RAM file */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string fname1= new string(' ',16) ; /* S-RAM data Name1 */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string fname2= new string(' ',16) ; /* S-RAM data Name2 */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string fname3= new string(' ',16) ; /* S-RAM data Name3 */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string fname4= new string(' ',16) ; /* S-RAM data Name4 */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string fname5= new string(' ',16) ; /* S-RAM data Name5 */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string fname6= new string(' ',16) ; /* S-RAM data Name6 */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSINFO1 + { + public ODBSINFO_info info1 = new ODBSINFO_info(); + public ODBSINFO_info info2 = new ODBSINFO_info(); + public ODBSINFO_info info3 = new ODBSINFO_info(); + public ODBSINFO_info info4 = new ODBSINFO_info(); + public ODBSINFO_info info5 = new ODBSINFO_info(); + public ODBSINFO_info info6 = new ODBSINFO_info(); + public ODBSINFO_info info7 = new ODBSINFO_info(); + public ODBSINFO_info info8 = new ODBSINFO_info(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSINFO + { + public int sramnum; /* Number of S-RAM data */ + public ODBSINFO1 info = new ODBSINFO1(); + } + + /* cnc_rdsramaddr:read S-RAM address on CNC */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class SRAMADDR + { + public short type ; /* SRAM data type */ + public int size ; /* SRAM data size */ + public int offset ; /* offset from top address of SRAM */ + } + + /* cnc_dtsvrdpgdir:read file directory in Data Server */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBDSDIR_data + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string file_name= new string(' ',16) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=64)] + public string comment= new string(' ',64) ; + public int size; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string date= new string(' ',16) ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDSDIR1 + { + public ODBDSDIR_data data1 = new ODBDSDIR_data(); + public ODBDSDIR_data data2 = new ODBDSDIR_data(); + public ODBDSDIR_data data3 = new ODBDSDIR_data(); + public ODBDSDIR_data data4 = new ODBDSDIR_data(); + public ODBDSDIR_data data5 = new ODBDSDIR_data(); + public ODBDSDIR_data data6 = new ODBDSDIR_data(); + public ODBDSDIR_data data7 = new ODBDSDIR_data(); + public ODBDSDIR_data data8 = new ODBDSDIR_data(); + public ODBDSDIR_data data9 = new ODBDSDIR_data(); + public ODBDSDIR_data data10= new ODBDSDIR_data(); + public ODBDSDIR_data data11= new ODBDSDIR_data(); + public ODBDSDIR_data data12= new ODBDSDIR_data(); + public ODBDSDIR_data data13= new ODBDSDIR_data(); + public ODBDSDIR_data data14= new ODBDSDIR_data(); + public ODBDSDIR_data data15= new ODBDSDIR_data(); + public ODBDSDIR_data data16= new ODBDSDIR_data(); + public ODBDSDIR_data data17= new ODBDSDIR_data(); + public ODBDSDIR_data data18= new ODBDSDIR_data(); + public ODBDSDIR_data data19= new ODBDSDIR_data(); + public ODBDSDIR_data data20= new ODBDSDIR_data(); + public ODBDSDIR_data data21= new ODBDSDIR_data(); + public ODBDSDIR_data data22= new ODBDSDIR_data(); + public ODBDSDIR_data data23= new ODBDSDIR_data(); + public ODBDSDIR_data data24= new ODBDSDIR_data(); + public ODBDSDIR_data data25= new ODBDSDIR_data(); + public ODBDSDIR_data data26= new ODBDSDIR_data(); + public ODBDSDIR_data data27= new ODBDSDIR_data(); + public ODBDSDIR_data data28= new ODBDSDIR_data(); + public ODBDSDIR_data data29= new ODBDSDIR_data(); + public ODBDSDIR_data data30= new ODBDSDIR_data(); + public ODBDSDIR_data data31= new ODBDSDIR_data(); + public ODBDSDIR_data data32= new ODBDSDIR_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDSDIR + { + public int file_num ; + public int remainder ; + public short data_num ; + public ODBDSDIR1 data = new ODBDSDIR1(); + } + + /* cnc_dtsvrdset:read setting data for Data Server */ + /* cnc_dtsvwrset:write setting data for Data Server */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBDSSET + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string host_ip= new string(' ',16) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string host_uname= new string(' ',32) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string host_passwd= new string(' ',32) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] + public string host_dir= new string(' ',128) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=13)] + public string dtsv_mac= new string(' ',13) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string dtsv_ip= new string(' ',16) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string dtsv_mask= new string(' ',16) ; + } + + /* cnc_dtsvmntinfo:read maintenance information for Data Server */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDSMNT + { + public int empty_cnt ; + public int total_size ; + public int read_ptr ; + public int write_ptr ; + } + + /* cnc_rdposerrs2:read the position deviation S1 and S2 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPSER + { + public int poserr1 ; + public int poserr2 ; + } + + /* cnc_rdctrldi:read the control input signal */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPDI_data + { + public byte sgnl1 ; + public byte sgnl2 ; + public byte sgnl3 ; + public byte sgnl4 ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPDI + { + public ODBSPDI_data di1 = new ODBSPDI_data(); + public ODBSPDI_data di2 = new ODBSPDI_data(); + public ODBSPDI_data di3 = new ODBSPDI_data(); + public ODBSPDI_data di4 = new ODBSPDI_data(); + } + + /* cnc_rdctrldo:read the control output signal */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPDO_data + { + public byte sgnl1 ; + public byte sgnl2 ; + public byte sgnl3 ; + public byte sgnl4 ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPDO + { + public ODBSPDO_data do1 = new ODBSPDO_data(); + public ODBSPDO_data do2 = new ODBSPDO_data(); + public ODBSPDO_data do3 = new ODBSPDO_data(); + public ODBSPDO_data do4 = new ODBSPDO_data(); + } + + /* cnc_rdwaveprm:read the parameter of wave diagnosis */ + /* cnc_wrwaveprm:write the parameter of wave diagnosis */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWAVE_io + { + public byte adr ; + public byte bit ; + public short no ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWAVE_axis + { + public short axis ; + } + [StructLayout(LayoutKind.Explicit)] + public class IODBWAVE_u + { + [ FieldOffset( 0 )] + public IODBWAVE_io io = new IODBWAVE_io(); + [ FieldOffset( 0 )] + public IODBWAVE_axis axis = new IODBWAVE_axis(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWAVE_ch_data + { + public short kind ; + public IODBWAVE_u u = new IODBWAVE_u(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWAVE_ch + { + public IODBWAVE_ch_data ch1 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch2 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch3 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch4 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch5 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch6 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch7 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch8 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch9 = new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch10= new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch11= new IODBWAVE_ch_data(); + public IODBWAVE_ch_data ch12= new IODBWAVE_ch_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWAVE + { + public short condition ; + public char trg_adr ; + public byte trg_bit ; + public short trg_no ; + public short delay ; + public short t_range ; + public IODBWAVE_ch ch = new IODBWAVE_ch(); + } + + /* cnc_rdwaveprm2:read the parameter of wave diagnosis 2 */ + /* cnc_wrwaveprm2:write the parameter of wave diagnosis 2 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWVPRM_io + { + public byte adr ; + public byte bit ; + public short no ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWVPRM_axis + { + public short axis ; + } + [StructLayout(LayoutKind.Explicit)] + public class IODBWVPRM_u + { + [ FieldOffset( 0 )] + public IODBWVPRM_io io = new IODBWVPRM_io(); + [ FieldOffset( 0 )] + public IODBWVPRM_axis axis = new IODBWVPRM_axis(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWVPRM_ch_data + { + public short kind ; + public IODBWVPRM_u u = new IODBWVPRM_u(); + public int reserve2 ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWVPRM_ch + { + public IODBWVPRM_ch_data ch1 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch2 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch3 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch4 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch5 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch6 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch7 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch8 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch9 = new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch10= new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch11= new IODBWVPRM_ch_data(); + public IODBWVPRM_ch_data ch12= new IODBWVPRM_ch_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWVPRM + { + public short condition ; + public byte trg_adr ; + public byte trg_bit ; + public short trg_no ; + public short reserve1 ; + public int delay ; + public int t_range ; + public IODBWVPRM_ch ch = new IODBWVPRM_ch(); + } + + /* cnc_rdwavedata:read the data of wave diagnosis */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBWVDT_io + { + public byte adr ; + public byte bit ; + public short no ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBWVDT_axis + { + public short axis ; + } + [StructLayout(LayoutKind.Explicit)] + public class ODBWVDT_u + { + [ FieldOffset( 0 )] + public ODBWVDT_io io = new ODBWVDT_io(); + [ FieldOffset( 0 )] + public ODBWVDT_axis axis = new ODBWVDT_axis(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBWVDT + { + public short channel ; + public short kind ; + public ODBWVDT_u u = new ODBWVDT_u(); + public byte year ; + public byte month ; + public byte day ; + public byte hour ; + public byte minute ; + public byte second ; + public short t_cycle ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8192)] + public short[] data ; + } + + /* cnc_rdrmtwaveprm:read the parameter of wave diagnosis for remort diagnosis */ + /* cnc_wrrmtwaveprm:write the parameter of wave diagnosis for remort diagnosis */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBRMTPRM_alm + { + public short no ; + public sbyte axis ; + public byte type ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBRMTPRM_io + { + public char adr ; + public byte bit ; + public short no ; + } + [StructLayout(LayoutKind.Explicit)] + public class IODBRMTPRM_trg + { + [ FieldOffset( 0 )] + public IODBRMTPRM_alm alm = new IODBRMTPRM_alm(); + [ FieldOffset( 0 )] + public IODBRMTPRM_io io = new IODBRMTPRM_io(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBRMTPRM_smpl + { + public char adr ; + public byte bit ; + public short no ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBRMTPRM1 + { + public IODBRMTPRM_smpl ampl1 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl2 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl3 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl4 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl5 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl6 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl7 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl8 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl9 = new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl10= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl11= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl12= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl13= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl14= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl15= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl16= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl17= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl18= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl19= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl20= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl21= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl22= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl23= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl24= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl25= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl26= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl27= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl28= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl29= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl30= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl31= new IODBRMTPRM_smpl(); + public IODBRMTPRM_smpl ampl32= new IODBRMTPRM_smpl(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBRMTPRM + { + public short condition ; + public short reserve ; + public IODBRMTPRM_trg trg = new IODBRMTPRM_trg(); + public int delay ; + public short wv_intrvl ; + public short io_intrvl ; + public short kind1 ; + public short kind2 ; + public IODBRMTPRM1 ampl= new IODBRMTPRM1(); + } + + /* cnc_rdrmtwavedt:read the data of wave diagnosis for remort diagnosis */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBRMTDT + { + public short channel ; + public short kind ; + public byte year ; + public byte month ; + public byte day ; + public byte hour ; + public byte minute ; + public byte second ; + public short t_intrvl ; + public short trg_data; + public int ins_ptr; + public short t_delta; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=1917)] + public short[] data; + } + + /* cnc_rdsavsigadr:read of address for PMC signal batch save */ + /* cnc_wrsavsigadr:write of address for PMC signal batch save */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSIGAD + { + public byte adr ; + public byte reserve ; + public short no ; + public short size ; + } + + /* cnc_rdmgrpdata:read M-code group data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBMGRP_data + { + public int m_code ; + public short grp_no ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=21)] + public string m_name= new string(' ',21) ; + public byte dummy ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMGRP + { + public ODBMGRP_data mgrp1 = new ODBMGRP_data(); + public ODBMGRP_data mgrp2 = new ODBMGRP_data(); + public ODBMGRP_data mgrp3 = new ODBMGRP_data(); + public ODBMGRP_data mgrp4 = new ODBMGRP_data(); + public ODBMGRP_data mgrp5 = new ODBMGRP_data(); + public ODBMGRP_data mgrp6 = new ODBMGRP_data(); + public ODBMGRP_data mgrp7 = new ODBMGRP_data(); + public ODBMGRP_data mgrp8 = new ODBMGRP_data(); + public ODBMGRP_data mgrp9 = new ODBMGRP_data(); + public ODBMGRP_data mgrp10= new ODBMGRP_data(); + } + + /* cnc_wrmgrpdata:write M-code group data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBMGRP + { + public short s_no ; + public short dummy ; + public short num ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=500)] + public short[] group = new short[500]; + } + + /* cnc_rdexecmcode:read executing M-code group data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBEXEM_data + { + public int no; + public short flag; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBEXEM1 + { + public ODBEXEM_data m_code1 = new ODBEXEM_data(); + public ODBEXEM_data m_code2 = new ODBEXEM_data(); + public ODBEXEM_data m_code3 = new ODBEXEM_data(); + public ODBEXEM_data m_code4 = new ODBEXEM_data(); + public ODBEXEM_data m_code5 = new ODBEXEM_data(); + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBEXEM + { + public short grp_no; + public short mem_no; + public ODBEXEM1 m_code = new ODBEXEM1(); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=21)] + public string m_name= new string(' ',21) ; + public byte dummy; + } + + /* cnc_rdrstrmcode:read program restart M-code group data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class M_CODE_data + { + public int no; + public short flag; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class M_CODE1 + { + public M_CODE_data m_code1 = new M_CODE_data(); + public M_CODE_data m_code2 = new M_CODE_data(); + public M_CODE_data m_code3 = new M_CODE_data(); + public M_CODE_data m_code4 = new M_CODE_data(); + public M_CODE_data m_code5 = new M_CODE_data(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBRSTRM + { + public short grp_no; + public short mem_no; + public M_CODE1 m_code = new M_CODE1(); + } + + /* cnc_rdproctime:read processing time stamp data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPTIME_data + { + public int prg_no; + public short hour; + public byte minute; + public byte second; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPTIME1 + { + public ODBPTIME_data data1 = new ODBPTIME_data(); + public ODBPTIME_data data2 = new ODBPTIME_data(); + public ODBPTIME_data data3 = new ODBPTIME_data(); + public ODBPTIME_data data4 = new ODBPTIME_data(); + public ODBPTIME_data data5 = new ODBPTIME_data(); + public ODBPTIME_data data6 = new ODBPTIME_data(); + public ODBPTIME_data data7 = new ODBPTIME_data(); + public ODBPTIME_data data8 = new ODBPTIME_data(); + public ODBPTIME_data data9 = new ODBPTIME_data(); + public ODBPTIME_data data10= new ODBPTIME_data(); + } /* In case that the number of data is 10 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPTIME + { + public short num; + public ODBPTIME1 data = new ODBPTIME1(); + } + + /* cnc_rdprgdirtime:read program directory for processing time data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIRTM_data + { + public int prg_no; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=51)] + public string comment= new string(' ',51) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=13)] + public string cuttime= new string(' ',13) ; + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIRTM + { + public PRGDIRTM_data data1 = new PRGDIRTM_data(); + public PRGDIRTM_data data2 = new PRGDIRTM_data(); + public PRGDIRTM_data data3 = new PRGDIRTM_data(); + public PRGDIRTM_data data4 = new PRGDIRTM_data(); + public PRGDIRTM_data data5 = new PRGDIRTM_data(); + public PRGDIRTM_data data6 = new PRGDIRTM_data(); + public PRGDIRTM_data data7 = new PRGDIRTM_data(); + public PRGDIRTM_data data8 = new PRGDIRTM_data(); + public PRGDIRTM_data data9 = new PRGDIRTM_data(); + public PRGDIRTM_data data10= new PRGDIRTM_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdprogdir2:read program directory 2 */ +#if (!ONO8D) + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR2_data + { + public short number ; + public int length ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=51)] + public string comment= new string(' ',51) ; + public byte dummy ; + } +#else + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR2_data + { + public int number ; + public int length ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=51)] + public string comment= new string(' ',51) ; + public byte dummy ; + } +#endif + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR2 + { + public PRGDIR2_data dir1 = new PRGDIR2_data(); + public PRGDIR2_data dir2 = new PRGDIR2_data(); + public PRGDIR2_data dir3 = new PRGDIR2_data(); + public PRGDIR2_data dir4 = new PRGDIR2_data(); + public PRGDIR2_data dir5 = new PRGDIR2_data(); + public PRGDIR2_data dir6 = new PRGDIR2_data(); + public PRGDIR2_data dir7 = new PRGDIR2_data(); + public PRGDIR2_data dir8 = new PRGDIR2_data(); + public PRGDIR2_data dir9 = new PRGDIR2_data(); + public PRGDIR2_data dir10= new PRGDIR2_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdprogdir3:read program directory 3 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class DIR3_MDATE + { + public short year; + public short month; + public short day; + public short hour; + public short minute; + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class DIR3_CDATE + { + public short year; + public short month; + public short day; + public short hour; + public short minute; + public short dummy; + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR3_data + { + public int number ; + public int length ; + public int page ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=52)] + public string comment= new string(' ',52) ; + public DIR3_MDATE mdate = new DIR3_MDATE(); + public DIR3_CDATE cdate = new DIR3_CDATE(); + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR3 + { + public PRGDIR3_data dir1 = new PRGDIR3_data(); + public PRGDIR3_data dir2 = new PRGDIR3_data(); + public PRGDIR3_data dir3 = new PRGDIR3_data(); + public PRGDIR3_data dir4 = new PRGDIR3_data(); + public PRGDIR3_data dir5 = new PRGDIR3_data(); + public PRGDIR3_data dir6 = new PRGDIR3_data(); + public PRGDIR3_data dir7 = new PRGDIR3_data(); + public PRGDIR3_data dir8 = new PRGDIR3_data(); + public PRGDIR3_data dir9 = new PRGDIR3_data(); + public PRGDIR3_data dir10= new PRGDIR3_data(); + } /* In case that the number of data is 10 */ + + + /* cnc_rdprogdir4:read program directory 4 */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class DIR4_MDATE + { + public short year; + public short month; + public short day; + public short hour; + public short minute; + public short dummy; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class DIR4_CDATE + { + public short year; + public short month; + public short day; + public short hour; + public short minute; + public short dummy; + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR4_data + { + public int number ; + public int length ; + public int page ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=52)] + public string comment= new string(' ',52) ; + public DIR4_MDATE mdate = new DIR4_MDATE(); + public DIR4_CDATE cdate = new DIR4_CDATE(); + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class PRGDIR4 + { + public PRGDIR4_data dir1 = new PRGDIR4_data(); + public PRGDIR4_data dir2 = new PRGDIR4_data(); + public PRGDIR4_data dir3 = new PRGDIR4_data(); + public PRGDIR4_data dir4 = new PRGDIR4_data(); + public PRGDIR4_data dir5 = new PRGDIR4_data(); + public PRGDIR4_data dir6 = new PRGDIR4_data(); + public PRGDIR4_data dir7 = new PRGDIR4_data(); + public PRGDIR4_data dir8 = new PRGDIR4_data(); + public PRGDIR4_data dir9 = new PRGDIR4_data(); + public PRGDIR4_data dir10= new PRGDIR4_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdcomparam:read communication parameter for DNC1, DNC2, OSI-Ethernet */ + /* cnc_wrcomparam:write communication parameter for DNC1, DNC2, OSI-Ethernet */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBCPRM + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=65)] + public string NcApli= new string(' ',65) ; + public byte Dummy1 ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=65)] + public string HostApli= new string(' ',65) ; + public byte Dummy2 ; + public uint StatPstv ; + public uint StatNgtv ; + public uint Statmask ; + public uint AlarmStat ; + public uint PsclHaddr ; + public uint PsclLaddr ; + public ushort SvcMode1 ; + public ushort SvcMode2 ; + public int FileTout ; + public int RemTout ; + } + + /* cnc_rdintchk:read interference check */ + /* cnc_wrintchk:write interference check */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBINT + { + public short datano_s; /* start offset No. */ + public short type; /* kind of position */ + public short datano_e; /* end offset No. */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8*3)] + public int[] data = new int[8*3]; /* position value of area for not attach */ + } + + /* cnc_rdwkcdshft:read work coordinate shift */ + /* cnc_wrwkcdshft:write work coordinate shift */ + /* cnc_rdwkcdsfms:read work coordinate shift measure */ + /* cnc_wrwkcdsfms:write work coordinate shift measure */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBWCSF + { + public short datano; /* datano */ + public short type; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] data = new int[MAX_AXIS]; /* data */ + } + + /* cnc_rdomhisinfo:read operator message history information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOMIF + { + public ushort om_max ; /* maximum operator message history */ + public ushort om_sum ; /* actually operator message history */ + public ushort om_char ; /* maximum character (include NULL) */ + } + + /* cnc_rdomhistry:read operator message history */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBOMHIS_data + { + public short om_no; /* operator message number */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* mimute */ + public short second; /* second */ + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=256)] + public string om_msg= new string(' ',256) ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBOMHIS + { + public ODBOMHIS_data omhis1 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis2 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis3 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis4 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis5 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis6 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis7 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis8 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis9 = new ODBOMHIS_data(); + public ODBOMHIS_data omhis10= new ODBOMHIS_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdbtofsr:read b-axis tool offset value(area specified) */ + /* cnc_wrbtofsr:write b-axis tool offset value(area specified) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBBTO + { + public short datano_s; /* start offset number */ + public short type; /* offset type */ + public short datano_e; /* end offset number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=18)] + public int[] ofs = new int [18]; /* offset */ + } /* In case that the number of data is 9 (B type) */ + + /* cnc_rdbtofsinfo:read b-axis tool offset information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBBTLINF + { + public short ofs_type; /* memory type */ + public short use_no; /* sum of b-axis offset */ + public short sub_no; /* sub function number of offset cancel */ + } + + /* cnc_rdbaxis:read b-axis command */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBBAXIS + { + public short flag ; /* b-axis command exist or not */ + public short command ; /* b-axis command */ + public ushort speed ; /* b-axis speed */ + public int sub_data ; /* b-axis sub data */ + } + + /* cnc_rdsyssoft:read CNC system soft series and version */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBSYSS + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] slot_no_p; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] slot_no_l; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] module_id; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] soft_id; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series1 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series2 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series3 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series4 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series5 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series6 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series7 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series8 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series9 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series10= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series11= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series12= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series13= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series14= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series15= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series16= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version1 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version2 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version3 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version4 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version5 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version6 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version7 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version8 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version9 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version10= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version11= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version12= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version13= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version14= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version15= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version16= new string(' ',5) ; + public short soft_inst; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string boot_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string boot_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string servo_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string servo_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string ladder_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string ladder_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrlib_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrlib_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrapl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrapl_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl1_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl1_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl2_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl2_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl3_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl3_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exelib_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exelib_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exeapl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exeapl_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string int_vga_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string int_vga_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string out_vga_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string out_vga_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmm_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmm_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_mng_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_mng_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shin_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shin_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shout_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shout_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_c_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_c_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_edit_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_edit_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_mng_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_mng_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_apl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_apl_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl4_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl4_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr2_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr2_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr3_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr3_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string eth_boot_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string eth_boot_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8*5)] + public byte[] reserve; + } + + /* cnc_rdsyssoft2:read CNC system soft series and version (2) */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBSYSS2 + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] slot_no_p; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public byte[] slot_no_l; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] module_id; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] soft_id; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series1 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series2 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series3 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series4 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series5 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series6 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series7 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series8 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series9 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series10= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series11= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series12= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series13= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series14= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series15= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_series16= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version1 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version2 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version3 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version4 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version5 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version6 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version7 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version8 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version9 = new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version10= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version11= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version12= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version13= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version14= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version15= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string soft_version16= new string(' ',5) ; + public short soft_inst; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string boot_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string boot_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string servo_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string servo_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string ladder_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string ladder_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrlib_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrlib_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrapl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcrapl_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl1_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl1_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl2_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl2_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl3_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl3_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exelib_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exelib_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exeapl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string c_exeapl_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string int_vga_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string int_vga_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string out_vga_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string out_vga_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmm_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmm_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_mng_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_mng_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shin_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shin_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shout_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_shout_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_c_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_c_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_edit_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string pmc_edit_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_mng_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_mng_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_apl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string lddr_apl_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl4_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string spl4_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr2_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr2_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr3_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string mcr3_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string eth_boot_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string eth_boot_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8*5)] + public byte[] reserve; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string embEthe_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string embEthe_ver= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=38*5)] + public byte[] reserve2; + } + + /* cnc_rdsyssoft3:read CNC system soft series and version (3) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSS3_data + { + public short soft_id; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public char[] soft_series; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public char[] soft_edition; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSS3 + { + public ODBSYSS3_data p1 =new ODBSYSS3_data(); + public ODBSYSS3_data p2 =new ODBSYSS3_data(); + public ODBSYSS3_data p3 =new ODBSYSS3_data(); + public ODBSYSS3_data p4 =new ODBSYSS3_data(); + public ODBSYSS3_data p5 =new ODBSYSS3_data(); + public ODBSYSS3_data p6 =new ODBSYSS3_data(); + public ODBSYSS3_data p7 =new ODBSYSS3_data(); + public ODBSYSS3_data p8 =new ODBSYSS3_data(); + public ODBSYSS3_data p9 =new ODBSYSS3_data(); + public ODBSYSS3_data p10 =new ODBSYSS3_data(); + public ODBSYSS3_data p11 =new ODBSYSS3_data(); + public ODBSYSS3_data p12 =new ODBSYSS3_data(); + public ODBSYSS3_data p13 =new ODBSYSS3_data(); + public ODBSYSS3_data p14 =new ODBSYSS3_data(); + public ODBSYSS3_data p15 =new ODBSYSS3_data(); + public ODBSYSS3_data p16 =new ODBSYSS3_data(); + public ODBSYSS3_data p17 =new ODBSYSS3_data(); + public ODBSYSS3_data p18 =new ODBSYSS3_data(); + public ODBSYSS3_data p19 =new ODBSYSS3_data(); + public ODBSYSS3_data p20 =new ODBSYSS3_data(); + public ODBSYSS3_data p21 =new ODBSYSS3_data(); + public ODBSYSS3_data p22 =new ODBSYSS3_data(); + public ODBSYSS3_data p23 =new ODBSYSS3_data(); + public ODBSYSS3_data p24 =new ODBSYSS3_data(); + public ODBSYSS3_data p25 =new ODBSYSS3_data(); + public ODBSYSS3_data p26 =new ODBSYSS3_data(); + public ODBSYSS3_data p27 =new ODBSYSS3_data(); + public ODBSYSS3_data p28 =new ODBSYSS3_data(); + public ODBSYSS3_data p29 =new ODBSYSS3_data(); + public ODBSYSS3_data p30 =new ODBSYSS3_data(); + public ODBSYSS3_data p31 =new ODBSYSS3_data(); + public ODBSYSS3_data p32 =new ODBSYSS3_data(); + public ODBSYSS3_data p33 =new ODBSYSS3_data(); + public ODBSYSS3_data p34 =new ODBSYSS3_data(); + public ODBSYSS3_data p35 =new ODBSYSS3_data(); + public ODBSYSS3_data p36 =new ODBSYSS3_data(); + public ODBSYSS3_data p37 =new ODBSYSS3_data(); + public ODBSYSS3_data p38 =new ODBSYSS3_data(); + public ODBSYSS3_data p39 =new ODBSYSS3_data(); + public ODBSYSS3_data p40 =new ODBSYSS3_data(); + } + + /* cnc_rdsyshard:read CNC system hard info */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSH_data + { + public uint id1 ; + public uint id2 ; + public short group_id ; + public short hard_id ; + public short hard_num ; + public short slot_no ; + public short id1_format ; + public short id2_format ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSH + { + public ODBSYSH_data data1 = new ODBSYSH_data(); + public ODBSYSH_data data2 = new ODBSYSH_data(); + public ODBSYSH_data data3 = new ODBSYSH_data(); + public ODBSYSH_data data4 = new ODBSYSH_data(); + public ODBSYSH_data data5 = new ODBSYSH_data(); + public ODBSYSH_data data6 = new ODBSYSH_data(); + public ODBSYSH_data data7 = new ODBSYSH_data(); + public ODBSYSH_data data8 = new ODBSYSH_data(); + public ODBSYSH_data data9 = new ODBSYSH_data(); + public ODBSYSH_data data10 = new ODBSYSH_data(); + public ODBSYSH_data data11 = new ODBSYSH_data(); + public ODBSYSH_data data12 = new ODBSYSH_data(); + public ODBSYSH_data data13 = new ODBSYSH_data(); + public ODBSYSH_data data14 = new ODBSYSH_data(); + public ODBSYSH_data data15 = new ODBSYSH_data(); + public ODBSYSH_data data16 = new ODBSYSH_data(); + public ODBSYSH_data data17 = new ODBSYSH_data(); + public ODBSYSH_data data18 = new ODBSYSH_data(); + public ODBSYSH_data data19 = new ODBSYSH_data(); + public ODBSYSH_data data20 = new ODBSYSH_data(); + public ODBSYSH_data data21 = new ODBSYSH_data(); + public ODBSYSH_data data22 = new ODBSYSH_data(); + public ODBSYSH_data data23 = new ODBSYSH_data(); + public ODBSYSH_data data24 = new ODBSYSH_data(); + public ODBSYSH_data data25 = new ODBSYSH_data(); + } + + /* cnc_rdmdlconfig:read CNC module configuration information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMDLC + { + public short from; + public short dram; + public short sram; + public short pmc; + public short crtc; + public short servo12; + public short servo34; + public short servo56; + public short servo78; + public short sic; + public short pos_lsi; + public short hi_aio; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=12)] + public short[] reserve; + public short drmmrc; + public short drmarc; + public short pmcmrc; + public short dmaarc; + public short iopt; + public short hdiio; + public short gm2gr1; + public short crtgr2; + public short gm1gr2; + public short gm2gr2; + public short cmmrb; + public short sv5axs; + public short sv7axs; + public short sicaxs; + public short posaxs; + public short hamaxs; + public short romr64; + public short srmr64; + public short dr1r64; + public short dr2r64; + public short iopio2; + public short hdiio2; + public short cmmrb2; + public short romfap; + public short srmfap; + public short drmfap; + public short drmare; + public short pmcmre; + public short dmaare; + public short frmbgg; + public short drmbgg; + public short asrbgg; + public short edtpsc; + public short slcpsc; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=34)] + public short[] reserve2; + } + + /* cnc_rdpscdproc:read processing condition file (processing data) */ + /* cnc_wrpscdproc:write processing condition file (processing data) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSCD_data + { + public short slct; + public int feed; + public short power; + public short freq; + public short duty; + public short g_press; + public short g_kind; + public short g_ready_t; + public short displace; + public int supple; + public short edge_slt; + public short appr_slt; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] reserve = new short[5]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPSCD + { + public IODBPSCD_data data1 = new IODBPSCD_data(); + public IODBPSCD_data data2 = new IODBPSCD_data(); + public IODBPSCD_data data3 = new IODBPSCD_data(); + public IODBPSCD_data data4 = new IODBPSCD_data(); + public IODBPSCD_data data5 = new IODBPSCD_data(); + public IODBPSCD_data data6 = new IODBPSCD_data(); + public IODBPSCD_data data7 = new IODBPSCD_data(); + public IODBPSCD_data data8 = new IODBPSCD_data(); + public IODBPSCD_data data9 = new IODBPSCD_data(); + public IODBPSCD_data data10= new IODBPSCD_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdpscdpirc:read processing condition file (piercing data) */ + /* cnc_wrpscdpirc:write processing condition file (piercing data) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPIRC_data + { + public short slct; + public short power; + public short freq; + public short duty; + public short i_freq; + public short i_duty; + public short step_t; + public short step_sum; + public int pier_t; + public short g_press; + public short g_kind; + public short g_time; + public short def_pos; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public short[] reserve = new short[4]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPIRC + { + public IODBPIRC_data data1 = new IODBPIRC_data(); + public IODBPIRC_data data2 = new IODBPIRC_data(); + public IODBPIRC_data data3 = new IODBPIRC_data(); + } + + /* cnc_rdpscdedge:read processing condition file (edging data) */ + /* cnc_wrpscdedge:write processing condition file (edging data) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBEDGE_data + { + public short slct; + public short angle; + public short power; + public short freq; + public short duty; + public int pier_t; + public short g_press; + public short g_kind; + public int r_len; + public short r_feed; + public short r_freq; + public short r_duty; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] reserve = new short[5]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBEDGE + { + public IODBEDGE_data data1 = new IODBEDGE_data(); + public IODBEDGE_data data2 = new IODBEDGE_data(); + public IODBEDGE_data data3 = new IODBEDGE_data(); + public IODBEDGE_data data4 = new IODBEDGE_data(); + public IODBEDGE_data data5 = new IODBEDGE_data(); + } + + /* cnc_rdpscdslop:read processing condition file (slope data) */ + /* cnc_wrpscdslop:write processing condition file (slope data) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLOP_data + { + public int slct; + public int upleng; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public short[] upsp = new short[10]; + public int dwleng; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public short[] dwsp = new short[10]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=10)] + public short[] reserve = new short[10]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLOP + { + public IODBSLOP_data data1 = new IODBSLOP_data(); + public IODBSLOP_data data2 = new IODBSLOP_data(); + public IODBSLOP_data data3 = new IODBSLOP_data(); + public IODBSLOP_data data4 = new IODBSLOP_data(); + public IODBSLOP_data data5 = new IODBSLOP_data(); + } + + /* cnc_rdlpwrdty:read power controll duty data */ + /* cnc_wrlpwrdty:write power controll duty data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBLPWDT + { + public short slct; + public short dty_const; + public short dty_min; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public short[] reserve = new short[6]; + } + + /* cnc_rdlpwrdat:read laser power data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBLOPDT + { + public short slct; + public short pwr_mon; + public short pwr_ofs; + public short pwr_act; + public int feed_act; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public short[] reserve; + } + + /* cnc_rdlagslt:read laser assist gas selection */ + /* cnc_wrlagslt:write laser assist gas selection */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBLAGSL + { + public short slct; + public short ag_slt; + public short agflow_slt; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public short[] reserve = new short[6]; + } + + /* cnc_rdlagst:read laser assist gas flow */ + /* cnc_wrlagst:write laser assist gas flow */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class GASFLOW + { + public short slct; + public short pre_time; + public short pre_press; + public short proc_press; + public short end_time; + public short end_press; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public short[] reserve = new short[3]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBLAGST + { + public GASFLOW data1 = new GASFLOW(); + public GASFLOW data2 = new GASFLOW(); + public GASFLOW data3 = new GASFLOW(); + } + + /* cnc_rdledgprc:read laser power for edge processing */ + /* cnc_wrledgprc:write laser power for edge processing */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBLEGPR + { + public short slct; + public short power; + public short freq; + public short duty; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] reserve = new short[5]; + } + + /* cnc_rdlprcprc:read laser power for piercing */ + /* cnc_wrlprcprc:write laser power for piercing */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBLPCPR + { + public short slct; + public short power; + public short freq; + public short duty; + public int time; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public short[] reserve = new short[4]; + } + + /* cnc_rdlcmddat:read laser command data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBLCMDT + { + public short slct; + public int feed; + public short power; + public short freq; + public short duty; + public short g_kind; + public short g_ready_t; + public short g_press; + public short error; + public int dsplc; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=7)] + public short[] reserve = new short[7]; + } + + /* cnc_rdlactnum:read active number */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBLACTN + { + public short slct; + public short act_proc; + public short act_pirce; + public short act_slop; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] reserve = new short[5]; + } + + /* cnc_rdlcmmt:read laser comment */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBLCMMT + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=25)] + public string comment= new string(' ',25) ; + } + + /* cnc_rdpwofsthis:read power correction factor history data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPWOFST_data + { + public int pwratio; + public int rfvolt; + public ushort year; + public ushort month; + public ushort day; + public ushort hour; + public ushort minute; + public ushort second; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPWOFST + { + public ODBPWOFST_data data1 = new ODBPWOFST_data(); + public ODBPWOFST_data data2 = new ODBPWOFST_data(); + public ODBPWOFST_data data3 = new ODBPWOFST_data(); + public ODBPWOFST_data data4 = new ODBPWOFST_data(); + public ODBPWOFST_data data5 = new ODBPWOFST_data(); + public ODBPWOFST_data data6 = new ODBPWOFST_data(); + public ODBPWOFST_data data7 = new ODBPWOFST_data(); + public ODBPWOFST_data data8 = new ODBPWOFST_data(); + public ODBPWOFST_data data9 = new ODBPWOFST_data(); + public ODBPWOFST_data data10= new ODBPWOFST_data(); + public ODBPWOFST_data data11= new ODBPWOFST_data(); + public ODBPWOFST_data data12= new ODBPWOFST_data(); + public ODBPWOFST_data data13= new ODBPWOFST_data(); + public ODBPWOFST_data data14= new ODBPWOFST_data(); + public ODBPWOFST_data data15= new ODBPWOFST_data(); + public ODBPWOFST_data data16= new ODBPWOFST_data(); + public ODBPWOFST_data data17= new ODBPWOFST_data(); + public ODBPWOFST_data data18= new ODBPWOFST_data(); + public ODBPWOFST_data data19= new ODBPWOFST_data(); + public ODBPWOFST_data data20= new ODBPWOFST_data(); + public ODBPWOFST_data data21= new ODBPWOFST_data(); + public ODBPWOFST_data data22= new ODBPWOFST_data(); + public ODBPWOFST_data data23= new ODBPWOFST_data(); + public ODBPWOFST_data data24= new ODBPWOFST_data(); + public ODBPWOFST_data data25= new ODBPWOFST_data(); + public ODBPWOFST_data data26= new ODBPWOFST_data(); + public ODBPWOFST_data data27= new ODBPWOFST_data(); + public ODBPWOFST_data data28= new ODBPWOFST_data(); + public ODBPWOFST_data data29= new ODBPWOFST_data(); + public ODBPWOFST_data data30= new ODBPWOFST_data(); + } + + /* cnc_rdmngtime:read management time */ + /* cnc_wrmngtime:write management time */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMNGTIME_data + { + public uint life; + public uint total; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMNGTIME + { + public IODBMNGTIME_data data1 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data2 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data3 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data4 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data5 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data6 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data7 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data8 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data9 = new IODBMNGTIME_data(); + public IODBMNGTIME_data data10= new IODBMNGTIME_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rddischarge:read data related to electrical discharge at power correction ends */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDISCHRG + { + public ushort aps; + public ushort year; + public ushort month; + public ushort day; + public ushort hour; + public ushort minute; + public ushort second; + public short hpc; + public short hfq; + public short hdt; + public short hpa; + public int hce; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] rfi; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] rfv; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] dci; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] dcv; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] dcw; + } + + /* cnc_rddischrgalm:read alarm history data related to electrical discharg */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDISCHRGALM_data + { + public ushort year; + public ushort month; + public ushort day; + public ushort hour; + public ushort minute; + public ushort second; + public int almnum; + public uint psec; + public short hpc; + public short hfq; + public short hdt; + public short hpa; + public int hce; + public ushort asq; + public ushort psu; + public ushort aps; + public short dummy; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] rfi; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] rfv; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] dci; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] dcv; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] dcw; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public short[] almcd; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBDISCHRGALM + { + public ODBDISCHRGALM_data data1 = new ODBDISCHRGALM_data(); + public ODBDISCHRGALM_data data2 = new ODBDISCHRGALM_data(); + public ODBDISCHRGALM_data data3 = new ODBDISCHRGALM_data(); + public ODBDISCHRGALM_data data4 = new ODBDISCHRGALM_data(); + public ODBDISCHRGALM_data data5 = new ODBDISCHRGALM_data(); + } + + /* cnc_gettimer:get date and time from cnc */ + /* cnc_settimer:set date and time for cnc */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct TIMER_DATE + { + public short year; + public short month; + public short date; + } + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct TIMER_TIME + { + public short hour; + public short minute; + public short second; + } + [StructLayout(LayoutKind.Explicit)] + public class IODBTIMER + { + [FieldOffset(0)] + public short type; + [FieldOffset(2)] + public short dummy; + [FieldOffset(4)] + public TIMER_DATE date; + [FieldOffset(4)] + public TIMER_TIME time; + } + + /* cnc_rdtimer:read timer data from cnc */ + /* cnc_wrtimer:write timer data for cnc */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTIME + { + public int minute ; + public int msec ; + } + + /* cnc_rdtlctldata: read tool controll data */ + /* cnc_wrtlctldata: write tool controll data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLCTL + { + public short slct; + public short used_tool; + public short turret_indx; + public int zero_tl_no; + public int t_axis_move; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] total_punch = new int[2]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=11)] + public short[] reserve = new short[11]; + } + + /* cnc_rdtooldata: read tool data */ + /* cnc_wrtooldata: read tool data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLDT_data + { + public short slct; + public int tool_no; + public int x_axis_ofs; + public int y_axis_ofs; + public int turret_pos; + public int chg_tl_no; + public int punch_count; + public int tool_life; + public int m_tl_radius; + public int m_tl_angle; + public byte tl_shape; + public int tl_size_i; + public int tl_size_j; + public int tl_angle; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public int[] reserve = new int[3]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLDT + { + public IODBTLDT_data data1 = new IODBTLDT_data(); + public IODBTLDT_data data2 = new IODBTLDT_data(); + public IODBTLDT_data data3 = new IODBTLDT_data(); + public IODBTLDT_data data4 = new IODBTLDT_data(); + public IODBTLDT_data data5 = new IODBTLDT_data(); + public IODBTLDT_data data6 = new IODBTLDT_data(); + public IODBTLDT_data data7 = new IODBTLDT_data(); + public IODBTLDT_data data8 = new IODBTLDT_data(); + public IODBTLDT_data data9 = new IODBTLDT_data(); + public IODBTLDT_data data10= new IODBTLDT_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdmultitldt: read multi tool data */ + /* cnc_wrmultitldt: write multi tool data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMLTTL_data + { + public short slct; + public short m_tl_no; + public int m_tl_radius; + public int m_tl_angle; + public int x_axis_ofs; + public int y_axis_ofs; + public byte tl_shape; + public int tl_size_i; + public int tl_size_j; + public int tl_angle; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=7)] + public int[] reserve = new int[7]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMLTTL + { + public IODBMLTTL_data data1 = new IODBMLTTL_data(); + public IODBMLTTL_data data2 = new IODBMLTTL_data(); + public IODBMLTTL_data data3 = new IODBMLTTL_data(); + public IODBMLTTL_data data4 = new IODBMLTTL_data(); + public IODBMLTTL_data data5 = new IODBMLTTL_data(); + public IODBMLTTL_data data6 = new IODBMLTTL_data(); + public IODBMLTTL_data data7 = new IODBMLTTL_data(); + public IODBMLTTL_data data8 = new IODBMLTTL_data(); + public IODBMLTTL_data data9 = new IODBMLTTL_data(); + public IODBMLTTL_data data10= new IODBMLTTL_data(); + } /* In case that the number of data is 10 */ + + /* cnc_rdmtapdata: read multi tap data */ + /* cnc_wrmtapdata: write multi tap data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMTAP_data + { + public short slct; + public int tool_no; + public int x_axis_ofs; + public int y_axis_ofs; + public int punch_count; + public int tool_life; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=11)] + public int[] reserve = new int[11]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBMTAP + { + public IODBMTAP_data data1 = new IODBMTAP_data(); + public IODBMTAP_data data2 = new IODBMTAP_data(); + public IODBMTAP_data data3 = new IODBMTAP_data(); + public IODBMTAP_data data4 = new IODBMTAP_data(); + public IODBMTAP_data data5 = new IODBMTAP_data(); + public IODBMTAP_data data6 = new IODBMTAP_data(); + public IODBMTAP_data data7 = new IODBMTAP_data(); + public IODBMTAP_data data8 = new IODBMTAP_data(); + public IODBMTAP_data data9 = new IODBMTAP_data(); + public IODBMTAP_data data10= new IODBMTAP_data(); + } + + /* cnc_rdtoolinfo: read tool information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPTLINF + { + public short tld_max; + public short mlt_max; + public short reserve; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] tld_size; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] mlt_size; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=16)] + public short[] reserves; + } + + /* cnc_rdsafetyzone: read safetyzone data */ + /* cnc_wrsafetyzone: write safetyzone data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSAFE_data + { + public short slct; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public int[] data = new int[3]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSAFE + { + public IODBSAFE_data data1 = new IODBSAFE_data(); + public IODBSAFE_data data2 = new IODBSAFE_data(); + public IODBSAFE_data data3 = new IODBSAFE_data(); + public IODBSAFE_data data4 = new IODBSAFE_data(); + } /* In case that the number of data is 4 */ + + /* cnc_rdtoolzone: read toolzone data */ + /* cnc_wrtoolzone: write toolzone data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLZN_data + { + public short slct; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] data = new int[12]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBTLZN + { + public IODBTLZN_data data1 = new IODBTLZN_data(); + public IODBTLZN_data data2 = new IODBTLZN_data(); + public IODBTLZN_data data3 = new IODBTLZN_data(); + public IODBTLZN_data data4 = new IODBTLZN_data(); + public IODBTLZN_data data5 = new IODBTLZN_data(); + public IODBTLZN_data data6 = new IODBTLZN_data(); + public IODBTLZN_data data7 = new IODBTLZN_data(); + public IODBTLZN_data data8 = new IODBTLZN_data(); + public IODBTLZN_data data9 = new IODBTLZN_data(); + public IODBTLZN_data data10= new IODBTLZN_data(); + public IODBTLZN_data data11= new IODBTLZN_data(); + public IODBTLZN_data data12= new IODBTLZN_data(); + } /* In case that the number of data is 12 */ + + /* cnc_rdacttlzone: read active toolzone data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBACTTLZN + { + public short act_no; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] data; + } + + /* cnc_rdbrstrinfo:read block restart information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBBRS + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] dest; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] dist; + } /* In case that the number of axes is MAX_AXIS */ + + /* cnc_rdradofs:read tool radius offset for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBROFS + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] pln_axes; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] ofsvct; + } + + /* cnc_rdlenofs:read tool length offset for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBLOFS + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ofsvct; + } /* In case that the number of axes is MAX_AXIS */ + + /* cnc_rdfixcycle:read fixed cycle for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBFIX + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] pln_axes; + public short drl_axes; + public int i_pos; + public int r_pos; + public int z_pos; + public int cmd_cnt; + public int act_cnt; + public int cut; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] shift; + } + + /* cnc_rdcdrotate:read coordinate rotate for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBROT + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public short[] pln_axes; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] center; + public int angle; + } + + /* cnc_rd3dcdcnv:read 3D coordinate convert for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB3DCD + { + public short mode; + public short dno; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public short[] cd_axes; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2*3)] + public int[] center; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2*3)] + public int[] direct; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=2)] + public int[] angle; + } + + /* cnc_rdmirimage:read programable mirror image for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBMIR + { + public short mode; + public int mir_flag; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] mir_pos; + } /* In case that the number of axes is MAX_AXIS */ + + /* cnc_rdscaling:read scaling data for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSCL + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] center; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] magnif; + } /* In case that the number of axes is MAX_AXIS */ + + /* cnc_rd3dtofs:read 3D tool offset for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB3DTO + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public short[] ofs_axes; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public int[] ofsvct; + } + + /* cnc_rdposofs:read tool position offset for position data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPOFS + { + public short mode; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public int[] ofsvct; + } /* In case that the number of axes is MAX_AXIS */ + + /* cnc_rdhpccset:read hpcc setting data */ + /* cnc_wrhpccset:write hpcc setting data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBHPST + { + public short slct ; + public short hpcc ; + public short multi ; + public short ovr1 ; + public short ign_f ; + public short foward ; + public int max_f ; + public short ovr2 ; + public short ovr3 ; + public short ovr4 ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=7)] + public int[] reserve = new int[7]; + } + + /* cnc_rdhpcctupr:read hpcc tuning data ( parameter input ) */ + /* cnc_wrhpcctupr:write hpcc tuning data ( parameter input ) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBHPPR_tune + { + public short slct ; + public short diff ; + public short fine ; + public short acc_lv ; + public int max_f ; + public short bipl ; + public short aipl ; + public int corner ; + public short clamp ; + public int radius ; + public int max_cf ; + public int min_cf ; + public int foward ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] reserve = new int[5] ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBHPPR + { + public IODBHPPR_tune tune1 = new IODBHPPR_tune(); + public IODBHPPR_tune tune2 = new IODBHPPR_tune(); + public IODBHPPR_tune tune3 = new IODBHPPR_tune(); + } + + /* cnc_rdhpcctuac:read hpcc tuning data ( acc input ) */ + /* cnc_wrhpcctuac:write hpcc tuning data ( acc input ) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBHPAC_tune + { + public short slct ; + public short diff ; + public short fine ; + public short acc_lv ; + public int bipl ; + public short aipl ; + public int corner ; + public int clamp ; + public int c_acc ; + public int foward ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public int[] reserve = new int[8]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBHPAC + { + public IODBHPAC_tune tune1 = new IODBHPAC_tune(); + public IODBHPAC_tune tune2 = new IODBHPAC_tune(); + public IODBHPAC_tune tune3 = new IODBHPAC_tune(); + } + + /* cnc_rd3dtooltip:read tip of tool for 3D handle */ + /* cnc_rd3dmovrlap:read move overrlap of tool for 3D handle */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB3DHDL_data + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] axes ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] data ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB3DHDL + { + public ODB3DHDL_data data1 = new ODB3DHDL_data(); + public ODB3DHDL_data data2 = new ODB3DHDL_data(); + } + + /* cnc_rd3dpulse:read pulse for 3D handle */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB3DPLS_data + { + public int right_angle_x ; + public int right_angle_y ; + public int tool_axis ; + public int tool_tip_a_b ; + public int tool_tip_c ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODB3DPLS + { + public ODB3DPLS_data pls1 = new ODB3DPLS_data(); + public ODB3DPLS_data pls2 = new ODB3DPLS_data(); + } + + /* cnc_rdaxisname: read axis name */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXISNAME_data + { + public byte name; /* axis name */ + public byte suff; /* suffix */ + } +#if M_AXIS2 + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXISNAME + { + public ODBAXISNAME_data data1 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data2 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data3 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data4 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data5 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data6 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data7 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data8 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data9 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data10= new ODBAXISNAME_data(); + public ODBAXISNAME_data data11= new ODBAXISNAME_data(); + public ODBAXISNAME_data data12= new ODBAXISNAME_data(); + public ODBAXISNAME_data data13= new ODBAXISNAME_data(); + public ODBAXISNAME_data data14= new ODBAXISNAME_data(); + public ODBAXISNAME_data data15= new ODBAXISNAME_data(); + public ODBAXISNAME_data data16= new ODBAXISNAME_data(); + public ODBAXISNAME_data data17= new ODBAXISNAME_data(); + public ODBAXISNAME_data data18= new ODBAXISNAME_data(); + public ODBAXISNAME_data data19= new ODBAXISNAME_data(); + public ODBAXISNAME_data data20= new ODBAXISNAME_data(); + public ODBAXISNAME_data data21= new ODBAXISNAME_data(); + public ODBAXISNAME_data data22= new ODBAXISNAME_data(); + public ODBAXISNAME_data data23= new ODBAXISNAME_data(); + public ODBAXISNAME_data data24= new ODBAXISNAME_data(); + } +#elif FS15D + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXISNAME + { + public ODBAXISNAME_data data1 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data2 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data3 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data4 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data5 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data6 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data7 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data8 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data9 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data10= new ODBAXISNAME_data(); + } +#else + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBAXISNAME + { + public ODBAXISNAME_data data1 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data2 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data3 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data4 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data5 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data6 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data7 = new ODBAXISNAME_data(); + public ODBAXISNAME_data data8 = new ODBAXISNAME_data(); + } +#endif + + /* cnc_rdspdlname: read spindle name */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPDLNAME_data + { + public byte name; /* spindle name */ + public byte suff1; /* suffix */ + public byte suff2; /* suffix */ + public byte suff3; /* suffix */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSPDLNAME + { + public ODBSPDLNAME_data data1 = new ODBSPDLNAME_data(); + public ODBSPDLNAME_data data2 = new ODBSPDLNAME_data(); + public ODBSPDLNAME_data data3 = new ODBSPDLNAME_data(); + public ODBSPDLNAME_data data4 = new ODBSPDLNAME_data(); + } + + /* cnc_exaxisname: read extended axis name */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBEXAXISNAME + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname1 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname2 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname3 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname4 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname5 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname6 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname7 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname8 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname9 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname10 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname11 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname12 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname13 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname14 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname15 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname16 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname17 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname18 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname19 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname20 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname21 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname22 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname23 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname24 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname25 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname26 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname27 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname28 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname29 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname30 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname31 = new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string axname32 = new string(' ',4) ; + } + + /* cnc_wrunsolicprm: Set the unsolicited message parameters */ + /* cnc_rdunsolicprm: Get the unsolicited message parameters */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public struct IODBUNSOLIC_pmc + { + public short type ; + public short rdaddr ; + public short rdno ; + public short rdsize ; + private int dummy ; + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBUNSOLIC + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string ipaddr= new string(' ',16) ; + public ushort port ; + public short reqaddr ; + public short pmcno ; + public short retry ; + public short timeout ; + public short alivetime; + public short setno ; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public IODBUNSOLIC_pmc[] rddata = new IODBUNSOLIC_pmc[3]; + } + + /* cnc_wrunsolicprm2: Set the unsolicited message parameters(2) */ + /* cnc_rdunsolicprm2: Get the unsolicited message parameters(2) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public struct UNSOLICMSG_TYPE_PRM + { + public ushort type; + private ushort dummy1; + public ushort path; + public short addr; + public uint no; + public uint num_or_size; + } + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBUNSOLIC2 + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=64)] + public string ipaddr= new string(' ',64) ; + public uint port ; + public ushort retry ; + public ushort timeout ; + public ushort alivetime; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] + private byte[] dummy1 = new byte[8]; + public UNSOLICMSG_TYPE_PRM cntrl; + public ushort transnum; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 14)] + private byte[] dummy2 = new byte[14]; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public UNSOLICMSG_TYPE_PRM[] trans = new UNSOLICMSG_TYPE_PRM[3]; + } + + /* cnc_rdunsolicmsg: Reads the unsolicited message data */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct IDBUNSOLICMSG_msg + { + public short rdsize; + public IntPtr data; + } + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class IDBUNSOLICMSG + { + public short getno ; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public IDBUNSOLICMSG_msg[] msg = new IDBUNSOLICMSG_msg[3]; + } + + /* cnc_rdunsolicmsg2: Reads the unsolicited message data(2) */ + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct UNSOLICMSG_TYPE_MSG + { + public ushort type; + private ushort dummy1; + public ushort path; + private ushort dummy2; + public int num_or_size; + public IntPtr data; + } + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public class IDBUNSOLICMSG2 + { + public ushort getnum; + private ushort dummy; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] + public UNSOLICMSG_TYPE_MSG[] get = new UNSOLICMSG_TYPE_MSG[3]; + } + + /* cnc_rdpm_cncitem: read cnc maintenance item */ + /* cnc_rdpm_mcnitem: read machine specific maintenance item */ + /* cnc_wrpm_mcnitem: write machine specific maintenance item */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBITEM + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name1 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name2 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name3 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name4 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name5 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name6 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name7 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name8 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name9 = new string(' ',62) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name10 = new string(' ',62) ; + } + + /* cnc_rdpm_item:read maintenance item status */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPMAINTE_data + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=62)] + public string name = new string(' ',62) ; /* name */ + public int type; /* life count type */ + public int total; /* total life time (minite basis) */ + public int remain; /* life rest time */ + public int stat; /* life state */ + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPMAINTE + { + public IODBPMAINTE_data data1 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data2 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data3 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data4 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data5 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data6 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data7 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data8 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data9 = new IODBPMAINTE_data(); + public IODBPMAINTE_data data10 = new IODBPMAINTE_data(); + } + + /* cnc_sysinfo_ex:read CNC system path information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSEX_path + { + public short system; + public short group; + public short attrib; + public short ctrl_axis; + public short ctrl_srvo; + public short ctrl_spdl; + public short mchn_no; + public short reserved; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSEX_data + { + public ODBSYSEX_path data1 = new ODBSYSEX_path(); + public ODBSYSEX_path data2 = new ODBSYSEX_path(); + public ODBSYSEX_path data3 = new ODBSYSEX_path(); + public ODBSYSEX_path data4 = new ODBSYSEX_path(); + public ODBSYSEX_path data5 = new ODBSYSEX_path(); + public ODBSYSEX_path data6 = new ODBSYSEX_path(); + public ODBSYSEX_path data7 = new ODBSYSEX_path(); + public ODBSYSEX_path data8 = new ODBSYSEX_path(); + public ODBSYSEX_path data9 = new ODBSYSEX_path(); + public ODBSYSEX_path data10 = new ODBSYSEX_path(); + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSYSEX + { + public short max_axis; + public short max_spdl; + public short max_path; + public short max_mchn; + public short ctrl_axis; + public short ctrl_srvo; + public short ctrl_spdl; + public short ctrl_path; + public short ctrl_mchn; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=3)] + public short[] reserved = new short[3]; + public ODBSYSEX_data path = new ODBSYSEX_data(); + } + +/*------------------*/ +/* CNC : SERCOS I/F */ +/*------------------*/ + + /* cnc_srcsrdidinfo:Read ID information of SERCOS I/F */ + /* cnc_srcswridinfo:Write ID information of SERCOS I/F */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class IODBIDINF + { + public int id_no; + public short drv_no; + public short acc_element; + public short err_general; + public short err_id_no; + public short err_id_name; + public short err_attr; + public short err_unit; + public short err_min_val; + public short err_max_val; + public short id_name_len; + public short id_name_max; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=60)] + public string id_name= new string(' ',60) ; + public int attr; + public short unit_len; + public short unit_max; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=12)] + public byte[] unit = new byte[12]; + public int min_val; + public int max_val; + } + + /* cnc_srcsrdexstat:Get execution status of reading/writing operation data of SERCOS I/F */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSRCSST + { + public short acc_element; + public short err_general; + public short err_id_no; + public short err_attr; + public short err_op_data; + } + + /* cnc_srcsrdlayout:Read drive assign of SERCOS I/F */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBSRCSLYT + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=4)] + public short[] spndl; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public short[] servo; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=8)] + public string axis_name= new string(' ',8) ; + } + +/*----------------------------*/ +/* CNC : Servo Guide */ +/*----------------------------*/ + /* cnc_sdsetchnl:Servo Guide (Channel data set) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBCHAN_data + { + public byte chno; + public sbyte axis; + public int datanum; + public ushort datainf; + public short dataadr; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBCHAN + { + public IDBCHAN_data data1 = new IDBCHAN_data(); + public IDBCHAN_data data2 = new IDBCHAN_data(); + public IDBCHAN_data data3 = new IDBCHAN_data(); + public IDBCHAN_data data4 = new IDBCHAN_data(); + public IDBCHAN_data data5 = new IDBCHAN_data(); + public IDBCHAN_data data6 = new IDBCHAN_data(); + public IDBCHAN_data data7 = new IDBCHAN_data(); + public IDBCHAN_data data8 = new IDBCHAN_data(); + } + + /* cnc_sdsetchnl:Servo Guide (read Sampling data) */ + /* cnc_sfbreadsmpl:Servo feedback data (read Sampling data) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSD + { + public IntPtr chadata; + public IntPtr count; + } + + /* cnc_sfbsetchnl:Servo feedback data (Channel data set) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IDBSFBCHAN + { + public byte chno; + public sbyte axis; + public ushort shift; + } + + +/*-------------------------*/ +/* CNC : FS18-LN function */ +/*-------------------------*/ + + /* cnc_allowcnd:read allowanced state */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBCAXIS + { + public short dummy ; /* dummy */ + public short type ; /* axis number */ + [MarshalAs(UnmanagedType.ByValArray,SizeConst=MAX_AXIS)] + public sbyte[] data ; /* data value */ + } + + +/*---------------------------------*/ +/* CNC : C-EXE SRAM file function */ +/*---------------------------------*/ + + /* read C-EXE SRAM disk directory */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class CFILEINFO_data + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=12)] + public string fname= new string(' ',12) ; /* file name */ + public int file_size ; /* file size (bytes) */ + public int file_attr ; /* attribute */ + public short year; /* year */ + public short month; /* month */ + public short day; /* day */ + public short hour; /* hour */ + public short minute; /* mimute */ + public short second; /* second */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class CFILEINFO + { + public CFILEINFO_data data1 = new CFILEINFO_data(); + public CFILEINFO_data data2 = new CFILEINFO_data(); + public CFILEINFO_data data3 = new CFILEINFO_data(); + public CFILEINFO_data data4 = new CFILEINFO_data(); + public CFILEINFO_data data5 = new CFILEINFO_data(); + public CFILEINFO_data data6 = new CFILEINFO_data(); + public CFILEINFO_data data7 = new CFILEINFO_data(); + public CFILEINFO_data data8 = new CFILEINFO_data(); + public CFILEINFO_data data9 = new CFILEINFO_data(); + public CFILEINFO_data data10= new CFILEINFO_data(); + } + +/*-----*/ +/* PMC */ +/*-----*/ + + /* pmc_rdpmcrng:read PMC data(area specified) */ + /* pmc_wrpmcrng:write PMC data(area specified) */ + [StructLayout(LayoutKind.Explicit)] + public class IODBPMC0 + { + [ FieldOffset( 0 )] + public short type_a ; /* PMC address type */ + [ FieldOffset( 2 )] + public short type_d ; /* PMC data type */ + [ FieldOffset( 4 )] + public short datano_s ; /* start PMC address */ + [ FieldOffset( 6 )] + public short datano_e ; /* end PMC address */ + [ FieldOffset( 8 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public byte[] cdata; /* PMC data */ + } /* In case that the number of data is 5 */ + + [StructLayout(LayoutKind.Explicit)] + public class IODBPMC1 + { + [ FieldOffset( 0 )] + public short type_a ; /* PMC address type */ + [ FieldOffset( 2 )] + public short type_d ; /* PMC data type */ + [ FieldOffset( 4 )] + public short datano_s ; /* start PMC address */ + [ FieldOffset( 6 )] + public short datano_e ; /* end PMC address */ + [ FieldOffset( 8 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public short[] idata; + } /* In case that the number of data is 5 */ + + [StructLayout(LayoutKind.Explicit)] + public class IODBPMC2 + { + [ FieldOffset( 0 )] + public short type_a ; /* PMC address type */ + [ FieldOffset( 2 )] + public short type_d ; /* PMC data type */ + [ FieldOffset( 4 )] + public short datano_s ; /* start PMC address */ + [ FieldOffset( 6 )] + public short datano_e ; /* end PMC address */ + [ FieldOffset( 8 ), + MarshalAs(UnmanagedType.ByValArray,SizeConst=5)] + public int[] ldata; + } /* In case that the number of data is 5 */ + + /* pmc_rdpmcinfo:read informations of PMC data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCINF_info + { + public char pmc_adr ; + public byte adr_attr ; + public ushort top_num ; + public ushort last_num ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCINF1 + { + public ODBPMCINF_info info1 = new ODBPMCINF_info(); + public ODBPMCINF_info info2 = new ODBPMCINF_info(); + public ODBPMCINF_info info3 = new ODBPMCINF_info(); + public ODBPMCINF_info info4 = new ODBPMCINF_info(); + public ODBPMCINF_info info5 = new ODBPMCINF_info(); + public ODBPMCINF_info info6 = new ODBPMCINF_info(); + public ODBPMCINF_info info7 = new ODBPMCINF_info(); + public ODBPMCINF_info info8 = new ODBPMCINF_info(); + public ODBPMCINF_info info9 = new ODBPMCINF_info(); + public ODBPMCINF_info info10= new ODBPMCINF_info(); + public ODBPMCINF_info info11= new ODBPMCINF_info(); + public ODBPMCINF_info info12= new ODBPMCINF_info(); + public ODBPMCINF_info info13= new ODBPMCINF_info(); + public ODBPMCINF_info info14= new ODBPMCINF_info(); + public ODBPMCINF_info info15= new ODBPMCINF_info(); + public ODBPMCINF_info info16= new ODBPMCINF_info(); + public ODBPMCINF_info info17= new ODBPMCINF_info(); + public ODBPMCINF_info info18= new ODBPMCINF_info(); + public ODBPMCINF_info info19= new ODBPMCINF_info(); + public ODBPMCINF_info info20= new ODBPMCINF_info(); + public ODBPMCINF_info info21= new ODBPMCINF_info(); + public ODBPMCINF_info info22= new ODBPMCINF_info(); + public ODBPMCINF_info info23= new ODBPMCINF_info(); + public ODBPMCINF_info info24= new ODBPMCINF_info(); + public ODBPMCINF_info info25= new ODBPMCINF_info(); + public ODBPMCINF_info info26= new ODBPMCINF_info(); + public ODBPMCINF_info info27= new ODBPMCINF_info(); + public ODBPMCINF_info info28= new ODBPMCINF_info(); + public ODBPMCINF_info info29= new ODBPMCINF_info(); + public ODBPMCINF_info info30= new ODBPMCINF_info(); + public ODBPMCINF_info info31= new ODBPMCINF_info(); + public ODBPMCINF_info info32= new ODBPMCINF_info(); + public ODBPMCINF_info info33= new ODBPMCINF_info(); + public ODBPMCINF_info info34= new ODBPMCINF_info(); + public ODBPMCINF_info info35= new ODBPMCINF_info(); + public ODBPMCINF_info info36= new ODBPMCINF_info(); + public ODBPMCINF_info info37= new ODBPMCINF_info(); + public ODBPMCINF_info info38= new ODBPMCINF_info(); + public ODBPMCINF_info info39= new ODBPMCINF_info(); + public ODBPMCINF_info info40= new ODBPMCINF_info(); + public ODBPMCINF_info info41= new ODBPMCINF_info(); + public ODBPMCINF_info info42= new ODBPMCINF_info(); + public ODBPMCINF_info info43= new ODBPMCINF_info(); + public ODBPMCINF_info info44= new ODBPMCINF_info(); + public ODBPMCINF_info info45= new ODBPMCINF_info(); + public ODBPMCINF_info info46= new ODBPMCINF_info(); + public ODBPMCINF_info info47= new ODBPMCINF_info(); + public ODBPMCINF_info info48= new ODBPMCINF_info(); + public ODBPMCINF_info info49= new ODBPMCINF_info(); + public ODBPMCINF_info info50= new ODBPMCINF_info(); + public ODBPMCINF_info info51= new ODBPMCINF_info(); + public ODBPMCINF_info info52= new ODBPMCINF_info(); + public ODBPMCINF_info info53= new ODBPMCINF_info(); + public ODBPMCINF_info info54= new ODBPMCINF_info(); + public ODBPMCINF_info info55= new ODBPMCINF_info(); + public ODBPMCINF_info info56= new ODBPMCINF_info(); + public ODBPMCINF_info info57= new ODBPMCINF_info(); + public ODBPMCINF_info info58= new ODBPMCINF_info(); + public ODBPMCINF_info info59= new ODBPMCINF_info(); + public ODBPMCINF_info info60= new ODBPMCINF_info(); + public ODBPMCINF_info info61= new ODBPMCINF_info(); + public ODBPMCINF_info info62= new ODBPMCINF_info(); + public ODBPMCINF_info info63= new ODBPMCINF_info(); + public ODBPMCINF_info info64= new ODBPMCINF_info(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCINF + { + public short datano ; + public ODBPMCINF1 info = new ODBPMCINF1(); + } + + /* pmc_rdcntldata:read PMC parameter data table control data */ + /* pmc_wrcntldata:write PMC parameter data table control data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPMCCNTL_info + { + public byte tbl_prm ; + public byte data_type ; + public ushort data_size ; + public ushort data_dsp ; + public short dummy ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPMCCNTL1 + { + public IODBPMCCNTL_info info1 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info2 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info3 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info4 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info5 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info6 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info7 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info8 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info9 = new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info10= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info11= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info12= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info13= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info14= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info15= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info16= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info17= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info18= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info19= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info20= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info21= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info22= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info23= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info24= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info25= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info26= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info27= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info28= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info29= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info30= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info31= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info32= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info33= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info34= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info35= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info36= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info37= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info38= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info39= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info40= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info41= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info42= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info43= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info44= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info45= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info46= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info47= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info48= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info49= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info50= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info51= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info52= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info53= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info54= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info55= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info56= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info57= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info58= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info59= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info60= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info61= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info62= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info63= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info64= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info65= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info66= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info67= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info68= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info69= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info70= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info71= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info72= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info73= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info74= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info75= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info76= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info77= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info78= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info79= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info80= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info81= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info82= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info83= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info84= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info85= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info86= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info87= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info88= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info89= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info90= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info91= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info92= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info93= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info94= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info95= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info96= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info97= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info98= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info99= new IODBPMCCNTL_info(); + public IODBPMCCNTL_info info100= new IODBPMCCNTL_info(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPMCCNTL + { + public short datano_s ; + public short dummy ; + public short datano_e ; + public IODBPMCCNTL1 info = new IODBPMCCNTL1(); + } + + /* pmc_rdalmmsg:read PMC alarm message */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBPMCALM_data + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] + public string almmsg= new string(' ',128) ; /* alarm message */ + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCALM + { + public ODBPMCALM_data msg1 = new ODBPMCALM_data(); + public ODBPMCALM_data msg2 = new ODBPMCALM_data(); + public ODBPMCALM_data msg3 = new ODBPMCALM_data(); + public ODBPMCALM_data msg4 = new ODBPMCALM_data(); + public ODBPMCALM_data msg5 = new ODBPMCALM_data(); + public ODBPMCALM_data msg6 = new ODBPMCALM_data(); + public ODBPMCALM_data msg7 = new ODBPMCALM_data(); + public ODBPMCALM_data msg8 = new ODBPMCALM_data(); + public ODBPMCALM_data msg9 = new ODBPMCALM_data(); + public ODBPMCALM_data msg10= new ODBPMCALM_data(); + } /* In case that the number of data is 10 */ + + /* pmc_getdtailerr:get detail error for pmc */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCERR + { + public short err_no ; + public short err_dtno ; + } + + /* pmc_rdpmctitle:read pmc title data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBPMCTITLE + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string mtb= new string(' ',48) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string machine= new string(' ',48) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string type= new string(' ',48) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=8)] + public string prgno= new string(' ',8) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=4)] + public string prgvers= new string(' ',4) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string prgdraw= new string(' ',48) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string date= new string(' ',32) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string design= new string(' ',48) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string written= new string(' ',48) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=48)] + public string remarks= new string(' ',48) ; + } + + /* pmc_rdpmcrng_ext:read PMC data */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPMCEXT + { + public short type_a ; /* PMC address type */ + public short type_d ; /* PMC data type */ + public short datano_s ; /* start PMC address */ + public short datano_e ; /* end PMC address */ + public short err_code ; /* error code */ + public short reserved ; /* reserved */ + [MarshalAs(UnmanagedType.AsAny)] + public object data ; /* pointer to buffer */ + } + + /* pmc_rdpmcaddr:read PMC address information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCADR_info + { + public byte pmc_adr ; + public byte adr_attr ; + public ushort offset ; + public ushort top ; + public ushort num ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCADR1 + { + public ODBPMCADR_info info1 = new ODBPMCADR_info(); + public ODBPMCADR_info info2 = new ODBPMCADR_info(); + public ODBPMCADR_info info3 = new ODBPMCADR_info(); + public ODBPMCADR_info info4 = new ODBPMCADR_info(); + public ODBPMCADR_info info5 = new ODBPMCADR_info(); + public ODBPMCADR_info info6 = new ODBPMCADR_info(); + public ODBPMCADR_info info7 = new ODBPMCADR_info(); + public ODBPMCADR_info info8 = new ODBPMCADR_info(); + public ODBPMCADR_info info9 = new ODBPMCADR_info(); + public ODBPMCADR_info info10= new ODBPMCADR_info(); + public ODBPMCADR_info info11= new ODBPMCADR_info(); + public ODBPMCADR_info info12= new ODBPMCADR_info(); + public ODBPMCADR_info info13= new ODBPMCADR_info(); + public ODBPMCADR_info info14= new ODBPMCADR_info(); + public ODBPMCADR_info info15= new ODBPMCADR_info(); + public ODBPMCADR_info info16= new ODBPMCADR_info(); + public ODBPMCADR_info info17= new ODBPMCADR_info(); + public ODBPMCADR_info info18= new ODBPMCADR_info(); + public ODBPMCADR_info info19= new ODBPMCADR_info(); + public ODBPMCADR_info info20= new ODBPMCADR_info(); + public ODBPMCADR_info info21= new ODBPMCADR_info(); + public ODBPMCADR_info info22= new ODBPMCADR_info(); + public ODBPMCADR_info info23= new ODBPMCADR_info(); + public ODBPMCADR_info info24= new ODBPMCADR_info(); + public ODBPMCADR_info info25= new ODBPMCADR_info(); + public ODBPMCADR_info info26= new ODBPMCADR_info(); + public ODBPMCADR_info info27= new ODBPMCADR_info(); + public ODBPMCADR_info info28= new ODBPMCADR_info(); + public ODBPMCADR_info info29= new ODBPMCADR_info(); + public ODBPMCADR_info info30= new ODBPMCADR_info(); + public ODBPMCADR_info info31= new ODBPMCADR_info(); + public ODBPMCADR_info info32= new ODBPMCADR_info(); + public ODBPMCADR_info info33= new ODBPMCADR_info(); + public ODBPMCADR_info info34= new ODBPMCADR_info(); + public ODBPMCADR_info info35= new ODBPMCADR_info(); + public ODBPMCADR_info info36= new ODBPMCADR_info(); + public ODBPMCADR_info info37= new ODBPMCADR_info(); + public ODBPMCADR_info info38= new ODBPMCADR_info(); + public ODBPMCADR_info info39= new ODBPMCADR_info(); + public ODBPMCADR_info info40= new ODBPMCADR_info(); + public ODBPMCADR_info info41= new ODBPMCADR_info(); + public ODBPMCADR_info info42= new ODBPMCADR_info(); + public ODBPMCADR_info info43= new ODBPMCADR_info(); + public ODBPMCADR_info info44= new ODBPMCADR_info(); + public ODBPMCADR_info info45= new ODBPMCADR_info(); + public ODBPMCADR_info info46= new ODBPMCADR_info(); + public ODBPMCADR_info info47= new ODBPMCADR_info(); + public ODBPMCADR_info info48= new ODBPMCADR_info(); + public ODBPMCADR_info info49= new ODBPMCADR_info(); + public ODBPMCADR_info info50= new ODBPMCADR_info(); + public ODBPMCADR_info info51= new ODBPMCADR_info(); + public ODBPMCADR_info info52= new ODBPMCADR_info(); + public ODBPMCADR_info info53= new ODBPMCADR_info(); + public ODBPMCADR_info info54= new ODBPMCADR_info(); + public ODBPMCADR_info info55= new ODBPMCADR_info(); + public ODBPMCADR_info info56= new ODBPMCADR_info(); + public ODBPMCADR_info info57= new ODBPMCADR_info(); + public ODBPMCADR_info info58= new ODBPMCADR_info(); + public ODBPMCADR_info info59= new ODBPMCADR_info(); + public ODBPMCADR_info info60= new ODBPMCADR_info(); + public ODBPMCADR_info info61= new ODBPMCADR_info(); + public ODBPMCADR_info info62= new ODBPMCADR_info(); + public ODBPMCADR_info info63= new ODBPMCADR_info(); + public ODBPMCADR_info info64= new ODBPMCADR_info(); + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBPMCADR + { + public uint io_adr ; + public short datano ; + public ODBPMCADR1 info = new ODBPMCADR1(); + } + + +/*--------------------------*/ +/* PROFIBUS function */ +/*--------------------------*/ + + /* pmc_prfrdconfig:read PROFIBUS configration data */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBPRFCNF + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string master_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=3)] + public string master_ver= new string(' ',3) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string slave_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=3)] + public string slave_ver= new string(' ',3) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=5)] + public string cntl_ser= new string(' ',5) ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=3)] + public string cntl_ver= new string(' ',3) ; + } + + /* pmc_prfrdbusprm:read bus parameter for master function */ + /* pmc_prfwrbusprm:write bus parameter for master function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBBUSPRM + { + public sbyte fdl_add ; + public sbyte baudrate ; + public ushort tsl ; + public ushort min_tsdr ; + public ushort max_tsdr ; + public byte tqui ; + public byte tset ; + public int ttr ; + public sbyte gap ; + public sbyte hsa ; + public sbyte max_retry ; + public byte bp_flag ; + public ushort min_slv_int ; + public ushort poll_tout ; + public ushort data_cntl ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=6)] + public byte[] reserve1 = new byte[6] ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public byte[] cls2_name = new byte[32] ; + public short user_dlen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=62)] + public byte[] user_data = new byte[62] ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=96)] + public byte[] reserve2 = new byte[96] ; + } + + /* pmc_prfrdslvprm:read slave parameter for master function */ + /* pmc_prfwrslvprm:write slave parameter for master function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLVPRM + { + public short dis_enb ; + public ushort ident_no ; + public byte slv_flag ; + public byte slv_type ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=12)] + public byte[] reserve1 = new byte[12]; + public byte slv_stat ; + public byte wd_fact1 ; + public byte wd_fact2 ; + public byte min_tsdr ; + public char reserve2 ; + public byte grp_ident ; + public short user_plen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public byte[] user_pdata = new byte[32]; + public short cnfg_dlen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=126)] + public byte[] cnfg_data = new byte[126]; + public short slv_ulen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=30)] + public byte[] slv_udata = new byte[30]; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public byte[] reserve3 = new byte[8]; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLVPRM2 + { + public short dis_enb ; + public ushort ident_no ; + public byte slv_flag ; + public byte slv_type ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=12)] + public byte[] reserve1 = new byte[12] ; + public byte slv_stat ; + public byte wd_fact1 ; + public byte wd_fact2 ; + public byte min_tsdr ; + public sbyte reserve2 ; + public byte grp_ident ; + public short user_plen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=206)] + public byte[] user_pdata = new byte[206]; + public short cnfg_dlen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=126)] + public byte[] cnfg_data = new byte[126] ; + public short slv_ulen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=30)] + public byte[] slv_udata = new byte[30] ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=8)] + public byte[] reserve3 = new byte[8]; + } + + /* pmc_prfrdallcadr:read allocation address for master function */ + /* pmc_prfwrallcadr:set allocation address for master function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBPRFADR + { + public byte di_size ; + public byte di_type ; + public ushort di_addr ; + public short reserve1; + public byte do_size ; + public byte do_type ; + public ushort do_addr ; + public short reserve2; + public byte dgn_size ; + public byte dgn_type ; + public ushort dgn_addr ; + } + + /* pmc_prfrdslvaddr:read allocation address for slave function */ + /* pmc_prfwrslvaddr:set allocation address for slave function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLVADR + { + public byte slave_no ; + public byte di_size ; + public byte di_type ; + public ushort di_addr ; + public byte do_size ; + public byte do_type ; + public ushort do_addr ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=7)] + public byte[] reserve = new byte[7]; + } + + /* pmc_prfrdslvstat:read status for slave function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBSLVST + { + public byte cnfg_stat ; + public byte prm_stat ; + public sbyte wdg_stat ; + public byte live_stat ; + public short ident_no ; + } + + /* pmc_prfrdslvid:Reads slave index data of master function */ + /* pmc_prfwrslvid:Writes slave index data of master function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLVID + { + public short dis_enb ; + public short slave_no ; + public short nsl ; + public byte dgn_size ; + public char dgn_type ; + public ushort dgn_addr ; + } + + /* pmc_prfrdslvprm2:Reads slave parameter of master function(2) */ + /* pmc_prfwrslvprm2:Writes slave parameter of master function(2) */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBSLVPRM3 + { + public ushort ident_no ; + public byte slv_flag ; + public byte slv_type ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=12)] + public char[] reserve1 = new char[12]; + public byte slv_stat ; + public byte wd_fact1 ; + public byte wd_fact2 ; + public byte min_tsdr ; + public char reserve2 ; + public byte grp_ident ; + public short user_plen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=206)] + public char[] user_pdata = new char[206]; + public short slv_ulen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=30)] + public char[] slv_udata = new char[30]; + } + + /* pmc_prfrddido:Reads DI/DO parameter of master function */ + /* pmc_prfwrdido:Writes DI/DO parameter of master function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBDIDO + { + public short slave_no ; + public short slot_no ; + public byte di_size ; + public char di_type ; + public ushort di_addr ; + public byte do_size ; + public char do_type ; + public ushort do_addr ; + public short shift; + public byte module_dlen ; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=128)] + public char[] module_data = new char[128]; + } + + /* pmc_prfrdindiadr:Reads indication address of master function */ + /* pmc_prfwrindiadr:Writes indication address of master function */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBINDEADR + { + public byte dummy ; + public char indi_type ; + public ushort indi_addr ; + } + +/*-----------------------------------------------*/ +/* DS : Data server & Ethernet board function */ +/*-----------------------------------------------*/ + + /* etb_rdparam : read@the parameter of the Ethernet board */ + /* etb_wrparam : write the parameter of the Ethernet board */ + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class TCPPRM + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string OwnIPAddress = new string(' ',16); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string SubNetMask = new string(' ',16); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string RouterIPAddress = new string(' ',16); + } + + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class HOSTPRM + { + public short DataServerPort ; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string DataServerIPAddress = new string(' ',16); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string DataServerUserName = new string(' ',32); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string DataServerPassword = new string(' ',32); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] + public string DataServerLoginDirectory = new string(' ',128); + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class FTPPRM + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string FTPServerUserName = new string(' ',32); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] + public string FTPServerPassword = new string(' ',32); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] + public string FTPServerLoginDirectory = new string(' ',128); + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ETBPRM + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=13)] + public string OwnMACAddress = new string(' ',128); + public short MaximumChannel ; + public short HDDExistence; + public short NumberOfScreens; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBETP + { + public short Dummy_ParameterType ; + + [MarshalAs(UnmanagedType.ByValArray,SizeConst=210)] + public byte[] prm = new byte[210]; + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBETP_TCP + { + public short ParameterType ; + public TCPPRM tcp ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBETP_HOST + { + public short ParameterType ; + public HOSTPRM host ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBETP_FTP + { + public short ParameterType ; + public FTPPRM ftp ; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class IODBETP_ETB + { + public short ParameterType ; + public ETBPRM etb ; + } + + /* etb_rderrmsg : read the error message of the Ethernet board */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBETMSG + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=33)] + public string title = new string(' ',33); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=390)] + public string message = new string(' ',390); + } + + /* ds_rdhddinfo : read information of the Data Server's HDD */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHDDINF + { + public int file_num; + public int remainder_l; + public int remainder_h; + [MarshalAs(UnmanagedType.ByValArray,SizeConst=32)] + public char[] current_dir = new char[32]; + } + + /* ds_rdhdddir : read the file list of the Data Server's HDD */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHDDDIR_data + { + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=64)] + public string file_name = new string(' ',64); + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=80)] + public string comment = new string(' ',80); + public short attribute; + public short reserved; + public int size; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=16)] + public string date = new string(' ',16); + } + + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHDDDIR + { + public ODBHDDDIR_data data1 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data2 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data3 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data4 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data5 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data6 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data7 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data8 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data9 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data10 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data11 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data12 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data13 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data14 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data15 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data16 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data17 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data18 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data19 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data20 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data21 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data22 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data23 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data24 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data25 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data26 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data27 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data28 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data29 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data30 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data31 =new ODBHDDDIR_data(); + public ODBHDDDIR_data data32 =new ODBHDDDIR_data(); + } + + /* ds_rdhostdir : read the file list of the host */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHOSTDIR_data + { + [MarshalAs(UnmanagedType.ByValArray,SizeConst=128)] + public char[] host_file = new char[128]; + } + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class ODBHOSTDIR + { + public ODBHOSTDIR_data data1 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data2 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data3 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data4 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data5 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data6 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data7 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data8 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data9 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data10 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data11 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data12 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data13 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data14 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data15 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data16 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data17 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data18 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data19 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data20 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data21 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data22 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data23 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data24 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data25 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data26 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data27 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data28 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data29 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data30 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data31 =new ODBHOSTDIR_data(); + public ODBHOSTDIR_data data32 =new ODBHOSTDIR_data(); + } + + /* ds_rdmntinfo : read maintenance information */ + [StructLayout(LayoutKind.Sequential,Pack=4)] + public class DSMNTINFO + { + public ushort empty_cnt; + public uint total_size; + public ushort ReadPtr; + public ushort WritePtr; + } ; + +/*--------------------------*/ +/* HSSB multiple connection */ +/*--------------------------*/ + + /* cnc_rdnodeinfo:read node informations */ + [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=4)] + public class ODBNODE + { + public int node_no; + public int io_base; + public int status; + public int cnc_type; + [MarshalAs(UnmanagedType.ByValTStr,SizeConst=20)] + public string node_name= new string(' ', 20) ; + } + + // Personalizzate + + /* read alarm message(2) */ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 4)] + public struct ODBALMMSG_data_custom + { + public int alm_no; + public short type; + public short axis; + public short dummy; + public short msg_len; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] + public string alm_msg; + } + + /* read alarm message(2) */ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 4)] + public struct ODBALMMSG2_data_custom + { + public int alm_no; + public short type; + public short axis; + public short dummy; + public short msg_len; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] + public string alm_msg; + } + + /* cnc_rdopmsg3:read operator's message */ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 4)] + public struct OPMSG3_data_custom + { + public short datano; /* operator's message number */ + public short type; /* operator's message type */ + public short char_num; /* message string length */ + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] + public string data; /* operator's message string */ + } /* In case that the data length is 256 */ + + /*-------------------------------------*/ + /* CNC: Control axis / spindle related */ + /*-------------------------------------*/ + + /* read actual axis feedrate(F) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_actf")] + public static extern short cnc_actf(ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBACT a); + + /* read absolute axis position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_absolute")] + public static extern short cnc_absolute(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read machine axis position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_machine")] + public static extern short cnc_machine(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read relative axis position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_relative")] + public static extern short cnc_relative(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read distance to go */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_distance")] + public static extern short cnc_distance(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read skip position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_skip")] + public static extern short cnc_skip(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read servo delay value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srvdelay")] + public static extern short cnc_srvdelay(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read acceleration/deceleration delay value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_accdecdly")] + public static extern short cnc_accdecdly(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read all dynamic data */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddynamic")] + public static extern short cnc_rddynamic(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDY_1 c); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddynamic")] + public static extern short cnc_rddynamic(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDY_2 c); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddynamico8")] + public static extern short cnc_rddynamic(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDY_1 c); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddynamico8")] + public static extern short cnc_rddynamic(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDY_2 c); +#endif + + /* read all dynamic data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddynamic2")] + public static extern short cnc_rddynamic2(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDY2_1 c); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddynamic2")] + public static extern short cnc_rddynamic2(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDY2_2 c); + + /* read actual spindle speed(S) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_acts")] + public static extern short cnc_acts(ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBACT a); + + /* read actual spindle speed(S) (All or spesified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_acts2")] + public static extern short cnc_acts2(ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBACT2 b); + + /* set origin / preset relative axis position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrrelpos")] + public static extern short cnc_wrrelpos( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IDBWRR b ); + + /* preset work coordinate */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_prstwkcd")] + public static extern short cnc_prstwkcd( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IDBWRA b ); + + /* read manual overlapped motion value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmovrlap")] + public static extern short cnc_rdmovrlap( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBOVL c ); + + /* cancel manual overlapped motion value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_canmovrlap")] + public static extern short cnc_canmovrlap( ushort FlibHndl, short a ); + + /* read load information of serial spindle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspload")] + public static extern short cnc_rdspload( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPN b ); + + /* read maximum r.p.m. ratio of serial spindle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspmaxrpm")] + public static extern short cnc_rdspmaxrpm( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPN b ); + + /* read gear ratio of serial spindle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspgear")] + public static extern short cnc_rdspgear( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPN b ); + + /* read absolute axis position 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_absolute2")] + public static extern short cnc_absolute2(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read relative axis position 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_relative2")] + public static extern short cnc_relative2(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* set wire vertival position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setvrtclpos")] + public static extern short cnc_setvrtclpos( ushort FlibHndl, short a ); + + /* set wire threading position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setthrdngpos")] + public static extern short cnc_setthrdngpos( ushort FlibHndl ); + + /* read tool position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdposition")] + public static extern short cnc_rdposition(ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPOS c); + + /* read current speed */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspeed")] + public static extern short cnc_rdspeed( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPEED b ); + + /* read servo load meter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsvmeter")] + public static extern short cnc_rdsvmeter( ushort FlibHndl, + ref short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSVLOAD b ); + + /* read spindle load meter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspmeter")] + public static extern short cnc_rdspmeter( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPLOAD c ); + + /* read manual feed for 5-axis machining */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd5axmandt")] + public static extern short cnc_rd5axmandt( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODB5AXMAN a ); + + /* read amount of machine axes movement of manual feed for 5-axis machining */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd5axovrlap")] + public static extern short cnc_rd5axovrlap( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c ); + + /* read handle interruption */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhndintrpt")] + public static extern short cnc_rdhndintrpt( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBHND c ); + + /* clear pulse values of manual feed for 5-axis machining */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clr5axpls")] + public static extern short cnc_clr5axpls( ushort FlibHndl, short a); + + /* read constant surface speed */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspcss")] + public static extern short cnc_rdspcss( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBCSS a ); + + /* read execution program pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdexecpt")] + public static extern short cnc_rdexecpt( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGPNT a , [Out,MarshalAs(UnmanagedType.LPStruct)] PRGPNT b ); + + /* read various axis data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdaxisdata")] + public static extern short cnc_rdaxisdata( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, short c, ref short d, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXDT e ); + +/*----------------------*/ +/* CNC: Program related */ +/*----------------------*/ + + /* start downloading NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnstart")] + public static extern short cnc_dwnstart( ushort FlibHndl ); + + /* download NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_download")] + public static extern short cnc_download( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, short b ); + + /* download NC program(conditional) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cdownload")] + public static extern short cnc_cdownload( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, short b ); + + /* end of downloading NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnend")] + public static extern short cnc_dwnend( ushort FlibHndl ); + + /* end of downloading NC program 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnend2")] + public static extern short cnc_dwnend2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* start downloading NC program 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnstart3")] + public static extern short cnc_dwnstart3( ushort FlibHndl, short a ); + + /* start downloading NC program 3 special */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnstart3_f")] + public static extern short cnc_dwnstart3_f( ushort FlibHndl, + short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, [In,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* download NC program 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_download3")] + public static extern short cnc_download3( ushort FlibHndl, ref int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* end of downloading NC program 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnend3")] + public static extern short cnc_dwnend3( ushort FlibHndl ); + + /* start downloading NC program 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnstart4")] + public static extern short cnc_dwnstart4( ushort FlibHndl, short a , [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* download NC program 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_download4")] + public static extern short cnc_download4( ushort FlibHndl, ref int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* end of downloading NC program 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dwnend4")] + public static extern short cnc_dwnend4( ushort FlibHndl ); + + /* start verification of NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_vrfstart")] + public static extern short cnc_vrfstart( ushort FlibHndl ); + + /* verify NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_verify")] + public static extern short cnc_verify( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, short b ); + + /* verify NC program(conditional) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cverify")] + public static extern short cnc_cverify( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, short b ); + + /* end of verification */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_vrfend")] + public static extern short cnc_vrfend( ushort FlibHndl ); + + /* start verification of NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_vrfstart4")] + public static extern short cnc_vrfstart4( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* verify NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_verify4")] + public static extern short cnc_verify4( ushort FlibHndl, ref int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* end of verification */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_vrfend4")] + public static extern short cnc_vrfend4( ushort FlibHndl ); + + /* start downloading DNC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dncstart")] + public static extern short cnc_dncstart( ushort FlibHndl ); + + /* download DNC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dnc")] + public static extern short cnc_dnc( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, ushort b ); + + /* download DNC program(conditional) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cdnc")] + public static extern short cnc_cdnc( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, ushort b ); + + /* end of downloading DNC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dncend")] + public static extern short cnc_dncend( ushort FlibHndl ); + + /* start downloading DNC program 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dncstart2")] + public static extern short cnc_dncstart2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* download DNC program 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dnc2")] + public static extern short cnc_dnc2( ushort FlibHndl, ref int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* end of downloading DNC program 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dncend2")] + public static extern short cnc_dncend2( ushort FlibHndl, short a ); + + /* read the diagnosis data of DNC operation */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddncdgndt")] + public static extern short cnc_rddncdgndt( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDNCDGN a ); + + /* start uploading NC program */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_upstart")] + public static extern short cnc_upstart( ushort FlibHndl, short a ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_upstarto8")] + public static extern short cnc_upstart( ushort FlibHndl, int a ); +#endif + + /* upload NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upload")] + public static extern short cnc_upload( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBUP a, ref ushort b ); + + /* upload NC program(conditional) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cupload")] + public static extern short cnc_cupload( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBUP a, ref ushort b ); + + /* end of uploading NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upend")] + public static extern short cnc_upend( ushort FlibHndl ); + + /* start uploading NC program 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upstart3")] + public static extern short cnc_upstart3( ushort FlibHndl, short a, int b, int c ); + + /* start uploading NC program special 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upstart3_f")] + public static extern short cnc_upstart3_f( ushort FlibHndl, + short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, [In,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* upload NC program 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upload3")] + public static extern short cnc_upload3( ushort FlibHndl, ref int a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* end of uploading NC program 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upend3")] + public static extern short cnc_upend3( ushort FlibHndl ); + + /* start uploading NC program 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upstart4")] + public static extern short cnc_upstart4( ushort FlibHndl , short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* upload NC program 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upload4")] + public static extern short cnc_upload4( ushort FlibHndl , ref int a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* end of uploading NC program 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_upend4")] + public static extern short cnc_upend4( ushort FlibHndl ); + + /* read buffer status for downloading/verification NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_buff")] + public static extern short cnc_buff( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBBUF a ); + + /* search specified program */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_search")] + public static extern short cnc_search( ushort FlibHndl, short a ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_searcho8")] + public static extern short cnc_search( ushort FlibHndl, int a ); +#endif + + /* search specified program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_search2")] + public static extern short cnc_search2( ushort FlibHndl, int a ); + + /* delete all programs */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_delall")] + public static extern short cnc_delall( ushort FlibHndl ); + + /* delete specified program */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_delete")] + public static extern short cnc_delete( ushort FlibHndl, short a ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_deleteo8")] + public static extern short cnc_delete( ushort FlibHndl, int a ); +#endif + + /* delete program (area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_delrange")] + public static extern short cnc_delrange( ushort FlibHndl, int a , int b ); + +/* read program directory */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogdir")] + public static extern short cnc_rdprogdir( ushort FlibHndl, + short a, short b, short c, ushort d, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIR e ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogdiro8")] + public static extern short cnc_rdprogdir( ushort FlibHndl, + short a, short b, short c, ushort d, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIR e ); +#endif + + /* read program information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdproginfo")] + public static extern short cnc_rdproginfo( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBNC_1 c); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdproginfo")] + public static extern short cnc_rdproginfo( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBNC_2 c); + + /* read program number under execution */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprgnum")] + public static extern short cnc_rdprgnum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPRO a ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprgnumo8")] + public static extern short cnc_rdprgnum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPRO a ); +#endif + + /* read program name under execution */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_exeprgname")] + public static extern short cnc_exeprgname( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBEXEPRG a ); + + /* read sequence number under execution */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdseqnum")] + public static extern short cnc_rdseqnum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSEQ a ); + + /* search specified sequence number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_seqsrch")] + public static extern short cnc_seqsrch( ushort FlibHndl, int a ); + + /* search specified sequence number (2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_seqsrch2")] + public static extern short cnc_seqsrch2( ushort FlibHndl, int a ); + + /* rewind cursor of NC program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rewind")] + public static extern short cnc_rewind( ushort FlibHndl ); + + /* read block counter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdblkcount")] + public static extern short cnc_rdblkcount( ushort FlibHndl, out int a ); + + /* read program under execution */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdexecprog")] + public static extern short cnc_rdexecprog( ushort FlibHndl, ref ushort a, out short b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* read program for MDI operation */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmdiprog")] + public static extern short cnc_rdmdiprog( ushort FlibHndl, ref short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* write program for MDI operation */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmdiprog")] + public static extern short cnc_wrmdiprog( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + +/* read execution pointer for MDI operation */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmdipntr")] + public static extern short cnc_rdmdipntr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDIP a ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmdipntro8")] + public static extern short cnc_rdmdipntr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDIP a ); +#endif + + /* write execution pointer for MDI operation */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmdipntr")] + public static extern short cnc_wrmdipntr( ushort FlibHndl, int a ); + + /* register new program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_newprog")] + public static extern short cnc_newprog( ushort FlibHndl, int a ); + + /* copy program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_copyprog")] + public static extern short cnc_copyprog( ushort FlibHndl, int a, int b ); + + /* rename program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_renameprog")] + public static extern short cnc_renameprog( ushort FlibHndl, int a, int b ); + + /* condense program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_condense")] + public static extern short cnc_condense( ushort FlibHndl, short a, int b ); + + /* merge program */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_mergeprog")] + public static extern short cnc_mergeprog( ushort FlibHndl, short a, int b, uint c, int d ); + + /* read current program and its pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdactpt")] + public static extern short cnc_rdactpt( ushort FlibHndl, out int a, out int b ); + + /* read current program and its pointer and UV macro pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rduvactpt")] + public static extern short cnc_rduvactpt( ushort FlibHndl, out int a, out int b, out int c ); + + /* set current program and its pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wractpt")] + public static extern short cnc_wractpt( ushort FlibHndl, int a, short b, ref int c ); + + /* line edit (read program) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogline")] + public static extern short cnc_rdprogline( ushort FlibHndl, + int a, uint b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c, ref uint d, ref uint e ); + + /* line edit (read program) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogline2")] + public static extern short cnc_rdprogline2( ushort FlibHndl, + int a, uint b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c, ref uint d, ref uint e ); + + /* line edit (write program) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrprogline")] + public static extern short cnc_wrprogline( ushort FlibHndl, int a, uint b, [In,MarshalAs(UnmanagedType.AsAny)] Object c, uint d ); + + /* line edit (delete line in program) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_delprogline")] + public static extern short cnc_delprogline( ushort FlibHndl, int a, uint b, uint c ); + + /* line edit (search string) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_searchword")] + public static extern short cnc_searchword( ushort FlibHndl, + int a, uint b, short c, short d, uint e, [In,MarshalAs(UnmanagedType.AsAny)] Object f ); + + /* line edit (search string) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_searchresult")] + public static extern short cnc_searchresult( ushort FlibHndl, out uint a ); + + /* line edit (read program by file name) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_line")] + public static extern short cnc_rdpdf_line( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, uint b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c, ref uint d, ref uint e ); + + /* program lock */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setpglock")] + public static extern short cnc_setpglock( ushort FlibHndl, int a ); + + /* program unlock */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_resetpglock")] + public static extern short cnc_resetpglock( ushort FlibHndl, int a ); + + /* read the status of the program lock */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpglockstat")] + public static extern short cnc_rdpglockstat( ushort FlibHndl, out int a, out int b ); + + /* create file or directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_add")] + public static extern short cnc_pdf_add( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* condense program file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_cond")] + public static extern short cnc_pdf_cond( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* change attribute of program file and directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpdf_attr")] + public static extern short cnc_wrpdf_attr( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, [Out,MarshalAs(UnmanagedType.LPStruct)] IDBPDFTDIR b ); + + /* copy program file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_copy")] + public static extern short cnc_pdf_copy( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , [In,MarshalAs(UnmanagedType.AsAny)] Object b); + + /* delete file or directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_del")] + public static extern short cnc_pdf_del( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* line edit (write program by file name) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpdf_line")] + public static extern short cnc_wrpdf_line( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , uint b, [In,MarshalAs(UnmanagedType.AsAny)] Object c , uint d ); + + /* line edit (delete line by file name) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_delline")] + public static extern short cnc_pdf_delline( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , uint b, uint c ); + + /* move program file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_move")] + public static extern short cnc_pdf_move( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read current program and its pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_rdactpt")] + public static extern short cnc_pdf_rdactpt( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a , out int b ); + + /* read selected file name */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_rdmain")] + public static extern short cnc_pdf_rdmain( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* rename file or directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_rename")] + public static extern short cnc_pdf_rename( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* line edit (search string) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_searchword")] + public static extern short cnc_pdf_searchword( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , uint b , uint c , uint d , uint e , [In,MarshalAs(UnmanagedType.AsAny)] Object f ); + + /* line edit (search string) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_searchresult")] + public static extern short cnc_pdf_searchresult( ushort FlibHndl, out uint a ); + + /* select program file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_slctmain")] + public static extern short cnc_pdf_slctmain( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* set current program and its pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_pdf_wractpt")] + public static extern short cnc_pdf_wractpt( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , short b , ref int c ); + + /* read program drive information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_inf")] + public static extern short cnc_rdpdf_inf( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a , short b , [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* read program drive directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_drive")] + public static extern short cnc_rdpdf_drive( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read current directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_curdir")] + public static extern short cnc_rdpdf_curdir( ushort FlibHndl, short a , [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* set current directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpdf_curdir")] + public static extern short cnc_wrpdf_curdir( ushort FlibHndl, short a , [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read directory (sub directories) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_subdir")] + public static extern short cnc_rdpdf_subdir( ushort FlibHndl, + ref short a , [In,MarshalAs(UnmanagedType.LPStruct)] IDBPDFSDIR b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPDFSDIR c ); + + /* read directory (all files) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_alldir")] + public static extern short cnc_rdpdf_alldir( ushort FlibHndl, ref short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b , [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* read file count in directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpdf_subdirn")] + public static extern short cnc_rdpdf_subdirn( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPDFNFIL b ); + +/*---------------------------*/ +/* CNC: NC file data related */ +/*---------------------------*/ + + /* read tool offset value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofs")] + public static extern short cnc_rdtofs(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTOFS d); + + /* write tool offset value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtofs")] + public static extern short cnc_wrtofs( ushort FlibHndl, short a, short b, short c, int d ); + + /* read tool offset value(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsr")] + public static extern short cnc_rdtofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTO_1_1 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsr")] + public static extern short cnc_rdtofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTO_1_2 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsr")] + public static extern short cnc_rdtofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTO_1_3 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsr")] + public static extern short cnc_rdtofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTO_2 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsr")] + public static extern short cnc_rdtofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTO_3 e); + + /* write tool offset value(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtofsr")] + public static extern short cnc_wrtofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTO_1_1 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtofsr")] + public static extern short cnc_wrtofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTO_1_2 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtofsr")] + public static extern short cnc_wrtofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTO_1_3 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtofsr")] + public static extern short cnc_wrtofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTO_2 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtofsr")] + public static extern short cnc_wrtofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTO_3 b ); + + /* read work zero offset value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdzofs")] + public static extern short cnc_rdzofs( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBZOFS d ); + + /* write work zero offset value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrzofs")] + public static extern short cnc_wrzofs( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBZOFS b ); + + /* read work zero offset value(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdzofsr")] + public static extern short cnc_rdzofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBZOR e ); + + /* write work zero offset value(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrzofsr")] + public static extern short cnc_wrzofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBZOR b ); + + /* read mesured point value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmsptype")] + public static extern short cnc_rdmsptype( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBMSTP d); + + /* write mesured point value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmsptype")] + public static extern short cnc_wrmsptype( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBMSTP d); + + /* read parameter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam")] + public static extern short cnc_rdparam(ushort FlibHndl, + short number, short axis, short length, [Out, MarshalAs(UnmanagedType.LPStruct)] IODBPSD param); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam")] + public static extern short cnc_rdparam(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_1 d); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam")] + public static extern short cnc_rdparam(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_2 d); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam")] + public static extern short cnc_rdparam(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_3 d); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam")] + public static extern short cnc_rdparam(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_4 d); +#endif + /* write parameter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrparam")] + public static extern short cnc_wrparam(ushort FlibHndl, short length, [In, MarshalAs(UnmanagedType.LPStruct)] IODBPSD param); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrparam")] + public static extern short cnc_wrparam( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_1 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrparam")] + public static extern short cnc_wrparam( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_2 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrparam")] + public static extern short cnc_wrparam( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_3 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrparam")] + public static extern short cnc_wrparam( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_4 b ); +#endif + /* read parameter(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparar")] + public static extern short cnc_rdparar( ushort FlibHndl, + ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.AsAny)] Object e ); +// [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparar")] +// public static extern short cnc_rdparar( ushort FlibHndl, +// ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_A e ); +// [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparar")] +// public static extern short cnc_rdparar( ushort FlibHndl, +// ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_B e ); +// [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparar")] +// public static extern short cnc_rdparar( ushort FlibHndl, +// ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_C e ); +// [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparar")] +// public static extern short cnc_rdparar( ushort FlibHndl, +// ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_D e ); + + /* write parameter(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrparas")] + public static extern short cnc_wrparas( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdset")] + public static extern short cnc_rdset( ushort FlibHndl, + short number, short axis, short length, [Out, MarshalAs(UnmanagedType.LPStruct)] IODBPSD set); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdset")] + public static extern short cnc_rdset( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_1 d ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdset")] + public static extern short cnc_rdset( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_2 d ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdset")] + public static extern short cnc_rdset( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_3 d ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdset")] + public static extern short cnc_rdset( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_4 d ); +#endif + /* write setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrset")] + public static extern short cnc_wrset(ushort FlibHndl, short length, [In, MarshalAs(UnmanagedType.LPStruct)] IODBPSD set); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrset")] + public static extern short cnc_wrset( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_1 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrset")] + public static extern short cnc_wrset( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_2 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrset")] + public static extern short cnc_wrset( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_3 b ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrset")] + public static extern short cnc_wrset( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_4 b ); +#endif + /* read setting data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsetr")] + public static extern short cnc_rdsetr( ushort FlibHndl, + ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.AsAny)] Object e ); + + /* write setting data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrsets")] + public static extern short cnc_wrsets( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read parameters */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam_ext")] + public static extern short cnc_rdparam_ext( ushort FlibHndl, + [In,Out,MarshalAs(UnmanagedType.LPStruct)] IODBPRMNO a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPRM c ); + + /* read parameter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam3")] + public static extern short cnc_rdparam3(ushort FlibHndl, + short number, short axis, short length, short absolute, [Out, MarshalAs(UnmanagedType.LPStruct)] IODBPSD param); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam3")] + public static extern short cnc_rdparam3(ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_1 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam3")] + public static extern short cnc_rdparam3(ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_2 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam3")] + public static extern short cnc_rdparam3(ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_3 e); + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparam3")] + public static extern short cnc_rdparam3(ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSD_4 e); +#endif + /* async parameter write start */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_start_async_wrparam")] + public static extern short cnc_start_async_wrparam( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPRM a ); + + /* async parameter write end */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_end_async_wrparam")] + public static extern short cnc_end_async_wrparam( ushort FlibHndl, out short a ); + + /* read cause of busy for async parameter write */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_async_busy_state")] + public static extern short cnc_async_busy_state( ushort FlibHndl, out short a ); + + /* read diagnosis data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddiag_ext")] + public static extern short cnc_rddiag_ext( ushort FlibHndl, + [In,Out,MarshalAs(UnmanagedType.LPStruct)] IODBPRMNO a, short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPRM c ); + + /* read pitch error compensation data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpitchr")] + public static extern short cnc_rdpitchr( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPI d ); + + /* write pitch error compensation data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpitchr")] + public static extern short cnc_wrpitchr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPI b ); + + /* read custom macro variable */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmacro")] + public static extern short cnc_rdmacro( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBM c ); + + /* write custom macro variable */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmacro")] + public static extern short cnc_wrmacro( ushort FlibHndl, short a, short b, int c, short d ); + + /* read custom macro variables(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmacror")] + public static extern short cnc_rdmacror( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBMR d ); + + /* write custom macro variables(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmacror")] + public static extern short cnc_wrmacror( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBMR b ); + + /* read custom macro variables(IEEE double version) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmacror2")] + public static extern short cnc_rdmacror2( ushort FlibHndl, int a, ref int b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* write custom macro variables(IEEE double version) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmacror2")] + public static extern short cnc_wrmacror2( ushort FlibHndl, int a, ref int b, [In,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* read P code macro variable */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpmacro")] + public static extern short cnc_rdpmacro( ushort FlibHndl, int a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPM b ); + + /* write P code macro variable */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpmacro")] + public static extern short cnc_wrpmacro( ushort FlibHndl, int a, int b, short c ); + + /* read P code macro variables(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpmacror")] + public static extern short cnc_rdpmacror( ushort FlibHndl, + int a, int b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPR d ); + + /* write P code macro variables(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpmacror")] + public static extern short cnc_wrpmacror( ushort FlibHndl, ushort a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPR b ); + + /* read P code macro variables(IEEE double version) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpmacror2")] + public static extern short cnc_rdpmacror2( ushort FlibHndl, uint a, ref uint b, ushort c, [Out,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* write P code macro variables(IEEE double version) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpmacror2")] + public static extern short cnc_wrpmacror2( ushort FlibHndl, uint a, ref uint b, ushort c, [In,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* read tool offset information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsinfo")] + public static extern short cnc_rdtofsinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLINF a ); + + /* read tool offset information(2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtofsinfo2")] + public static extern short cnc_rdtofsinfo2( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLINF2 a ); + + /* read work zero offset information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdzofsinfo")] + public static extern short cnc_rdzofsinfo( ushort FlibHndl, out short a ); + + /* read pitch error compensation data information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpitchinfo")] + public static extern short cnc_rdpitchinfo( ushort FlibHndl, out short a ); + + /* read custom macro variable information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmacroinfo")] + public static extern short cnc_rdmacroinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMVINF a ); + + /* read P code macro variable information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpmacroinfo")] + public static extern short cnc_rdpmacroinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPMINF a ); + + /* read validity of tool offset */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_tofs_rnge")] + public static extern short cnc_tofs_rnge( ushort FlibHndl, short a , short b , [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDATRNG c ); + + /* read validity of work zero offset */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_zofs_rnge")] + public static extern short cnc_zofs_rnge( ushort FlibHndl, short a , short b , [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDATRNG c ); + + /* read validity of work zero offset */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wksft_rnge")] + public static extern short cnc_wksft_rnge( ushort FlibHndl, short a , [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDATRNG b ); + + /* read the information for function cnc_rdhsparam() */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhsprminfo")] + public static extern short cnc_rdhsprminfo( ushort FlibHndl, int a , [Out,MarshalAs(UnmanagedType.LPStruct)] HSPINFO_data b ); + + /* read parameters at the high speed */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhsparam")] + public static extern short cnc_rdhsparam( ushort FlibHndl, int a , [In,MarshalAs(UnmanagedType.LPStruct)] HSPINFO b , [Out,MarshalAs(UnmanagedType.LPStruct)] HSPDATA_1 c ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhsparam")] + public static extern short cnc_rdhsparam( ushort FlibHndl, int a , [In,MarshalAs(UnmanagedType.LPStruct)] HSPINFO b , [Out,MarshalAs(UnmanagedType.LPStruct)] HSPDATA_2 c ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhsparam")] + public static extern short cnc_rdhsparam( ushort FlibHndl, int a , [In,MarshalAs(UnmanagedType.LPStruct)] HSPINFO b , [Out,MarshalAs(UnmanagedType.LPStruct)] HSPDATA_3 c ); + +/*----------------------------------------*/ +/* CNC: Tool life management data related */ +/*----------------------------------------*/ + + /* read tool life management data(tool group number) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrpid")] + public static extern short cnc_rdgrpid( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE1 b ); + + /* read tool life management data(number of tool groups) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdngrp")] + public static extern short cnc_rdngrp( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE2 a ); + + /* read tool life management data(number of tools) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdntool")] + public static extern short cnc_rdntool( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE3 b ); + + /* read tool life management data(tool life) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlife")] + public static extern short cnc_rdlife( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE3 b ); + + /* read tool life management data(tool lift counter) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcount")] + public static extern short cnc_rdcount( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE3 b ); + + /* read tool life management data(tool length number-1) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd1length")] + public static extern short cnc_rd1length( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(tool length number-2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd2length")] + public static extern short cnc_rd2length( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(cutter compensation no.-1) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd1radius")] + public static extern short cnc_rd1radius( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(cutter compensation no.-2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd2radius")] + public static extern short cnc_rd2radius( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(tool information-1) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_t1info")] + public static extern short cnc_t1info( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(tool information-2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_t2info")] + public static extern short cnc_t2info( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(tool number) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_toolnum")] + public static extern short cnc_toolnum( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE4 c ); + + /* read tool life management data(tool number, tool life, tool life counter)(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtoolrng")] + public static extern short cnc_rdtoolrng( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTR d ); + + /* read tool life management data(all data within group) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtoolgrp")] + public static extern short cnc_rdtoolgrp( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTG c ); + + /* write tool life management data(tool life counter) (area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrcountr")] + public static extern short cnc_wrcountr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IDBWRC b ); + + /* read tool life management data(used tool group number) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdusegrpid")] + public static extern short cnc_rdusegrpid( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBUSEGR a ); + + /* read tool life management data(max. number of tool groups) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmaxgrp")] + public static extern short cnc_rdmaxgrp( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLFNO a ); + + /* read tool life management data(maximum number of tool within group) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmaxtool")] + public static extern short cnc_rdmaxtool( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLFNO a ); + + /* read tool life management data(used tool no. within group) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdusetlno")] + public static extern short cnc_rdusetlno( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLUSE d ); + + /* read tool life management data(tool data1) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd1tlifedata")] + public static extern short cnc_rd1tlifedata( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTD c ); + + /* read tool life management data(tool data2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd2tlifedata")] + public static extern short cnc_rd2tlifedata( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTD c ); + + /* write tool life management data(tool data1) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wr1tlifedata")] + public static extern short cnc_wr1tlifedata( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTD a ); + + /* write tool life management data(tool data2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wr2tlifedata")] + public static extern short cnc_wr2tlifedata( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTD a ); + + /* read tool life management data(tool group information) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrpinfo")] + public static extern short cnc_rdgrpinfo( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTGI d ); + + /* read tool life management data(tool group information 2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrpinfo2")] + public static extern short cnc_rdgrpinfo2( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTGI2 d ); + + /* read tool life management data(tool group information 3) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrpinfo3")] + public static extern short cnc_rdgrpinfo3( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTGI3 d ); + + /* read tool life management data(tool group information 4) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrpinfo4")] + public static extern short cnc_rdgrpinfo4( ushort FlibHndl, + short a, short b, short c, out short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTGI4 e ); + + /* write tool life management data(tool group information) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrgrpinfo")] + public static extern short cnc_wrgrpinfo( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTGI b ); + + /* write tool life management data(tool group information 2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrgrpinfo2")] + public static extern short cnc_wrgrpinfo2( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTGI2 b ); + + /* write tool life management data(tool group information 3) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrgrpinfo3")] + public static extern short cnc_wrgrpinfo3( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTGI3 b ); + + /* delete tool life management data(tool group) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_deltlifegrp")] + public static extern short cnc_deltlifegrp( ushort FlibHndl, short a ); + + /* insert tool life management data(tool data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_instlifedt")] + public static extern short cnc_instlifedt( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IDBITD a ); + + /* delete tool life management data(tool data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_deltlifedt")] + public static extern short cnc_deltlifedt( ushort FlibHndl, short a, short b ); + + /* clear tool life management data(tool life counter, tool information)(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clrcntinfo")] + public static extern short cnc_clrcntinfo( ushort FlibHndl, short a, short b ); + + /* read tool life management data(tool group number) 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrpid2")] + public static extern short cnc_rdgrpid2( ushort FlibHndl, int a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLIFE5 b ); + + /* read tool life management data(tool data1) 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd1tlifedat2")] + public static extern short cnc_rd1tlifedat2( ushort FlibHndl, + short a, int b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTD2 c ); + + /* write tool life management data(tool data1) 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wr1tlifedat2")] + public static extern short cnc_wr1tlifedat2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTD2 a ); + + /* read tool life management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtlinfo")] + public static extern short cnc_rdtlinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBTLINFO a ); + + /* read tool life management data(used tool group number) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtlusegrp")] + public static extern short cnc_rdtlusegrp( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBUSEGRP a ); + + /* read tool life management data(tool group information 2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtlgrp")] + public static extern short cnc_rdtlgrp( ushort FlibHndl, + int a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLGRP c ); + + /* read tool life management data (tool data1) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtltool")] + public static extern short cnc_rdtltool( ushort FlibHndl, + int a, int b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLTOOL d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdexchgtgrp")] + public static extern short cnc_rdexchgtgrp( ushort FlibHndl, + ref short b , [Out,MarshalAs(UnmanagedType.LPStruct)] ODBEXGP c ); + +/*-----------------------------------*/ +/* CNC: Tool management data related */ +/*-----------------------------------*/ + + /* new registration of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_regtool")] + public static extern short cnc_regtool( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLMNG c ); + + /* new registration of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_regtool_f2")] + public static extern short cnc_regtool_f2( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLMNG_F2 c ); + + /* deletion of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_deltool")] + public static extern short cnc_deltool( ushort FlibHndl, short a, ref short b ); + + /* lead of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtool")] + public static extern short cnc_rdtool( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLMNG c ); + + /* lead of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtool_f2")] + public static extern short cnc_rdtool_f2( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLMNG_F2 c ); + + /* write of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtool")] + public static extern short cnc_wrtool( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLMNG b ); + + /* write of individual data of tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtool2")] + public static extern short cnc_wrtool2( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IDBTLM b ); + + /* write tool management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtool_f2")] + public static extern short cnc_wrtool_f2( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLMNG_F2_data b ); + + /* new registration of magazine management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_regmagazine")] + public static extern short cnc_regmagazine( ushort FlibHndl, ref short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLMAG b ); + + /* deletion of magazine management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_delmagazine")] + public static extern short cnc_delmagazine( ushort FlibHndl, ref short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLMAG2 b ); + + /* lead of magazine management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmagazine")] + public static extern short cnc_rdmagazine( ushort FlibHndl, ref short a, [In,Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLMAG b ); + + /* Individual write of magazine management data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmagazine")] + public static extern short cnc_wrmagazine( ushort FlibHndl, short a, short b, short c ); + + +/*-------------------------------------*/ +/* CNC: Operation history data related */ +/*-------------------------------------*/ + + /* stop logging operation history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stopophis")] + public static extern short cnc_stopophis( ushort FlibHndl ); + + /* restart logging operation history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startophis")] + public static extern short cnc_startophis( ushort FlibHndl ); + + /* read number of operation history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophisno")] + public static extern short cnc_rdophisno( ushort FlibHndl, out ushort a ); + + /* read operation history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry")] + public static extern short cnc_rdophistry( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBHIS d ); + + /* read operation history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry2")] + public static extern short cnc_rdophistry2( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* read operation history data F30i*/ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_1 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_2 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_3 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_4 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_5 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_6 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_7 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_8 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_9 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_10 d ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdophistry4")] + public static extern short cnc_rdophistry4( ushort FlibHndl, + ushort a, ref ushort b, ref ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOPHIS4_11 d ); + + /* read number of alarm history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmhisno")] + public static extern short cnc_rdalmhisno( ushort FlibHndl, out ushort a ); + + /* read alarm history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmhistry")] + public static extern short cnc_rdalmhistry( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAHIS d ); + + /* read alarm history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmhistry_w")] + public static extern short cnc_rdalmhistry_w( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAHIS d ); + + /* read alarm history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmhistry2")] + public static extern short cnc_rdalmhistry2( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAHIS2 d ); + + /* read alarm history data F30i*/ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmhistry3")] + public static extern short cnc_rdalmhistry3( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAHIS3 d ); + + /* read alarm history data F30i*/ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmhistry5")] + public static extern short cnc_rdalmhistry5( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAHIS5 d ); + + /* clear operation history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clearophis")] + public static extern short cnc_clearophis( ushort FlibHndl, short a ); + + /* read signals related operation history */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhissgnl")] + public static extern short cnc_rdhissgnl( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSIG a ); + + /* read signals related operation history 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhissgnl2")] + public static extern short cnc_rdhissgnl2( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSIG2 a ); + + /* read signals related operation history 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhissgnl3")] + public static extern short cnc_rdhissgnl3( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSIG3 a ); + + /* write signals related operation history */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrhissgnl")] + public static extern short cnc_wrhissgnl( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSIG a ); + + /* write signals related operation history 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrhissgnl2")] + public static extern short cnc_wrhissgnl2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSIG2 a ); + + /* write signals related operation history for F30i*/ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrhissgnl3")] + public static extern short cnc_wrhissgnl3( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSIG3 a ); + + /* read number of operater message history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdomhisno")] + public static extern short cnc_rdomhisno( ushort FlibHndl, out ushort a ); + +/*-------------*/ +/* CNC: Others */ +/*-------------*/ + + /* read CNC system information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sysinfo")] + public static extern short cnc_sysinfo(ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYS a); + + /* read CNC status information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_statinfo")] + public static extern short cnc_statinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBST a ); + + /* read alarm status */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_alarm")] + public static extern short cnc_alarm(ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBALM a); + + /* read alarm status */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_alarm2")] + public static extern short cnc_alarm2( ushort FlibHndl, out int a ); + + /* read alarm information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalminfo")] + public static extern short cnc_rdalminfo(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ALMINFO_1 d); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalminfo")] + public static extern short cnc_rdalminfo(ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ALMINFO_2 d); + + /* read alarm message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmmsg")] + public static extern short cnc_rdalmmsg( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBALMMSG c ); + + /* read alarm message(2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdalmmsg2")] + public static extern short cnc_rdalmmsg2( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBALMMSG2 c ); + + /* clear CNC alarm */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clralm")] + public static extern short cnc_clralm( ushort FlibHndl, short a ); + + /* read modal data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_modal")] + public static extern short cnc_modal( ushort FlibHndl, + short type, short block, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDL modal ); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_modal")] + public static extern short cnc_modal( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDL_1 c ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_modal")] + public static extern short cnc_modal( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDL_2 c ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_modal")] + public static extern short cnc_modal( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDL_3 c ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_modal")] + public static extern short cnc_modal( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDL_4 c ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_modal")] + public static extern short cnc_modal( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDL_5 c ); +#endif + /* read G code */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgcode")] + public static extern short cnc_rdgcode( ushort FlibHndl, + short a, short b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBGCD d ); + + /* read command value */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcommand")] + public static extern short cnc_rdcommand( ushort FlibHndl, + short a, short b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBCMD d ); + + /* read diagnosis data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnoss")] + public static extern short cnc_diagnoss( ushort FlibHndl, + short number, short axis, short length, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDGN diag ); +#if LEAVE_OLD_STYLE + [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnoss")] + public static extern short cnc_diagnoss( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDGN_1 d ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnoss")] + public static extern short cnc_diagnoss( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDGN_2 d ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnoss")] + public static extern short cnc_diagnoss( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDGN_3 d ); + [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnoss")] + public static extern short cnc_diagnoss( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDGN_4 d ); +#endif + /* read diagnosis data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnosr")] + public static extern short cnc_diagnosr( ushort FlibHndl, + ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.AsAny)] Object e ); +// [DllImport("FWLIB32.dll", EntryPoint="cnc_diagnosr")] +// public static extern short cnc_diagnosr( ushort FlibHndl, +// ref short a, short b, ref short c, ref short d, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDGN e ); + + /* read A/D conversion data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_adcnv")] + public static extern short cnc_adcnv( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAD c ); + + /* read operator's message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopmsg")] + public static extern short cnc_rdopmsg( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] OPMSG c ); + + /* read operator's message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopmsg2")] + public static extern short cnc_rdopmsg2( ushort FlibHndl, short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] OPMSG2 c ); + + /* read operator's message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopmsg3")] + public static extern short cnc_rdopmsg3( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] OPMSG3 c ); + + /* set path number(for 4 axes lathes, multi-path) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setpath")] + public static extern short cnc_setpath( ushort FlibHndl, short a ); + + /* get path number(for 4 axes lathes, multi-path) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getpath")] + public static extern short cnc_getpath( ushort FlibHndl, out short a, out short b ); + + /* allocate library handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_allclibhndl")] + public static extern short cnc_allclibhndl( out ushort FlibHndl ); + + /* free library handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_freelibhndl")] + public static extern short cnc_freelibhndl( ushort FlibHndl ); + + /* get library option */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getlibopt")] + public static extern short cnc_getlibopt( ushort FlibHndl , int a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* set library option */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setlibopt")] + public static extern short cnc_setlibopt( ushort FlibHndl , int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, int c ); + + /* get custom macro type */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getmactype")] + public static extern short cnc_getmactype( ushort FlibHndl, out short a ); + + /* set custom macro type */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setmactype")] + public static extern short cnc_setmactype( ushort FlibHndl, short a ); + + /* get P code macro type */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getpmactype")] + public static extern short cnc_getpmactype( ushort FlibHndl, out short a ); + + /* set P code macro type */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setpmactype")] + public static extern short cnc_setpmactype( ushort FlibHndl, short a ); + + /* get screen status */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getcrntscrn")] + public static extern short cnc_getcrntscrn( ushort FlibHndl, out short a ); + + /* change screen mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_slctscrn")] + public static extern short cnc_slctscrn( ushort FlibHndl, short a ); + + /* read CNC configuration information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sysconfig")] + public static extern short cnc_sysconfig( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYSC a ); + + /* read program restart information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprstrinfo")] + public static extern short cnc_rdprstrinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPRS a ); + + /* search sequence number for program restart */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rstrseqsrch")] + public static extern short cnc_rstrseqsrch( ushort FlibHndl, int a, int b, short c, short d ); + + /* search sequence number for program restart 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rstrseqsrch2")] + public static extern short cnc_rstrseqsrch2( ushort FlibHndl, int a, int b, short c, short d, int e ); + + /* read output signal image of software operator's panel */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopnlsgnl")] + public static extern short cnc_rdopnlsgnl( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSGNL b ); + + /* write output signal of software operator's panel */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wropnlsgnl")] + public static extern short cnc_wropnlsgnl( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSGNL a ); + + /* read general signal image of software operator's panel */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopnlgnrl")] + public static extern short cnc_rdopnlgnrl( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBGNRL b ); + + /* write general signal image of software operator's panel */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wropnlgnrl")] + public static extern short cnc_wropnlgnrl( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBGNRL a ); + + /* read general signal name of software operator's panel */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopnlgsname")] + public static extern short cnc_rdopnlgsname( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBRDNA b ); + + /* write general signal name of software operator's panel */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wropnlgsname")] + public static extern short cnc_wropnlgsname( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBRDNA a ); + + /* get detail error */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getdtailerr")] + public static extern short cnc_getdtailerr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBERR a ); + + /* read informations of CNC parameter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparainfo")] + public static extern short cnc_rdparainfo( ushort FlibHndl, + short a, ushort b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPARAIF c ); + + /* read informations of CNC setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsetinfo")] + public static extern short cnc_rdsetinfo( ushort FlibHndl, + short a, ushort b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSETIF c ); + + /* read informations of CNC diagnose data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddiaginfo")] + public static extern short cnc_rddiaginfo( ushort FlibHndl, + short a, ushort b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDIAGIF c ); + + /* read maximum, minimum and total number of CNC parameter */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdparanum")] + public static extern short cnc_rdparanum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPARANUM a ); + + /* read maximum, minimum and total number of CNC setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsetnum")] + public static extern short cnc_rdsetnum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSETNUM a ); + + /* read maximum, minimum and total number of CNC diagnose data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddiagnum")] + public static extern short cnc_rddiagnum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDIAGNUM a ); + + /* get maximum valid figures and number of decimal places */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getfigure")] + public static extern short cnc_getfigure( ushort FlibHndl, + short a, out short b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c, [Out,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* read F-ROM information on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdfrominfo")] + public static extern short cnc_rdfrominfo( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBFINFO b ); + + /* start of reading F-ROM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromsvstart")] + public static extern short cnc_fromsvstart( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, int c ); + + /* read F-ROM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromsave")] + public static extern short cnc_fromsave( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* end of reading F-ROM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromsvend")] + public static extern short cnc_fromsvend( ushort FlibHndl ); + + /* start of writing F-ROM data to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromldstart")] + public static extern short cnc_fromldstart( ushort FlibHndl, short a, int b ); + + /* write F-ROM data to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromload")] + public static extern short cnc_fromload( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, ref int b ); + + /* end of writing F-ROM data to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromldend")] + public static extern short cnc_fromldend( ushort FlibHndl ); + + /* delete F-ROM data on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromdelete")] + public static extern short cnc_fromdelete( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, int c ); + + /* read S-RAM information on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsraminfo")] + public static extern short cnc_rdsraminfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSINFO a ); + + /* start of reading S-RAM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srambkstart")] + public static extern short cnc_srambkstart( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, int b ); + + /* read S-RAM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srambackup")] + public static extern short cnc_srambackup( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* end of reading S-RAM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srambkend")] + public static extern short cnc_srambkend( ushort FlibHndl ); + + /* read F-ROM information on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getfrominfo")] + public static extern short cnc_getfrominfo( ushort FlibHndl, + short a, out short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBFINFORM c ); + + /* start of reading F-ROM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromgetstart")] + public static extern short cnc_fromgetstart( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read F-ROM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromget")] + public static extern short cnc_fromget( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* end of reading F-ROM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromgetend")] + public static extern short cnc_fromgetend( ushort FlibHndl ); + + /* start of writing F-ROM data to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromputstart")] + public static extern short cnc_fromputstart( ushort FlibHndl, short a ); + + /* write F-ROM data to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromput")] + public static extern short cnc_fromput( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, ref int b ); + + /* end of writing F-ROM data to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromputend")] + public static extern short cnc_fromputend( ushort FlibHndl ); + + /* delete F-ROM data on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_fromremove")] + public static extern short cnc_fromremove( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read S-RAM information on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getsraminfo")] + public static extern short cnc_getsraminfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSINFO a ); + + /* start of reading S-RAM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sramgetstart")] + public static extern short cnc_sramgetstart( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* start of reading S-RAM data from CNC (2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sramgetstart2")] + public static extern short cnc_sramgetstart2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read S-RAM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sramget")] + public static extern short cnc_sramget( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* read S-RAM data from CNC (2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sramget2")] + public static extern short cnc_sramget2( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* end of reading S-RAM data from CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sramgetend")] + public static extern short cnc_sramgetend( ushort FlibHndl ); + + /* end of reading S-RAM data from CNC (2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sramgetend2")] + public static extern short cnc_sramgetend2( ushort FlibHndl ); + + /* read number of S-RAM data kind on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsramnum")] + public static extern short cnc_rdsramnum( ushort FlibHndl, out short a ); + + /* read S-RAM data address information on CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsramaddr")] + public static extern short cnc_rdsramaddr( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.LPStruct)] SRAMADDR b ); + + /* get current NC data protection information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getlockstat")] + public static extern short cnc_getlockstat( ushort FlibHndl, short a, out byte b ); + + /* change NC data protection status */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_chgprotbit")] + public static extern short cnc_chgprotbit( ushort FlibHndl, short a, ref byte b, int c ); + + /* transfer a file from host computer to CNC by FTP */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvftpget")] + public static extern short cnc_dtsvftpget( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* transfer a file from CNC to host computer by FTP */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvftpput")] + public static extern short cnc_dtsvftpput( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* get transfer status for FTP */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvftpstat")] + public static extern short cnc_dtsvftpstat( ushort FlibHndl ); + + /* read file directory in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvrdpgdir")] + public static extern short cnc_dtsvrdpgdir( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDSDIR c ); + + /* delete files in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvdelete")] + public static extern short cnc_dtsvdelete( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* down load from CNC (transfer a file from CNC to MMC) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvdownload")] + public static extern short cnc_dtsvdownload( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* up load to CNC (transfer a file from MMC to CNC) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvupload")] + public static extern short cnc_dtsvupload( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* close upload/download between Data Server and CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvcnclupdn")] + public static extern short cnc_dtsvcnclupdn( ushort FlibHndl ); + + /* get transfer status for up/down load */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvupdnstat")] + public static extern short cnc_dtsvupdnstat( ushort FlibHndl ); + + /* get file name for DNC operation in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvgetdncpg")] + public static extern short cnc_dtsvgetdncpg( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* set program number of DNC oparation to CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvsetdncpg")] + public static extern short cnc_dtsvsetdncpg( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read setting data for Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvrdset")] + public static extern short cnc_dtsvrdset( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBDSSET a ); + + /* write setting data for Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvwrset")] + public static extern short cnc_dtsvwrset( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBDSSET a ); + + /* check hard disk in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvchkdsk")] + public static extern short cnc_dtsvchkdsk( ushort FlibHndl ); + + /* format hard disk in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvhdformat")] + public static extern short cnc_dtsvhdformat( ushort FlibHndl ); + + /* save interface area in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvsavecram")] + public static extern short cnc_dtsvsavecram( ushort FlibHndl ); + + /* get interface area in Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvrdcram")] + public static extern short cnc_dtsvrdcram( ushort FlibHndl, int a, ref int b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* read maintenance information for Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvmntinfo")] + public static extern short cnc_dtsvmntinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDSMNT a ); + + /* get Data Server mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvgetmode")] + public static extern short cnc_dtsvgetmode( ushort FlibHndl, out short a ); + + /* set Data Server mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvsetmode")] + public static extern short cnc_dtsvsetmode( ushort FlibHndl, short a ); + + /* read error message for Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvrderrmsg")] + public static extern short cnc_dtsvrderrmsg( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* transfar file from Pc to Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvwrfile")] + public static extern short cnc_dtsvwrfile( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, short c ); + + /* transfar file from Data Server to Pc */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dtsvrdfile")] + public static extern short cnc_dtsvrdfile( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, short c ); + + /* read the loop gain for each axis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdloopgain")] + public static extern short cnc_rdloopgain( ushort FlibHndl, out int a ); + + /* read the actual current for each axis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcurrent")] + public static extern short cnc_rdcurrent( ushort FlibHndl, out short a ); + + /* read the actual speed for each axis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsrvspeed")] + public static extern short cnc_rdsrvspeed( ushort FlibHndl, out int a ); + + /* read the operation mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdopmode")] + public static extern short cnc_rdopmode( ushort FlibHndl, out short a ); + + /* read the position deviation S */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdposerrs")] + public static extern short cnc_rdposerrs( ushort FlibHndl, out int a ); + + /* read the position deviation S1 and S2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdposerrs2")] + public static extern short cnc_rdposerrs2( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPSER a ); + + /* read the position deviation Z in the rigid tap mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdposerrz")] + public static extern short cnc_rdposerrz( ushort FlibHndl, out int a ); + + /* read the synchronous error in the synchronous control mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsynerrsy")] + public static extern short cnc_rdsynerrsy( ushort FlibHndl, out int a ); + + /* read the synchronous error in the rigid tap mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsynerrrg")] + public static extern short cnc_rdsynerrrg( ushort FlibHndl, out int a ); + + /* read the spindle alarm */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspdlalm")] + public static extern short cnc_rdspdlalm( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read the control input signal */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdctrldi")] + public static extern short cnc_rdctrldi( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPDI a ); + + /* read the control output signal */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdctrldo")] + public static extern short cnc_rdctrldo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPDO a ); + + /* read the number of controled spindle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdnspdl")] + public static extern short cnc_rdnspdl( ushort FlibHndl, out short a ); + + /* read data from FANUC BUS */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdfbusmem")] + public static extern short cnc_rdfbusmem( ushort FlibHndl, + short a, short b, int c, int d, [Out,MarshalAs(UnmanagedType.AsAny)] Object e ); + + /* write data to FANUC BUS */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrfbusmem")] + public static extern short cnc_wrfbusmem( ushort FlibHndl, + short a, short b, int c, int d, [In,MarshalAs(UnmanagedType.AsAny)] Object e ); + + /* read the parameter of wave diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdwaveprm")] + public static extern short cnc_rdwaveprm( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBWAVE a ); + + /* write the parameter of wave diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrwaveprm")] + public static extern short cnc_wrwaveprm( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBWAVE a ); + + /* read the parameter of wave diagnosis 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdwaveprm2")] + public static extern short cnc_rdwaveprm2( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBWVPRM a ); + + /* write the parameter of wave diagnosis 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrwaveprm2")] + public static extern short cnc_wrwaveprm2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBWVPRM a ); + + /* start the sampling for wave diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wavestart")] + public static extern short cnc_wavestart( ushort FlibHndl ); + + /* stop the sampling for wave diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wavestop")] + public static extern short cnc_wavestop( ushort FlibHndl ); + + /* read the status of wave diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wavestat")] + public static extern short cnc_wavestat( ushort FlibHndl, out short a ); + + /* read the data of wave diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdwavedata")] + public static extern short cnc_rdwavedata( ushort FlibHndl, + short a, short b, int c, ref int d, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBWVDT e ); + + /* read the parameter of wave diagnosis for remort diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrmtwaveprm")] + public static extern short cnc_rdrmtwaveprm( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBRMTPRM a, short b ); + + /* write the parameter of wave diagnosis for remort diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrrmtwaveprm")] + public static extern short cnc_wrrmtwaveprm( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBRMTPRM a ); + + /* start the sampling for wave diagnosis for remort diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rmtwavestart")] + public static extern short cnc_rmtwavestart( ushort FlibHndl ); + + /* stop the sampling for wave diagnosis for remort diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rmtwavestop")] + public static extern short cnc_rmtwavestop( ushort FlibHndl ); + + /* read the status of wave diagnosis for remort diagnosis*/ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rmtwavestat")] + public static extern short cnc_rmtwavestat( ushort FlibHndl, out short a ); + + /* read the data of wave diagnosis for remort diagnosis */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrmtwavedt")] + public static extern short cnc_rdrmtwavedt( ushort FlibHndl, + short a, int b, ref int c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBRMTDT d ); + + /* read of address for PMC signal batch save */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsavsigadr")] + public static extern short cnc_rdsavsigadr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSIGAD a, short b ); + + /* write of address for PMC signal batch save */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrsavsigadr")] + public static extern short cnc_wrsavsigadr( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSIGAD a, out short b ); + + /* read of data for PMC signal batch save */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsavsigdata")] + public static extern short cnc_rdsavsigdata( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c, ref short d ); + + /* read M-code group data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmgrpdata")] + public static extern short cnc_rdmgrpdata( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMGRP c ); + + /* write M-code group data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmgrpdata")] + public static extern short cnc_wrmgrpdata( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IDBMGRP a ); + + /* read executing M-code group data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdexecmcode")] + public static extern short cnc_rdexecmcode( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBEXEM c ); + + /* read program restart M-code group data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrstrmcode")] + public static extern short cnc_rdrstrmcode( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBRSTRM c ); + + /* read processing time stamp data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdproctime")] + public static extern short cnc_rdproctime( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPTIME a ); + + /* read MDI program stat */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmdiprgstat")] + public static extern short cnc_rdmdiprgstat( ushort FlibHndl, out ushort a ); + + /* read program directory for processing time data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprgdirtime")] + public static extern short cnc_rdprgdirtime( ushort FlibHndl, + ref int a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIRTM c ); + + /* read program directory 2 */ +#if (!ONO8D) + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogdir2")] + public static extern short cnc_rdprogdir2( ushort FlibHndl, + short a, ref short b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIR2 d ); +#else + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogdir2o8")] + public static extern short cnc_rdprogdir2( ushort FlibHndl, + short a, ref short b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIR2 d ); +#endif + + /* read program directory 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogdir3")] + public static extern short cnc_rdprogdir3( ushort FlibHndl, + short a, ref int b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIR3 d ); + + /* read program directory 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdprogdir4")] + public static extern short cnc_rdprogdir4( ushort FlibHndl, + short a, int b, ref short c, [Out,MarshalAs(UnmanagedType.LPStruct)] PRGDIR4 d ); + + /* read DNC file name for DNC1, DNC2, OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddncfname")] + public static extern short cnc_rddncfname( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* write DNC file name for DNC1, DNC2, OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrdncfname")] + public static extern short cnc_wrdncfname( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read communication parameter for DNC1, DNC2, OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcomparam")] + public static extern short cnc_rdcomparam( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBCPRM a ); + + /* write communication parameter for DNC1, DNC2, OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrcomparam")] + public static extern short cnc_wrcomparam( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBCPRM a ); + + /* read log message for DNC2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcomlogmsg")] + public static extern short cnc_rdcomlogmsg( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read operator message for DNC1, DNC2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcomopemsg")] + public static extern short cnc_rdcomopemsg( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read recieve message for OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrcvmsg")] + public static extern short cnc_rdrcvmsg( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read send message for OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsndmsg")] + public static extern short cnc_rdsndmsg( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* send message for OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sendmessage")] + public static extern short cnc_sendmessage( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* clear message buffer for OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clrmsgbuff")] + public static extern short cnc_clrmsgbuff( ushort FlibHndl, short a ); + + /* read message recieve status for OSI-Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrcvstat")] + public static extern short cnc_rdrcvstat( ushort FlibHndl, out ushort a ); + + /* read interference check */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdintchk")] + public static extern short cnc_rdintchk( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBINT e ); + + /* write interference check */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrintchk")] + public static extern short cnc_wrintchk( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBINT b ); + + /* read interference check information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdintinfo")] + public static extern short cnc_rdintinfo( ushort FlibHndl, out short a ); + + /* read work coordinate shift */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdwkcdshft")] + public static extern short cnc_rdwkcdshft( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBWCSF c ); + + /* write work coordinate shift */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrwkcdshft")] + public static extern short cnc_wrwkcdshft( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBWCSF b ); + + /* read work coordinate shift measure */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdwkcdsfms")] + public static extern short cnc_rdwkcdsfms( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBWCSF c ); + + /* write work coordinate shift measure */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrwkcdsfms")] + public static extern short cnc_wrwkcdsfms( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBWCSF b ); + + /* stop the sampling for operator message history */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stopomhis")] + public static extern short cnc_stopomhis( ushort FlibHndl ); + + /* start the sampling for operator message history */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startomhis")] + public static extern short cnc_startomhis( ushort FlibHndl ); + + /* read operator message history information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdomhisinfo")] + public static extern short cnc_rdomhisinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOMIF a ); + + /* read operator message history */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdomhistry")] + public static extern short cnc_rdomhistry( ushort FlibHndl, + ushort a, ref ushort b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOMHIS c ); + + /* read operater message history data F30i */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdomhistry2")] + public static extern short cnc_rdomhistry2( ushort FlibHndl, + ushort a, ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBOMHIS2 d ); + + /* write external key operation history for F30i*/ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrkeyhistry")] + public static extern short cnc_wrkeyhistry( ushort FlibHndl, byte a ); + + /* clear operator message history */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clearomhis")] + public static extern short cnc_clearomhis( ushort FlibHndl ); + + /* read b-axis tool offset value(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdbtofsr")] + public static extern short cnc_rdbtofsr( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBBTO e ); + + /* write b-axis tool offset value(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrbtofsr")] + public static extern short cnc_wrbtofsr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBBTO b ); + + /* read b-axis tool offset information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdbtofsinfo")] + public static extern short cnc_rdbtofsinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBBTLINF a ); + + /* read b-axis command */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdbaxis")] + public static extern short cnc_rdbaxis( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBBAXIS a ); + + /* read CNC system soft series and version */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsyssoft")] + public static extern short cnc_rdsyssoft( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYSS a ); + + /* read CNC system soft series and version (2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsyssoft2")] + public static extern short cnc_rdsyssoft2( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYSS2 a ); + + /* read CNC module configuration information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmdlconfig")] + public static extern short cnc_rdmdlconfig( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMDLC a ); + + /* read CNC module configuration information 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmdlconfig2")] + public static extern short cnc_rdmdlconfig2( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* read processing condition file (processing data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpscdproc")] + public static extern short cnc_rdpscdproc( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPSCD c ); + + /* write processing condition file (processing data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpscdproc")] + public static extern short cnc_wrpscdproc( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPSCD c ); + + /* read processing condition file (piercing data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpscdpirc")] + public static extern short cnc_rdpscdpirc( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPIRC c ); + + /* write processing condition file (piercing data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpscdpirc")] + public static extern short cnc_wrpscdpirc( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPIRC c ); + + /* read processing condition file (edging data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpscdedge")] + public static extern short cnc_rdpscdedge( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBEDGE c ); + + /* write processing condition file (edging data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpscdedge")] + public static extern short cnc_wrpscdedge( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBEDGE c ); + + /* read processing condition file (slope data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpscdslop")] + public static extern short cnc_rdpscdslop( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSLOP c ); + + /* write processing condition file (slope data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpscdslop")] + public static extern short cnc_wrpscdslop( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSLOP c ); + + /* read power controll duty data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlpwrdty")] + public static extern short cnc_rdlpwrdty( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBLPWDT a ); + + /* write power controll duty data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlpwrdty")] + public static extern short cnc_wrlpwrdty( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBLPWDT a ); + + /* read laser power data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlpwrdat")] + public static extern short cnc_rdlpwrdat( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLOPDT a ); + + /* read power complement */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlpwrcpst")] + public static extern short cnc_rdlpwrcpst( ushort FlibHndl, out short a ); + + /* write power complement */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlpwrcpst")] + public static extern short cnc_wrlpwrcpst( ushort FlibHndl, short a ); + + /* read laser assist gas selection */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlagslt")] + public static extern short cnc_rdlagslt( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBLAGSL a ); + + /* write laser assist gas selection */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlagslt")] + public static extern short cnc_wrlagslt( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBLAGSL a ); + + /* read laser assist gas flow */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlagst")] + public static extern short cnc_rdlagst( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBLAGST a ); + + /* write laser assist gas flow */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlagst")] + public static extern short cnc_wrlagst( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBLAGST a ); + + /* read laser power for edge processing */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdledgprc")] + public static extern short cnc_rdledgprc( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBLEGPR a ); + + /* write laser power for edge processing */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrledgprc")] + public static extern short cnc_wrledgprc( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBLEGPR a ); + + /* read laser power for piercing */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlprcprc")] + public static extern short cnc_rdlprcprc( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBLPCPR a ); + + /* write laser power for piercing */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlprcprc")] + public static extern short cnc_wrlprcprc( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBLPCPR a ); + + /* read laser command data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlcmddat")] + public static extern short cnc_rdlcmddat( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLCMDT a ); + + /* read displacement */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdldsplc")] + public static extern short cnc_rdldsplc( ushort FlibHndl, out short a ); + + /* write displacement */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrldsplc")] + public static extern short cnc_wrldsplc( ushort FlibHndl, short a ); + + /* read error for axis z */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlerrz")] + public static extern short cnc_rdlerrz( ushort FlibHndl, out short a ); + + /* read active number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlactnum")] + public static extern short cnc_rdlactnum( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLACTN a ); + + /* read laser comment */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlcmmt")] + public static extern short cnc_rdlcmmt( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLCMMT a ); + + /* read laser power select */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlpwrslt")] + public static extern short cnc_rdlpwrslt( ushort FlibHndl, out short a ); + + /* write laser power select */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlpwrslt")] + public static extern short cnc_wrlpwrslt( ushort FlibHndl, short a ); + + /* read laser power controll */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlpwrctrl")] + public static extern short cnc_rdlpwrctrl( ushort FlibHndl, out short a ); + + /* write laser power controll */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrlpwrctrl")] + public static extern short cnc_wrlpwrctrl( ushort FlibHndl, short a ); + + /* read power correction factor history data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpwofsthis")] + public static extern short cnc_rdpwofsthis( ushort FlibHndl, + int a, ref int b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPWOFST c ); + + /* read management time */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmngtime")] + public static extern short cnc_rdmngtime( ushort FlibHndl, + int a, ref int b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBMNGTIME c ); + + /* write management time */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmngtime")] + public static extern short cnc_wrmngtime( ushort FlibHndl, int a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBMNGTIME b ); + + /* read data related to electrical discharge at power correction ends */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddischarge")] + public static extern short cnc_rddischarge( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDISCHRG a ); + + /* read alarm history data related to electrical discharg */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddischrgalm")] + public static extern short cnc_rddischrgalm( ushort FlibHndl, + int a, ref int b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBDISCHRGALM c ); + + /* get date and time from cnc */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_gettimer")] + public static extern short cnc_gettimer( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTIMER a ); + + /* set date and time for cnc */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_settimer")] + public static extern short cnc_settimer( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTIMER a ); + + /* read timer data from cnc */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtimer")] + public static extern short cnc_rdtimer( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTIME b ); + + /* write timer data for cnc */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtimer")] + public static extern short cnc_wrtimer( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTIME b ); + + /* read tool controll data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtlctldata")] + public static extern short cnc_rdtlctldata( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLCTL a ); + + /* write tool controll data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtlctldata")] + public static extern short cnc_wrtlctldata( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLCTL a ); + + /* read tool data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtooldata")] + public static extern short cnc_rdtooldata( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLDT c ); + + /* read tool data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtooldata")] + public static extern short cnc_wrtooldata( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLDT c ); + + /* read multi tool data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmultitldt")] + public static extern short cnc_rdmultitldt( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBMLTTL c ); + + /* write multi tool data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmultitldt")] + public static extern short cnc_wrmultitldt( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBMLTTL c ); + + /* read multi tap data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmtapdata")] + public static extern short cnc_rdmtapdata( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBMTAP c ); + + /* write multi tap data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmtapdata")] + public static extern short cnc_wrmtapdata( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBMTAP c ); + + /* read multi-piece machining number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmultipieceno")] + public static extern short cnc_rdmultipieceno( ushort FlibHndl, out int a ); + + /* read tool information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtoolinfo")] + public static extern short cnc_rdtoolinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPTLINF a ); + + /* read safetyzone data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsafetyzone")] + public static extern short cnc_rdsafetyzone( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSAFE c ); + + /* write safetyzone data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrsafetyzone")] + public static extern short cnc_wrsafetyzone( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSAFE c ); + + /* read toolzone data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdtoolzone")] + public static extern short cnc_rdtoolzone( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBTLZN c ); + + /* write toolzone data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrtoolzone")] + public static extern short cnc_wrtoolzone( ushort FlibHndl, + short a, ref short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBTLZN c ); + + /* read active toolzone data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdacttlzone")] + public static extern short cnc_rdacttlzone(ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBACTTLZN a); + + /* read setzone number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsetzone")] + public static extern short cnc_rdsetzone( ushort FlibHndl, out short a ); + + /* write setzone number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrsetzone")] + public static extern short cnc_wrsetzone( ushort FlibHndl, short a ); + + /* read block restart information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdbrstrinfo")] + public static extern short cnc_rdbrstrinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBBRS a ); + + /* read menu switch signal */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmenuswitch")] + public static extern short cnc_rdmenuswitch( ushort FlibHndl, out short a ); + + /* write menu switch signal */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrmenuswitch")] + public static extern short cnc_wrmenuswitch( ushort FlibHndl, short a, short b ); + + /* read tool radius offset for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdradofs")] + public static extern short cnc_rdradofs( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBROFS a ); + + /* read tool length offset for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdlenofs")] + public static extern short cnc_rdlenofs( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBLOFS a ); + + /* read fixed cycle for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdfixcycle")] + public static extern short cnc_rdfixcycle( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBFIX a ); + + /* read coordinate rotate for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcdrotate")] + public static extern short cnc_rdcdrotate( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBROT a ); + + /* read 3D coordinate convert for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd3dcdcnv")] + public static extern short cnc_rd3dcdcnv( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODB3DCD a ); + + /* read programable mirror image for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdmirimage")] + public static extern short cnc_rdmirimage( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBMIR a ); + + /* read scaling for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdscaling")] + public static extern short cnc_rdscaling( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSCL a ); + + /* read 3D tool offset for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd3dtofs")] + public static extern short cnc_rd3dtofs( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODB3DTO a ); + + /* read tool position offset for position data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdposofs")] + public static extern short cnc_rdposofs( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPOFS a ); + + /* read hpcc setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhpccset")] + public static extern short cnc_rdhpccset( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBHPST a ); + + /* write hpcc setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrhpccset")] + public static extern short cnc_wrhpccset( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBHPST a ); + + /* hpcc data auto setting data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_hpccatset")] + public static extern short cnc_hpccatset( ushort FlibHndl ); + + /* read hpcc tuning data ( parameter input ) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhpcctupr")] + public static extern short cnc_rdhpcctupr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBHPPR a ); + + /* write hpcc tuning data ( parameter input ) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrhpcctupr")] + public static extern short cnc_wrhpcctupr( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBHPPR a ); + + /* read hpcc tuning data ( acc input ) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdhpcctuac")] + public static extern short cnc_rdhpcctuac( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBHPAC a ); + + /* write hpcc tuning data ( acc input ) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrhpcctuac")] + public static extern short cnc_wrhpcctuac( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBHPAC a ); + + /* hpcc data auto tuning */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_hpccattune")] + public static extern short cnc_hpccattune( ushort FlibHndl, short a, out short b ); + + /* read hpcc fine level */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_hpccactfine")] + public static extern short cnc_hpccactfine( ushort FlibHndl, out short a ); + + /* select hpcc fine level */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_hpccselfine")] + public static extern short cnc_hpccselfine( ushort FlibHndl, short a ); + + /* read active fixture offset */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdactfixofs")] + public static extern short cnc_rdactfixofs( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBZOFS b ); + + /* read fixture offset */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdfixofs")] + public static extern short cnc_rdfixofs( ushort FlibHndl, + short a, short b, short c, short d, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBZOR e ); + + /* write fixture offset */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrfixofs")] + public static extern short cnc_wrfixofs( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBZOR b ); + + /* read tip of tool for 3D handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd3dtooltip")] + public static extern short cnc_rd3dtooltip( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODB3DHDL a ); + + /* read pulse for 3D handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd3dpulse")] + public static extern short cnc_rd3dpulse( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODB3DPLS a ); + + /* read move overrlap of tool for 3D handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd3dmovrlap")] + public static extern short cnc_rd3dmovrlap( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODB3DHDL a ); + + /* read change offset for 3D handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rd3dofschg")] + public static extern short cnc_rd3dofschg( ushort FlibHndl, ref int a ); + + /* clear pulse and change offset for 3D handle */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clr3dplsmov")] + public static extern short cnc_clr3dplsmov( ushort FlibHndl, short a ); + + /* cycle start */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_start")] + public static extern short cnc_start( ushort FlibHndl ); + + /* reset CNC */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_reset")] + public static extern short cnc_reset( ushort FlibHndl ); + + /* reset CNC 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_reset2")] + public static extern short cnc_reset2( ushort FlibHndl ); + + /* read axis name */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdaxisname")] + public static extern short cnc_rdaxisname( ushort FlibHndl, + ref short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXISNAME b ); + + /* read spindle name */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdspdlname")] + public static extern short cnc_rdspdlname( ushort FlibHndl, + ref short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSPDLNAME b ); + + /* read extended axis name */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_exaxisname")] + public static extern short cnc_exaxisname( ushort FlibHndl, + short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBEXAXISNAME c ); + + /* read SRAM variable area for C language executor */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcexesram")] + public static extern short cnc_rdcexesram( ushort FlibHndl, int a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* write SRAM variable area for C language executor */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrcexesram")] + public static extern short cnc_wrcexesram( ushort FlibHndl, int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, ref int c ); + + /* read maximum size and linear address of SRAM variable area for C language executor */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cexesraminfo")] + public static extern short cnc_cexesraminfo( ushort FlibHndl, out short a, out int b, out int c ); + + /* read maximum size of SRAM variable area for C language executor */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cexesramsize")] + public static extern short cnc_cexesramsize( ushort FlibHndl, out int a ); + + /* read additional workpiece coordinate systems number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcoordnum")] + public static extern short cnc_rdcoordnum( ushort FlibHndl, out short a ); + + /* converts from FANUC code to Shift JIS code */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_ftosjis")] + public static extern short cnc_ftosjis( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* Set the unsolicited message parameters */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrunsolicprm")] + public static extern short cnc_wrunsolicprm( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBUNSOLIC b ); + + /* Get the unsolicited message parameters */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdunsolicprm")] + public static extern short cnc_rdunsolicprm( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBUNSOLIC b ); + + /* Set the unsolicited message parameters(2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrunsolicprm2")] + public static extern short cnc_wrunsolicprm2( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBUNSOLIC2 b ); + + /* Get the unsolicited message parameters(2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdunsolicprm2")] + public static extern short cnc_rdunsolicprm2( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBUNSOLIC2 b ); + + /* Start of unsolicited message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_unsolicstart")] + public static extern short cnc_unsolicstart( ushort FlibHndl, short a, int hWnd, uint c, short d, out short e ); + + /* End of unsolicited message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_unsolicstop")] + public static extern short cnc_unsolicstop( ushort FlibHndl, short a ); + + /* Reads the unsolicited message data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdunsolicmsg")] + public static extern short cnc_rdunsolicmsg(short a, [In, Out] IDBUNSOLICMSG b); + + /* Reads the unsolicited message data(2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdunsolicmsg2")] + public static extern short cnc_rdunsolicmsg2(short a, [In, Out] IDBUNSOLICMSG2 b); + + /* read machine specific maintenance item */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpm_mcnitem")] + public static extern short cnc_rdpm_mcnitem( ushort FlibHndl, short a , ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBITEM c ); + + /* write machine specific maintenance item */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpm_mcnitem")] + public static extern short cnc_wrpm_mcnitem( ushort FlibHndl, short a , short b, [In,MarshalAs(UnmanagedType.LPStruct)] IODBITEM c ); + + /* read cnc maintenance item */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpm_cncitem")] + public static extern short cnc_rdpm_cncitem( ushort FlibHndl, short a , ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBITEM c ); + + /* read maintenance item status */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdpm_item")] + public static extern short cnc_rdpm_item( ushort FlibHndl, short a , ref short b , [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPMAINTE c ); + + /* write maintenance item status */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrpm_item")] + public static extern short cnc_wrpm_item( ushort FlibHndl, short a , short b , short c , [In,MarshalAs(UnmanagedType.LPStruct)] IODBPMAINTE d ); + + /* Display of optional message */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_dispoptmsg")] + public static extern short cnc_dispoptmsg( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* Reading of answer for optional message display */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_optmsgans")] + public static extern short cnc_optmsgans( ushort FlibHndl, out short a ); + + /* Get CNC Model */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getcncmodel")] + public static extern short cnc_getcncmodel( ushort FlibHndl, out short a ); + + /* read number of repeats */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrepeatval")] + public static extern short cnc_rdrepeatval( ushort FlibHndl, out int a ); + + /* read CNC system hard info */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsyshard")] + public static extern short cnc_rdsyshard( ushort FlibHndl, short a, ref short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYSH c ); + + /* read CNC system soft series and version (3) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdsyssoft3")] + public static extern short cnc_rdsyssoft3( ushort FlibHndl, short a , ref short b , out short c , [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYSS3 d ); + + /* read digit of program number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_progdigit")] + public static extern short cnc_progdigit( ushort FlibHndl, out short a ); + + /* read CNC system path information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sysinfo_ex")] + public static extern short cnc_sysinfo_ex( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSYSEX a ); + +/*------------------*/ +/* CNC : SERCOS I/F */ +/*------------------*/ + + /* Get reservation of service channel for SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsrsvchnl")] + public static extern short cnc_srcsrsvchnl( ushort FlibHndl ); + + /* Read ID information of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsrdidinfo")] + public static extern short cnc_srcsrdidinfo( ushort FlibHndl, + int a, short b, short c, [Out,MarshalAs(UnmanagedType.AsAny)] IODBIDINF d ); + + /* Write ID information of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcswridinfo")] + public static extern short cnc_srcswridinfo( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBIDINF a ); + + /* Start of reading operation data from drive of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsstartrd")] + public static extern short cnc_srcsstartrd( ushort FlibHndl, int a, short b ); + + /* Start of writing operation data to drive of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsstartwrt")] + public static extern short cnc_srcsstartwrt( ushort FlibHndl, int a, short b ); + + /* Stop of reading/writing operation data from/to drive of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsstopexec")] + public static extern short cnc_srcsstopexec( ushort FlibHndl ); + + /* Get execution status of reading/writing operation data of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsrdexstat")] + public static extern short cnc_srcsrdexstat( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSRCSST a ); + + /* Read operation data from data buffer for SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsrdopdata")] + public static extern short cnc_srcsrdopdata( ushort FlibHndl, int a, ref int b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* Write operation data to data buffer for SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcswropdata")] + public static extern short cnc_srcswropdata( ushort FlibHndl, int a, int b, [In,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* Free reservation of service channel for SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsfreechnl")] + public static extern short cnc_srcsfreechnl( ushort FlibHndl ); + + /* Read drive assign of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsrdlayout")] + public static extern short cnc_srcsrdlayout( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSRCSLYT a ); + + /* Read communication phase of drive of SERCOS I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_srcsrddrvcp")] + public static extern short cnc_srcsrddrvcp( ushort FlibHndl, out short a ); + + +/*----------------------------*/ +/* CNC : Graphic command data */ +/*----------------------------*/ + + /* Start drawing position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startdrawpos")] + public static extern short cnc_startdrawpos( ushort FlibHndl ); + + /* Stop drawing position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stopdrawpos")] + public static extern short cnc_stopdrawpos( ushort FlibHndl ); + + /* Start dynamic graphic */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startdyngrph")] + public static extern short cnc_startdyngrph( ushort FlibHndl ); + + /* Stop dynamic graphic */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stopdyngrph")] + public static extern short cnc_stopdyngrph( ushort FlibHndl ); + + /* Read graphic command data */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrphcmd")] + public static extern short cnc_rdgrphcmd( ushort FlibHndl, ref short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* Update graphic command read pointer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrgrphcmdptr")] + public static extern short cnc_wrgrphcmdptr( ushort FlibHndl, short a ); + + /* Read cancel flag */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdgrphcanflg")] + public static extern short cnc_rdgrphcanflg( ushort FlibHndl, out short a ); + + /* Clear graphic command */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clrgrphcmd")] + public static extern short cnc_clrgrphcmd( ushort FlibHndl ); + + +/*---------------------------*/ +/* CNC : Servo learning data */ +/*---------------------------*/ + + /* Servo learning data read start */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtstartrd")] + public static extern short cnc_svdtstartrd( ushort FlibHndl, short a ); + + /* Servo learning data write start */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtstartwr")] + public static extern short cnc_svdtstartwr( ushort FlibHndl, short a ); + + /* Servo learning data read end */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtendrd")] + public static extern short cnc_svdtendrd( ushort FlibHndl ); + + /* Servo learning data write end */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtendwr")] + public static extern short cnc_svdtendwr( ushort FlibHndl ); + + /* Servo learning data read/write stop */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtstopexec")] + public static extern short cnc_svdtstopexec( ushort FlibHndl ); + + /* Servo learning data read from I/F buffer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtrddata")] + public static extern short cnc_svdtrddata( ushort FlibHndl, + out short a, ref int b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* Servo learning data write to I/F buffer */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_svdtwrdata")] + public static extern short cnc_svdtwrdata( ushort FlibHndl, + out short a, ref int b, [In,MarshalAs(UnmanagedType.AsAny)] Object c ); + + +/*----------------------------*/ +/* CNC : Servo Guide */ +/*----------------------------*/ + /* Servo Guide (Channel data set) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdsetchnl")] + public static extern short cnc_sdsetchnl( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IDBCHAN b ); + + /* Servo Guide (Channel data clear) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdclrchnl")] + public static extern short cnc_sdclrchnl( ushort FlibHndl ); + + /* Servo Guide (Sampling start) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdstartsmpl")] + public static extern short cnc_sdstartsmpl( ushort FlibHndl, short a, int b, [Out,MarshalAs(UnmanagedType.AsAny)] Object c ); + + /* Servo Guide (Sampling cancel) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdcancelsmpl")] + public static extern short cnc_sdcancelsmpl( ushort FlibHndl ); + + /* Servo Guide (read Sampling data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdreadsmpl")] + public static extern short cnc_sdreadsmpl( ushort FlibHndl, + out short a, int b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSD c ); + + /* Servo Guide (Sampling end) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdendsmpl")] + public static extern short cnc_sdendsmpl( ushort FlibHndl ); + + /* Servo Guide (read 1 shot data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdread1shot")] + public static extern short cnc_sdread1shot( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* Servo feedback data (Channel data set) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sfbsetchnl")] + public static extern short cnc_sfbsetchnl( ushort FlibHndl, + short a, int b, [In,MarshalAs(UnmanagedType.LPStruct)] IDBSFBCHAN c ); + + /* Servo feedback data (Channel data clear) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sfbclrchnl")] + public static extern short cnc_sfbclrchnl( ushort FlibHndl ); + + /* Servo feedback data (Sampling start) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sfbstartsmpl")] + public static extern short cnc_sfbstartsmpl( ushort FlibHndl, short a, int b ); + + /* Servo feedback data (Sampling cancel) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sfbcancelsmpl")] + public static extern short cnc_sfbcancelsmpl( ushort FlibHndl ); + + /* Servo feedback data (read Sampling data) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sfbreadsmpl")] + public static extern short cnc_sfbreadsmpl( ushort FlibHndl, + out short a, int b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSD c ); + + /* Servo feedback data (Sampling end) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_sfbendsmpl")] + public static extern short cnc_sfbendsmpl( ushort FlibHndl ); + + +/*----------------------------*/ +/* CNC : NC display function */ +/*----------------------------*/ + + /* Start NC display */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startnccmd")] + public static extern short cnc_startnccmd( ushort FlibHndl ); + + /* Start NC display (2) */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startnccmd2")] + public static extern short cnc_startnccmd2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ); + + /* Stop NC display */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stopnccmd")] + public static extern short cnc_stopnccmd( ushort FlibHndl ); + + /* Get NC display mode */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getdspmode")] + public static extern short cnc_getdspmode( ushort FlibHndl, out short a ); + + +/*------------------------------------*/ +/* CNC : Remote diagnostics function */ +/*------------------------------------*/ + + /* Start remote diagnostics function */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startrmtdgn")] + public static extern short cnc_startrmtdgn( ushort FlibHndl ); + + /* Stop remote diagnostics function */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stoprmtdgn")] + public static extern short cnc_stoprmtdgn( ushort FlibHndl ); + + /* Read data from remote diagnostics I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdrmtdgn")] + public static extern short cnc_rdrmtdgn( ushort FlibHndl, out int a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* Write data to remote diagnostics I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrrmtdgn")] + public static extern short cnc_wrrmtdgn( ushort FlibHndl, ref int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* Set CommStatus of remote diagnostics I/F area */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrcommstatus")] + public static extern short cnc_wrcommstatus( ushort FlibHndl, short a ); + + /* Check remote diagnostics I/F */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_chkrmtdgn")] + public static extern short cnc_chkrmtdgn( ushort FlibHndl ); + + +/*-------------------------*/ +/* CNC : FS18-LN function */ +/*-------------------------*/ + + /* read allowance */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_allowance")] + public static extern short cnc_allowance(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + /* read allowanced state */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_allowcnd")] + public static extern short cnc_allowcnd( ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBCAXIS c ); + + /* set work zero */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_workzero")] + public static extern short cnc_workzero( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBZOFS b ); + + /* set slide position */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_slide")] + public static extern short cnc_slide(ushort FlibHndl, + short a, short b, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBAXIS c); + + +/*----------------------------------*/ +/* CNC: Teaching data I/F function */ +/*----------------------------------*/ + + /* Teaching data get start */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_startgetdgdat")] + public static extern short cnc_startgetdgdat( ushort FlibHndl ); + + /* Teaching data get stop */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_stopgetdgdat")] + public static extern short cnc_stopgetdgdat( ushort FlibHndl ); + + /* Teaching data read */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rddgdat")] + public static extern short cnc_rddgdat( ushort FlibHndl, ref short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* Teaching data read pointer write */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrdgdatptr")] + public static extern short cnc_wrdgdatptr( ushort FlibHndl, short a ); + + /* Teaching data clear */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_clrdgdat")] + public static extern short cnc_clrdgdat( ushort FlibHndl ); + + +/*---------------------------------*/ +/* CNC : C-EXE SRAM file function */ +/*---------------------------------*/ + + /* open C-EXE SRAM file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_opencexefile")] + public static extern short cnc_opencexefile( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, short b, short c ); + + /* close C-EXE SRAM file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_closecexefile")] + public static extern short cnc_closecexefile( ushort FlibHndl ); + + /* read C-EXE SRAM file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdcexefile")] + public static extern short cnc_rdcexefile( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a, ref uint b ); + + /* write C-EXE SRAM file */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_wrcexefile")] + public static extern short cnc_wrcexefile( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, ref uint b ); + + /* read C-EXE SRAM disk directory */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_cexedirectory")] + public static extern short cnc_cexedirectory( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, ref ushort b, ushort c, [Out,MarshalAs(UnmanagedType.LPStruct)] CFILEINFO d ); + + +/*-----*/ +/* PMC */ +/*-----*/ + + /* read message from PMC to MMC */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdmsg")] + public static extern short pmc_rdmsg( ushort FlibHndl, ref short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* write message from MMC to PMC */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrmsg")] + public static extern short pmc_wrmsg( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read message from PMC to MMC(conditional) */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_crdmsg")] + public static extern short pmc_crdmsg( ushort FlibHndl, ref short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* write message from MMC to PMC(conditional) */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_cwrmsg")] + public static extern short pmc_cwrmsg( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* read PMC data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcrng")] + public static extern short pmc_rdpmcrng( ushort FlibHndl, + short a, short b, ushort c, ushort d, ushort e, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPMC0 f ); + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcrng")] + public static extern short pmc_rdpmcrng( ushort FlibHndl, + short a, short b, ushort c, ushort d, ushort e, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPMC1 f ); + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcrng")] + public static extern short pmc_rdpmcrng( ushort FlibHndl, + short a, short b, ushort c, ushort d, ushort e, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPMC2 f ); + + /* write PMC data(area specified) */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrpmcrng")] + public static extern short pmc_wrpmcrng( ushort FlibHndl, ushort a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPMC0 b ); + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrpmcrng")] + public static extern short pmc_wrpmcrng( ushort FlibHndl, ushort a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPMC1 b ); + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrpmcrng")] + public static extern short pmc_wrpmcrng( ushort FlibHndl, ushort a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPMC2 b ); + + /* read data from extended backup memory */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdkpm")] + public static extern short pmc_rdkpm( ushort FlibHndl, uint a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, ushort c ); + + /* write data to extended backup memory */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrkpm")] + public static extern short pmc_wrkpm( ushort FlibHndl, uint a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, ushort c ); + + /* read data from extended backup memory 2 */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdkpm2")] + public static extern short pmc_rdkpm2( ushort FlibHndl, uint a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b, uint c ); + + /* write data to extended backup memory 2 */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrkpm2")] + public static extern short pmc_wrkpm2( ushort FlibHndl, uint a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, uint c ); + + /* read maximum size of extended backup memory */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_kpmsiz")] + public static extern short pmc_kpmsiz( ushort FlibHndl, out uint a ); + + /* read informations of PMC data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcinfo")] + public static extern short pmc_rdpmcinfo( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPMCINF b ); + + /* read PMC parameter data table contorol data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdcntldata")] + public static extern short pmc_rdcntldata( ushort FlibHndl, + short a, short b, short c, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPMCCNTL d ); + + /* write PMC parameter data table contorol data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrcntldata")] + public static extern short pmc_wrcntldata( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPMCCNTL b ); + + /* read PMC parameter data table contorol data group number */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdcntlgrp")] + public static extern short pmc_rdcntlgrp( ushort FlibHndl, out short a ); + + /* write PMC parameter data table contorol data group number */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrcntlgrp")] + public static extern short pmc_wrcntlgrp( ushort FlibHndl, short a ); + + /* read PMC alarm message */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdalmmsg")] + public static extern short pmc_rdalmmsg( ushort FlibHndl, + short a, ref short b, out short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPMCALM d ); + + /* get detail error for pmc */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_getdtailerr")] + public static extern short pmc_getdtailerr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPMCERR a ); + + /* read PMC memory data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcmem")] + public static extern short pmc_rdpmcmem( ushort FlibHndl, + short a, int b, int c, [Out,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* write PMC memory data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrpmcmem")] + public static extern short pmc_wrpmcmem( ushort FlibHndl, + short a, int b, int c, [In,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* read PMC-SE memory data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcsemem")] + public static extern short pmc_rdpmcsemem( ushort FlibHndl, + short a, int b, int c, [Out,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* write PMC-SE memory data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrpmcsemem")] + public static extern short pmc_wrpmcsemem( ushort FlibHndl, + short a, int b, int c, [In,MarshalAs(UnmanagedType.AsAny)] Object d ); + + /* read pmc title data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmctitle")] + public static extern short pmc_rdpmctitle( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPMCTITLE a ); + + /* read PMC parameter start */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdprmstart")] + public static extern short pmc_rdprmstart( ushort FlibHndl); + + /* read PMC parameter */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcparam")] + public static extern short pmc_rdpmcparam( ushort FlibHndl, ref int a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b); + + /* read PMC parameter end */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdprmend")] + public static extern short pmc_rdprmend( ushort FlibHndl); + + /* write PMC parameter start */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrprmstart")] + public static extern short pmc_wrprmstart( ushort FlibHndl); + + /* write PMC parameter */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrpmcparam")] + public static extern short pmc_wrpmcparam( ushort FlibHndl,ref int a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* write PMC parameter end */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wrprmend")] + public static extern short pmc_wrprmend( ushort FlibHndl); + + /* read PMC data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcrng_ext")] + public static extern short pmc_rdpmcrng_ext( ushort FlibHndl, + short a, [In,Out,MarshalAs(UnmanagedType.LPStruct)] IODBPMCEXT b ); + + /* write PMC I/O link assigned data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_wriolinkdat")] + public static extern short pmc_wriolinkdat( ushort FlibHndl, uint a, [In,MarshalAs(UnmanagedType.AsAny)] Object b, uint c ); + + /* read PMC address information */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_rdpmcaddr")] + public static extern short pmc_rdpmcaddr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPMCADR a ); + + /* select PMC unit */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_select_pmc_unit")] + public static extern short pmc_select_pmc_unit( ushort FlibHndl, int a ); + + /* get current PMC unit */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_get_current_pmc_unit")] + public static extern short pmc_get_current_pmc_unit( ushort FlibHndl, ref int a ); + + /* get number of PMC */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_get_number_of_pmc")] + public static extern short pmc_get_number_of_pmc( ushort FlibHndl, ref int a ); + + /* get PMC unit types */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_get_pmc_unit_types")] + public static extern short pmc_get_pmc_unit_types( ushort FlibHndl, int[] a, ref int b ); + + /* set PMC Timer type */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_set_timer_type")] + public static extern short pmc_set_timer_type( ushort FlibHndl, ushort a, ushort b, ref short c ); + + /* get PMC Timer type */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_get_timer_type")] + public static extern short pmc_get_timer_type( ushort FlibHndl, ushort a, ushort b, ref short c ); + +/*----------------------------*/ +/* PMC : PROFIBUS function */ +/*----------------------------*/ + + /* read PROFIBUS configration data */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdconfig")] + public static extern short pmc_prfrdconfig( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBPRFCNF a ); + + /* read bus parameter for master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdbusprm")] + public static extern short pmc_prfrdbusprm( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBBUSPRM a ); + + /* write bus parameter for master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrbusprm")] + public static extern short pmc_prfwrbusprm( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBBUSPRM a ); + + /* read slave parameter for master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdslvprm")] + public static extern short pmc_prfrdslvprm( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSLVPRM b ); + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdslvprm")] + public static extern short pmc_prfrdslvprm( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSLVPRM2 b ); + + /* write slave parameter for master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrslvprm")] + public static extern short pmc_prfwrslvprm( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSLVPRM b ); + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrslvprm")] + public static extern short pmc_prfwrslvprm( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSLVPRM2 b ); + + /* read allocation address for master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdallcadr")] + public static extern short pmc_prfrdallcadr( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBPRFADR b ); + + /* set allocation address for master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrallcadr")] + public static extern short pmc_prfwrallcadr( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBPRFADR b ); + + /* read allocation address for slave function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdslvaddr")] + public static extern short pmc_prfrdslvaddr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSLVADR a ); + + /* set allocation address for slave function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrslvaddr")] + public static extern short pmc_prfwrslvaddr( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSLVADR a ); + + /* read status for slave function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdslvstat")] + public static extern short pmc_prfrdslvstat( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBSLVST a ); + + /* Reads slave index data of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdslvid")] + public static extern short pmc_prfrdslvid( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSLVID b ); + + /* Writes slave index data of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrslvid")] + public static extern short pmc_prfwrslvid( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSLVID b ); + + /* Reads slave parameter of master function(2) */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdslvprm2")] + public static extern short pmc_prfrdslvprm2( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBSLVPRM3 b ); + + /* Writes slave parameter of master function(2) */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrslvprm2")] + public static extern short pmc_prfwrslvprm2( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBSLVPRM3 b ); + + /* Reads DI/DO parameter of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrddido")] + public static extern short pmc_prfrddido( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBDIDO b ) ; + + /* Writes DI/DO parameter of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrdido")] + public static extern short pmc_prfwrdido( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.LPStruct)] IODBDIDO b ) ; + + /* Reads indication address of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdindiadr")] + public static extern short pmc_prfrdindiadr( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBINDEADR a ) ; + + /* Writes indication address of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwrindiadr")] + public static extern short pmc_prfwrindiadr( ushort FlibHndl, [In,MarshalAs(UnmanagedType.LPStruct)] IODBINDEADR a ) ; + + /* Reads operation mode of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfrdopmode")] + public static extern short pmc_prfrdopmode( ushort FlibHndl, ref short a ) ; + + /* Writes operation mode of master function */ + [DllImport("FWLIB32.dll", EntryPoint="pmc_prfwropmode")] + public static extern short pmc_prfwropmode( ushort FlibHndl, short a, ref short b ) ; + +/*-----------------------------------------------*/ +/* DS : Data server & Ethernet board function */ +/*-----------------------------------------------*/ + + /* read the parameter of the Ethernet board */ + [DllImport("FWLIB32.dll", EntryPoint="etb_rdparam")] + public static extern short etb_rdparam( ushort FlibHndl, + short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBETP_TCP b ) ; + [DllImport("FWLIB32.dll", EntryPoint="etb_rdparam")] + public static extern short etb_rdparam(ushort FlibHndl, + short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBETP_HOST b ) ; + [DllImport("FWLIB32.dll", EntryPoint="etb_rdparam")] + public static extern short etb_rdparam(ushort FlibHndl, + short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBETP_FTP b ) ; + [DllImport("FWLIB32.dll", EntryPoint="etb_rdparam")] + public static extern short etb_rdparam(ushort FlibHndl, + short a, [Out,MarshalAs(UnmanagedType.LPStruct)] IODBETP_ETB b ) ; + + /* write the parameter of the Ethernet board */ + [DllImport("FWLIB32.dll", EntryPoint="etb_wrparam")] + public static extern short etb_wrparam( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.LPStruct)] IODBETP_TCP a ) ; + [DllImport("FWLIB32.dll", EntryPoint="etb_wrparam")] + public static extern short etb_wrparam( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.LPStruct)] IODBETP_HOST a ) ; + [DllImport("FWLIB32.dll", EntryPoint="etb_wrparam")] + public static extern short etb_wrparam( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.LPStruct)] IODBETP_FTP a ) ; + + /* read the error message of the Ethernet board */ + [DllImport("FWLIB32.dll", EntryPoint="etb_rderrmsg")] + public static extern short etb_rderrmsg( ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBETMSG b ) ; + + /* read the mode of the Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdmode")] + public static extern short ds_rdmode( ushort FlibHndl, ref short a ) ; + + /* write the mode of the Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrmode")] + public static extern short ds_wrmode( ushort FlibHndl, short a ) ; + + /* read information of the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdhddinfo")] + public static extern short ds_rdhddinfo( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBHDDINF a ) ; + + /* read the file list of the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdhdddir")] + public static extern short ds_rdhdddir(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, int b, out short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBHDDDIR d); + + /* delete the file of the Data Serve's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_delhddfile")] + public static extern short ds_delhddfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* copy the file of the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_copyhddfile")] + public static extern short ds_copyhddfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b); + + /* change the file name of the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_renhddfile")] + public static extern short ds_renhddfile( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ) ; + + /* execute the PUT command of the FTP */ + [DllImport("FWLIB32.dll", EntryPoint="ds_puthddfile")] + public static extern short ds_puthddfile( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ); + + /* execute the MPUT command of the FTP */ + [DllImport("FWLIB32.dll", EntryPoint="ds_mputhddfile")] + public static extern short ds_mputhddfile(ushort hLib, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* read information of the host */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdhostinfo")] + public static extern short ds_rdhostinfo( ushort FlibHndl, out int a, int b ) ; + + /* read the file list of the host */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdhostdir")] + public static extern short ds_rdhostdir( ushort FlibHndl, short a, int b,out short c, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBHOSTDIR d, int e ) ; + + /* read the file list of the host 2 */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdhostdir2")] + public static extern short ds_rdhostdir2( ushort FlibHndl, short a, int b,out short c,out int d, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBHOSTDIR e, int f ) ; + + /* delete the file of the host */ + [DllImport("FWLIB32.dll", EntryPoint="ds_delhostfile")] + public static extern short ds_delhostfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, int b); + + /* execute the GET command of the FTP */ + [DllImport("FWLIB32.dll", EntryPoint="ds_gethostfile")] + public static extern short ds_gethostfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a, [In,MarshalAs(UnmanagedType.AsAny)] Object b); + + /* execute the MGET command of the FTP */ + [DllImport("FWLIB32.dll", EntryPoint="ds_mgethostfile")] + public static extern short ds_mgethostfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* read the execution result */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdresult")] + public static extern short ds_rdresult( ushort FlibHndl ) ; + + /* stop the execution of the command */ + [DllImport("FWLIB32.dll", EntryPoint="ds_cancel")] + public static extern short ds_cancel( ushort FlibHndl ) ; + + /* read the file from the Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdncfile")] + public static extern short ds_rdncfile( ushort FlibHndl, short a, [In,MarshalAs(UnmanagedType.AsAny)] Object b ) ; + + /* read the file from the Data Server 2 */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdncfile2")] + public static extern short ds_rdncfile2( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ) ; + + /* write the file to the Data Server */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrncfile")] + public static extern short ds_wrncfile( ushort FlibHndl, short a, int b ) ; + + /* read the file name for the DNC operation in the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rddnchddfile")] + public static extern short ds_rddnchddfile( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ) ; + + /* write the file name for the DNC operation in the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrdnchddfile")] + public static extern short ds_wrdnchddfile( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ) ; + + /* read the file name for the DNC operation in the host */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rddnchostfile")] + public static extern short ds_rddnchostfile( ushort FlibHndl, out short a, [Out,MarshalAs(UnmanagedType.AsAny)] Object b); + + /* write the file name for the DNC operation in the host */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrdnchostfile")] + public static extern short ds_wrdnchostfile( ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a ) ; + + /* read the connecting host number */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdhostno")] + public static extern short ds_rdhostno(ushort FlibHndl, out short a); + + /* read maintenance information */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdmntinfo")] + public static extern short ds_rdmntinfo(ushort FlibHndl, short a, [Out,MarshalAs(UnmanagedType.LPStruct)]DSMNTINFO b); + + /* check the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_checkhdd")] + public static extern short ds_checkhdd(ushort FlibHndl); + + /* format the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_formathdd")] + public static extern short ds_formathdd(ushort FlibHndl); + + /* create the directory in the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_makehdddir")] + public static extern short ds_makehdddir(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* delete directory in the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_delhdddir")] + public static extern short ds_delhdddir(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* change the current directory */ + [DllImport("FWLIB32.dll", EntryPoint="ds_chghdddir")] + public static extern short ds_chghdddir(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* execute the PUT command according to the list file */ + [DllImport("FWLIB32.dll", EntryPoint="ds_lputhddfile")] + public static extern short ds_lputhddfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* delete files according to the list file */ + [DllImport("FWLIB32.dll", EntryPoint="ds_ldelhddfile")] + public static extern short ds_ldelhddfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* execute the GET command according to the list file */ + [DllImport("FWLIB32.dll", EntryPoint="ds_lgethostfile")] + public static extern short ds_lgethostfile(ushort FlibHndl, [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* read the directory for M198 operation */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdm198hdddir")] + public static extern short ds_rdm198hdddir( ushort FlibHndl, [Out,MarshalAs(UnmanagedType.AsAny)] Object a ) ; + + /* write the directory for M198 operation */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrm198hdddir")] + public static extern short ds_wrm198hdddir( ushort FlibHndl ) ; + + /* read the connecting host number for the M198 operation */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdm198host")] + public static extern short ds_rdm198host( ushort FlibHndl, out short a ) ; + + /* write the connecting host number for the M198 operation */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrm198host")] + public static extern short ds_wrm198host( ushort FlibHndl ) ; + + /* write the connecting host number */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrhostno")] + public static extern short ds_wrhostno( ushort FlibHndl, short a ) ; + + /* search string in data server program */ + [DllImport("FWLIB32.dll", EntryPoint="ds_searchword")] + public static extern short ds_searchword( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a); + + /* read the searching result */ + [DllImport("FWLIB32.dll", EntryPoint="ds_searchresult")] + public static extern short ds_searchresult( ushort FlibHndl); + + /* read file in the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_rdfile")] + public static extern short ds_rdfile( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, + [In,MarshalAs(UnmanagedType.AsAny)] Object b); + + /* write file in the Data Server's HDD */ + [DllImport("FWLIB32.dll", EntryPoint="ds_wrfile")] + public static extern short ds_wrfile( ushort FlibHndl, + [In,MarshalAs(UnmanagedType.AsAny)] Object a, + [In,MarshalAs(UnmanagedType.AsAny)] Object b); + +/*--------------------------*/ +/* HSSB multiple connection */ +/*--------------------------*/ + + /* read number of node */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdnodenum")] + public static extern short cnc_rdnodenum( out int a ); + + /* read node informations */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdnodeinfo")] + public static extern short cnc_rdnodeinfo( int a, [Out,MarshalAs(UnmanagedType.LPStruct)] ODBNODE b ); + + /* set default node number */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_setdefnode")] + public static extern short cnc_setdefnode( int a ); + + /* allocate library handle 2 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_allclibhndl2")] + public static extern short cnc_allclibhndl2( int node, out ushort FlibHndl ); + + +/*---------------------*/ +/* Ethernet connection */ +/*---------------------*/ + + /* allocate library handle 3 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_allclibhndl3")] + public static extern short cnc_allclibhndl3( [In,MarshalAs(UnmanagedType.AsAny)] Object ip, + ushort port,int timeout, out ushort FlibHndl); + + /* allocate library handle 4 */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_allclibhndl4")] + public static extern short cnc_allclibhndl4( [In,MarshalAs(UnmanagedType.AsAny)] Object ip, + ushort port,int timeout, uint id, out ushort FlibHndl); + + /* set timeout for socket */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_settimeout")] + public static extern short cnc_settimeout( ushort FlibHndl, int a ); + + /* reset all socket connection */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_resetconnect")] + public static extern short cnc_resetconnect( ushort FlibHndl ); + + /* get option state for FOCAS1/Ethernet */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_getfocas1opt")] + public static extern short cnc_getfocas1opt( ushort FlibHndl, short a, out int b ); + + /* read Ethernet board information */ + [DllImport("FWLIB32.dll", EntryPoint="cnc_rdetherinfo")] + public static extern short cnc_rdetherinfo( ushort FlibHndl, out short a, out short b ); + + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct IDBSDTCHAN + { + public short type; + public byte chno; + public byte axis; + public ushort shift; + } + //[StructLayout(LayoutKind.Sequential, Pack = 4)] + //public struct ODBSD + //{ + // public IntPtr chadata; + // public IntPtr count; + //} + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtsetchnl")] + public static extern short cnc_sdtsetchnl(ushort FlibHndl, short num, int datanum, [In] IDBSDTCHAN[] channel); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtclrchnl")] + public static extern short cnc_sdtclrchnl( ushort FlibHndl ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtstartsmpl")] + public static extern short cnc_sdtstartsmpl( ushort FlibHndl, short path, int seq_no ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtcancelsmpl")] + public static extern short cnc_sdtcancelsmpl( ushort FlibHndl ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtreadsmpl")] + public static extern short cnc_sdtreadsmpl(ushort FlibHndl, out short stat, int datanum, [In] ODBSD[] sampledata); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtendsmpl")] + public static extern short cnc_sdtendsmpl( ushort FlibHndl ); + + [DllImport("FWLIB32.dll", EntryPoint="cnc_sdtread1shot")] + public static extern short cnc_sdtread1shot(ushort FlibHndl, out ushort[] data); + + // Personalizzate + [DllImport("FWLIB32.dll", EntryPoint = "cnc_rdalmmsg")] + public static extern short cnc_rdalmmsg_custom(ushort FlibHndl, short a, ref short b, [Out, MarshalAs(UnmanagedType.LPArray, SizeConst = 17)] ODBALMMSG_data_custom[] c); + + + [DllImport("FWLIB32.dll", EntryPoint = "cnc_rdalmmsg2")] + public static extern short cnc_rdalmmsg2_custom(ushort FlibHndl, short a, ref short b, [Out, MarshalAs(UnmanagedType.LPArray, SizeConst = 17)] ODBALMMSG2_data_custom[] c); + + /* read operator's message */ + [DllImport("FWLIB32.dll", EntryPoint = "cnc_rdopmsg3")] + public static extern short cnc_rdopmsg3_custom(ushort FlibHndl, + short type, ref short number, [Out, MarshalAs(UnmanagedType.LPArray, SizeConst = 17)] Focas1.OPMSG3_data_custom[] opmsg); + +} // End for Focas1 class diff --git a/nunit.runsettings b/nunit.runsettings new file mode 100644 index 0000000..4ab25bc --- /dev/null +++ b/nunit.runsettings @@ -0,0 +1,12 @@ + + + + {m} + + + diff --git a/packages.config b/packages.config new file mode 100755 index 0000000..1d940f5 --- /dev/null +++ b/packages.config @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file