/// <summary> /// Easy solution to write fields to be sent back to the PLC /// </summary> /// <param name="theField">Key to be written</param> /// <param name="theValue">value to be used</param> /// <param name="dataOut">Neutrino to be worked on</param> private void WriteField(string theField, string theValue, ref Neutrino dataOut) { int byteCount = Encoding.GetEncoding(1252).GetByteCount(theValue); byte[] data = new byte[byteCount]; Array.Copy(Encoding.GetEncoding(1252).GetBytes(theValue), data, byteCount); dataOut.AddField(theField, data); }
/// <summary> /// Makes it easier to retrieve the most current field values /// </summary> /// <param name="dataIn">data to be analysed</param> /// <param name="currentLocation">Extracted location from the neutriono</param> /// <param name="picValue">Extracted picValue from the neutriono</param> /// <param name="barcode">Extracted barcode from the neutriono</param> private void GetStandardFields( Neutrino dataIn, out string currentLocation, out string picValue, out string barcode) { byte[] vi = dataIn.GetRawField("SourceLocation"); currentLocation = Encoding.GetEncoding(1252).GetString(vi); vi = dataIn.GetRawField("PIC"); picValue = Encoding.GetEncoding(1252).GetString(vi); vi = dataIn.GetRawField("Barcode"); barcode = Encoding.GetEncoding(1252).GetString(vi); }
private void OnSortationReport(Neutrino dataIn) { string currentLocation, picValue, barcode; GetStandardFields(dataIn, out currentLocation, out picValue, out barcode); string requestedDestination = GetField(dataIn, "RequestedDestination"); string actualDestination = GetField(dataIn, "ActualDestination"); string divertCode = GetField(dataIn, "DivertCode"); if (actualDestination != requestedDestination) { logger.ErrorMethod("Wrong sortation of " + barcode + " at " + currentLocation + " detected."); } }
private void CreateDestinationReply( string picValue, string barcode, string sourceLocation, string destinationLocation, out Neutrino dataOut) { dataOut = new Neutrino(); WriteField(StandardTelegramFieldNames.TelegramId, "51", ref dataOut); WriteField("PIC", picValue, ref dataOut); WriteField("Barcode", barcode, ref dataOut); WriteField("SourceLocation", sourceLocation, ref dataOut); WriteField("DestinationLocation", destinationLocation, ref dataOut); }
/// <summary> /// Tote passed a scanner. PLC is waiting for destination location from MFC /// while tote is stopped. /// </summary> /// <param name="dataIn">data to be analysed</param> /// <param name="dataOut">The data to send back. If null then no data will be send back.</param> private void OnWaitingPointRequest(Neutrino dataIn, out Neutrino dataOut) { string currentLocation, picValue, barcode; dataOut = null; GetStandardFields(dataIn, out currentLocation, out picValue, out barcode); // Just an example. Please put your code here... if (currentLocation == "010202") { // Increment tote counter toteCounterWaitingPoint++; string destinationLocation; if (toteCounterWaitingPoint % 10 == 0) { // We send every 10th tote to the premium quality check... destinationLocation = "010502"; } else { if (barcode.EndsWith("1")) { // In case tote barcode ends by "1", we will send it to reject lane destinationLocation = "010402"; } else { // By default, all totes will go straight destinationLocation = "010392"; } } CreateWaitingPointReply(picValue, barcode, currentLocation, destinationLocation, out dataOut); } // Feel free to check other locations as well... }
/// <summary> /// Will be called each time a telegram has arrived. /// </summary> /// <param name="theInstance">Communication Instance</param> /// <param name="dataIn">data to be analysed</param> /// <param name="dataOut">The data to send back. If null then no data will be send back.</param> public virtual void Process(string theInstance, Neutrino dataIn, out List <Neutrino> dataOut) { Neutrino theNeutrino = null; // Default: We will not send anything back... dataOut = null; // What kind of telegram came in? byte[] vi = dataIn.GetRawField(StandardTelegramFieldNames.TelegramId); logger.InfoMethod("Processing " + dataIn.TheName + "."); switch (Encoding.GetEncoding(1252).GetString(vi)) { // Tote passed a scanner. PLC is waiting for destination location from MFC. case "01": OnDestinationRequest(dataIn, out theNeutrino); break; // Tote passed a waiting point scanner. PLC is waiting for destination location from MFC // while having the tote stop. case "02": OnWaitingPointRequest(dataIn, out theNeutrino); break; // Tote has passed a message point case "03": OnMessagePointRequest(dataIn); break; case "04": OnRequestAtToteStart(dataIn, out theNeutrino); break; // Tote has been sorted out after a destination request case "11": OnSortationReport(dataIn); break; // Tote has been sorted out after a waiting point request case "12": OnSortationReportWaitingPoint(dataIn); break; case "14": OnSortationReportToteStart(dataIn); break; // MFC State telegram request. MFC is requested to send it's state back to the PLC. case "61": OnMFCState(dataIn, out theNeutrino); break; case "81": OnPLCLoggingInfo(dataIn); break; // PLC reports it's state to the MFC. case "91": OnPLCState(dataIn, out theNeutrino); break; // Server sends back it's watchdog telegram case "98": OnWatchdogReply(dataIn, out theNeutrino); break; // Client should send it's watchdog telegram case "99": OnWatchdogRequest(dataIn, out theNeutrino); break; } if (theNeutrino != null) { dataOut = new List <Neutrino>(); dataOut.Add(theNeutrino); } }
/// <summary> /// Tote has passed a message point /// </summary> /// <param name="dataIn">data to be analysed</param> private void OnMessagePointRequest(Neutrino dataIn) { // Put your code in here. }
/// <summary> /// Incoming watchdog reply from peer detected. /// </summary> /// <param name="dataIn">data to be analysed</param> /// <param name="dataOut">The data to send back. If null then no data will be send back.</param> private void OnWatchdogReply(Neutrino dataIn, out Neutrino dataOut) { dataOut = null; }
/// <summary> /// Client is requested to send it's watchdog /// </summary> /// <param name="dataIn">data to be analysed</param> /// <param name="dataOut">The data to send back. If null then no data will be send back.</param> private void OnWatchdogRequest(Neutrino dataIn, out Neutrino dataOut) { dataOut = null; WriteField(StandardTelegramFieldNames.TelegramId, "99", ref dataOut); }
/// <summary> /// PLC wants to log some data... /// </summary> /// <param name="dataIn">data to be analysed</param> private void OnPLCLoggingInfo(Neutrino dataIn) { string theLogInfo = GetField(dataIn, "LoggingData"); logger.InfoMethod(theLogInfo); }
/// <summary> /// Sortation report after a tote start reply /// </summary> /// <param name="dataIn">data to be analysed</param> private void OnSortationReportToteStart(Neutrino dataIn) { // We just call the standard waiting point method. Feel free // to implement whatever you like... OnSortationReport(dataIn); }
/// <summary> /// PLC State telegram. PLC sends it's state to the MFC. /// </summary> /// <param name="dataIn">data to be analysed</param> /// <param name="dataOut">The data to send back. If null then no data will be send back.</param> private void OnPLCState(Neutrino dataIn, out Neutrino dataOut) { dataOut = null; }
/// <summary> /// Returns the value of the specified field as a string /// </summary> /// <param name="dataIn">data to be analysed</param> /// <param name="field">Key name for which data should be extracted from the neutrino</param> /// <returns>data found for given key</returns> private string GetField(Neutrino dataIn, string field) { return(Encoding.GetEncoding(1252).GetString(dataIn.GetRawField(field))); }