public override string ToString()
{
return("[ " + _msgType.ToString() +
" - " + _priority.ToString() +
" - ID: " + _msgID +
" (" + CNCRTools.BytesToHex(this.toSerial()) + ") ]");
}
/// <summary>
/// Transfers message data to a byte array for transfer.
/// </summary>
/// <returns>
/// Command Structure:
/// [Type XYZ P] [SpeedUpper7 P] [SpeedLower7 P] [0000 0 SU1 SL1 P] [Parity]
/// - Type: 5
/// - XYZ: 110 would set the speed for X and Y, but not Z
/// - Speed: 16 bit unsigned int, a range of about 64k
/// </returns>
public override byte[] toSerial()
{
// Build first byte [Type 0 XYZ] --> [0101 0XYZ]
byte TypeAndAxis = getMsgTypeByte();
if (_X)
{
TypeAndAxis |= 0x08;
} // Set X bit [0000 1000]
if (_Y)
{
TypeAndAxis |= 0x04;
} // Set Y bit [0000 0100]
if (_Z)
{
TypeAndAxis |= 0x02;
} // Set Z bit [0000 0010]
byte[] speedBytes = CNCRTools.generateThreeBytesFromUInt16(_speed);
byte[] result = { TypeAndAxis, speedBytes[0],
speedBytes[1], speedBytes[2], 0 };
CNCRTools.generateParity(ref result);
return(result);
}
private void button1_Click(object sender, EventArgs e)
{
// center start stop
// (0, 0) (0, -1) (0, 1)
//int[] a180 = new int[] { 0, 0,/**/ 0, -1,/**/ 0, 1 }; // -180 // CCW
//int[] a180 = new int[] { 0, 0,/**/ 0, -1,/**/ -1, 0 };// -270 // CCW
//int[] a180 = new int[] { 0, 0,/**/ -1, 0,/**/ 0, -1 };// 270 // CW (360 - 270) = 90
//int[] a180 = new int[] { 0, 0,/**/ 1, 0,/**/ -1, 0 };// -180
int[] a180 = new int[] { 0, 0, /**/ 1, 0, /**/ 0, -1 };// -90
// From (0, -1) to (0, 1) = -180
double angle = CNCRTools.getAngleFromLines(a180[0], a180[1], a180[2], a180[3], a180[0], a180[1], a180[4], a180[5]);
label1.Text = angle.ToString();
//CNCRMessage bob = new CNCRMessage(CNCRMSG_TYPE.E_STOP);
/* For testing the priority Queue
* PriorityQueue<CNCRMessage> testQ = new PriorityQueue<CNCRMessage>();
* testQ.Enqueue(new CNCRMsgSetSpeed(true, true, false, 300));
* testQ.Enqueue(new CNCRMsgSetSpeed(false, false, true, 100));
* testQ.Enqueue(new CNCRMsgMove(0, 0, 5));
* testQ.Enqueue(new CNCRMsgToolCmd(true));
* testQ.Enqueue(new CNCRMsgMove(0, 0, 0));
* CNCRMessage testM = new CNCRMsgCmdAck(false, 0);
* testM.setPriority(CNCRMSG_PRIORITY.MEDIUM);
* testQ.Enqueue(testM);
*
* label1.Text = "";
* while (testQ.Count > 0)
* {
* label1.Text += testQ.Dequeue().ToString() + "\n";
* }//*/
/* For testing queue joining.
*
* List<int> bob = new List<int>();
* bob.Add(1);
* bob.Add(2);
* bob.Add(3);
* bob.Add(4);
*
* List<int> bob2 = new List<int>();
* bob2.Add(5);
* bob2.Add(6);
* bob2.Add(7);
* bob2.Add(8);
*
* bob.AddRange(bob2);
*
* Queue<int> jim = new Queue<int>(bob);
*
* label1.Text = "";
* while (jim.Count > 0)
* {
* label1.Text += jim.Dequeue().ToString() + "\n";
* }//*/
}
/// <summary>
/// Transfers CNCRMsgEStop to a byte array for transfer.
/// </summary>
/// <returns>
/// Command Structure:
/// [Type 000 P] [Parity]
/// </returns>
public override byte[] toSerial()
{
// [0010 000 P] [Parity]
byte Type = getMsgTypeByte();
byte[] result = { Type, 0 };
CNCRTools.generateParity(ref result);
return(result);
}
public CNCRMsgMove(byte[] msgBytes)
: this()
{
//TODO: CNCRMsgMove: Error check the bytes
//Convert Bytes to X, Y, Z
this._X = CNCRTools.generateInt16FromThreeBytes(msgBytes, 1);
this._Y = CNCRTools.generateInt16FromThreeBytes(msgBytes, 4);
this._Z = CNCRTools.generateInt16FromThreeBytes(msgBytes, 7);
}
private void DisplayDataQueue()
{
_displayLabel.Invoke(new EventHandler(delegate
{
_displayLabel.Text = string.Empty;
byte[] bytesInQ = _commBufferQueue.ToArray();
_displayLabel.Text = CNCRTools.BytesToHex(bytesInQ);
}));
}
/// <summary>
/// Converts message data to a byte array for transfer over serial.
/// </summary>
/// <returns>
/// Command Structure:
/// [Type 000 P] [#Cmds P] [255]
/// - Type: 3
/// - #Cmds: 7 bits, gives a range of 1 to 128.
/// </returns>
public override byte[] toSerial()
{
byte Type = getMsgTypeByte();
byte CmdCount = Convert.ToByte(_cmdCnt << 1);
byte[] result = { Type, CmdCount, 0 }; // Build the result array.
// generate parity
CNCRTools.generateParity(ref result);
return(result);
}
/// <summary>
/// Transfers the message data to a byte array for transfer.
/// </summary>
/// <returns>
/// Command Structure:
/// [Type 00 isEndQueue P] [Parity]
/// - Type: 4
/// - isStopQueue: Set to 1 to indicate an end of the build process.
/// </returns>
public override byte[] toSerial()
{
byte typeEndQueue = getMsgTypeByte();
if (_isEndQueue)
{
typeEndQueue |= 0x02; // Set the EndQueue bit.
}
byte[] result = { typeEndQueue, 0 };
CNCRTools.generateParity(ref result);
return(result);
}
/// <summary>
/// Transfers the message data to a byte array for transfer.
/// </summary>
/// <returns>
/// [Type 00 OnOff P][Parity]
/// - Type: 7
/// - OnOff: 0 for off, 1 for on
/// </returns>
public override byte[] toSerial()
{
byte TypeOnOff = getMsgTypeByte();
if (_toolOn)
{
TypeOnOff |= 0x02;
} // If tool on, set the bit.
byte[] result = { TypeOnOff, 0 };
CNCRTools.generateParity(ref result);
return(result);
}
/// <summary>
/// Outputs the message in a format that can be sent over the
/// serial connection.
/// </summary>
/// <returns>
/// Command Structure:
/// [Type 000] [UpperX] [LowerX] [EndsX]
/// [UpperY] [LowerY] [EndsY]
/// [UpperZ] [LowerZ] [EndsZ]
/// [Parity]
/// </returns>
public override byte[] toSerial()
{
byte Type = getMsgTypeByte();
byte[] xBits = CNCRTools.generateThreeBytesFromInt16(getX());
byte[] yBits = CNCRTools.generateThreeBytesFromInt16(getY());
byte[] zBits = CNCRTools.generateThreeBytesFromInt16(getZ());
byte[] result = { Type,
xBits[0],xBits[1], xBits[2],
yBits[0],yBits[1], yBits[2],
zBits[0],zBits[1], zBits[2],
0 };
CNCRTools.generateParity(ref result);
return(result);
}
public void SendBytes(byte[] bytes)
{
if (!(comPort.IsOpen == true))
{
OpenPort();
}
if (comPort.IsOpen && (bytes.Length > 0))
{
comPort.Write(bytes, 0, bytes.Length);
}
else
{
DisplayData("Error: Failed to send bytes - [" +
CNCRTools.BytesToHex(bytes) + "]\n");
}
//comPort.Close();
}
/// <summary>
/// Transfers CNCRMsgCmdAck data to a byte array for transfer.
/// </summary>
/// <returns>
/// Structure of result:
/// 0001 001 0 | 0000 000 0 | Parity
/// type err P | firmware P | Parity
/// </returns>
public override byte[] toSerial()
{
// Set top 4 bits to "0001"
byte TypeAndErr = getMsgTypeByte();
// Set the error flag.
if (_isError)
{
TypeAndErr |= 0x02;
}
byte[] result = { TypeAndErr, Convert.ToByte(_firmware << 1), 0 };
// Set the parity bits and byte.
CNCRTools.generateParity(ref result);
return(result);
}
/// <summary>
/// method that will be called when there is data waiting in the buffer
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void comPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
int bytes = comPort.BytesToRead;
byte[] comBuffer = new byte[bytes];
comPort.Read(comBuffer, 0, bytes);
if (getDiscardingData())
{
DisplayData("Discarded: " + CNCRTools.BytesToHex(comBuffer) + "\n");
}
else
{
DisplayData("Received: " + CNCRTools.BytesToHex(comBuffer) + "\n");
handleData(comBuffer);
DisplayDataQueue();
}
}
public CNCRMsgSetSpeed(byte[] msgBytes)
: this()
{
//TODO: CNCRMsgSetSpeed: msgBytes constructor needs to validate msgBytes.
if ((msgBytes[0] & 0x08) == 0x08)
{
_X = true;
}
if ((msgBytes[0] & 0x04) == 0x04)
{
_Y = true;
}
if ((msgBytes[0] & 0x02) == 0x02)
{
_Z = true;
}
_speed = CNCRTools.generateUInt16FromThreeBytes(msgBytes, 1);
}
public void SendMsg(CNCRMessage msg)
{
//TODO: SendMsg: Should this function really be doing this check? Shouldnt the function errorhandler do this?
if (getDiscardingData() && // If we are discarding data.
msg.getMessageType() == CNCRMSG_TYPE.CMD_ACKNOWLEDGE && // and sending an acknowledge
((CNCRMsgCmdAck)msg).getError() == true) // and that acknowledge is saying we have an error.
{
setDiscardingData(false); // Then clear the discard data bit so we can see the response.
byte[] serialStuff = msg.toSerial();
string toDisplay = "Ack Sent: " + CNCRTools.BytesToHex(msg.toSerial());
toDisplay += "\n";
DisplayData(toDisplay);
}
if (msg.getMessageType() != CNCRMSG_TYPE.CMD_ACKNOWLEDGE)
{
setWaitingOnAck(true);
}
setLastMessage(msg);
DisplayData("Sending: " + msg.ToString() + "\n");
SendBytes(msg.toSerial());
}
private void CNCRouterCommand_Load(object sender, EventArgs e)
{
#if !DEBUG
tcInterface.TabPages.Remove(tpGenDebug);
tcInterface.TabPages.Remove(tpCommDebug);
#endif
// Setup the debug tab.
string[] ports = CNCRTools.GetCNCRouterPorts();
cmbPorts.Items.AddRange(ports);
if (cmbPorts.Items.Count > 0)
{
cmbPorts.SelectedIndex = 0;
}
cmbMsgs.SelectedIndex = 0;
// Setup the Auto Tab
commCmd._rtbOutputCommDbg = rtbTraffic;
commCmd._rtbOutputAuto = rtbRCOutput;
commCmd._displayLabel = lblQueue;
// Setup the manual tab.
for (int i = 0; i < distances.Length; i++)
{
cmbMoveDistance.Items.Add(distances[i].ToString() + " mm");
}
cmbMoveDistance.SelectedIndex = 0;
// Setup the Settings tab.
cmbRouterPort.Items.AddRange(ports);
if (cmbRouterPort.Items.Count > 0)
{
cmbRouterPort.SelectedIndex = 0;
}
}
// Events and functions related to the "Auto" tab.
#region Auto Tab
private void btnLoadGCode_Click(object sender, EventArgs e)
{
string eventLog = "";
if (ofdGcodeBrowse.ShowDialog() == DialogResult.OK)
{
rtbRCOutput.Clear();
eventLog += "Opening " + ofdGcodeBrowse.SafeFileName + "\n";
System.IO.StreamReader readFile = new System.IO.StreamReader(ofdGcodeBrowse.OpenFile());
string gcode = readFile.ReadToEnd();
CNCRTools.arcRes = Double.Parse(txtArcAccuracy.Text);
Queue <CNCRMessage> tempQueue = CNCRTools.parseGCode(gcode, ref eventLog);
commCmd.commCommandQueueSet(tempQueue);
eventLog += "Finished Loading. Created " + tempQueue.Count().ToString() + " messages.\n";
rtbRCOutput.AppendText(eventLog);
rtbRCOutput.ScrollToCaret();
lblStatusFile.Text = ofdGcodeBrowse.SafeFileName;
/* Debug output of the commands to a text file.
* string outputText = "";
*
* while (tempQueue.Count() > 0)
* {
* CNCRMessage curMsg = tempQueue.Dequeue();
* if (curMsg.getMessageType() == CNCRMSG_TYPE.MOVE)
* {
* outputText += ((CNCRMsgMove)curMsg).getX().ToString() +
* "\t" + ((CNCRMsgMove)curMsg).getY().ToString() + "\n";
* }
* }
* System.IO.TextWriter tw = new System.IO.StreamWriter("output2.txt");
* tw.Write("");
* tw.Close();//*/
}
}
public void handleData(byte[] commBuffer)
{
// Are we currently in the middle of a type?
if (_commBufferQueue.Count == 0)
{
// No, so grab the type in the next byte.
setCurType((CNCRMSG_TYPE)Enum.ToObject(typeof(CNCRMSG_TYPE), (commBuffer[0] & 0xF0) >> 4));
}
// Get the current type, if it is not between MIN and MAX_TYPE
CNCRMSG_TYPE currentType = getCurType();
if (CNCRMSG_TYPE.zMIN_TYPE < currentType && currentType < CNCRMSG_TYPE.zMAX_TYPE)
{
// Drop all incoming bytes into the queue
for (int i = 0; i < commBuffer.Length; i++)
{
if (CNCRTools.validateParityBit(commBuffer[i]))
{
_commBufferQueue.Enqueue(commBuffer[i]);
}
else
{
// Bad Parity bit, Discard the data and log an error.
handleError("Invalid Parity Bit.");
return;
}
}
// Check how long of a message we are expecting
int expectedLength = CNCRTools.getMsgLenFromType(getCurType());
// Uh, Oh, what about expectedLength = 0, AKA, bad type?
// - At this point, curType should be validated and curType
// should not be unknown, throw an error in getMsgLenFromType.
if (expectedLength > 0)
{
// Process the current Queue
while (_commBufferQueue.Count >= expectedLength)
{
// We have enough bytes, lets get the message for those bytes.
byte[] msgBytes = new byte[expectedLength];
for (int i = 0; i < msgBytes.Length; i++)
{
msgBytes[i] = _commBufferQueue.Dequeue();
}
if (CNCRTools.validateParityByte(msgBytes))
{
DisplayData("- Valid Parity\n");
CNCRMessage CommMsg = CNCRTools.getMsgFromBytes(msgBytes);
DisplayData("- Type: " + CommMsg.ToString() + "\n");
Thread runActOnMessage = new Thread(new ParameterizedThreadStart(actOnMessage));
runActOnMessage.Start(CommMsg);
}
else
{
handleError("Invalid Parity Byte.");
return;
}
}
}
else
{
handleError("Expected length was 0 or less.");
return;
}
}
else
{
// Bad type: log an error, discard bytes.
handleError("Invalid message type.");
return;
}
}
private void btnRefreshPorts_Click(object sender, EventArgs e)
{
cmbPorts.Items.Clear();
cmbPorts.Items.AddRange(CNCRTools.GetCNCRouterPorts());
cmbPorts.SelectedIndex = 0;
}
private void btnSndMsg_Click(object sender, EventArgs e)
{
/*
* int discarded = 0;
* byte[] bytes = CNCRTools.GetBytes(txtHex.Text, out discarded);
* lblDbgOut.Text = "";
* for (int i = 0; i < bytes.Length; i++)
* {
* lblDbgOut.Text += bytes[i].ToString() + " ";
* }//*/
byte[] sendBytes = { 0 };
CNCRMessage sendMsg = null;
switch (cmbMsgs.SelectedIndex)
{
case 0:
int discarded = 0;
sendBytes = CNCRTools.GetBytes(txtHex.Text, out discarded);
break;
case 1:
sendMsg = new CNCRMsgPing();
sendBytes = sendMsg.toSerial();
break;
case 2:
sendMsg = new CNCRMsgCmdAck(false, 127);
sendBytes = sendMsg.toSerial();
break;
case 3:
sendMsg = new CNCRMsgEStop();
sendBytes = sendMsg.toSerial();
break;
case 4:
sendMsg = new CNCRMsgRequestCommands(128);
sendBytes = sendMsg.toSerial();
break;
case 5:
sendMsg = new CNCRMsgStartQueue(false);
sendBytes = sendMsg.toSerial();
break;
case 6:
sendMsg = new CNCRMsgSetSpeed(true, true, false, 40000);
sendBytes = sendMsg.toSerial();
break;
case 7:
sendMsg = new CNCRMsgMove(Int16.MinValue, Int16.MaxValue, 0);
sendBytes = sendMsg.toSerial();
break;
case 8:
sendMsg = new CNCRMsgToolCmd(true);
sendBytes = sendMsg.toSerial();
break;
}
rtbTraffic.AppendText(CNCRTools.BytesToHex(sendBytes) + "\n");
if (sendMsg == null)
{
commCmd.SendBytes(sendBytes);
}
else
{
commCmd.SendMsg(sendMsg);
}
}
private void button2_Click(object sender, EventArgs e)
{
cmbRouterPort.Items.Clear();
cmbRouterPort.Items.AddRange(CNCRTools.GetCNCRouterPorts());
cmbRouterPort.SelectedIndex = 0;
}
