private void TypeParser(CanParameter canParameter)
        {
            short myShort;

            myShort = BitConverter.ToInt16(canParameter.Data, 0);
            switch (myShort)
            {
            case 0x10:
                WriteDataToParametersTable(canParameter.ParameterId, 1, "codtSInt24");
                break;

            case 0xF:
                WriteDataToParametersTable(canParameter.ParameterId, 1, "codtDomain");
                break;

            case 8:
                WriteDataToParametersTable(canParameter.ParameterId, 1, "codtReal32");
                break;

            case 3:
                WriteDataToParametersTable(canParameter.ParameterId, 1, "codtSInt16");
                break;

            case 6:
                WriteDataToParametersTable(canParameter.ParameterId, 1, "codtSInt16");
                break;
            }
            this.Invoke((MethodInvoker) delegate
            {
                AddLineToLog("Выгружен тип параметра с индексом " + "0x" +
                             Convert.ToString(canParameter.ParameterId, 16) + ", address = " +
                             Convert.ToString(canParameter.ControllerId, 16));
            });
        }
 private void ValueParser(CanParameter canParameter)
 {
     if (canParameter.Data.Count() == 4)//real 32
     {
         float myFloat;
         myFloat = System.BitConverter.ToSingle(canParameter.Data, 0);
         var nfi = new NumberFormatInfo();
         nfi.NumberDecimalSeparator = ".";
         string strData = myFloat.ToString(nfi);
         WriteDataToParametersTable(canParameter.ParameterId, 2, strData);
     }
     else if (canParameter.Data.Count() == 2)    //sint16
     {
         short myShort;
         myShort = BitConverter.ToInt16(canParameter.Data, 0);
         WriteDataToParametersTable(canParameter.ParameterId, 2, myShort.ToString());
     }
     else if (canParameter.Data.Count() == 3)     //sint24
     {
         int myShort;
         myShort  = (canParameter.Data[0] << 8) + (canParameter.Data[1] << 16) + (canParameter.Data[2] << 24);
         myShort /= 256;
         WriteDataToParametersTable(canParameter.ParameterId, 2, myShort.ToString());
     }
     else     //codtDomain
     {
         int i = 0;
         var codtDomainDatas = new CodtDomainData[20];
         while (i < 20)
         {
             codtDomainDatas[i] = new CodtDomainData()
             {
                 Coordinate = BitConverter.ToInt32(canParameter.Data, i * 6),
                 Speed      = BitConverter.ToInt16(canParameter.Data, i * 6 + 4)
             };
             i++;
         }
         _parametersSettingsVm.ParametersSettingsDatas[canParameter.ParameterId - startIndex].CodtDomainArray = codtDomainDatas;
         this.Invoke((MethodInvoker) delegate
         {
             WriteDataToParametersTable(canParameter.ParameterId, 2, "Двоичные данные");
             var formDomain = new FormCodtDomainSettings(canParameter.ParameterId, _parametersSettingsVm.ParametersSettingsDatas);
             formDomain.Show();
         });
     }
     this.Invoke((MethodInvoker) delegate
     {
         AddLineToLog("Выгружено значение параметра с индексом " + "0x" +
                      Convert.ToString(canParameter.ParameterId, 16) + ", address = " +
                      Convert.ToString(canParameter.ControllerId, 16));
     });
 }
        private void NamePareser(CanParameter canParameter)
        {
            Encoding ansiCyrillic = Encoding.GetEncoding(1251);
            string   name         = ansiCyrillic.GetString(canParameter.Data, 0, canParameter.Data.Count());

            WriteDataToParametersTable(canParameter.ParameterId, 0, name);
            this.Invoke((MethodInvoker) delegate
            {
                AddLineToLog("Выгружено имя параметра с индексом " + "0x" +
                             Convert.ToString(canParameter.ParameterId, 16) + ", address = " +
                             Convert.ToString(canParameter.ControllerId, 16));
            });
        }
        private void ParameterReceive(List <CanParameter> parametersList)
        {
            if (_paramSettingsOperation == 1)
            {
                int i = 0;
                foreach (var canParameter in parametersList)
                {
                    if (canParameter.Data == null) //parameter was seted
                    {
                        _isLoaded.Set();
                        CanParameter parameter = canParameter;
                        this.Invoke((MethodInvoker) delegate
                        {
                            AddLineToLog("Загружен параметр с индексом " + "0x" +
                                         Convert.ToString(parameter.ParameterId, 16) + ", address = " +
                                         Convert.ToString(parameter.ControllerId, 16));
                        });
                        continue;
                    }
                    if (canParameter.ParameterId == 0x2000)
                    {
                        DeviceInformationParser(canParameter);
                        _isUnloaded.Set();
                        return;
                    }
                    switch (canParameter.ParameterSubIndex)
                    {
                    case (byte)CanSubindexes.Value:
                        _isUnloaded.Set();
                        ValueParser(canParameter);
                        break;

                    case (byte)CanSubindexes.Name:
                        _isUnloaded.Set();
                        NamePareser(canParameter);
                        break;

                    case (byte)CanSubindexes.Type:
                        _isUnloaded.Set();
                        TypeParser(canParameter);
                        break;
                    }
                }
                _paramSettingsOperation = 0;
            }
        }
 private void DeviceInformationParser(CanParameter canParameter)
 {
     if (canParameter.ParameterSubIndex == 1) //number of parameters
     {
         short myShort;
         myShort = BitConverter.ToInt16(canParameter.Data, 0);
         _deviceInformation.Add(myShort.ToString());
         _parametersNumber = myShort;
     }
     else // other string information
     {
         Encoding ansiCyrillic = Encoding.GetEncoding(1251);
         string   name         = ansiCyrillic.GetString(canParameter.Data, 0, canParameter.Data.Count());
         if (!_deviceInformation.Contains(name))
         {
             _deviceInformation.Add(name);
         }
     }
 }
