public static void CommunicationsProtocol(PrinterControl simCtl, byte[] commandPkt)
{
var complete = false;
var header = new byte[4];
do
{
Buffer.BlockCopy(commandPkt, 0, header, 0, 4);
var paramDataLen = commandPkt[1];
var commandParam = new byte[paramDataLen];
Buffer.BlockCopy(commandPkt, 4, commandParam, 0, paramDataLen);
var checksumBytes = CalculateChecksum(header, commandParam);
header[2] = checksumBytes[0];
header[3] = checksumBytes[1];
var rcvHeader = SendHeaderAndReceive(simCtl, header);
if (ByteArraysEquals(header, rcvHeader))
{
//Console.WriteLine("Sending ACK");
var ackParam = CombineBytes(ACK, commandParam);
//simCtl.WriteSerialToFirmware(ACK, 1);
//simCtl.WriteSerialToFirmware(commandParam, commandParam.Length);
simCtl.WriteSerialToFirmware(ackParam, ackParam.Length);
complete = WaitForResponse(simCtl);
}
else
{
//Console.WriteLine("Sending NACK");
simCtl.WriteSerialToFirmware(NACK, 1);
}
} while (complete == false);
}
public void execute(Command cmd, List <Object> param)
{
switch (cmd)
{
case Command.GetFirmwareVersion:
var byteMessage = new byte[4] {
0x00, 0x00, 0x00, 0x00
};
break;
case Command.ResetStepper:
byteMessage = new byte[4] {
0x01, 0x00, 0x00, 0x00
};
printer.WriteSerialToFirmware(byteMessage, 4); // send command
handleResponse(cmd, byteMessage, param);
break;
case Command.StepStepper:
byteMessage = new byte[4] {
0x02, 0x00, 0x00, 0x00
};
// send command with param[0] (up or down)
break;
case Command.SetLaser:
byteMessage = new byte[4] {
0x03, 0x00, 0x00, 0x00
};
// send command param[0] (on or off)
break;
case Command.MoveGalvonometer:
byteMessage = new byte[4] {
0x04, 0x00, 0x00, 0x00
};
// send commandwith param[0] x and param[1] y
break;
default:
break;
}
}
static byte[] SendHeaderAndReceive(PrinterControl printer, byte[] header)
{
//Console.WriteLine("SendingHeader");
var fooRcvd = new byte[4];
int bytesRead = 0;
printer.WriteSerialToFirmware(header, 4);
do
{
bytesRead = printer.ReadSerialFromFirmware(fooRcvd, 4);
} while (bytesRead < 1);
return(fooRcvd);
}
/*
* HostToFirmware
*
* Returns: true on success, false on failure
* Arguments:
* packet: Packet to be sent
* simCtl: PrinterControl variable that gets passed around to everything
* (optional) maxRetries: Maximum number of retries before faliure is returned
* (internal) currentRetry: Used internally to track the current retry count
*/
// MAKE SURE TO CHANGE MAXRETI
static bool HostToFirmware(byte[] packet, PrinterControl simCtl, int maxRetries = 10, int currentRetry = 0) // MAKE COPIES OF ALL THE THINGS
{
if (currentRetry >= maxRetries)
{
return(false);
}
//Console.Write("+++++++++++++++NEXT COMMAND++++++++++++++++ \n");
// Host-to-Firmware Communication Procedure
const int header_size = 4; // 4 is header size
int response_size = 1; // So it reads one byte at a time
int ACK_NAK_size = 1; // size of both ACK and NAK bytes
byte null_byte = 0x30; // Null byte
const int max_size = 20;
byte[] ACK = { 0xA5 }; // ACK byte
byte[] NAK = { 0xFF }; // ACK byte
string success = "SUCCESS";
// Send 4-byte header consisting of command byte, length, and 16-bit checksum
byte[] checksummed_packet = Checksum(packet);
byte[] header = checksummed_packet.Skip(0).Take(header_size).ToArray(); // array substring from Skip and Take, 0 to 4
var header_copy = header.ToArray(); // making a copy for header to go in so it doesn't change it
printByteArray(header_copy, "Host sending header");
int header_bytes_sent = simCtl.WriteSerialToFirmware(header_copy, header_size);
// Read header bytes back from firmware to verify correct receipt of command header
byte[] possible_header = new byte[header_size];
// int header_bytes_recieved = simCtl.ReadSerialFromFirmware(possible_header, header_size);
while (simCtl.ReadSerialFromFirmware(possible_header, header_size) < header_size) // function inside returns header_bytes_recieved
{
; // wait for four bytes to be recieved // 4 bytes
}
int test = 0;
printByteArray(possible_header, "Host received header response");
// If header is correct
if (header.SequenceEqual(possible_header)) // header == possible_header
{
// Send ACK(0xA5) to firmware
byte[] ACK_to_send = ACK.ToArray();
printByteArray(ACK_to_send, "Host sending ack");
int ACK_send = simCtl.WriteSerialToFirmware(ACK_to_send, ACK_NAK_size); // 1 is the size of the ACK and NAK bytes
// Send rest of packet not including the 4-byte header
byte[] rest_bytes_send = checksummed_packet.Skip(header_size).Take(checksummed_packet.Length - header_size).ToArray(); // array substring
printByteArray(rest_bytes_send, "Host sending remaining bytes");
int rest_bytes_sent = simCtl.WriteSerialToFirmware(rest_bytes_send, packet.Length - header_size); // change last argument to parameter data length in the 4th byte
// Wait for first byte of response to be received
byte[] response_byte = new byte[response_size];
byte[] response_bytes = new byte[max_size];
int num_received = 0;
int i = 0;
//int response_bytes_recieved = simCtl.ReadSerialFromFirmware(response_bytes, response_size);
// Continue reading rest of response until null byte (0) is received
while (true) // might get hung up here
{
num_received = simCtl.ReadSerialFromFirmware(response_byte, 1);
if (num_received == 1)
{
i++; // ++'s the number of bytes received
response_bytes[i] = response_byte[response_byte.Length - 1]; // fills the byte[] with the bytes starting at 1 for some reason
num_received = 0; // resets num_received
}
if (response_bytes[i] == null_byte) // should I use .SequenceEqual()?
{
break; // exit the wait loop
}
else if (i >= max_size)
{
Console.Write("Broke when trying to read response \n");
return(false);
}
}
var new_response = response_bytes.Skip(1).Take(i - 1).ToArray(); // i - 1 to take off the null and skip 1 to get rid of the 0 in first
string response_string = System.Text.Encoding.ASCII.GetString(new_response); // converts from byte[] to string
printByteArray(response_bytes, "Host received response string " + response_string);
// Verify that response string equals “SUCCESS” or “VERSION n.n” (If not, re-send entire command)
if (response_string == success) // || response_bytes == "VERSION n.n"
{
return(true);
}
else
{
Console.Write("retry NO SUCCESS \n");
// retry command
return(HostToFirmware(packet, simCtl, maxRetries, currentRetry + 1)); // this retries the command and returns the result of that command
}
}
// else if header is not received correctly
else
{
// Send NAK(0xFF)
byte[] NAK_to_send = NAK.ToArray();
printByteArray(NAK_to_send, "Host sending nak :(");
int NAK_send = simCtl.WriteSerialToFirmware(NAK_to_send, ACK_NAK_size);
Console.Write("retry NAK \n");
// Retry command
return(HostToFirmware(packet, simCtl, maxRetries, currentRetry + 1)); // this retries the command and returns the result of that command
}
}
public string SendCommand()
{
byte[] value = new byte[HEADER_SIZE];
int bytesRetrieved;
string retString = "";
// Calculate checksum
short checkSum = 0;
for (int i = 0; i < curCommand.Count(); i++)
{
checkSum += curCommand[i];
}
curCommand[2] = (byte)checkSum; // Stuff checksum into buffer at reserved spot
curCommand[3] = (byte)(checkSum >> 8);
do
{
// Write the header
printer.WriteSerialToFirmware(curCommand.ToArray(), HEADER_SIZE);
// Get header back
while ((bytesRetrieved = printer.ReadSerialFromFirmware(value, HEADER_SIZE)) == 0)
{
;
}
if (value[0] == curCommand[0] && value[1] == curCommand[1] && value[2] == curCommand[2] && value[3] == curCommand[3])
{
// Send ACK
value[0] = 0xA5;
printer.WriteSerialToFirmware(value, 1);
// Send command payload
while (printer.WriteSerialToFirmware(curCommand.Skip(HEADER_SIZE).ToArray(), curCommand.Count() - HEADER_SIZE) == 0)
{
;
}
retString = "";
// Wait for response byte
do
{
bytesRetrieved = printer.ReadSerialFromFirmware(value, 1);
} while (bytesRetrieved == 0);
retString += (char)value[0]; // Add returned value to return string
// Add rest of response string until null byte read
while (value[0] != 0)
{
bytesRetrieved = printer.ReadSerialFromFirmware(value, 1);
if (bytesRetrieved != 0 && value[0] != 0)
{
retString += (char)value[0];
}
}
if (curCommand[0] == FWCommands.CMD_VERSION)
{
break; // Return version info
}
// if (retString != "SUCCESS") Console.WriteLine("Error {0}: " + retString, cmdNum);
}
else // error - send NACK
{
// Send NACK
value[0] = 0xFF;
printer.WriteSerialToFirmware(value, 1);
retString = "NAK";
}
} while (retString != "SUCCESS");
Clear();
cmdNum++;
return(retString);
}
public static void SendPacket(PrinterControl printer, Packet packet)
{
byte[] header = packet.GetHeader();
byte[] headerCopy = new byte[4];
header.CopyTo(headerCopy, 0);
int result = 0;
//Console.WriteLine("\nHost sending to firmware: ");
//for (int i = 0; i < header.Length; i++)
//{
// Console.Write(" ");
// Console.Write(header[i]);
//}
result = printer.WriteSerialToFirmware(headerCopy, header.Length);
byte[] responseHeader = ReadPacket(printer, header.Length);
if (SameHead(header, responseHeader) == true)
{
//Console.WriteLine("\nHost sent ACK to firmware: ");
printer.WriteSerialToFirmware(new byte[] { 0xA5 }, 1);
//Console.WriteLine("\nHost sending packet to firmware: ");
//for (int i = 0; i < packet.data.Length; i++)
//{
// Console.Write(" ");
// Console.Write(packet.data[i]);
//}
byte[] packetDataCopy = new byte[packet.data.Length];
packet.data.CopyTo(packetDataCopy, 0);
printer.WriteSerialToFirmware(packetDataCopy, packet.data.Length);
byte[] character = ReadPacket(printer, 1);
string response = "";
while (character[0] != 0)
{
response += Encoding.ASCII.GetString(new byte[] { character[0] });
character = ReadPacket(printer, 1);
}
//Console.WriteLine("\nResponse: " + response);
if (response == "SUCCESS")
{
return;
}
else if (response.Contains("VERSION"))
{
return;
}
else
{
SendPacket(printer, packet);
}
}
else
{
printer.WriteSerialToFirmware(new byte[] { 0xFF }, 1);
SendPacket(printer, packet);
}
return;
}
private void handleMessage(Command cmd, byte[] byteMessage, byte[] paramBytes, float[] floatParam)
{
var fullMessage = getFullMessage(byteMessage, paramBytes);
var checksum = HelperFunctions.ParseCmdPacket(fullMessage);
byteMessage[2] = checksum[0];
byteMessage[3] = checksum[1];
bool done = false;
while (!done)
{
if (byteMessage[1] > 0x08)
{
var breakp = 0;
}
Console.WriteLine("Host: Writing command {0} to firmware", cmd);
Console.Write("Host: Params in command: ");
foreach (float p in floatParam)
{
Console.Write("{0}, ", p);
}
Console.Write("\n");
Console.WriteLine("Host: Checksum verification returned {0}", HelperFunctions.validateChecksum(byteMessage, paramBytes));
printer.WriteSerialToFirmware(byteMessage, byteMessage.Length);
var finalResponse = "";
var headerResponse = new byte[4];
Console.WriteLine("Host: Reading header back from firmware");
if (!read(headerResponse, 4))
{
continue;
}
bool isRight = byteMessage.SequenceEqual(headerResponse);
if (isRight)
{
Console.WriteLine("Host: Header was correct, sending parameter data");
printer.WriteSerialToFirmware(new byte[1] {
0xA5
}, 1);
printer.WriteSerialToFirmware(paramBytes, paramBytes.Length);
var ch = new byte[1] {
0xFF
};
Console.WriteLine("Host: Waiting for success string");
while (!ch.SequenceEqual(new byte[1] {
0x00
}))
{
var readResult = read(ch, 1);
if (!readResult)
{
ch[0] = 0x00;
}
finalResponse += System.Text.Encoding.UTF8.GetString(ch);
}
if (finalResponse.Split(':')[0] == "VERSION")
{
Console.WriteLine("Host: received version confirmation\n");
this.firmwareVersion = "FIRMWARE VERSION: " + finalResponse.Split(':')[1].Replace("\0", string.Empty);
done = true;
return;
}
else
{
Console.WriteLine("Host: Did not receive version confirmation\n");
continue;
}
}
else
{
Console.WriteLine("Host: Header was wrong, resending command\n");
printer.WriteSerialToFirmware(new byte[1] {
0xFF
}, 1);
continue;
}
}
}