Repair Method for Two-Dimensional Barcode Information of Cigarette Cartons

Abstract

The present invention relates to the field of computer technology, and discloses a method for repairing two-dimensional barcode information of cigarette cartons. Before the 25-flat package of small cartons is formed by the packaging machine, the barcode information of the small cartons has been read and a "carton code queue" has been formed, which may contain unrecognizable small carton information. By reading the two-dimensional barcodes (hereinafter referred to as positioning codes) of two small cartons in the first stack when or after the 25-flat package is established, the small carton barcode information is pulled from the queue, and the two-dimensional barcode information that fails to be read in the carton code queue and is exactly located at the positioning code position is verified and attempted to be repaired.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method for repairing two-dimensional barcode information of cigarette cartons and cartons of strips. Background Art

[0002] The auxiliary machine of the tobacco packaging machine is responsible for processes such as adding small transparent films to small boxes, packing small boxes into cartons of strips, and adding strip transparent films to cartons of strips. The equipment has a high degree of automation and good integration. Currently, the State Tobacco Monopoly Administration is organizing technical forces to track tobacco products by adding two-dimensional codes to tobacco product packaging. Therefore, it is necessary to transform the existing tobacco packaging machines to achieve the reading of two-dimensional codes on the production line. Due to the limitations of the existing equipment and working conditions on the production line, in addition to installing barcode readers, a series of data recovery and verification are also required to improve the data reading rate and ensure accuracy.

[0003] The positioning codes (two codes for two boxes in a stack) returned by the existing box code verification station are only used to pull the box codes of 10 boxes in a carton of strips from the box code queue, and it is required that there are no unrecognized box codes in the box code queue. Otherwise, the carton of strips will be rejected due to the failure of the carton of strips information association. Chinese Patent Document CN2021106475822 discloses a method and device for associating two-dimensional barcode information of cigarette cartons and cartons of strips with a verification function, which is different in the verification position, the data recovery method, and the method of pulling the small box data corresponding to the carton of strips.

[0004] The present invention provides a method for repairing two-dimensional barcode information of cigarette cartons and cartons of strips, which reduces the rejection of cartons of strips caused by the failure of the carton of strips information association due to the existence of unreadable records in the box code queue and the failure of the box code verification station to read, and increases the yield. Summary of the Invention

[0005] The purpose of the present invention is to provide a method for repairing two-dimensional barcode information of cigarette cartons and cartons of strips, which reduces the rejection of cartons of strips caused by the failure of the carton of strips information association due to the existence of unreadable records in the box code queue and the failure of the box code verification station to read, and increases the yield.

[0006] To achieve the above technical purpose and reach the above technical effect, the present invention discloses a method for repairing two-dimensional barcode information of cigarette cartons and cartons of strips. Before the two-five flat packaging of small boxes is formed on the packaging machine, the barcode information of the small boxes has been read and a "box code queue" has been formed, which may contain unrecognizable small box information. By reading the two-dimensional codes (hereinafter referred to as positioning codes) of the first stack of two small boxes when or after the establishment of the two-five flat packaging, the small box two-dimensional barcode information is pulled from the queue, and the two-dimensional barcode information that fails to be read in the box code queue and is just located at the positioning code position is verified and attempted to be repaired. The specific implementation process is as follows:

[0007] S1. Input the box code queue from the outside. Unrecognized barcode elements are allowed to exist in the box code queue, and the format requirements of the algorithm need to be met;

[0008] S2. Obtain the barcodes of the fifth stack (the 9th / 10th pack) of the 25-piece flat pack from the carton code verification station, i.e., the positioning codes. In addition to normally recognizing two barcodes, it is also allowed to recognize one barcode and the situation where no barcode is recognized;

[0009] S3. The algorithm processes the carton code queue through the positioning codes and packs the carton codes of all 10 small cartons in this strip for subsequent operations. When processing the carton code queue, in the case where two barcodes are normally recognized by the positioning codes, the repairable barcode data in the carton code queue is repaired; in the case where one barcode is recognized or no barcode is recognized by the positioning codes, the carton code packing operation is completed as much as possible;

