Beispiel #1
0
        public Error Empaqueta(byte[] entrada, out byte[] salida, int longent, EnumPaquete tipo, ushort orden)
        {
            byte[] _salida = new byte[longent + 6];

            if (longent != entrada.Length)
            {
                TransacManager.ProtoConfig.NACK_ENV = NackEnv.EMPAQUETADO;
                salida = null;
                return(new Error("Error protocolo: longitud incorrecta.", (int)ErrProtocolo.LONGITUD, 0));
            }

            _salida[0] = (INI_PAQ);

            _salida[1] = (byte)tipo;

            Array.Copy(DataConverter.Pack("^S", orden), 0, _salida, 2, 2);       // Secuencia en 2 bytes

            Array.Copy(DataConverter.Pack("^S", longent + 9), 0, _salida, 4, 2); // Longitud en 2 bytes

            if (tipo == EnumPaquete.DATOS || tipo == EnumPaquete.NACK || tipo == EnumPaquete.DATOSMULTIPLES)
            {
                Array.Copy(entrada, 0, _salida, 6, longent);
            }

            Crc16Ccitt crc = new Crc16Ccitt(0);

            salida = new byte[_salida.Length + 3];

            _salida = crc.AddCrcToBuffer(_salida, _salida.Length);

            _salida.CopyTo(salida, 0);
            salida[salida.Length - 1] = FIN_PAQ;

            return(new Error());
        }
Beispiel #2
0
        public Error Unpack(byte[] entrada, out byte[] salida)
        {
            Enmascarador enmask = new Enmascarador(ProtoConfig.CONFIG);
            Crc16Ccitt   crc    = new Crc16Ccitt(0);
            Empaquetador emp    = new Empaquetador();

            int lonMenR = 0;

            byte[] menRArr = new byte[0];

            if (entrada[entrada.Length - 1] != 0x03)
            {
                foreach (byte byt in entrada)
                {
                    lonMenR++;
                    if (byt == 0x03)
                    {
                        Array.Resize(ref entrada, lonMenR);
                        break;
                    }
                }
                menRArr = new byte[lonMenR];
            }
            else
            {
                menRArr = new byte[entrada.Length];
            }

            enmask.Desenmascara(entrada, entrada.Length, ref menRArr, ref lonMenR);

            //if (ProtoConfig.CONFIG.LevelLog == EnumMessageType.DEBUG)
            //    PeTR.LogBuffer(byteToChar(aRecibir), "Paquete enmascarado ( " + aRecibir.Length.ToString() + "b )", 16, aRecibir.Length);
            //PeTR.LogBuffer(byteToChar(menRArr), "Recibe " + tipoMen.Substring(0, 1) + " ( " + menRArr.Length.ToString() + "b )", 16, menRArr.Length);

            if (crc.compruebaCrc(menRArr, lonMenR))
            {
                Error Err = emp.Desempaqueta(menRArr, out salida, ref lonMenR, 2, ref ordenAckE);
                if (Err.CodError != 0)
                {
                    return(Err);
                }
            }
            else
            {
                TransacManager.ProtoConfig.NACK_ENV = NackEnv.CRC;
                salida = null;
                return(new Error("Error protocolo: CRC recibido inválido.", (int)ErrProtocolo.CRC, 0));
            }
            //if (CONFIG.LevelLog == EnumMessageType.DEBUG) pe.LogBuffer(byteToChar(aRecibir), "Paquete sin desenmascarar: ", 16, aRecibir.Length);
            //pe.LogBuffer(byteToChar(menRArr), "Paquete desenmascarado: ", 16, menRArr.Length);
            //Comunicacion.setErrorNACK(NackEnv.SINERROR);
            return(new Error());
        }