Exemple #6
0
 private void ValueParser(CanParameter canParameter)
 {
     if (canParameter.Data.Count() == 4)//real 32
     {
         float myFloat;
         myFloat = System.BitConverter.ToSingle(canParameter.Data, 0);
         var nfi = new NumberFormatInfo();
         nfi.NumberDecimalSeparator = ".";
         string strData = myFloat.ToString(nfi);
         WriteDataToTextBox(canParameter.ParameterId, canParameter.ControllerId, strData);
     }
     else if (canParameter.Data.Count() == 3) //sint24
     {
         int myShort;
         myShort  = (canParameter.Data[0] << 8) + (canParameter.Data[1] << 16) + (canParameter.Data[2] << 24);
         myShort /= 256;
         WriteDataToTextBox(canParameter.ParameterId, canParameter.ControllerId, myShort.ToString());
     }
 }
        public bool SetParameter(CanParameter canParameter)
        {
            int repeatCount = 0;
            var msg         = new CanDriver.canmsg_t();

            msg.flags   = CanDriver.MSG_BOVR;
            msg.cob     = 0;
            msg.id      = (uint)(0x600 + canParameter.ControllerId); //rSdo + id=1
            msg.length  = (short)CanDriver.DATALENGTH;
            msg.data    = new byte[CanDriver.DATALENGTH];
            msg.data[1] = (byte)(canParameter.ParameterId);      //id low
            msg.data[2] = (byte)(canParameter.ParameterId >> 8); //id high
            msg.data[3] = canParameter.ParameterSubIndex;        //subindex
            if (canParameter.Data.Count() == 4)
            {
                msg.data[0] = 0x22; //write 4 byte e=1 s=0;
                msg.data[4] = canParameter.Data[0];
                msg.data[5] = canParameter.Data[1];
                msg.data[6] = canParameter.Data[2];
                msg.data[7] = canParameter.Data[3];
            }
            else if (canParameter.Data.Count() == 3)
            {
                msg.data[0] = 0x26; //write 3 byte e=1 s=0;
                msg.data[4] = canParameter.Data[0];
                msg.data[5] = canParameter.Data[1];
                msg.data[6] = canParameter.Data[2];
            }
            else if (canParameter.Data.Count() == 2)
            {
                msg.data[0] = 0x2A; //write 2 byte e=1 s=0;
                msg.data[4] = canParameter.Data[0];
                msg.data[5] = canParameter.Data[1];
            }
            else if (canParameter.Data.Count() > 4) //codtDomain
            {
                _codtDomainThread = new Thread(SetSegment)
                {
                    IsBackground = true
                };
                _codtDomainThread.Start(canParameter);
                return(true);
            }
            while ((true))
            {
                if (repeatCount == 10)
                {
                    MessageBox.Show("Превышен лимит ожидания записи параметра 0x" + Convert.ToString(canParameter.ParameterId, 16) + "!!!", "Ошибка");
                    return(false);
                }
                _device.SendData(new List <CanDriver.canmsg_t> {
                    msg
                });
                if (!_isLoaded.WaitOne(TimeSpan.FromMilliseconds(500)))
                {
                    repeatCount++;
                    continue;
                }
                break;
            }
            return(true);
        }
        private List <CanParameter> TryGetParameterValue(List <CanDriver.canmsg_t> msgData)
        {
            var canParameters = new List <CanParameter>();
            var msgList       = msgData.Where(m => (m.id & 0xF80) == 0x580).ToList();

            if (msgList.Count != 0)
            {
                foreach (var canmsgT in msgList)
                {
                    if ((canmsgT.data[0] & 0x73) == 0x43) // value block
                    {
                        var canParameter = new CanParameter()
                        {
                            ControllerId      = (ushort)(canmsgT.id & 0x7F),
                            ParameterId       = (ushort)(canmsgT.data[1] + (canmsgT.data[2] << 8)),
                            ParameterSubIndex = canmsgT.data[3]
                        };
                        int unusedBytes = (canmsgT.data[0] & 0x0C) >> 2;
                        canParameter.Data = new byte[4 - unusedBytes];
                        for (int j = 0; j < 4 - unusedBytes; j++)
                        {
                            canParameter.Data[j] = canmsgT.data[4 + j];
                        }
                        canParameters.Add(canParameter);
                        _isUnloaded.Set();
                    }
                    else if (canmsgT.data[0] == 0x41) //get codtDomain
                    {
                        _codtDomainArray.Clear();
                        _codtDomainId       = (ushort)(canmsgT.data[1] + (canmsgT.data[2] << 8));
                        _codtDomainSubIndex = canmsgT.data[3];
                        _codtDomainThread   = new Thread(GetSegment)
                        {
                            IsBackground = true
                        };
                        _codtDomainThread.Start(canmsgT);
                        _isUnloaded.Set();
                    }
                    else if ((canmsgT.data[0] & 0xE0) == 0) //get codtDomain block
                    {
                        _isUnloaded.Set();
                        int unusedBytes = (canmsgT.data[0] & 0x0E) >> 1;
                        for (int j = 0; j < 7 - unusedBytes; j++)
                        {
                            _codtDomainArray.Add(canmsgT.data[j + 1]);
                        }
                        if ((canmsgT.data[0] & 0x01) == 1)//last codtDomain Element
                        {
                            if (_codtDomainArray.Count < 5)
                            {
                                continue;
                            }
                            canParameters.Add(new CanParameter
                            {
                                ControllerId      = (ushort)(canmsgT.id & 0x7F),
                                ParameterId       = _codtDomainId,
                                ParameterSubIndex = _codtDomainSubIndex,
                                Data = _codtDomainArray.ToArray()
                            });
                            _codtDomainArray.Clear();
                        }
                    }
                    else if (canmsgT.data[0] == 0x20 || canmsgT.data[0] == 0x30) //segment was accepted
                    {
                        _isLoaded.Set();
                    }
                    else if ((canmsgT.data[0] & 0xE0) == 0x80)
                    {
                        _isUnloaded.Set();
                    }
                    else if (canmsgT.data[0] == 0x60) //parameter was seted
                    {
                        _isLoaded.Set();
                        if (_codtDomainThread != null)
                        {
                            if (_codtDomainThread.IsAlive)
                            {
                                continue;
                            }
                        }
                        canParameters.Add(new CanParameter
                        {
                            ControllerId      = (ushort)(canmsgT.id & 0x7F),
                            ParameterId       = (ushort)(canmsgT.data[1] + (canmsgT.data[2] << 8)),
                            ParameterSubIndex = canmsgT.data[3]
                        });
                    }
                }
            }
            return(canParameters);
        }
 public bool SetParameter(CanParameter canParameter)
 {
     throw new NotImplementedException();
 }