[0010] S4. For the verification status (success, failure, pending) of the completed packing mark, where success means that the barcodes of the 10 small cartons in this pack have passed the verification; failure indicates that the barcode verification of the small cartons in this pack has failed and needs to be excluded in subsequent operations; pending means that the verification status of the small carton barcodes in this strip cannot be determined temporarily, and the algorithm will modify it later;

[0011] In particular, when the positioning code fails to recognize, etc., resulting in the carton code packing can only be inferred in the queue order, its packing status will be set to pending and will be modified after the subsequent verification code is confirmed.

[0012] The present invention has the following beneficial effects: 1. If only one code is read by the positioning code, the function can also be realized; 2. If the positioning code is successfully read and there is one missing barcode at the corresponding position in the carton code queue, it can be repaired; 3. If the positioning code fails to read, it is allowed to infer the information and release it within a certain continuous quantity, and the inferred information is confirmed by the subsequent positioning code. Detailed implementation manners

[0013] In order to make the purpose, technical solution and advantages of the present invention clearer, the following further details the present invention in conjunction with embodiments.

[0014] The present invention discloses a method for repairing two-dimensional barcode information of cigarette cartons and strips. Before the 25-piece flat pack of small cartons is formed by the packing machine, the barcode information of the small cartons has been read and a "carton code queue" has been formed, which may contain unrecognized small carton information. By reading the two-dimensional barcodes (hereinafter referred to as positioning codes) of the first two small cartons when or after the 25-piece flat pack is established, the small carton barcode information is pulled from the queue, and the unread two-dimensional barcode information in the carton code queue just located at the positioning code position is verified and attempted to be repaired. The specific implementation process is as follows:

[0015] S1. Input the carton code queue from the outside. Unrecognized barcode elements are allowed to exist in the carton code queue, and the format requirements of the algorithm need to be met;

[0016] S2. Obtain the barcodes of the fifth stack (the 9th / 10th package) of the 25-piece flat package from the box code verification station, that is, the positioning code. In addition to the normal recognition of two barcodes, it is also allowed to recognize one barcode and the situation where no barcode is recognized;

[0017] S3. The algorithm processes the box code queue through the positioning code and packs the box codes of all 10 small boxes in this strip for subsequent operations. When processing the box code queue, in the case where the positioning code normally recognizes two barcodes, the repairable barcode data in the box code queue is repaired; in the case where the positioning code recognizes one barcode or no barcode is recognized, the box code packing operation is completed as much as possible;

[0018] S4. For the verification status (success, failure, pending) of the completed packing mark, where success means that the barcodes of 10 small boxes in this package have passed the verification; failure indicates that the verification of the small box barcodes in this package has failed and needs to be excluded in subsequent operations; pending means that the verification status of the small box barcodes in this strip cannot be determined temporarily, and the algorithm will modify it later;

[0019] Specifically, when the positioning code fails to recognize, etc., resulting in the box code packing can only be inferred in the queue order, its packing status will be set to pending and will be modified after the subsequent verification code is confirmed.

[0020] During specific operations, the box code queue is allowed to contain: Item elements, where:

[0021] When a single barcode is successfully read: Save it in the Item element;

[0022] When a single barcode reading fails: Save it in the Item element;

[0023] When the double barcodes of the stacked package (two small boxes are read simultaneously, the same below) are successfully read: Save them in two Item elements in the stacked package order (where State.Decoded is set and BarCode saves the recognized barcode);

[0024] For the stacked package, when one barcode is successfully read but the position of the successfully recognized barcode is determined: Save it in two Item elements in the stacked package order. For the successfully read one, State.Decoded is set and BarCode saves the recognized barcode; for the one with failed reading, State.Decoded is not set;

