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); }
private void handleResponse(Command cmd, byte[] byteMessage, List <Object> param) { var finalResponse = ""; var headerResponse = new byte[1]; printer.ReadSerialFromFirmware(headerResponse, 1); if (headerResponse[0] == byteMessage[0]) { printer.WriteSerialToFirmware(new byte[1] { 0xA5 }, 1); byte[] finalMessage = new byte[byteMessage.Length - 3]; Array.Copy(byteMessage, 4, finalMessage, 0, byteMessage.Length - 3); printer.WriteSerialToFirmware(finalMessage, byteMessage.Length - 3); var ch = new byte[2] { 0xFF, 0xFF }; while (ch != new byte[2] { 0x00, 0x00 }) { printer.ReadSerialFromFirmware(ch, 2); finalResponse += System.Text.Encoding.UTF8.GetString(ch); } if (finalResponse != "SUCCESS") { execute(cmd, param); } } else { printer.WriteSerialToFirmware(new byte[1] { 0xFF }, 1); execute(cmd, param); } }
private bool read(byte[] buffer, int expectedBytes) { int timeout = 100; while (printer.ReadSerialFromFirmware(buffer, expectedBytes) != expectedBytes && timeout > 0) { System.Threading.Thread.Sleep(20); timeout--; if (timeout == 0) { Console.WriteLine("Host: Read timeout"); System.Threading.Thread.Sleep(5); return(false); } } return(true); }
static bool WaitForResponse(PrinterControl printer) { //Console.WriteLine("HostWaitResponse"); var responseRcvd = false; var responseArray = new byte[successBytes.Length]; var readResponse = 0; while (!responseRcvd /* readResponse != successBytes.Length*/) { readResponse = printer.ReadSerialFromFirmware(responseArray, successBytes.Length); if (readResponse == successBytes.Length) { //Console.WriteLine("Host done waiting: " + responseArray[0]); responseRcvd = true; } } return(ByteArraysEquals(successBytes, responseArray)); }
public static byte[] ReadPacket(PrinterControl printer, int expected) { byte[] data = new byte[expected]; byte[] failure = new byte[4]; int count = 0; while (count < 1000000000) { int response = printer.ReadSerialFromFirmware(data, expected); if (response == expected) { //Console.WriteLine("\nHost is reading: "); //for (int i = 0; i < data.Length; i++) //{ // Console.Write(" "); // Console.Write(data[i]); //} return(data); } count++; } return(failure); }
/* * 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); }