Beispiel #3
0
        public Error Pack(byte[] entrada, out byte[] salida, EnumPaquete tipo, ushort orden)
        {
            if (tipo == EnumPaquete.ACK || tipo == EnumPaquete.EOT)
            {
                salida = new byte[256];
            }
            else
            {
                salida = new byte[(entrada.Length * 2) + 9];
            }

            if (entrada == null)
            {
                return(new Error("Buffer a enviar nulo.", (int)ErrProtocolo.PARAM_NULO_INVALIDO, 0));
            }

            Enmascarador enmask = new Enmascarador(TransacManager.ProtoConfig.CONFIG);
            Crc16Ccitt   crc    = new Crc16Ccitt(0);
            Empaquetador emp    = new Empaquetador();

            string tipoMen = "";

            if (tipo == EnumPaquete.DATOS)
            {
                tipoMen = Encoding.UTF8.GetString(entrada, 0, 1);
            }
            else
            {
                tipoMen = tipo.ToString();
            }

            int longi = 0;

            byte[] aEnviar3;

            if (TransacManager.ProtoConfig.NACK_ENV == NackEnv.SINERROR)
            {
                byte[] aEnviar2;
                Error  Err = emp.Empaqueta(entrada, out aEnviar2, entrada.Length, tipo, orden);
                if (Err.CodError != 0)
                {
                    return(Err);
                }

                //aEnviar3 = crc.AddCrcToBuffer(aEnviar2, aEnviar2.Length);
                longi = 0;

                // entrada no se usa, para que estaba esto??
                //entrada = new byte[aEnviar3.Length + 1];
                //entrada = aEnviar3;
                //Array.Resize(ref entrada, aEnviar3.Length + 1);
                //entrada[aEnviar3.Length] = 0x03;

                enmask.Enmascara(aEnviar2, aEnviar2.Length, ref salida, ref longi);
                //salida[longi] = Empaquetador.;
                //longi++;
                Array.Resize(ref salida, longi);
            }
            else // envio NACK con el tipo de error (TransacManager.ProtoConfig.NACK_ENV)
            {
                byte[] nac = new byte[1];
                nac = ConstructorMenEnv.crearNack((byte)TransacManager.ProtoConfig.NACK_ENV);

                byte[] aEnviar2;
                Error  Err = emp.Empaqueta(nac, out aEnviar2, nac.Length, EnumPaquete.NACK, orden);
                if (Err.CodError != 0)
                {
                    return(Err);
                }

                aEnviar3 = crc.AddCrcToBuffer(aEnviar2, aEnviar2.Length);
                longi    = 0;

                entrada = new byte[aEnviar3.Length + 1];
                entrada = aEnviar3;
                Array.Resize(ref entrada, aEnviar3.Length + 1);
                entrada[aEnviar3.Length] = 0x03;

                enmask.Enmascara(aEnviar3, aEnviar3.Length, ref salida, ref longi);
                salida[longi] = 0x03;
                longi++;
                Array.Resize(ref salida, longi);
            }

            return(new Error());
        }
Beispiel #4
0
        public Error Unpack(byte[] entrada, out byte[] salida)
        {
            Enmascarador enmask = new Enmascarador(ProtoConfig.CONFIG);
            Crc16Ccitt crc = new Crc16Ccitt(0);
            Empaquetador emp = new Empaquetador();

            int lonMenR = 0;
            byte[] menRArr = new byte[0];

            if (entrada[entrada.Length - 1] != 0x03)
            {
                foreach (byte byt in entrada)
                {
                    lonMenR++;
                    if (byt == 0x03)
                    {
                        Array.Resize(ref entrada, lonMenR);
                        break;
                    }
                }
                menRArr = new byte[lonMenR];
            }
            else
                menRArr = new byte[entrada.Length];

            enmask.Desenmascara(entrada, entrada.Length, ref menRArr, ref lonMenR);

            //if (ProtoConfig.CONFIG.LevelLog == EnumMessageType.DEBUG)
            //    PeTR.LogBuffer(byteToChar(aRecibir), "Paquete enmascarado ( " + aRecibir.Length.ToString() + "b )", 16, aRecibir.Length);
            //PeTR.LogBuffer(byteToChar(menRArr), "Recibe " + tipoMen.Substring(0, 1) + " ( " + menRArr.Length.ToString() + "b )", 16, menRArr.Length);

            if (crc.compruebaCrc(menRArr, lonMenR))
            {
                Error Err = emp.Desempaqueta(menRArr, out salida, ref lonMenR, 2, ref ordenAckE);
                if (Err.CodError != 0)
                    return Err;
            }
            else
            {
                TransacManager.ProtoConfig.NACK_ENV = NackEnv.CRC;
                salida = null;
                return new Error("Error protocolo: CRC recibido inválido.", (int)ErrProtocolo.CRC, 0);
            }
            //if (CONFIG.LevelLog == EnumMessageType.DEBUG) pe.LogBuffer(byteToChar(aRecibir), "Paquete sin desenmascarar: ", 16, aRecibir.Length);
            //pe.LogBuffer(byteToChar(menRArr), "Paquete desenmascarado: ", 16, menRArr.Length);
            //Comunicacion.setErrorNACK(NackEnv.SINERROR);
            return new Error();
        }