[0025] For the stacked package, when one barcode is successfully read and the position of the successfully recognized barcode is not determined: Save it in an ItemWithMissingPair element (where State.Decoded is set and BarCode saves the recognized barcode);

[0026] Stacked packages with unrecognized barcodes: Saved in an ItemWithMissingPair element (where State.Decoded is not set); or two Item elements (where State.Decoded is not set).

[0027] After the box code verification station reads the barcode information of the fifth stack (the 9th / 10th package) of the two-five flat packages, it calls the Validate method of the CTPackerWithLastTwoPositionsValidation object, passing in the read barcode information to implement verification and packing. This method will save the packed data in the Result property queue.

[0028] The parameters allowed by the Validate method are: 1. When both packages are successfully read: Pass in two BarCodeWithLocation entities, with State.Decoded set, BarCode being the read barcode, and Location set to 9 and 10 respectively; 2. When one package is read: Pass in one BarCodeWithLocation entity, with State.Decoded set, BarCode being the read barcode, and Location not set; 3. When neither is read: Pass in an empty array.

[0029] Enumerations used:

[0030] BarCodeStates: byte

[0031] Constants: Undefined = 0, Requested = 1, ScanningSucceeded = 7, ScanningFailed = 11, EjectRequested = 15

[0032] Bit sequence (from low to high):

[0033] Requested: Scanning has been requested;

[0034] Scanned: Scanning has been triggered;

[0035] Decoded: Decoding has been received;

[0036] ToBeEjected: Rejection due to other reasons;

[0037] 0: Not used in the present invention;

[0038] 0: Not used in the present invention;

[0039] 0: Not used in the present invention;

[0040] 0: Not used in the present invention;

[0041] Note: Only the cartons with the status of ScanningSucceeded (bit sequence 00000100) will not be rejected.

[0042] PackageValidation: byte

[0043] True: Verified successfully

[0044] False: Confirmed as failed

[0045] Pending: To be confirmed; indicating that it cannot be confirmed whether this package is verified successfully or failed at this moment;

[0046] Undefined: Undefined.

[0047] Entities used:

[0048] Entity Class:

[0049] StreamAbstractItem

[0050] int Length

[0051] bool Validated = false

[0052] StatefulItem

[0053] BarCodeStates State

[0054] Item: StatefulItem

[0055] string BarCode

[0056] int Length = 1

[0057] bool Validated = State == ScanningSucceeded

[0058] ItemWithMissingPair: Item means that for two Items in a stacked package, at most one barcode is read, and it cannot be confirmed which one is missing (if the State is abnormal, both are missing);

[0059] int Length = 2

[0060] bool Validated = false

[0061] PlaceHolder: StatefulItem represents a placeholder

[0062] int Length = 1

[0063] BarCodeStates State = 8 (ToBeEjected)

[0064] Package

[0065] PackageValidation Validated

[0066] Nullable <guid>StorageId

[0067] Item[] Items

[0068] BarCodeWithLocation: Item

[0069] int Location

[0070] Abstract classes used:

[0071] PackerBase (abstract)

[0072] Packing abstract class:

[0073] Constructor: Queue <streamabstractitem>source, int length

[0074] Method: void AddPendingPackage(Package package)

[0075] Method: void RemovePendingPackage(Package package)

[0076] Method: void ChangePackagesValidated()

[0077] Method: void ChangePackagesNotValidated()

[0078] Read-only property: Queue <package>Result

[0079] Private-level variable: HashTable <package>Pendings

[0080] Protected variable: int PackageLength

[0081] Constructor: Pass in the child element queue and the packaging length. In the box strip association, the box code queue and 10 are passed in.

[0082] Pendings: For all Packages that have been added to Result and whose Package.Validated is Pending, they are saved separately in a hash table (Pendings).

[0083] PackageLength: Obtained from the length value in the constructor.

[0084] AddPendingPackage(Package package): Add the package to the Pendings hash table.

[0085] RemovePendingPackage(Package package): Remove the package from the Pendings hash table.

