942 lines
36 KiB
C#
942 lines
36 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Runtime.InteropServices;
|
|
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
|
|
using LFP_Manager.DataStructure;
|
|
using LFP_Manager.Function;
|
|
using LFP_Manager.Utils;
|
|
using static DevExpress.Utils.Drawing.Helpers.NativeMethods;
|
|
|
|
namespace LFP_Manager.Threads
|
|
{
|
|
class csValueCanThread
|
|
{
|
|
#region DLL FUNCTION
|
|
|
|
#endregion
|
|
|
|
#region VARIABLES
|
|
|
|
int TxThreadPeriod = 10;
|
|
int RxThreadPeriod = 1;
|
|
|
|
public delegate void invokeDelegate();
|
|
|
|
CommConfig Config;
|
|
DeviceSystemData SystemData;
|
|
|
|
int SystemId = 0;
|
|
int DCP = 0;
|
|
|
|
Thread canCommTx = null;
|
|
Thread canCommRx = null;
|
|
//string Msg = "";
|
|
|
|
// ValueCAN Variables
|
|
IntPtr m_hObject; // handle for device
|
|
NeoDevice ndNeoToOpen;
|
|
byte[] bNetwork = new byte[255]; // List of hardware IDs
|
|
|
|
int iOpenDeviceType; // Storage for the device type that is open
|
|
|
|
////////////////////////////////////////
|
|
bool can_bOpen = false;
|
|
|
|
bool CanTxThreadEnd = true;
|
|
bool CanRxThreadEnd = true;
|
|
|
|
bool CanPolling = false;
|
|
bool AutoCanTx = true;
|
|
|
|
// Message Queue
|
|
icsSpyMessage[] stMessages = new icsSpyMessage[20000]; // TempSpace for messages
|
|
|
|
const int RX_QUEUE_MAX = 512;
|
|
icsSpyMessage[] RxMsgQueue = new icsSpyMessage[RX_QUEUE_MAX]; // RX Message Queue
|
|
int RxQueueFront = 0;
|
|
int RxQueueEnd = 0;
|
|
|
|
void RxQueuePut(ref icsSpyMessage rxMsg)
|
|
{
|
|
RxMsgQueue[RxQueueFront++] = rxMsg;
|
|
RxQueueFront %= RX_QUEUE_MAX;
|
|
}
|
|
|
|
bool RxQueueGet(ref icsSpyMessage rxMsg)
|
|
{
|
|
if (RxQueueFront != RxQueueEnd)
|
|
{
|
|
rxMsg = RxMsgQueue[RxQueueEnd++];
|
|
RxQueueEnd %= RX_QUEUE_MAX;
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public event CanDataUpdate OnUpdate = null;
|
|
public event CanDataPrint OnPrint = null;
|
|
public event CanDataRecv OnDataRecv = null;
|
|
|
|
private object lockObject = new object();
|
|
#endregion
|
|
|
|
#region CONSTRUCTORS
|
|
public csValueCanThread(int sId, CommConfig aConfig, ref DeviceSystemData aSystemData)
|
|
{
|
|
SystemId = sId;
|
|
Config = aConfig;
|
|
SystemData = aSystemData;
|
|
|
|
canCommTx = new Thread(canTxThread);
|
|
canCommRx = new Thread(canRxThread);
|
|
}
|
|
|
|
public void disposeThread()
|
|
{
|
|
CanTxThreadEnd = true;
|
|
if (canCommTx != null)
|
|
{
|
|
if (canCommTx.IsAlive)
|
|
{
|
|
canCommTx.Abort();
|
|
}
|
|
canCommTx = null;
|
|
}
|
|
CanRxThreadEnd = true;
|
|
if (canCommRx != null)
|
|
{
|
|
if (canCommRx.IsAlive)
|
|
{
|
|
canCommRx.Abort();
|
|
}
|
|
canCommRx = null;
|
|
}
|
|
|
|
//close the port
|
|
int iNumberOfErrors = 0;
|
|
int iResult = icsNeoDll.icsneoClosePort(m_hObject, ref iNumberOfErrors);
|
|
if (iResult == 1)
|
|
{
|
|
//MessageBox.Show("Port Closed OK!");
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - Problem ClosingPort"));
|
|
}
|
|
|
|
//Clear device type and open flag
|
|
iOpenDeviceType = 0;
|
|
can_bOpen = false;
|
|
}
|
|
|
|
public int CloseValueCAN()
|
|
{
|
|
int iNumberOfErrors = 0;
|
|
int iResult = icsNeoDll.icsneoClosePort(m_hObject, ref iNumberOfErrors);
|
|
if (iResult == 1)
|
|
{
|
|
//MessageBox.Show("Port Closed OK!");
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - Problem ClosingPort"));
|
|
}
|
|
|
|
return iResult;
|
|
}
|
|
|
|
public int ReOpenValueCAN()
|
|
{
|
|
int iNumberOfErrors = 0;
|
|
int iResult = icsNeoDll.icsneoClosePort(m_hObject, ref iNumberOfErrors);
|
|
if (iResult != 1) throw new Exception(String.Format("ValueCAN - Problem ClosingPort"));
|
|
|
|
iResult = icsNeoDll.icsneoOpenNeoDevice(ref ndNeoToOpen, ref m_hObject, ref bNetwork[0], 1, 0);
|
|
if (iResult != 1) throw new Exception(String.Format("ValueCAN - Problem Opening Port"));
|
|
|
|
return iResult;
|
|
}
|
|
|
|
public int OpenValueCan()
|
|
{
|
|
int iResult;
|
|
NeoDeviceEx[] ndNeoToOpenex = new NeoDeviceEx[16]; //Struct holding detected hardware information
|
|
int iNumberOfDevices; //Number of hardware devices to look for
|
|
|
|
OptionsNeoEx neoDeviceOption = new OptionsNeoEx();
|
|
|
|
//Set the number of devices to find, for this example look for 16. This example will only work with the first.
|
|
iNumberOfDevices = 15;
|
|
|
|
iResult = icsNeoDll.icsneoFindDevices(ref ndNeoToOpenex[0], ref iNumberOfDevices, 0, 0, ref neoDeviceOption, 0);
|
|
if (iResult == 0)
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - Problem finding devices"));
|
|
}
|
|
|
|
if (iNumberOfDevices < 1)
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - No devices found"));
|
|
}
|
|
|
|
ndNeoToOpen = ndNeoToOpenex[0].neoDevice;
|
|
//Open the first found device
|
|
iResult = icsNeoDll.icsneoOpenNeoDevice(ref ndNeoToOpen, ref m_hObject, ref bNetwork[0], 1, 0);
|
|
if (iResult == 1)
|
|
{
|
|
//MessageBox.Show("Port Opened OK!");
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - Problem Opening Port"));
|
|
}
|
|
//Set the device type for later use
|
|
iOpenDeviceType = ndNeoToOpen.DeviceType;
|
|
|
|
return 1;
|
|
}
|
|
|
|
private void ConfigBitRate(CommConfig aConfig)
|
|
{
|
|
//Get the network name index to set the baud rate of
|
|
int iNetworkID = (int)eNETWORK_ID.NETID_HSCAN;
|
|
int iBitRateToUse = csCanConstData.BaudRate.BaudRateInts[aConfig.CanBaudrate];
|
|
|
|
//Set the bit rate
|
|
int iResult = icsNeoDll.icsneoSetBitRate(m_hObject, iBitRateToUse, iNetworkID);
|
|
if (iResult != 1)
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - Problem setting bit rate"));
|
|
}
|
|
else
|
|
{
|
|
//MessageBox.Show("Bit Rate Set");
|
|
}
|
|
}
|
|
|
|
private void ConfigFDRate(CommConfig aConfig)
|
|
{
|
|
//Get the network name index to set the baud rate of
|
|
int iNetworkID = (int)eNETWORK_ID.NETID_HSCAN;
|
|
int iBitRateToUse = 10000000;
|
|
|
|
//Set the bit rate
|
|
int iResult = icsNeoDll.icsneoSetFDBitRate(m_hObject, iBitRateToUse, iNetworkID);
|
|
if (iResult != 1)
|
|
{
|
|
throw new Exception(String.Format("ValueCAN - Problem setting FD bit rate"));
|
|
}
|
|
else
|
|
{
|
|
//MessageBox.Show("FD Bit Rate Set");
|
|
}
|
|
}
|
|
|
|
private void GetSetting(CommConfig aConfig)
|
|
{
|
|
SVCAN3Settings VcanReadSettings = new SVCAN3Settings();
|
|
SFireSettings FireReadSettings = new SFireSettings();
|
|
SFire2Settings Fire2ReadSettings = new SFire2Settings();
|
|
SRADGalaxySettings RadGalaxyReadSettings = new SRADGalaxySettings();
|
|
SVCANRFSettings VcanRFReadSettings = new SVCANRFSettings();
|
|
SVCAN412Settings Vcan412ReadSettings = new SVCAN412Settings();
|
|
SRADPlutoSettingsPack RADPlutoSettings = new SRADPlutoSettingsPack();
|
|
|
|
CAN_SETTINGS HSCanSettings = new CAN_SETTINGS();
|
|
int iNumberOfBytes = 0;
|
|
int iResult;
|
|
|
|
//Get the settigns of the connected hardware
|
|
switch (iOpenDeviceType)
|
|
{
|
|
case (int)eHardwareTypes.NEODEVICE_FIRE: //FIRE
|
|
//Get the settings
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(FireReadSettings);
|
|
iResult = icsNeoDll.icsneoGetFireSettings(m_hObject, ref FireReadSettings, iNumberOfBytes);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading FIRE configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = FireReadSettings.can1;
|
|
break;
|
|
|
|
case (int)eHardwareTypes.NEODEVICE_VCAN3: //Vcan3
|
|
//Get the setting
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(VcanReadSettings);
|
|
iResult = icsNeoDll.icsneoGetVCAN3Settings(m_hObject, ref VcanReadSettings, iNumberOfBytes);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading VCAN3 configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = VcanReadSettings.Can1;
|
|
break;
|
|
|
|
case (int)eHardwareTypes.NEODEVICE_FIRE2: //FIRE2
|
|
//Get the setting
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(Fire2ReadSettings);
|
|
iResult = icsNeoDll.icsneoGetFire2Settings(m_hObject, ref Fire2ReadSettings, iNumberOfBytes);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading FIRE2 configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = Fire2ReadSettings.can1;
|
|
break;
|
|
|
|
case (int)eHardwareTypes.NEODEVICE_RADGALAXY: //RadGalaxy
|
|
//Get the setting
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(RadGalaxyReadSettings);
|
|
iResult = icsNeoDll.icsneoGetRADGalaxySettings(m_hObject, ref RadGalaxyReadSettings, iNumberOfBytes);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading RADGalaxy configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = RadGalaxyReadSettings.Can1;
|
|
break;
|
|
|
|
case (int)eHardwareTypes.NEODEVICE_VCANRF: //VcanRF
|
|
//Get the setting
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(VcanRFReadSettings);
|
|
iResult = icsNeoDll.icsneoGetVCANRFSettings(m_hObject, ref VcanRFReadSettings, iNumberOfBytes);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading VCANRF configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = VcanRFReadSettings.can1;
|
|
break;
|
|
|
|
case (int)eHardwareTypes.NEODEVICE_VCAN42: //Vcan4-2
|
|
case (int)eHardwareTypes.NEODEVICE_VCAN41: //Vcan4-1 (Same steps for both)
|
|
//Get the setting
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(Vcan412ReadSettings);
|
|
iResult = icsNeoDll.icsneoGetVCAN412Settings(m_hObject, ref Vcan412ReadSettings, iNumberOfBytes);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading VCAN412 configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = Vcan412ReadSettings.can1;
|
|
break;
|
|
case (int)eHardwareTypes.NEODEVICE_RADPLUTO: //RAD Pluto
|
|
//Get the setting
|
|
RADPlutoSettings.uiDevice = (UInt32)EDeviceSettingsType.DeviceRADPlutoSettingsType;
|
|
iNumberOfBytes = System.Runtime.InteropServices.Marshal.SizeOf(RADPlutoSettings);
|
|
iResult = icsNeoDll.icsneoGetDeviceSettings(m_hObject, ref RADPlutoSettings, iNumberOfBytes, 0);
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem reading RAD Pluto configuration");
|
|
return;
|
|
}
|
|
//Copy the HS CAN settings from the structure to sub struct
|
|
HSCanSettings = RADPlutoSettings.PlutoSettings.can1;
|
|
break;
|
|
default:
|
|
//Connected hardware does not support this command
|
|
MessageBox.Show("Problem reading configuration, unsupported device");
|
|
return;
|
|
}
|
|
|
|
//fill text boxes with data from sub struct
|
|
//txt3GPSeg1.Text = Convert.ToString(HSCanSettings.TqSeg1);
|
|
//txt3GPSeg2.Text = Convert.ToString(HSCanSettings.TqSeg2);
|
|
//txt3GPropDelay.Text = Convert.ToString(HSCanSettings.TqProp);
|
|
//txt3GSJumpW.Text = Convert.ToString(HSCanSettings.TqSync);
|
|
//txt3GBRP.Text = Convert.ToString(HSCanSettings.BRP);
|
|
|
|
}
|
|
|
|
public unsafe bool Start(CommConfig aConfig, int sId, bool aPolling)
|
|
{
|
|
bool result = false;
|
|
|
|
SystemId = sId;
|
|
CanPolling = aPolling;
|
|
|
|
try
|
|
{
|
|
if (OpenValueCan() == 0)
|
|
throw new System.InvalidOperationException("Failed to open the device, please check if the device type and device index number are correct.");
|
|
|
|
// Baudrate Config
|
|
ConfigBitRate(aConfig);
|
|
|
|
// FD Rate Config
|
|
ConfigFDRate(aConfig);
|
|
|
|
// Get Setting Value
|
|
GetSetting(aConfig);
|
|
|
|
can_bOpen = true;
|
|
|
|
CanTxThreadEnd = false;
|
|
CanRxThreadEnd = false;
|
|
|
|
canCommTx.Start();
|
|
canCommRx.Start();
|
|
|
|
result = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Exception Ex = new System.Exception(ex.Message, ex);
|
|
throw Ex;
|
|
}
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region TX FUNCTION
|
|
|
|
private int GetErrorValueCAN()
|
|
{
|
|
int result = 0;
|
|
int[] iErrors = new int[600]; //Array for Error Numbers
|
|
int iNumberOfErrors = 0; // Storage for number of errors
|
|
|
|
// Read Out the errors
|
|
int iResult = icsNeoDll.icsneoGetErrorMessages(m_hObject, ref iErrors[0], ref iNumberOfErrors);
|
|
|
|
// Test the returned result
|
|
if (iResult == 0)
|
|
{
|
|
MessageBox.Show("Problem Reading Errors");
|
|
}
|
|
else
|
|
{
|
|
if (iNumberOfErrors != 0)
|
|
{
|
|
ReOpenValueCAN();
|
|
for (int iCount = 0; iCount < iNumberOfErrors; iCount++)
|
|
{
|
|
if (iErrors[iCount] == 44) result++;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
private void SendPacketByValueCAN(UInt32 ExID, byte[] Data)
|
|
{
|
|
Monitor.Enter(lockObject);
|
|
try
|
|
{
|
|
//OnPrint?.Invoke(this, csCanCommFunction.PacketToMsg(sendobj, 1));
|
|
|
|
long lResult;
|
|
icsSpyMessage stMessagesTx = new icsSpyMessage();
|
|
long lNetworkID;
|
|
string sTempString;
|
|
|
|
// Read the Network we will transmit on (indicated by lstNetwork ListBox)
|
|
sTempString = "HSCAN";
|
|
lNetworkID = icsNeoDll.GetNetworkIDfromString(ref sTempString);
|
|
|
|
// Is this a CAN network or a J1850/ISO one?
|
|
// load the message structure
|
|
|
|
//Make id Extended
|
|
stMessagesTx.StatusBitField = Convert.ToInt16(eDATA_STATUS_BITFIELD_1.SPY_STATUS_XTD_FRAME);
|
|
|
|
stMessagesTx.ArbIDOrHeader = (int)ExID; // The ArbID
|
|
stMessagesTx.NumberBytesData = (byte)Data.Length; // The number of Data Bytes
|
|
if (stMessagesTx.NumberBytesData > 8) stMessagesTx.NumberBytesData = 8; // You can only have 8 databytes with CAN
|
|
// Load all of the data bytes in the structure
|
|
|
|
stMessagesTx.Data1 = Data[0];
|
|
stMessagesTx.Data2 = Data[1];
|
|
stMessagesTx.Data3 = Data[2];
|
|
stMessagesTx.Data4 = Data[3];
|
|
stMessagesTx.Data5 = Data[4];
|
|
stMessagesTx.Data6 = Data[5];
|
|
stMessagesTx.Data7 = Data[6];
|
|
stMessagesTx.Data8 = Data[7];
|
|
|
|
// Transmit the assembled message
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
lResult = icsNeoDll.icsneoTxMessages(m_hObject, ref stMessagesTx, Convert.ToInt32(lNetworkID), 1);
|
|
if (lResult == 1)
|
|
break;
|
|
else
|
|
{
|
|
if (GetErrorValueCAN() == 0) break;
|
|
//ReOpenValueCAN();
|
|
}
|
|
}
|
|
//GetErrorValueCAN();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//throw new Exception(String.Format("CAN Transmit Exception", ex.Message));
|
|
}
|
|
finally
|
|
{
|
|
Monitor.Exit(lockObject);
|
|
}
|
|
|
|
}
|
|
|
|
private unsafe void SendPacketByValueCAN(ref VCI_CAN_OBJ senObj)
|
|
{
|
|
long lResult;
|
|
icsSpyMessage stMessagesTx = new icsSpyMessage();
|
|
long lNetworkID;
|
|
string sTempString;
|
|
|
|
// Read the Network we will transmit on (indicated by lstNetwork ListBox)
|
|
sTempString = "HSCAN";
|
|
lNetworkID = icsNeoDll.GetNetworkIDfromString(ref sTempString);
|
|
|
|
// Is this a CAN network or a J1850/ISO one?
|
|
// load the message structure
|
|
|
|
//Make id Extended
|
|
stMessagesTx.StatusBitField = Convert.ToInt16(eDATA_STATUS_BITFIELD_1.SPY_STATUS_XTD_FRAME);
|
|
|
|
stMessagesTx.ArbIDOrHeader = (int)senObj.ID; // The ArbID
|
|
stMessagesTx.NumberBytesData = (byte)senObj.DataLen; // The number of Data Bytes
|
|
if (stMessagesTx.NumberBytesData > 8) stMessagesTx.NumberBytesData = 8; // You can only have 8 databytes with CAN
|
|
// Load all of the data bytes in the structure
|
|
|
|
stMessagesTx.Data1 = senObj.Data[0];
|
|
stMessagesTx.Data2 = senObj.Data[1];
|
|
stMessagesTx.Data3 = senObj.Data[2];
|
|
stMessagesTx.Data4 = senObj.Data[3];
|
|
stMessagesTx.Data5 = senObj.Data[4];
|
|
stMessagesTx.Data6 = senObj.Data[5];
|
|
stMessagesTx.Data7 = senObj.Data[6];
|
|
stMessagesTx.Data8 = senObj.Data[7];
|
|
|
|
// Transmit the assembled message
|
|
lResult = icsNeoDll.icsneoTxMessages(m_hObject, ref stMessagesTx, Convert.ToInt32(lNetworkID), 1);
|
|
// Test the returned result
|
|
if (lResult != 1)
|
|
{
|
|
MessageBox.Show(String.Format("Problem Transmitting Message - ({0})", lResult));
|
|
}
|
|
}
|
|
|
|
public void SetAutoTx(bool autoTx)
|
|
{
|
|
AutoCanTx = autoTx;
|
|
}
|
|
|
|
unsafe public void SendDataFromApp(UInt32 header, byte[] data)
|
|
{
|
|
if (can_bOpen == false) return;
|
|
|
|
VCI_CAN_OBJ sendobj = new VCI_CAN_OBJ();
|
|
|
|
sendobj.SendType = csCanConstData.SendType.Normal;
|
|
sendobj.ExternFlag = csCanConstData.FrameType.Extended;
|
|
sendobj.RemoteFlag = csCanConstData.FrameFormat.Data_Frame;
|
|
sendobj.ID = header; // 0x1815c9c8
|
|
|
|
int len = 8;
|
|
sendobj.DataLen = System.Convert.ToByte(len);
|
|
for (int i = 0; i < len; i++)
|
|
sendobj.Data[i] = data[i];
|
|
|
|
SendPacketByValueCAN(sendobj.ID, data);
|
|
|
|
OnPrint?.Invoke(this, csCanCommFunction.PacketToMsg(sendobj, 1));
|
|
}
|
|
|
|
public void SetPolling(bool flag, int sId, ref DeviceSystemData aSystemData)
|
|
{
|
|
SystemId = sId;
|
|
CanPolling = flag;
|
|
SystemData = aSystemData;
|
|
SystemData.mNo = SystemId;
|
|
}
|
|
|
|
public void SetDCP(int aDCP)
|
|
{
|
|
DCP = aDCP;
|
|
}
|
|
|
|
public void SendProcessFromApp(int sId, int mode, int flag, int dcp, ref DeviceParamData aParam, ref DeviceCalibration aCalib)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case 5: // Cell Volatge Parameter
|
|
SendData(sId, 5, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 23, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 7:
|
|
SendData(sId, 7, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 23, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 6:
|
|
SendData(sId, 6, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 24, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 22:
|
|
SendData(sId, 22, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 24, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 14:
|
|
SendData(sId, 14, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 99: // All param read
|
|
SendData(sId, 5, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 6, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 7, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 14, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 22, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 23, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 24, flag, dcp, ref aParam, ref aCalib);
|
|
SendData(sId, 2, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 9: // Cell Voltage Calibration
|
|
SendData(sId, 9, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 1: // Cell Voltage Calibration
|
|
SendData(sId, 1, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 12: // Cell Voltage Calibration
|
|
SendData(sId, 12, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 8: // Battery Parameter Setting
|
|
SendData(sId, 8, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 17: // Cell Balancing Parameter - 240531
|
|
SendData(sId, 17, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 21: // System Information (Device Address)
|
|
SendData(sId, 21, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 13: // Soc Calibration
|
|
SendData(sId, 13, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 15: // Default Parameter
|
|
SendData(sId, 15, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 16: // Default Parameter
|
|
if (aParam.DefalutParamAll == 1)
|
|
SendData(0xFF, 16, flag, dcp, ref aParam, ref aCalib);
|
|
else
|
|
SendData(sId, 16, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 2: // Cell Voltage Difference Parameter
|
|
SendData(sId, 2, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 25:
|
|
SendData(sId, 25, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
|
|
// Inventory Data Control
|
|
case 900: // Manufacturer Cmd
|
|
SendData(sId, 900, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 901: // Serial Number #1 Cmd
|
|
SendData(sId, 901, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
case 902: // Serial Number #2 Cmd
|
|
SendData(sId, 902, flag, dcp, ref aParam, ref aCalib);
|
|
break;
|
|
}
|
|
}
|
|
|
|
unsafe void SendData(int sId, int mode, int flag, int dcp, ref DeviceParamData aParam, ref DeviceCalibration aCalib)
|
|
{
|
|
if (can_bOpen == false) return;
|
|
|
|
VCI_CAN_OBJ sendobj = MakeTxData(sId, mode, flag, dcp, ref aParam, ref aCalib);
|
|
|
|
byte[] data = new byte[8];
|
|
for (int i = 0; i < 8; i++) data[i] = sendobj.Data[i];
|
|
|
|
SendPacketByValueCAN(sendobj.ID, data);
|
|
}
|
|
|
|
private UInt32 MakeID(int sId, int mode)
|
|
{
|
|
UInt32 result = 0;
|
|
PACKET_HEADER hdr = new PACKET_HEADER();
|
|
|
|
hdr.Index = 6; // Fixed 6
|
|
hdr.R = 0; // Fixed 0
|
|
hdr.DP = 0; // Fixed 0
|
|
hdr.PF = (byte)mode; // Command
|
|
if (sId == 0xFF) hdr.PS = (byte)(sId); // PDU SPECIFIC
|
|
else hdr.PS = (byte)(sId + 200); // PDU SPECIFIC
|
|
hdr.SA = 200; // SOURCE ADDRESS
|
|
|
|
result = csCanCommFunction.CovertHtoP(hdr);
|
|
return result;
|
|
}
|
|
|
|
private UInt32 MakeInvID(int sId, int mode)
|
|
{
|
|
UInt32 result = 0;
|
|
PACKET_HEADER hdr = new PACKET_HEADER();
|
|
|
|
hdr.Index = 1; // Fixed 1 for Inventory Data
|
|
hdr.R = 0; // Fixed 0
|
|
hdr.DP = 0; // Fixed 0
|
|
hdr.PF = (byte)((mode % 900) + 1); // Command
|
|
if (sId == 0xFF) hdr.PS = (byte)(sId); // PDU SPECIFIC
|
|
else hdr.PS = (byte)(sId + 200); // PDU SPECIFIC
|
|
hdr.SA = 200; // SOURCE ADDRESS
|
|
|
|
result = csCanCommFunction.CovertHtoP(hdr);
|
|
return result;
|
|
}
|
|
|
|
unsafe private VCI_CAN_OBJ MakeTxData(int sId, int mode, int flag, int dcp, ref DeviceParamData aParam, ref DeviceCalibration aCalib)
|
|
{
|
|
VCI_CAN_OBJ sendobj = new VCI_CAN_OBJ();
|
|
|
|
sendobj.SendType = csCanConstData.SendType.Normal;
|
|
sendobj.RemoteFlag = csCanConstData.FrameFormat.Data_Frame;
|
|
sendobj.ExternFlag = csCanConstData.FrameType.Extended;
|
|
if (mode < 900)
|
|
sendobj.ID = MakeID(sId, mode);
|
|
else
|
|
sendobj.ID = MakeInvID(sId, mode);
|
|
sendobj.DataLen = (byte)(8);
|
|
|
|
byte[] aData = csCanCommFunction.MakeCanData(mode, flag, dcp, ref aParam, ref aCalib);
|
|
for (int i = 0; i < 8; i++)
|
|
{ sendobj.Data[i] = aData[i]; }
|
|
|
|
return sendobj;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region COMM TX THREAD
|
|
|
|
int current_cmd = 0;
|
|
int RxSystemId = 0;
|
|
|
|
public int GetCommSystemId()
|
|
{
|
|
return RxSystemId;
|
|
}
|
|
|
|
unsafe private void canTxThread()
|
|
{
|
|
int txTick = 0;
|
|
|
|
while (CanTxThreadEnd == false)
|
|
{
|
|
txTick++;
|
|
if (txTick >= TxThreadPeriod)
|
|
{
|
|
if (CanPolling && AutoCanTx)
|
|
{
|
|
int flag = 0;
|
|
|
|
TxProcess(ref flag);
|
|
RxSystemId = SystemId;
|
|
SendData(SystemId, current_cmd, flag, DCP, ref SystemData.ParamData, ref SystemData.CalibriationData);
|
|
//Thread.Sleep(1);
|
|
}
|
|
txTick %= TxThreadPeriod;
|
|
}
|
|
GetMessageBuff();
|
|
|
|
Thread.Sleep(1);
|
|
}
|
|
}
|
|
|
|
void TxProcess(ref int aflag)
|
|
{
|
|
switch (current_cmd)
|
|
{
|
|
case 20: current_cmd = 900; break;
|
|
case 900: current_cmd = 901; break;
|
|
case 901: current_cmd = 902; break;
|
|
case 902: current_cmd = 1; break;
|
|
case 1: current_cmd = 19; break;
|
|
case 19: current_cmd = 3; break;
|
|
case 3: current_cmd = 4; break;
|
|
case 4: current_cmd = 11; break;
|
|
case 11: current_cmd = 16; break;
|
|
case 16: current_cmd = 20; break;
|
|
default: current_cmd = 20; break;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region COMM RX THREAD
|
|
unsafe private void canRxThread()
|
|
{
|
|
while (CanRxThreadEnd == false)
|
|
{
|
|
DateTime aTime = DateTime.Now;
|
|
|
|
if (GetMessageProcess())
|
|
{
|
|
// Received data
|
|
SystemData.ShelfCommFail = false;
|
|
SystemData.LastRxTime = DateTime.Now;
|
|
}
|
|
else
|
|
{
|
|
TimeSpan dTime = DateTime.Now - SystemData.LastRxTime;
|
|
if (SystemData.ShelfCommFail == false)
|
|
{
|
|
if (dTime.TotalSeconds > 10)
|
|
{
|
|
SystemData.ShelfCommFail = true;
|
|
DataInit();
|
|
OnUpdate?.Invoke(this, ref SystemData);
|
|
}
|
|
}
|
|
}
|
|
Thread.Sleep(RxThreadPeriod);
|
|
}
|
|
}
|
|
|
|
unsafe private int GetMessageBuff()
|
|
{
|
|
int result = 0;
|
|
int lNumberOfMessages = 1;
|
|
int lNumberOfErrors = 0;
|
|
//double dTime = 0;
|
|
|
|
// read the messages from the driver
|
|
int lResult = icsNeoDll.icsneoGetMessages(m_hObject, ref stMessages[0], ref lNumberOfMessages, ref lNumberOfErrors);
|
|
|
|
// was the read successful?
|
|
if (lResult == 1)
|
|
{
|
|
for (int i = 0; i < lNumberOfMessages; i++)
|
|
{
|
|
// Calculate the messages timestamp
|
|
//lResult = icsNeoDll.icsneoGetTimeStampForMsg(m_hObject, ref stMessages[i], ref dTime);
|
|
if ((stMessages[i].StatusBitField & Convert.ToInt32(eDATA_STATUS_BITFIELD_1.SPY_STATUS_TX_MSG)) == 0)
|
|
{
|
|
// Rx Data
|
|
if (stMessages[i].ArbIDOrHeader != 0)
|
|
RxQueuePut(ref stMessages[i]);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private bool GetMessageProcess()
|
|
{
|
|
bool result = false;
|
|
icsSpyMessage rxMsg = new icsSpyMessage();
|
|
|
|
if (RxQueueGet(ref rxMsg))
|
|
{
|
|
switch (rxMsg.Protocol)
|
|
{
|
|
case (int)ePROTOCOL.SPY_PROTOCOL_CAN:
|
|
{
|
|
UInt32 exID = (UInt32)rxMsg.ArbIDOrHeader;
|
|
byte[] rData = new byte[8];
|
|
|
|
rData[0] = rxMsg.Data1;
|
|
rData[1] = rxMsg.Data2;
|
|
rData[2] = rxMsg.Data3;
|
|
rData[3] = rxMsg.Data4;
|
|
rData[4] = rxMsg.Data5;
|
|
rData[5] = rxMsg.Data6;
|
|
rData[6] = rxMsg.Data7;
|
|
rData[7] = rxMsg.Data8;
|
|
|
|
OnPrint?.Invoke(this, csCanCommFunction.PacketToMsg(exID, rData, 0));
|
|
|
|
PACKET_HEADER pHeader = csCanCommFunction.CovertPtoH(exID);
|
|
switch (pHeader.Index)
|
|
{
|
|
case 0x01: // Inventory Data Packet
|
|
if ((pHeader.SA == (200 + SystemId)))
|
|
{
|
|
result = true;
|
|
|
|
RxSystemId = pHeader.SA - 200;
|
|
csCanCommFunction.CanInvRxProcess(RxSystemId, exID, rData, ref SystemData, DateTime.Now);
|
|
OnUpdate?.Invoke(this, ref SystemData);
|
|
}
|
|
break;
|
|
case 0x04: // Firmware Update Packet
|
|
OnDataRecv?.Invoke(exID, rData);
|
|
break;
|
|
case 0x06: // Normal Packet
|
|
if (pHeader.SA == (200 + SystemId))
|
|
{
|
|
result = true;
|
|
|
|
RxSystemId = pHeader.SA - 200;
|
|
csCanCommFunction.CanRxProcess(ref Config, RxSystemId, exID, rData, ref SystemData, DateTime.Now);
|
|
OnUpdate?.Invoke(this, ref SystemData);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DATA INIT
|
|
|
|
private void DataInit()
|
|
{
|
|
SystemData.ShelfCommFail = true;
|
|
|
|
for (int j = 0; j < csConstData.SystemInfo.MAX_MODULE_CELL_SIZE; j++)
|
|
{
|
|
SystemData.ValueData.CellVoltage[j] = 0;
|
|
}
|
|
for (int j = 0; j < csConstData.SystemInfo.MAX_MODULE_TEMP_SIZE; j++)
|
|
{
|
|
SystemData.ValueData.CellTemperature[j] = 0;
|
|
}
|
|
SystemData.ValueData.voltageOfPack = 0;
|
|
SystemData.ValueData.current = 0;
|
|
SystemData.ValueData.rSOC = 0;
|
|
SystemData.AvgData.maxCellVoltage = 0;
|
|
SystemData.AvgData.minCellVoltage = 0;
|
|
SystemData.AvgData.avgCellVoltage = 0;
|
|
SystemData.AvgData.maxTemp = 0;
|
|
SystemData.AvgData.minTemp = 0;
|
|
SystemData.AvgData.avgTemp = 0;
|
|
SystemData.heatbeat = 0;
|
|
SystemData.StatusData.warning = 0;
|
|
SystemData.StatusData.protect = 0;
|
|
|
|
for (int j = 0; j < SystemData.Information.pcb_sn.Length; j++)
|
|
{
|
|
SystemData.Information.pcb_sn[j] = 0;
|
|
}
|
|
for (int j = 0; j < SystemData.Information.module_sn.Length; j++)
|
|
{
|
|
SystemData.Information.module_sn[j] = 0;
|
|
}
|
|
|
|
SystemData.CalibriationData.Battery.Capacity = 0;
|
|
SystemData.CalibriationData.Current.ChaAndDchSelect = 0;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|