public bool read(byte[] buffer, int expectedBytes) { try { if (expectedBytes == 0) { return(true); } int timeout = 10000; int readResult = 0; while (timeout > 0 && readResult == 0) { readResult = printer.ReadSerialFromHost(buffer, expectedBytes); if (readResult != expectedBytes) { timeout--; Thread.Sleep(10); } } if (timeout == 0) { var message = Encoding.UTF8.GetBytes("TIMEOUT" + char.MinValue); printer.WriteSerialToHost(message, message.Length); return(false); } return(true); } catch (Exception e) { System.Console.WriteLine(e.StackTrace); return(false); } }
void ReceiveHeaderAndSend(byte[] headerReceived) { int bytesRead = 0; while (bytesRead < 1) { bytesRead = printer.ReadSerialFromHost(headerReceived, 4); } printer.WriteSerialToHost(headerReceived, 4); }
static void ClearBuffer(PrinterControl printer) { int response_size = 1; byte[] read_byte = new byte[response_size]; int num_received = 0; while (true) // might get hung up here { num_received = printer.ReadSerialFromHost(read_byte, 1); if (num_received == 1) { num_received = 0; // resets num_received } else { return; } } }
public byte[] ReadPacket(PrinterControl printer, int expected) { byte[] data = new byte[expected]; byte[] failure = new byte[4]; int count = 0; while (count < 10000000) { int response = printer.ReadSerialFromHost(data, expected); if (response == expected) { //Console.WriteLine("\nFirmware is reading: "); //for (int i = 0; i < data.Length; i++) //{ // Console.Write(" "); // Console.Write(data[i]); //} return(data); } count++; } return(failure); }
void Process() { byte[] value = new byte[HEADER_SIZE]; byte[] cmdParams = new byte[64]; int bytesRead = 0; string retString = ""; int timeout; while (!fDone) { do // Wait for command byte { bytesRead = printer.ReadSerialFromHost(value, HEADER_SIZE); // Read command, length, and checksum } while (!fDone && bytesRead == 0); // Console.WriteLine("Process: {0} {1}", value[0], value[1]); if (!fDone && bytesRead == HEADER_SIZE) // Successfully read command byte, length byte, and checksum bytes { // Write header back to host printer.WriteSerialToHost(value, HEADER_SIZE); byte[] ACKNAK = new byte[2]; ACKNAK[0] = 0; do // Wait for ACK/NACK byte { bytesRead = printer.ReadSerialFromHost(ACKNAK, 1); // Read ACK/NAK } while (!fDone && bytesRead == 0); if (ACKNAK[0] == ACK_BYTE) { timeout = 0; if (value[1] > 0) { do { timeout++; } while ((bytesRead = printer.ReadSerialFromHost(cmdParams, value[1])) == 0 && timeout < TIMEOUT_THRESHOLD); // Read in the parameters } if (timeout == TIMEOUT_THRESHOLD) { retString = "TIMEOUT"; } else { // Validate checksum short checkSum = (byte)(value[0] + value[1]); short targetCheckSum = (short)(((short)value[3] << 8) + value[2]); for (int i = 0; i < value[1]; i++) { checkSum += cmdParams[i]; } if (checkSum == targetCheckSum) // Valid checksum, proceed { if (value[0] != FWCommands.CMD_BUFFER) { retString = DoCommand(value[0], cmdParams, 0); } else // Process command buffer { while (cmdParams[0] != FWCommands.CMD_INVALID) { byte Ndx = 0; byte bufferLen = value[1]; byte cmd = cmdParams[Ndx++]; byte len = cmdParams[Ndx++]; Ndx += len; retString = DoCommand(cmd, cmdParams, 2); // Delete used command for (byte i = 0; i < bufferLen - (len + 2); i++) { cmdParams[i] = cmdParams[len + 2 + i]; } for (byte i = (byte)(bufferLen - (len + 2)); i < bufferLen; i++) { cmdParams[i] = FWCommands.CMD_INVALID; } } } } else { retString = "CHECKSUM"; } } // If no TIMEOUT printer.WriteSerialToHost(retString.Select(c => (byte)c).ToArray(), retString.Length); value[0] = 0; printer.WriteSerialToHost(value, 1); } // if ACK'd } } }
string FirmwareToHost(PrinterControl printer) // took out byte[] packet, // need to change the return type to the same as the host side { //Firmware-to-Host Communication Procedure int header_size = 4; // 4 is header size int response_size = 1; // UNSURE OF SIZE OF RESPONSE int ACK_NAK_size = 1; // size of both ACK and NAK bytes byte[] ACK = { 0xA5 }; // ACK byte byte[] NAK = { 0xFF }; // ACK byte string timeout = "TIMEOUT"; string success = "SUCCESS"; string checksum = "CHECKSUM"; string nak = "NAK"; // Read 4-byte header from host byte[] header_recieved = new byte[header_size]; // wait for bytes to be recieved while (printer.ReadSerialFromHost(header_recieved, header_size) < header_size) // the function returns header_bytes_recieved { ; // wait } ClearBuffer(printer); // This should clear the buffer printByteArray(header_recieved, "Firmware received header"); // Write 4-byte header back to host byte[] header_sent = header_recieved.ToArray(); printByteArray(header_sent, "Firmware sent header"); int header_bytes_sent = printer.WriteSerialToHost(header_sent, header_size); // Read ACK/NAK byte byte[] ACK_NAK = { 0x00 }; // change this to a one element array with nothing in it while (printer.ReadSerialFromHost(ACK_NAK, ACK_NAK_size) < 1) // function inside returns ACK_NAK_recieved (int) { ; // wait } //ClearBuffer(printer); // This should clear the buffer printByteArray(ACK_NAK, "Firmware received ACK or NAK"); // If ACK received if (ACK_NAK.SequenceEqual(ACK)) { // Attempt to read number of parameter bytes indicated in command header int num_bytes_rest = (int)(header_recieved[1]); // header_recieved[1] is the number of bytes in the rest of the packet byte[] rest_bytes = new byte[num_bytes_rest]; int rest_bytes_recieved = 0; // header_recieved[1] should be rest of packet size int test_count = 0; bool timeout_test = false; while ((rest_bytes_recieved = printer.ReadSerialFromHost(rest_bytes, num_bytes_rest)) < num_bytes_rest) // function inside returns rest_bytes_recieved { // wait if (rest_bytes_recieved < num_bytes_rest && test_count >= 100) { timeout_test = true; break; } } ClearBuffer(printer); // This should clear the buffer printByteArray(rest_bytes, "Firmware received data"); // If insufficient bytes are received if (timeout_test) // if number of bytes recieved is less than number of bytes sent { // return “TIMEOUT” byte[] response_bytes = ResponseMaker(timeout); printByteArray(response_bytes, "Firmware sent response"); int response_bytes_sent = printer.WriteSerialToHost(response_bytes, response_size); return(timeout); } else { // Validate checksum(Be sure NOT to include checksum values themselves) byte[] combined = new byte[header_recieved.Length + rest_bytes.Length]; // change header_revcieved.,length to header_size System.Buffer.BlockCopy(header_recieved, 0, combined, 0, header_recieved.Length); System.Buffer.BlockCopy(rest_bytes, 0, combined, 4, rest_bytes.Length); byte[] combined_checksum = Checksum(combined); // compare bytes 2 and 3 from both the header and what is recieved by adding up both parts: header and rest var combined_checksum_bytes = combined_checksum.Skip(2).Take(2).ToArray(); var header_checksum_bytes = header_recieved.Skip(2).Take(2).ToArray(); // If checksum correct if (combined_checksum_bytes.SequenceEqual(header_checksum_bytes)) // .SequenceEqual checks the actual value { // Combined should be the packet without the checksum. make sure // Process // TYLER's Section ProcessCommand(combined, printer); // change from packet to actual packet that goes into the function // how can this work without returning???? // Return “SUCCESS” or “VERSION n.n” byte[] response_bytes = ResponseMaker(success); printByteArray(response_bytes, "Firmware sent Success or Version response"); int response_bytes_sent = printer.WriteSerialToHost(response_bytes, response_bytes.Length); //ClearBuffer(printer); // This should clear the buffer return(success); // SUCCESS } // Else else { // Return “CHECKSUM” byte[] response_bytes = ResponseMaker(checksum); printByteArray(response_bytes, "Firmware sent Checksum response"); int response_bytes_sent = printer.WriteSerialToHost(response_bytes, response_bytes.Length); return(checksum); // CHECKSUM } } } // Else if NAK received else if (ACK_NAK.SequenceEqual(NAK)) { //ClearBuffer(printer); // Ignore command – it will be resent return(nak); } else { // BANDAID int max_size = 20; byte[] nak_byte = new byte[response_size]; byte[] nak_bytes = new byte[max_size]; int num_received = 0; int i = 0; while (true) // might get hung up here { num_received = printer.ReadSerialFromHost(nak_byte, 1); if (num_received == 1) { i++; // ++'s the number of bytes received nak_bytes[i] = nak_byte[nak_byte.Length - 1]; // fills the byte[] with the bytes starting at 1 for some reason num_received = 0; // resets num_received } // NAK[0] because one byte long if (nak_bytes[i] == NAK[0]) // should I use .SequenceEqual()? { break; // exit the wait loop } } ClearBuffer(printer); // This should clear the buffer return("Found the bloody NAK"); // should never get to this but it does } }