[0086] ChangePackagesValidated: Called when the Package is confirmed.

[0087] For each Package in Pendings (if any):

[0088] Set Package.Validated to True for all;

[0089] If Package.StorageId has a value, the storage system needs to be notified to change its status to trusted.

[0090] Empty Pendings.

[0091] ChangePackagesNotValidated: Called when the Package is confirmed with an error;

[0092] For each Package in Pendings (if any):

[0093] Set Package.Validated to True for all;

[0094] If Package.StorageId has a value, the storage system needs to be notified to change its status to untrusted (it needs to be removed from storage).

[0095] Empty Pendings.

[0096] For a Package newly added to Result, check Package.Validated:

[0097] True

[0098] Call ChangePackagesValidated;

[0099] False

[0100] Call ChangePackagesNotValidated;

[0101] Pending

[0102] Call AddPendingPackage, passing in Package;

[0103] PackerWithValidationBase: PackerBase (abstract).

[0104] Packaging class for verification:

[0105] Constructor: Queue <streamabstractitem>source, int length: base(source,length)

[0106] Method: void Validate(BarCodeWithLocation[] barCodes)

[0107] Validate: Pass in one or more location verification barcodes. According to the specific algorithm, take a certain number of elements from source as Items, construct a Package (with StorageId empty), and after setting its Validated value, add it to Result.

[0108] Location code processing method:

[0109] CTPackerWithLastTwoPositionsValidation: PackerWithValidationBase

[0110] A 10-element packing class verified by the 9th and 10th elements. Note: Only applicable to the case of stack package reading;

[0111] Ctor: Queue <streamabstractitem>source: base(source, 10)

[0112] Private Field: int sourceOffset = 0

[0113] source only contains Item, including ItemWithMissingPair.

[0114] Validate: Pass in the bar code information of the 9th and 10th elements.

[0115] If two elements are passed in (when both are read successfully):

[0116] If the two elements passed in are not both Item, or Item.State is not ScanningSucceeded, or Location does not have one element each at 9 and 10, report an error (algorithm error);

[0117] Search for element item1 and its corresponding index1 in source in ascending order. It is required that item1 is of type Item, item1.State.Decoded, and item1.BarCode is the same as the bar code of the element at the 9th position;

[0118] If item1 is found:

[0119] If item1 is ItemWithMissingPair (9 / 10 stack pack, so the missing one must be 10):

[0120] Pack the 8 items before item1 (excluding item1, calculated by summing item.Length, can be less but not more), a newly created item (type Item, BarCode and State the same as item1), and a newly created item (type Item, BarCode the same as the bar code of the element at the 10th position, State is ScanningSucceeded) as Items, construct a Package, and the Validated value is the result of AND calculation of the Validated of all elements in Items (True or False);

[0121] Remove all elements before index1 (including index1) from source.

[0122] Set sourceOffset = 0;

[0123] Add the Package to Result;

[0124] End the method.

[0125] If item1 is the last element of source (item1 is 9 and it ends):

[0126] Package the 9 items before item1 (including item1, calculated by summing item.Length, can be less but not exceed) as Items, construct a Package, and set the Validated value to False.

[0127] Remove all elements from source;

[0128] Set sourceOffset = 0;

[0129] Add the Package to Result;

[0130] End the method.

[0131] Get the element item2 at index1 + 1 in source;

[0132] If the type of item2 is Item and not ItemWithMissingPair (item2 is 10):

[0133] Package the 10 items before item2 (including item2, calculated by summing item.Length, can be less but not exceed) as Items, construct a Package, and set the Validated value to the result of AND calculation of the Validated values of all elements in Items (True or False);

[0134] Remove all elements before index1 + 1 (including) from source.

[0135] Set sourceOffset = 0;

[0136] Add the Package to Result;

[0137] End the method.

[0138] (Elements after item2, and 10 is missing)

[0139] Alarm (queue data loss);

