Форум программистов [Powered by Invision Power Board]

Код

namespace PInvokeExample
{
    using System;
    // Нужно для получения доступа к типан PInvoke
    using System.Runtime.InteropServices;
    using System.Diagnostics;
    using System.Threading;
    using System.Text;
    public class PInvokeClient
    {
        public static IntPtr ptr;

        public static IntPtr _rebootNotification=CreateEvent(IntPtr.Zero, false, false, null);
        public static IntPtr _regulatoryRegionChangeNotification=CreateEvent(IntPtr.Zero, false, false, null);
        public static IntPtr _inventoryNotification=CreateEvent(IntPtr.Zero, false, false, null);

        public static int _rebootResultCode;
        public static int _regulatoryRegionResultCode;
        public static IntPtr _inventoryNtf;//=(IntPtr)Marshal.StructureToPtr(MAPI_DATA_INVENTORY_NTF,0,false);

        [DllImport("libMach1.dll")] 
        public static extern IntPtr MAPI_Connect(string host,int k,ref MAPI_CONNECT_ERROR sl);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="Reader"></param>
        /// <returns></returns>
        [DllImport("libMach1.dll")]
        public static extern MAPI_DATA MAPI_BootModemCmd(IntPtr Reader);
        
        [DllImport("libMach1.dll")]
        public static extern void MAPI_FlushData(IntPtr Reader);
        
        [DllImport("libMach1.dll")]
        public static extern void MAPI_Free(IntPtr mem);

        [DllImport("libMach1.dll",EntryPoint="MAPI_Free")]
        public unsafe static extern void MAPI_Free_(ushort * mem);

        [DllImport("libMach1.dll")]
        public static extern MAPI_DATA MAPI_GetData(IntPtr Reader);

        [DllImport("libMach1.dll")]
        public static extern MAPI_DATA MAPI_SetRegulatoryRegionCmd(IntPtr Reader,ref MAPI_DATA_SET_REGULATORY_REGION_CMD command);

        [DllImport("libMach1.dll")]
        public static extern MAPI_DATA MAPI_InventoryCmd(IntPtr Reader,ref MAPI_DATA_INVENTORY_CMD command);

        [DllImport("my.dll")]
        public static extern void _epc(char[] buffer, IntPtr EPCData, UInt32 EPCLength);

        [DllImport("my.dll")]
        public static extern int Add(int a,int b);

        [DllImport("kernel32.dll",SetLastError=true,ExactSpelling=true)]
        public static extern Int32 WaitForSingleObject(IntPtr handle,Int32 mlsec);

        [DllImport("kernel32.dll")]
        static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);

        [DllImport("kernel32.dll")]
        static extern bool SetEvent(IntPtr hEvent);

        static int Main()
        {
            ReaderConnect();
            if(ptr!=IntPtr.Zero)
            {
                Console.Write("Rebooting modem .");
                Thread t = new Thread(new ThreadStart(DataThread));
                if(t==null)
                    Console.WriteLine("Не удалось создать поток");
                t.Start(); 
                BootModem(ptr);
                
                SetRegulatoryRegion(2);
                StartInventory();
                //Console.WriteLine("add = "+Add(2,3));
                epc();
                return 1;
            }
            else
                return 0;
        }
        static int epc()
        {
            int i=0;
            while (ptr!=IntPtr.Zero )
            {

                WaitForSingleObject(_inventoryNotification, 99999);
                //int k=0;
                if (_inventoryNtf!=IntPtr.Zero)
                {
                    //Format the EPC
            
                    //char[] EPCString=new char[24];
                    //string EPCString="";
                    string temp="";
                    MAPI_DATA_INVENTORY_NTF _invent=(MAPI_DATA_INVENTORY_NTF)Marshal.PtrToStructure(_inventoryNtf,typeof(MAPI_DATA_INVENTORY_NTF));
                    unsafe
                    {
                        FormatEPC(ref temp,_invent.Epc,_invent.EpcLen);
                    }
                    MAPI_Free(_inventoryNtf);
                    if(_invent.EpcLen>0)
                    {
                        i++;
                        Console.WriteLine(i+")   antenna {0} >>      EPC: {1}",_invent.Antenna,temp);
                        unsafe
                        {
                            MAPI_Free_(_invent.Epc);
                        }
                        MAPI_Free(_inventoryNtf);
                        _inventoryNtf = IntPtr.Zero;
                    }
                }
            }
            return 0;
        }

