Beispiel #1
0
            protected override void DispatchByte(byte data)
            {
                switch (state)
                {
                case PacketingState.Idle: {
                    if (data == START)
                    {
                        packetBuffer.Clear();
                        byteBuffer.Clear();
                        state = PacketingState.WaitUpper;
                    }
                    else
                    {
                        //Symbol outside packet
                        OnLog(string.Format("Error({0})", data));
                    }
                    break;
                }

                case PacketingState.WaitUpper: {
                    if (data == END)
                    {
                        OnPackageReceived(packetBuffer);
                        OnLog("[in]", byteBuffer);

                        packetBuffer.Clear();
                        byteBuffer.Clear();
                        state = PacketingState.Idle;
                    }
                    else
                    {
                        upperNibble = GetInt(data);
                        byteBuffer.Add(data);
                        state = PacketingState.WaitLower;
                    }
                    break;
                }

                case PacketingState.WaitLower: {
                    byte lowerNibble = GetInt(data);
                    lowerNibble |= (byte)(upperNibble << 4);
                    packetBuffer.Add(lowerNibble);
                    byteBuffer.Add(data);
                    state = PacketingState.WaitUpper;
                    break;
                }
                }
            }
Beispiel #2
0
        private static void DispatchByte(byte data)
        {
            switch (ModBus.PackState)
            {
            case PacketingState.Idle: {
                if (data == (byte)':')
                {
                    ModBus.PacketBuffer.Clear();
                    ModBus.PackState = PacketingState.WaitUpper;
                }
                else
                {
                    ConsoleWriter.WriteLine("Error({0})", data);
                    //Symbol outside packet
                }
                break;
            }

            case PacketingState.WaitUpper: {
                if (data == 0x0d)
                {
                    ModBus.PacketReceived.Add((ModBus.PacketBuffer).ToArray());
                    ModBus.PacketBuffer.Clear();
                    ConsoleWriter.WriteLine();
                    ModBus.PackState = PacketingState.Idle;
                }
                else
                {
                    ModBus.UpperNibble = GetInt(data);
                    ModBus.PackState   = PacketingState.WaitLower;
                }
                break;
            }

            case PacketingState.WaitLower: {
                byte LowerNibble = GetInt(data);
                LowerNibble |= (byte)(ModBus.UpperNibble << 4);
                PacketBuffer.Add(LowerNibble);
                ModBus.PackState = PacketingState.WaitUpper;
                break;
            }
            }
        }
Beispiel #3
0
 private static void DispatchByte(byte data)
 {
     switch (ModBus.PackState) {
         case PacketingState.Idle: {
                 if (data == (byte)':') {
                     ModBus.PacketBuffer.Clear();
                     ModBus.PackState = PacketingState.WaitUpper;
                 } else {
                     ConsoleWriter.WriteLine("Error({0})", data);
                     //Symbol outside packet
                 }
                 break;
             }
         case PacketingState.WaitUpper: {
                 if (data == 0x0d) {
                     ModBus.PacketReceived.Add((ModBus.PacketBuffer).ToArray());
                     ModBus.PacketBuffer.Clear();
                     ConsoleWriter.WriteLine();
                     ModBus.PackState = PacketingState.Idle;
                 } else {
                     ModBus.UpperNibble = GetInt(data);
                     ModBus.PackState = PacketingState.WaitLower;
                 }
                 break;
             }
         case PacketingState.WaitLower: {
                 byte LowerNibble = GetInt(data);
                 LowerNibble |= (byte)(ModBus.UpperNibble << 4);
                 PacketBuffer.Add(LowerNibble);
                 ModBus.PackState = PacketingState.WaitUpper;
                 break;
             }
     }
 }
Beispiel #4
0
            protected override void DispatchByte(byte data)
            {
                switch (state)
                {
                case PacketingState.Idle:
                    if (data == KEY)
                    {
                        packetBuffer.Clear();
                        state = PacketingState.Wait;
                    }
                    else
                    {
                        //Symbol outside packet
                        OnLog(string.Format("Symbol outside packet: <{0}>", data));
                    }
                    break;

                case PacketingState.WaitLiteral:
                    switch (data)
                    {
                    case 0:
                    case 1:
                    case 2:
                        data += 250;
                        packetBuffer.Add(data);
                        break;

                    default:
                        //Wrong literal
                        OnLog(string.Format("Wrong literal: <{0}>", data));
                        break;
                    }
                    state = PacketingState.Wait;
                    break;

                case PacketingState.Wait:
                    switch (data)
                    {
                    case LOCK:
                        OnLog("[in]", packetBuffer);
                        OnPackageReceived(packetBuffer);
                        packetBuffer.Clear();
                        state = PacketingState.Idle;
                        break;

                    case SERVICE:
                        state = PacketingState.WaitLiteral;
                        break;

                    case KEY:
                        //Key inside packet
                        OnLog("Key inside packet");
                        break;

                    default:
                        packetBuffer.Add(data);
                        break;
                    }
                    break;
                }
            }