[0140] Package the 9 items before item2 (excluding item2, calculated by summing item.Length, can be less but not exceed) as Items, construct a Package, and set the Validated value to False;

[0141] Remove all elements before index1 (inclusive) from source;

[0142] Set sourceOffset = 0;

[0143] Add Package to Result;

[0144] End the method.

[0145] (item1 not found)

[0146] Search for element item2 and its corresponding index2 in source in ascending order. It is required that the type of item2 is Item, item2.State.Decoded, and the barcode of item2 is the same as the barcode of the element at the 10th position;

[0147] Pack the 8 items before item2 (excluding item2, calculated by summing item.Length, can be less but not exceeding), a newly created item (type Item, barcode the same as the barcode of the element at the 9th position, State is ScanningSucceeded), and a newly created item (type Item, barcode and State the same as item2) as Items, construct a Package, and the Validated value is the result of the AND calculation of the Validated values of all elements in Items (True or False);

[0148] Remove all elements before index2 (inclusive) from source.

[0149] Set sourceOffset = 0;

[0150] Add Package to Result;

[0151] End the method.

[0152] If item2 is the first element of source (data before the 10th package is missing):

[0153] Use item2 as Items, construct a Package, and the Validated value is False;

[0154] Remove all elements from source;

[0155] Set sourceOffset = 0;

[0156] Add Package to Result;

[0157] End the method.

[0158] Fetch the element item1 corresponding to the index 2 - 1 in source;

[0159] If the type of item1 is not Item, or is ItemWithMissingPair (when the 10th package is confirmed, the 9th package cannot be ItemWithMissingPair, so item1 is missing) or item1.Decoded does not exist (the type of item1 is Item and not ItemWithMissingPair, item1 is 9 but not scanned):

[0160] Pack the 8 items before item1 (including item1, calculated by summing item.Length, can be less but not exceed), a newly created item (type is Item, BarCode is the same as the bar code of the element in the 9th position, State is ScanningSucceeded), and item2 as Items, construct a Package, and the value of Validated is the result of AND calculation of all elements' Validated in Items (True or False);

[0161] Remove all elements before index2 (including) from source.

[0162] Set sourceOffset = 0;

[0163] Add the Package to Result;

[0164] End the method.

[0165] (The type of item1 is Item and not ItemWithMissingPair and decoding is successful, it may be that the 9th package code is missing)

[0166] Alarm (queue lost data);

[0167] Pack the 8 items before item1 (including item1, calculated by summing item.Length, can be less but not exceed), a newly created item (type is Item, BarCode is the same as the bar code of the element in the 9th position, State is ScanningSucceeded), and item2 as Items, construct a Package, and the value of Validated is the result of AND calculation of all elements' Validated in Items (True or False);

[0168] Remove all elements before index2 (including) from source;

[0169] Set sourceOffset = 0;

[0170] Add Package to Result;

[0171] End method.

[0172] (Neither item1 nor item2 is found)

[0173] Construct a Package with empty information as Items, and set Validated to False;

[0174] Set sourceOffset = 0;

[0175] Add Package to Result;

[0176] End method.

[0177] If what is passed in is an element and Location is not set (one is successfully read):

[0178] The user sets a constant, depending on the location with a higher success rate of 9 / 10 in the actual reading;

[0179] Set int count = 0, bool validated = true, bool matched = false, int length = 0;

[0180] When the constant is 9:

[0181] Start loop:

[0182] Get the count-th element item from source without removing it;

[0183] Set count++;

[0184] Set length += item.Length;

[0185] Set validated = validate AND item.Validated;

[0186] If item is Item, item.State.Decoded and item.BarCode is the passed-in bar code:

[0187] Set matched = true;

[0188] Exit loop;

[0189] If length >= 9 or the queue ends: Exit the loop;

[0190] If matched == true:

[0191] If the item is ItemWithMissingPair (9 / 10 stack pack):