        unsafe static void FormatEPC(ref string buffer, ushort * EPCData, UInt32 EPCLength)
        {
            if (0 == EPCLength)
            {
                buffer="Blank EPC";
            }
            else
            {
                UInt32 epcLenIter=0;
                ushort *epcIter = EPCData;
                string[]mas=new string[6];
                char[]m=new char[4];
                //Console.WriteLine("len: "+EPCLength);
                while (epcLenIter < EPCLength)
                {
                    //Console.WriteLine("-->"+String.Format("{0:X}",Int32.Parse(epcIter->ToString())));
                    mas[epcLenIter]=String.Format("{0:X4}",Int32.Parse(epcIter->ToString()));
                    epcLenIter++;
                    epcIter++;
                }
                buffer=mas[0]+"-"+mas[1]+"-"+mas[2]+"-"+mas[3]+"-"+mas[4]+"-"+mas[5];
            }
        }
        static void StartInventory()
        {
            MAPI_DATA_INVENTORY_CMD command=new MAPI_DATA_INVENTORY_CMD();
            MAPI_FlushData(ptr);
            MAPI_DATA response = MAPI_InventoryCmd(ptr, ref command);
            switch (response.Type)
            {
                case MAPI_DATA_TYPE.MAPI_DATA_TYPE_INVALID_COMMAND_NTF:
                {
                    MAPI_DATA_INVALID_COMMAND_NTF invalidCommand = 
                        (MAPI_DATA_INVALID_COMMAND_NTF)Marshal.PtrToStructure(response.Data,typeof(MAPI_DATA_INVALID_COMMAND_NTF));
                    Console.WriteLine("Received Invalid Command Notification while starting inventory\n");
                    Console.WriteLine("Reason Code = {0}, Reader State = {1}\n",invalidCommand.ReasonCode, invalidCommand.State);
                    //MAPI_Free(invalidCommand);
                    //exit(1);
                    break;
                }
                case MAPI_DATA_TYPE.MAPI_DATA_TYPE_INVENTORY_RSP:
                {
                    MAPI_DATA_INVENTORY_RSP inventoryResponse = 
                        (MAPI_DATA_INVENTORY_RSP)Marshal.PtrToStructure(response.Data,typeof(MAPI_DATA_INVENTORY_RSP));
                    byte resultCode = inventoryResponse.ResultCode;
                    //MAPI_Free(inventoryResponse);
                    if (0 != resultCode)
                    {
                        Console.WriteLine("Failed to start Inventory- Result Code = %d\n",resultCode);
                        //exit(1);
                        
                    }
                    break;
                }
            }
        }
        public static void BootModem(IntPtr ptr)
        {
            MAPI_FlushData(ptr);
            MAPI_DATA response=MAPI_BootModemCmd(ptr);
            MAPI_Free(response.Data);
            bool bootComplete = false;

            while(!bootComplete)
            {
                WaitForSingleObject(_rebootNotification,99999);
                //Console.WriteLine("-->>>WaitForSingleObject in BootModem is Complete");
                switch (_rebootResultCode)
                {
                    
                    case 0:
                    {
                        Console.Write("\nModem reboot successful\n");
                        bootComplete = true;
                        break;
                    }
                    case 1: //Boot in progress
                    {
                        Console.WriteLine("~"); //print out a dot to show boot progress
                        break;
                    }
                    case 2:
                    {
                        Console.WriteLine("Modem reboot failed: Invalid Firmware\n");
                        break;
                    }
                    case 3:
                    {
                        Console.WriteLine("Modem reboot failed: Hardware communication timeout\n");
                        break;
                    }
                    case 4:
                    {
                        Console.WriteLine("Modem reboot failed: Boot failed due to unknown hardware\n");
                        break;
                    }
                    default:
                    {
                        Console.WriteLine("Modem reboot failed: unspecified error code {0}",_rebootResultCode);
                        break;
                    }
                }
                if (0 != _rebootResultCode && 1 !=_rebootResultCode) 
                    Console.WriteLine("exit");
                //exit;    //exit if we have failed reboot

            }
        }
        static void DataThread()
        {
            while(ptr!=IntPtr.Zero)
            {
                MAPI_DATA ReturnedData = MAPI_GetData(ptr);
                //ReturnedData.Data=new IntPtr(3690448);
                switch(ReturnedData.Type)
                {
                    case MAPI_DATA_TYPE.MAPI_DATA_TYPE_BOOT_MODEM_NTF:
                    {
                        MAPI_DATA_BOOT_MODEM_NTF bootModemNtf=(MAPI_DATA_BOOT_MODEM_NTF)Marshal.PtrToStructure(ReturnedData.Data,typeof(MAPI_DATA_BOOT_MODEM_NTF));
                        
                        //save the reboot command result code
                        int _rebootResultCode = bootModemNtf.BootResultCode;
                        //Console.WriteLine("Code - > "+_rebootResultCode.ToString());
                        if (1 == _rebootResultCode)
                            Console.Write("."); //print a progress dot
                        else
                        {
                            SetEvent(_rebootNotification);
                            //ptr = IntPtr.Zero;
                            //Console.WriteLine("Закончили выполнять перезагрузку");
                        }
                        break;
                    }

                    case MAPI_DATA_TYPE.MAPI_DATA_TYPE_INVENTORY_NTF:
                    {
                        _inventoryNtf = ReturnedData.Data;
                        SetEvent(_inventoryNotification);
                        break;
                    }

                        /////////////////////////////////////////////////////
                        // Received Set Regulatory Region result notification
                        /////////////////////////////////////////////////////
                    case MAPI_DATA_TYPE.MAPI_DATA_TYPE_SET_REGULATORY_REGION_NTF:
                    {        
                        //Console.WriteLine("Free");
                        MAPI_DATA_SET_REGULATORY_REGION_NTF data=
                            (MAPI_DATA_SET_REGULATORY_REGION_NTF)Marshal.PtrToStructure(ReturnedData.Data,typeof(MAPI_DATA_SET_REGULATORY_REGION_NTF));

                        //data = (MAPI_DATA_SET_REGULATORY_REGION_NTF *)ReturnedData.Data;
            
                        //save the regulatory change request result code
                        int _regulatoryRegionResultCode = data.ResultCode;
                        //Free the returned data
                        MAPI_Free(ReturnedData.Data);
                        SetEvent(_regulatoryRegionChangeNotification);
                        break;
                    }

                        ////////////////////////////////////////////////////////
                        // Received Reader connection termination
                        ////////////////////////////////////////////////////////
                    case MAPI_DATA_TYPE.MAPI_DATA_TYPE_EMPTY:
                    {
                        Console.WriteLine("Data thread terminiating due to DLL Notification.\n");
                        //null out the reader handle- it's no longer valid
                        ptr = IntPtr.Zero;
                        break;
                    }
                    default:
                    {
                        if (ReturnedData.Data==IntPtr.Zero) 
                            MAPI_Free(ReturnedData.Data);
                        break;
                    }
                }
            }
            //AfxEndThread(0);
            //Notify thread is ending
            //SetEvent(_hDataThread->m_hThread);
            //return 0;
        }