Beispiel #5
0
        public Error Pack(byte[] entrada, out byte[] salida, EnumPaquete tipo, ushort orden)
        {
            if (tipo == EnumPaquete.ACK || tipo == EnumPaquete.EOT)
                salida = new byte[256];
            else
                salida = new byte[(entrada.Length * 2) + 9];

            if (entrada == null)
                return new Error("Buffer a enviar nulo.", (int)ErrProtocolo.PARAM_NULO_INVALIDO , 0);

            Enmascarador enmask = new Enmascarador(TransacManager.ProtoConfig.CONFIG);
            Crc16Ccitt crc = new Crc16Ccitt(0);
            Empaquetador emp = new Empaquetador();

            string tipoMen = "";
            if (tipo == EnumPaquete.DATOS) tipoMen = Encoding.UTF8.GetString(entrada, 0, 1);
            else tipoMen = tipo.ToString();

            int longi = 0;

            byte[] aEnviar3;

            if (TransacManager.ProtoConfig.NACK_ENV == NackEnv.SINERROR)
            {
                byte[] aEnviar2;
                Error Err = emp.Empaqueta(entrada, out aEnviar2, entrada.Length, tipo, orden);
                if (Err.CodError != 0)
                    return Err;

                aEnviar3 = crc.AddCrcToBuffer(aEnviar2, aEnviar2.Length);
                longi = 0;

                entrada = new byte[aEnviar3.Length + 1];
                entrada = aEnviar3;
                Array.Resize(ref entrada, aEnviar3.Length + 1);
                entrada[aEnviar3.Length] = 0x03;

                enmask.Enmascara(aEnviar3, aEnviar3.Length, ref salida, ref longi);
                salida[longi] = 0x03;
                longi++;
                Array.Resize(ref salida, longi);
            }
            else // envio NACK con el tipo de error (TransacManager.ProtoConfig.NACK_ENV)
            {
                byte[] nac = new byte[1];
                nac = ConstructorMenEnv.crearNack((byte)TransacManager.ProtoConfig.NACK_ENV);

                byte[] aEnviar2;
                Error Err = emp.Empaqueta(nac, out aEnviar2, nac.Length, EnumPaquete.NACK, orden);
                if (Err.CodError != 0)
                    return Err;

                aEnviar3 = crc.AddCrcToBuffer(aEnviar2, aEnviar2.Length);
                longi = 0;

                entrada = new byte[aEnviar3.Length + 1];
                entrada = aEnviar3;
                Array.Resize(ref entrada, aEnviar3.Length + 1);
                entrada[aEnviar3.Length] = 0x03;

                enmask.Enmascara(aEnviar3, aEnviar3.Length, ref salida, ref longi);
                salida[longi] = 0x03;
                longi++;
                Array.Resize(ref salida, longi);
            }

            return new Error();
        }