[0192] Pack the first count elements in source as Items, construct a Package, and the value of Validated is the result of AND calculation of all elements' Validated in Items (Pending or False. The 10th element is not confirmed, so True is changed to Pending);

[0193] Remove the first count elements from source;

[0194] Set sourceOffset = 0;

[0195] Add the Package to Result;

[0196] End the method.

[0197] (The item is not ItemWithMissingPair)

[0198] Set count++;

[0199] Start the loop:

[0200] If the number of elements in the source queue is less than count: Exit the loop;

[0201] Get the count-th element item from source without removing it;

[0202] If item.Length == 0:

[0203] Set count++;

[0204] If item.Length == 1:

[0205] Set count++;

[0206] Exit the loop;

[0207] Pack the first count elements in source as Items, construct a Package, and the value of Validated is Pending (Pending or False; The 10th element is not confirmed, so True is changed to Pending);

[0208] Remove the first `count` elements from `source`;

[0209] Set `sourceOffset` to 0;

[0210] Add `Package` to `Result`;

[0211] End the method.

[0212] Alarm (matching failed: the 9th element of the queue is not the confirmation value, unable to determine the match);

[0213] Construct `Package` with empty information as `Items` and `Validated` as `False`;

[0214] Set `sourceOffset` to 0;

[0215] Add `Package` to `Result`;

[0216] End the method.

[0217] When the constant is 10:

[0218] Start the loop:

[0219] Get the `count`-th element `item` from `source` without removing it;

[0220] Set `count`++;

[0221] Set `length` += `item.Length`;

[0222] Set `validated` = `validate` AND `item.Validated`;

[0223] If `item` is `Item`, `item.State.Decoded` and `item.BarCode` is the passed-in bar code:

[0224] Set `matched` = `true`;

[0225] Exit the loop;

[0226] If `length` >= 10 or the queue ends: Exit the loop; [[ID=5^6]]

[0227] If `matched` == `true`:

[0228] If `item` is `ItemWithMissingPair` (9 / 10 stack package):

[0229] If `length` > 10:

[0230] Alarm (matching failed: the 10th and 11th elements are stacked, which means data loss in the queue and cannot determine the match);

[0231] Construct a Package with empty information as Items, and Validated is False;

[0232] Set sourceOffset = 0;

[0233] Add the Package to Result;

[0234] End the method.

[0235] Package the first count - 1 elements in source, a newly created item (type Item, BarCode is empty, State is ScanningFailed), and a newly created item (type Item, BarCode is the same as the incoming bar code, State is ScanningSucceeded) as Items, construct a Package, and the value of Validated is the result of AND calculation of the Validated of all elements in Items (True or False);

[0236] Remove the first count elements from source.

[0237] Set sourceOffset = 0;

[0238] Add the Package to Result;

[0239] End the method.

[0240] (item is not ItemWithMissingPair)

[0241] Package the first count elements in source as Items, construct a Package, and the value of Validated is the result of AND calculation of the Validated of all elements in Items (True or False);

[0242] Remove the first count elements from source;

[0243] Set sourceOffset = 0;

[0244] Add the Package to Result;

[0245] End the method.

[0246] Alarm (matching failed: the 10th element in the queue is not the confirmation value, cannot determine the match);

[0247] Construct an empty information as Items, form it into a Package, and set Validated to False;

[0248] Set sourceOffset = 0;

[0249] Add the Package to Result;

[0250] End the method.

[0251] (Constants set to others: abandoned)

[0252] (All read unsuccessfully)

[0253] Pack 10 items starting from sourceOffset in source (calculated by summing item.Length, can be less but not exceeding) as Items, form them into a Package, and set the value of Validated to the result of AND calculation of the Validated of all elements in Items (Pending or False; not confirmed at the end, so True is changed to Pending);

[0254] (Do not delete elements from source)

[0255] Set sourceOffset += Package.Items.Length; (number of elements)