        static void ReaderConnect()
        {
            MAPI_CONNECT_ERROR connectResult=new MAPI_CONNECT_ERROR();
            //Connect to Speedway Reader
            string _readerHost = "192.168.127.22";
            Console.WriteLine(_readerHost);
            //READER _reader=new READER();// = MAPI_Connect(_readerHost,0,ref connectResult);
            

            ptr=MAPI_Connect(_readerHost,0,ref connectResult);
            if(ptr==IntPtr.Zero)
            {
                Console.WriteLine("Подключение к считывателю не удалось");
                Console.WriteLine("Failed to connect Speedway Reader {0}",_readerHost);
                switch(connectResult.ErrorType)
                {
                    case MAPI_CONNECT_ERROR_TYPE.MAPI_CONNECT_ERROR_ADDRESS:
                    {
                        Console.WriteLine("The address is not valid.\n");
                        break;
                    }
                    case MAPI_CONNECT_ERROR_TYPE.MAPI_CONNECT_ERROR_CONNECTION:
                    {
                        Console.WriteLine("A connection could not be established.\n");
                        break;
                    }
                    case MAPI_CONNECT_ERROR_TYPE.MAPI_CONNECT_ERROR_BUSY_UNKNOWN:
                    {
                        Console.WriteLine("The Reader is currently busy with another unknown client.\n");
                        break;
                    }
                    case MAPI_CONNECT_ERROR_TYPE.MAPI_CONNECT_ERROR_BUSY_KNOWN:
                    {
                        Console.WriteLine("The Reader is currently busy with another known client.\n");
                        break;
                    }
                    default:
                    {
                        Console.WriteLine("Error code %d received.\n", connectResult.ErrorType);
                        break;
                    }
                }
            }
            else
            {
                Console.WriteLine("1>>Подключение к считывателю прошло успешно\n");
            }
        }
        static void SetRegulatoryRegion(short regulatoryRegion)
        {
            MAPI_FlushData(ptr);

            //Create the command structure and clear the memory
            MAPI_DATA_SET_REGULATORY_REGION_CMD command=new MAPI_DATA_SET_REGULATORY_REGION_CMD();
            //memset(ref command, 0,sizeof(command));

            //Set the required parameter
            command.RegulatoryRegion = regulatoryRegion;
            
            //Call the Reader and get the Response
            MAPI_DATA response=MAPI_SetRegulatoryRegionCmd(ptr,ref command);

            //Check for an Invalid Command Notification
            switch (response.Type)
            {
                case MAPI_DATA_TYPE.MAPI_DATA_TYPE_SET_REGULATORY_REGION_RSP:
                {    
                    IntPtr setRegulatoryRegionRsp = response.Data;
                    MAPI_DATA_SET_REGULATORY_REGION_RSP _setRegulatoryRegionRsp=(MAPI_DATA_SET_REGULATORY_REGION_RSP)Marshal.PtrToStructure(setRegulatoryRegionRsp,typeof(MAPI_DATA_SET_REGULATORY_REGION_RSP));
                    byte resultCode = _setRegulatoryRegionRsp.ResultCode;
                    MAPI_Free(setRegulatoryRegionRsp);
                    if (resultCode != 0)
                    {
                        Console.WriteLine("Regulatory Region {0} not supported. Result Code: {1}",regulatoryRegion, resultCode);
                        //return 0;
                    }
                    break;
                }
                case MAPI_DATA_TYPE.MAPI_DATA_TYPE_INVALID_COMMAND_NTF:
                {
                    IntPtr invalidCommand = response.Data;
                    MAPI_DATA_INVALID_COMMAND_NTF _invalidCommand=(MAPI_DATA_INVALID_COMMAND_NTF)Marshal.PtrToStructure(invalidCommand,typeof(MAPI_DATA_INVALID_COMMAND_NTF));
                    Console.WriteLine("Received Invalid Command Notification while setting regulatory Region {0}\n", regulatoryRegion);
                    Console.WriteLine("Reason Code = {0}, Reader State = {1}\n",_invalidCommand.ReasonCode , _invalidCommand.State);
                    MAPI_Free(invalidCommand);
                    //return 0;
                    break;
                }
                case MAPI_DATA_TYPE.MAPI_DATA_TYPE_EMPTY:
                {
                    Console.WriteLine("Received reader disconnect message while setting Regulatory Region\n");
                    //return 0;
                    break;
                }
                case MAPI_DATA_TYPE.MAPI_DATA_TYPE_SYSTEM_ERROR_NTF:
                {
                    IntPtr systemErrNtf=response.Data;
                    //MAPI_DATA_SYSTEM_ERROR_NTF *systemErrNtf = (MAPI_DATA_SYSTEM_ERROR_NTF *)response.Data;
                    MAPI_DATA_SYSTEM_ERROR_NTF _systemErrNtf=(MAPI_DATA_SYSTEM_ERROR_NTF)Marshal.PtrToStructure(systemErrNtf,typeof(MAPI_DATA_SYSTEM_ERROR_NTF));
                    Console.WriteLine("Received System Error while setting regulatory Region %d\n", regulatoryRegion);
                    Console.WriteLine("Error Code %d, reason %d", _systemErrNtf.ErrorCode, _systemErrNtf.SystemErrorReason);
                    MAPI_Free(systemErrNtf);
                    //return 0;
                    break;
                }
                default:
                {
                    Console.WriteLine("Unexpected response received from Reader when setting Regulatory Region. Message Type %d\n", response.Type);
                    //return 0;
                    break;
                }
            }


            WaitForSingleObject(_regulatoryRegionChangeNotification,99999);
            switch(_regulatoryRegionResultCode)
            {
                case 0: 
                {
                    Console.WriteLine("Regulatory Region Set Successfully\n");
                    break;
                }
                case 1:
                {
                    Console.WriteLine("Regulatory Region not set- no valid regulatory calibration\n");
                    break;
                }
                case 2:
                {
                    Console.WriteLine("Regulatory Region not set- error setting regulatory region\n");
                    break;
                }
                default:
                {
                    Console.WriteLine("Regulatory Region not set- unspecified error %d\n",_regulatoryRegionResultCode);
                    break;
                }
            }
            if (0 != _regulatoryRegionResultCode) 
                Console.WriteLine("Exit immediately if failed setting regulatory region\nВыход из регулировки");

        }

    }
}