public static void sendInstruction(byte[] trame)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = trame; //new byte[8];
CANMsg.ID = CANDevice.HARDWARE_FILTER_TAC; // physical filtering address
PCANCom.Instance.send(CANMsg);
}
public void Update(TPCANMsg canMsg, TPCANTimestamp canTimestamp)
{
m_Msg = canMsg;
m_oldTimeStamp = m_TimeStamp;
m_TimeStamp = canTimestamp;
m_bWasChanged = true;
m_Count += 1;
}
public static void addGetMotorType(byte treatingFunction, byte id)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[0] = DynamixelCANInstruction.GET_MOTOR_TYPE;
CANMsg.DATA[1] = id;
CANMsg.DATA[2] = treatingFunction;
CANMsg.ID = CANDeviceConstant.HARDWARE_FILTER_GRIPPER;
CANQueue.Instance.add(CANMsg);
}
public MessageStatus(TPCANMsg canMsg, TPCANTimestamp canTimestamp, int listIndex)
{
m_Msg = canMsg;
m_TimeStamp = canTimestamp;
m_oldTimeStamp = canTimestamp;
m_iIndex = listIndex;
m_Count = 1;
m_bShowPeriod = true;
m_bWasChanged = false;
}
public static void homeTool()
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[INSTRUCTION_BYTE] = (byte)InstructionSet.Home;
CANMsg.ID = CANDevice.HARDWARE_FILTER_MUTLI_CHANNEL_PIPETTE;
PCANCom.Instance.send(CANMsg);
}
public static void printTransmittedPacket(TPCANMsg msg)
{
Console.WriteLine(" ");
Console.WriteLine("---------------------------------------");
Console.Write("T: ");
for (int n = 0; n < 8; n++)
{
Console.Write("[{0:X}] ", msg.DATA[n]);
}
}
public static void addGetInstruction(byte treatingFunction, byte id, byte adress, byte nbOfByte)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[0] = DynamixelCANInstruction.GET_DATA;
CANMsg.DATA[1] = id;
CANMsg.DATA[2] = adress;
CANMsg.DATA[3] = (byte)(nbOfByte % 5);
CANMsg.ID = CANDeviceConstant.HARDWARE_FILTER_GRIPPER;
CANQueue.Instance.add(CANMsg);
}
public static void sendPositionToMoveTo(Int16 position)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[INSTRUCTION_BYTE] = (byte)InstructionSet.GoTo;
CANMsg.DATA[6] = (byte)(position >> 8);
CANMsg.DATA[7] = (byte)(position);
CANMsg.ID = CANDevice.HARDWARE_FILTER_MUTLI_CHANNEL_PIPETTE;
PCANCom.Instance.send(CANMsg);
}
/// <summary>Converts a TPCANMsg into a CAN.Frame</summary>
public static Frame Frame(TPCANMsg msg)
{
var f = new Frame();
f.ID = (int)msg.ID;
f.Extended = (msg.MSGTYPE & TPCANMessageType.PCAN_MESSAGE_EXTENDED) == TPCANMessageType.PCAN_MESSAGE_EXTENDED;
f.Remote = (msg.MSGTYPE & TPCANMessageType.PCAN_MESSAGE_RTR) == TPCANMessageType.PCAN_MESSAGE_RTR;
f.Length = msg.LEN;
if (msg.DATA != null)
for (int i = 0; i < f.Length; i++)
f[i] = msg.DATA[i];
return f;
}
public static void pipette(Int16 volume)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[INSTRUCTION_BYTE] = (byte)InstructionSet.Pipette;
CANMsg.DATA[6] = (byte)(volume >> 8);
CANMsg.DATA[7] = (byte)(volume);
CANMsg.ID = CANDevice.HARDWARE_FILTER_MUTLI_CHANNEL_PIPETTE;
PCANCom.Instance.send(CANMsg);
}
public static void addSetInstruction(byte id, byte adress, byte nbOfByte, UInt16 data)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[0] = DynamixelCANInstruction.SET_DATA;
CANMsg.DATA[1] = id;
CANMsg.DATA[2] = adress;
CANMsg.DATA[3] = (byte)(nbOfByte % 3);
CANMsg.DATA[4] = (byte)data;
CANMsg.DATA[5] = (byte)(data >> 8);
CANMsg.ID = CANDeviceConstant.HARDWARE_FILTER_GRIPPER;
CANQueue.Instance.add(CANMsg);
}
public static void sendInstruction(byte direction, String volume)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
Int16 aaa;
Int16.TryParse(volume, out aaa);
CANMsg.DATA[4] = (byte)(aaa >> 8);
CANMsg.DATA[5] = (byte)(aaa);
CANMsg.DATA[6] = direction;
CANMsg.ID = CANDevice.HARDWARE_FILTER_MUTLI_CHANNEL_PIPETTE;
PCANCom.Instance.send(CANMsg);
}
/// <summary>Converts a Frame into a TPCANMsg</summary>
public static TPCANMsg Frame(Frame f)
{
var m = new TPCANMsg();
m.ID = (uint)f.ID;
m.DATA = new byte[8]; // needs to be the full 8 bytes
for (int i = 0; i < f.Length; i++)
m.DATA[i] = f[i];
m.LEN = f.Length;
m.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD;
m.MSGTYPE |= f.Extended ? TPCANMessageType.PCAN_MESSAGE_EXTENDED : 0;
m.MSGTYPE |= f.Remote ? TPCANMessageType.PCAN_MESSAGE_RTR : 0;
return m;
}
public static void sendInstruction(byte direction, Int16 volume)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[4] = (byte)(volume >> 8);
CANMsg.DATA[5] = (byte)(volume);
CANMsg.DATA[6] = direction;
CANMsg.ID = CANDevice.HARDWARE_FILTER_SINGLE_CHANNEL_PIPETTE;
PCANCom.Instance.send(CANMsg);
Console.WriteLine(" ");
Console.WriteLine("---------------------------------------");
Console.Write("T: ");
printPacket(CANMsg.DATA);
}
public static void sendInstruction(byte direction, char volume)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[4] = BitConverter.GetBytes(volume)[0];
CANMsg.DATA[5] = BitConverter.GetBytes(volume)[1];
CANMsg.DATA[6] = direction;
CANMsg.ID = CANDevice.HARDWARE_FILTER_MUTLI_CHANNEL_PIPETTE;
PCANCom.Instance.send(CANMsg);
Console.WriteLine(" ");
Console.WriteLine("---------------------------------------");
Console.Write("T: ");
printPacket(CANMsg.DATA);
}
/// <summary>
/// Reads a CAN message from the receive queue of a PCAN Channel
/// </summary>
/// <param name="Channel">The handle of a PCAN Channel</param>
/// <param name="MessageBuffer">A TPCANMsg structure buffer to store the CAN message</param>
/// <returns>A TPCANStatus error code</returns>
public static TPCANStatus Read(
TPCANHandle Channel,
out TPCANMsg MessageBuffer)
{
return Read(Channel, out MessageBuffer, IntPtr.Zero);
}
public static extern TPCANStatus Write(
[MarshalAs(UnmanagedType.U1)]
TPCANHandle Channel,
ref TPCANMsg MessageBuffer);
public static extern TPCANStatus Read(
[MarshalAs(UnmanagedType.U1)]
TPCANHandle Channel,
out TPCANMsg MessageBuffer,
out TPCANTimestamp TimestampBuffer);
private static extern TPCANStatus Read(
[MarshalAs(UnmanagedType.U1)]
TPCANHandle Channel,
out TPCANMsg MessageBuffer,
IntPtr bufferPointer);
public static void sendMessage(byte instruction, byte byte1, byte byte2, byte byte3, byte byte4, byte byte5, byte byte6, byte byte7)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[0] = instruction;
CANMsg.DATA[1] = byte1;
CANMsg.DATA[2] = byte2;
CANMsg.DATA[3] = byte3;
CANMsg.DATA[4] = byte4;
CANMsg.DATA[5] = byte5;
CANMsg.DATA[6] = byte6;
CANMsg.DATA[7] = byte7;
CANMsg.ID = CANDeviceConstant.HARDWARE_FILTER_GRIPPER;
PCANCom.Instance.send(CANMsg);
}
public PCANComEventArgs(TPCANMsg CanMsg)
{
this.CanMsg = CanMsg;
}
public void recieveCANMessagePEAK(TPCANMsg msg, TPCANTimestamp time)
{
string id = msg.ID.ToString(); //can_msg[2].Remove(0, 3);
// string time = time; //Convert.ToInt32(can_msg[1]).ToString();
string lengt = msg.LEN.ToString(); //can_msg[3].Remove(0, 2);
string bytes = "";
for (int i = 0; i < msg.LEN; i++)
{
bytes += Convert.ToString(msg.DATA[i], 16);
if (i != msg.LEN - 1)
bytes += ",";
}
update_can_log(id, lengt, bytes, time.millis.ToString());
update_vscp_mon(Convert.ToInt32(msg.ID), lengt, bytes, time.millis.ToString());
}
/// <summary>
/// Reads a CAN message from the receive queue of a PCAN Channel
/// </summary>
/// <param name="Channel">The handle of a PCAN Channel</param>
/// <param name="MessageBuffer">A TPCANMsg structure buffer to store the CAN message</param>
/// <returns>A TPCANStatus error code</returns>
public static TPCANStatus Read(
TPCANHandle Channel,
out TPCANMsg MessageBuffer)
{
return(Read(Channel, out MessageBuffer, IntPtr.Zero));
}
private void sendPacket(byte[] packet)
{
if (packet.Length > 2)
{
try
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
Array.Copy(packet, 2, CANMsg.DATA, 1, packet.Length-2);
CANMsg.ID = CANDeviceConstant.HARDWARE_FILTER_GRIPPER;
PCANCom.Instance.send(CANMsg);
} catch(Exception e){
Console.WriteLine("Can not transmit the command");
}
}
}
void send_message_PEAK(vscp_message msg)
{
UInt32 id = (UInt32)((msg.priority << 26) | (msg.vclass << 16) | (msg.type << 8) | (msg.nickname));
if (System.Convert.ToBoolean(msg.hard_mask))
id |= (1 << 25);
TPCANMsg CANMsg;
TPCANStatus stsResult;
// We create a TPCANMsg message structure
//
CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
// We configurate the Message. The ID (max 0x1FF),
// Length of the Data, Message Type (Standard in
// this example) and die data
//
CANMsg.ID = id;
CANMsg.LEN = (byte) msg.lenght;
CANMsg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_EXTENDED;
// We get so much data as the Len of the message
//
for (int i = 0; i < CANMsg.LEN; i++)
CANMsg.DATA[i] = Convert.ToByte(msg.data.Substring(i * 2, 1) + msg.data.Substring(i * 2 + 1, 1), 16);
// The message is sent to the configured hardware
//
stsResult = PCANBasic.Write(m_PcanHandle, ref CANMsg);
// The message was successfully sent
//
if (stsResult != TPCANStatus.PCAN_ERROR_OK)
MessageBox.Show(GetFormatedError(stsResult));
}
public TPCANStatus send(TPCANMsg CANMsg)
{
isBusy = true;
//System.Threading.Thread.Sleep(1000);
//while (InterOperationFlag.isSerialBusy != false)
//{
// System.Threading.Thread.Sleep(100);
//}
//InterOperationFlag.isCanBusy = true;
CANMsg.LEN = 8;
CANMsg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD;
Logger.Instance.logPacket(CANMsg.DATA, true, (int)CANMsg.ID);
TPCANStatus temp = PCANBasic.Write(m_PcanHandle, ref CANMsg);
//InterOperationFlag.isCanBusy = false;
return temp;
}
private void postMessage(TPCANMsg CANMsg)
{
//CANQueue.printReceivedPacket(CANMsg);
OnMessageReceivedEvent(new PCANComEventArgs(CANMsg));
}
public static void sendInstruction(byte instruction, byte id, UInt16 data)
{
TPCANMsg CANMsg = new TPCANMsg();
CANMsg.DATA = new byte[8];
CANMsg.DATA[0] = instruction;
CANMsg.DATA[1] = id;
CANMsg.DATA[2] = (byte)data;
CANMsg.DATA[3] = (byte)(data >> 8);
CANMsg.ID = CANDeviceConstant.HARDWARE_FILTER_GRIPPER;
CANQueue.Instance.add(CANMsg);
}
public static extern TPCANStatus Read(
[MarshalAs(UnmanagedType.U1)]
TPCANHandle Channel,
out TPCANMsg MessageBuffer,
out TPCANTimestamp TimestampBuffer);
public TPCANStatus send(TPCANMsg CANMsg)
{
CANMsg.LEN = 8;
CANMsg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD;
return PCANBasic.Write(m_PcanHandle, ref CANMsg);
}
private static extern TPCANStatus Read(
[MarshalAs(UnmanagedType.U1)]
TPCANHandle Channel,
out TPCANMsg MessageBuffer,
IntPtr bufferPointer);
private void postMessage(TPCANMsg CANMsg)
{
OnMessageReceivedEvent(new PCANComEventArgs(CANMsg));
}
public static extern TPCANStatus Write(
[MarshalAs(UnmanagedType.U1)]
TPCANHandle Channel,
ref TPCANMsg MessageBuffer);
public void add(TPCANMsg msg)
{
canQueue.Add(msg);
}