[0256] Specifically, in order to prevent the cumulative queue from being too long and affecting the rejection of cigarette packs, a value can be set. When sourceOffset exceeds this value, it is determined that Validated is False and ChangePendingNotValidated is called;

[0257] Add the Package to Result;

[0258] End the method.

[0259] Advantages of the present invention: 1. If only one positioning code is read, the function can also be realized; 2. If the positioning code is read successfully, but there is a missing code at the corresponding position in the cigarette box code queue, it can be repaired; 3. If the positioning code is read failed, the inferred information can be allowed to pass within a certain continuous quantity and be confirmed by subsequent positioning codes.

[0260] The above is only a preferred specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any changes or substitutions that can be easily thought of by those skilled in the art within the technical scope disclosed by the present invention should be covered within the protection scope of the present invention.< / streamabstractitem> < / streamabstractitem> < / package> < / package> < / streamabstractitem> < / guid>

Claims

1. A method for repairing two-dimensional barcode information of cigarette cartons and strips, characterized in that: Before the 25-pack flat package of the carton is formed by the packaging machine, the 2D barcode information of the carton has been read and a "carton code queue" has been formed. The "carton code queue" contains unrecognized carton information. By reading the 2D barcodes of the two cartons in the fifth stack when or after the 25-pack flat package is established, that is, the positioning codes, the 2D barcode information of the cartons is pulled from the carton code queue, and the 2D barcode information that fails to be read in the carton code queue and is just located at the positioning code position is verified and attempted to be repaired. The specific implementation process is as follows: S1. Pass in the carton code queue from the outside. The carton code queue allows the existence of unrecognized 2D barcode elements, which need to meet the format requirements of the algorithm; the carton code queue allows the existence of: Item elements, where: When a single 2D barcode is successfully read: it is saved in the Item element; When a single 2D barcode reading fails: it is saved in the Item element; For the stack package, when two 2D barcodes are successfully read: they are saved in two Item elements in the stack package order, where State.Decoded is set and BarCode saves the recognized 2D barcode; For the stack package, when one 2D barcode is successfully read but the position of the successfully recognized 2D barcode is determined: they are saved in two Item elements in the stack package order, where State.Decoded of the successfully read one is set and BarCode saves the recognized 2D barcode, and State.Decoded of the one with reading failure is not set; For the stack package, when one 2D barcode is successfully read and the position of the successfully recognized 2D barcode is not determined: it is saved in an ItemWithMissingPair element, where State.Decoded is set and BarCode saves the recognized 2D barcode; For the stack package, when 2D barcodes are not recognized: it is saved in an ItemWithMissingPair element, where State.Decoded is not set, or two Item elements, where State.Decoded is not set; S2. Obtain the 2D barcode of the fifth stack of the 25-pack flat package, that is, the positioning code, from the carton code verification station. The fifth stack includes the ninth and tenth cartons. In addition to the normal recognition of two 2D barcodes, the situation of recognizing one 2D barcode and not recognizing 2D barcodes is also allowed; S3. The algorithm processes the carton code queue through the positioning code and packs the carton codes of all 10 cartons in this strip for subsequent operations. When processing the carton code queue, in the case of the positioning code normally recognizing two 2D barcodes, the 2D barcode data that can be repaired in the carton code queue is repaired and the carton code packing operation is completed; in the case of the positioning code recognizing one or not recognizing 2D barcodes, the carton code packing operation is completed as much as possible; S4. For the verification status of the completed packing mark, the verification status includes success, failure, and pending. Among them, success means that the 2D barcodes of the 10 cartons in this strip have passed the verification; failure indicates that the 2D barcodes of the cartons in this strip have failed the verification and need to be excluded in subsequent operations; pending means that the verification status of the 2D barcodes of the cartons in this strip cannot be determined temporarily, and the algorithm will modify it subsequently; When the positioning code fails to recognize the 2D barcode and the box code packing can only be inferred in the order of the box code queue, its packing status will be set to pending and modified after the verification status of the subsequent one is confirmed.