A patching machine picking and positioning path optimization method based on full-dimensional coding genetic algorithm

Abstract

The application relates to a patching machine pickup positioning path optimization method based on full-dimensional coding genetic algorithm, and relates to a patching machine pickup positioning path optimization method.The application aims to solve the problem that the existing commercial software fails to comprehensively provide a full-dimensional chromosome coding method for pickup positioning-path optimization, thereby causing the pickup path to be too long and the patching production work efficiency to be low.The process is as follows: 1, obtaining patching machine parameters, circuit board production data and component distribution results;2, obtaining a full-dimensional coding chromosome population;3, obtaining a pickup positioning path optimization result;4, calculating a pickup path length;5, setting genetic algorithm parameters and loop conditions;6, operating each full-dimensional coding chromosome based on a crossover operator, and updating the pickup positioning path optimization result;7, operating each full-dimensional coding chromosome based on a mutation operator, and updating the pickup positioning path optimization result;8, outputting an optimal pickup positioning path optimization result.The application is used in the fields of electrical technology and electrical engineering.

Description

Technical Field

[0001] This invention relates to a method for optimizing the pick-and-place location path of a chip mounter, belonging to the field of electrical technology and electrical engineering. Background Technology

[0002] With the rapid expansion of the electronics manufacturing industry, the assembly technology of electronic products needs continuous improvement. In circuit board assembly, the current mainstream technology is surface mount technology, primarily implemented by pick-and-place machines. These machines utilize advanced opto-mechatronic systems to quickly pick up electronic components and chips, then rapidly and accurately transport them to various mounting points on the circuit board surface for placement. For simplicity, in the following text, "electronic components and chips" will be collectively referred to as "components," and "pick-up and placement" will be abbreviated as "pick-and-place."

[0003] Currently, all pick-and-place machines on the market are based on... Figure 2 On the gantry-type three-dimensional motion platform shown: several suction rods capable of suction and blowing are equidistantly installed inside the placement carrier. Each suction rod is driven by a motor inside the placement carrier to move up and down in the Z direction. The placement carrier is driven by translational guide rails and fixed guide rails to move in the X and Y directions in the horizontal plane. Using this motion mechanism, the picking, moving, and placement of components can be completed. Before the picking and placing process begins, the circuit board is conveyed by the circuit board conveyor belt to the stop position and is then pressed and fixed. During the picking and placing process, the feeder, fixedly installed on the feeder base, automatically replenishes the components to be supplied. The supplied components will appear at the pick-up point at the front end of the feeder, waiting to be picked up.

[0004] Figure 3 The diagram illustrates the pick-and-place process of a pick-and-place machine. Because the number of pick-and-place levers is limited and significantly less than the number of placement points, the pick-and-place carrier needs to complete the placement of an entire circuit board in multiple pick-and-place cycles (pick-and-place cycles). The pick-and-place process within one pick-and-place cycle can be summarized as follows: The pick-and-place carrier first moves to the feeder base; driven by the pick-and-place carrier, each pick-and-place lever moves sequentially to its corresponding pick-up point to pick up components; after all pick-and-place levers have completed component pickup, the pick-and-place carrier moves to the circuit board; driven by the pick-and-place carrier, each pick-and-place lever moves sequentially to its corresponding placement point to place components. After all pick-and-place levers have completed component placement, the pick-and-place process of the next pick-and-place cycle begins.

[0005] Optimizing the pick-and-place process of a pick-and-place machine can significantly shorten the surface mount time. This optimization problem includes two main sub-problems: "component allocation" and "pick-and-place location path optimization." "Component allocation" requires determining the type of component to be placed by each pick-and-place bar within each pick-and-place cycle. Based on this, "pick-and-place location path optimization" requires determining the movement path of the placement carrier throughout the entire pick-and-place process. Based on the component allocation method given in patent number 201810829630.8, this invention studies a pick-and-place location path optimization method.

[0006] During the pick-and-place process, the movement path of the placement carrier is called the pick-and-place path of the pick-and-place machine. A key objective of pick-and-place optimization is minimizing the pick-and-place path length. Based on the start and end point types of each path segment, the pick-and-place paths within any pick-and-place cycle can be categorized into four types: 1) Pick-up path: the path along which each pick-up bar sequentially picks up components within the current cycle, with both its start and end points being pick-up points; 2) Pick-to-place path: the path along which all pick-up bars move from the feeder base to the circuit board after completing pick-up within the current cycle, with its start point being the last pick-up point and its end point being the first placement point within the current cycle; 3) Placement path: the path along which each pick-up bar sequentially places components within the current cycle, with both its start and end points being placement points; 4) Place-to-pick path: the path along which all pick-up bars move from the circuit board to the feeder base after completing placement within the current cycle, with its start point being the last placement point within the current cycle and its end point being the first pick-up point in the next cycle.

[0007] Traditional pickup and placement path optimization methods require further decomposition of the original problem into a "feeder location problem" and a "placement location path optimization problem." "Feeder location" requires determining the mounting slot number of each feeder on the feeder base; "placement location path optimization" requires determining the placement points of each suction rod within each pickup cycle and the order in which they are placed. For example... Figure 3 As shown, the pick path is entirely determined by "feeder location", the placement path is entirely determined by "placement location path optimization", and the pick-to-place and place-to-pick paths are determined by both "feeder location" and "placement location path optimization".

[0008] The main shortcoming of current research is that existing commercial software fails to provide a comprehensive chromosome-based method for pick-and-place location-path optimization. It cannot coordinate the solution of each optimization sub-problem under the premise of considering coupling relationships, thus failing to enable each part of the path to work together to achieve global optimum, resulting in excessively long pick-and-place paths and low efficiency of mounting production. Summary of the Invention

[0009] The purpose of this invention is to address the problem that existing commercial software fails to provide a comprehensive chromosome-based method for pick-and-place location and path optimization, and cannot coordinate the solution of various optimization sub-problems under the premise of considering coupling relationships. As a result, it cannot achieve global optimization through the collaboration of various paths, leading to excessively long pick-and-place paths and low efficiency in placement production. Therefore, this invention proposes a pick-and-place location optimization method for placement machines based on a comprehensive genetic algorithm.

[0010] The specific process of a pick-and-place machine address selection path optimization method based on full-dimensional encoded genetic algorithm is as follows:

[0011] Step 1: Obtain the pick-and-place machine parameters, circuit board production data, and component allocation results;

[0012] Step 2: Encode the information of each dimension of the pick-and-place location optimization problem to obtain a fully encoded chromosome population;

[0013] Step 3: Decode the input full-dimensional encoded chromosome to obtain and output the corresponding optimized pick-and-place addressing path results;

[0014] Step 4: Calculate and output the corresponding pickup path length based on the input pickup and selection path optimization results;

[0015] Step 5: Set the parameters and loop conditions for the genetic algorithm;

[0016] Step 6: Perform operations on each full-dimensional encoded chromosome based on the crossover operator, and update the optimized picking and pasting addressing path results by comparison and selection;

[0017] Step 7: Perform operations on each full-dimensional encoded chromosome based on the mutation operator, and update the optimized picking and pasting addressing path results by comparison and selection;

[0018] Step 8: Output the optimal pick-and-place location optimization result.

[0019] The beneficial effects of this invention are as follows:

[0020] This invention discloses a method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm. The method provides a way to encode the full-dimensional information in the pick-and-place addressing path optimization problem, thereby obtaining a full-dimensional encoded chromosome population. Then, a method is provided to decode the full-dimensional encoded chromosomes to obtain the optimized pick-and-place addressing path result. Crossover and mutation operations adapted to each dimension of the chromosomes are also provided. Finally, the synchronous and coordinated solution of each optimization subproblem is achieved, enabling the paths to reach a global optimum through collaboration, thereby significantly shortening the pick-and-place path and improving the efficiency of the mounting production process. Experiments show that the method provided by this invention can significantly improve the production efficiency of a chip mounter, with a maximum efficiency improvement of 21.83% compared to commercial software.

[0021] Specifically, this invention has the following two innovative aspects:

[0022] (1) A method for encoding the full-dimensional information in the optimization problem of the pick-and-place location is proposed, which can realize the synchronous and coordinated solution of all optimization sub-problems, so that the paths of each part can work together to achieve the global optimum, and greatly improve the efficiency of the mounting production.

[0023] (2) Genetic operations adapted to fully coded chromosomes are given. With the help of specially designed selection, crossover and mutation operations, a stronger ability to search for optimal solutions is achieved, which can very efficiently approach the global optimal solution. Attached Figure Description

[0024] Figure 1 This is a flowchart of the pick-and-place path optimization method for a chip mounter according to the present invention;

[0025] Figure 2 A schematic diagram of a chip mounter equipped with a beam-type chip mount carrier;

[0026] Figure 3 This is a flowchart of the pick-and-place process for a chip mounter.

[0027] Figure 4 A schematic diagram of the pickup path derived from an example of commercial software;

[0028] Figure 5 This is a schematic diagram of the pickup path derived from an embodiment of the present invention;

[0029] Figure 6 This is a convergence curve of the pickup path length in an embodiment of the present invention. Detailed Implementation

[0030] Specific Implementation Method 1: The specific process of the pick-and-place address selection path optimization method for the patch machine based on a full-dimensional encoded genetic algorithm in this implementation method is as follows:

[0031] Step 1: Obtain the pick-and-place machine parameters, circuit board production data, and component allocation results;

[0032] Step 2: Encode the information of each dimension of the pick-and-place location optimization problem to obtain a fully encoded chromosome population;

[0033] Step 3: Decode the input full-dimensional encoded chromosome to obtain and output the corresponding optimized pick-and-place addressing path results;

[0034] Step 4: Calculate and output the corresponding pickup path length based on the input pickup and selection path optimization results;

[0035] Step 5: Set the parameters and loop conditions for the genetic algorithm;

[0036] Step 6: Perform operations on each full-dimensional encoded chromosome based on the crossover operator, and update the optimized picking and pasting addressing path results by comparison and selection;

[0037] Step 7: Perform operations on each full-dimensional encoded chromosome based on the mutation operator, and update the optimized picking and pasting addressing path results by comparison and selection;

[0038] Step 8: Output the optimal pick-and-place location optimization result.

[0039] Specific Implementation Method Two: This implementation method differs from Specific Implementation Method One in that step one involves acquiring the pick-and-place machine parameters, circuit board production data, and component allocation results; the specific process is as follows:

[0040] Step 11: Obtain the parameters of the pick-and-place machine;

[0041] The pick-and-place machine parameters include the total number of pick-and-place bars H, with each pick-and-place bar indexed in ascending order along the X-axis as h∈[1,…,H], pick-and-place bar spacing DI, slot spacing DM, and the number of slots on both the front and rear feeder bases M; initialized arrays OM0 and OM1, each with 1 row and M columns and all elements set to zero, are used to store whether each slot on the front and rear bases is occupied; the X and Y coordinates of slot 1 on the front feeder base are MX. f1 MY f1 The X and Y coordinates of slot 1 on the rear feeder base are MX respectively. r1 MY r1 ;

[0042] Steps 1 and 2: Obtain circuit board production data;

[0043] The circuit board production data includes: the total number of component types C, the index number of each component is c∈[1,…,C], the number of mounting points of each component is stored in an array n with 1 row and C columns, the X-offset of the feeder used by each component is stored in an array ox with 1 row and C columns, the Y-offset of the feeder used by each component is stored in an array oy with 1 row and C columns, and the number of slots occupied by the feeder used by each component is stored in an array q with 1 row and C columns; the total number of mounting points P, the index number of each mounting point is p∈[1,…,P], and the coordinates of the mounting points are stored in an array xyt with P rows and 2 columns. For example, the X coordinate and Y coordinate of the p-th mounting point are xyt(p,1) and xyt(p,2) respectively.

[0044] Step 13: Obtain component allocation results and feeder grouping information;

[0045] The total number of pickup cycles is K, and the index number of each pickup cycle is k∈[1,…,K]. The component allocation result is stored in a two-dimensional array CG with K rows and H columns, where the element CG(k,h) represents the type of component picked up by the h-th suction rod in the k-th pickup cycle, i.e., CG(k,h)∈[1,…,C]. Corresponding to the component allocation result, the feeders are divided into G feeder groups, and the index number of each feeder group is g∈[1,…,G]. The number of slots occupied by each feeder group is stored in a metaarray FQ with 1 row and G columns, and each feeder group is stored in a metaarray FQ{g} with 1 row and FQ{g} columns. The array fs{g} stores the information of each feeder group occupying the slot into a metaarray fq{g} with 1 row and FQ{g} columns; the feeder group allocation result is stored in a two-dimensional array FG with K rows and H columns, where the element FG(k,h) represents the feeder group number picked up by the h-th suction rod in the k-th picking cycle, i.e., FG(k,h)∈[1,…,G]; the feeder picking offset is stored in a two-dimensional array FR with K rows and H columns, where the element FR(k,h) represents the relative offset when the h-th suction rod picks up from the FG(k,h) feeder group in the k-th picking cycle;

[0046] Note: Due to the complexity of the problem and the high dimensionality of the stored data, it is necessary to have arrays of variable length stored within arrays. In this case, arrays indexed by curly braces {} are used, which are called metaarrays.

[0047] Step 14: Obtain the minimum positive and minimum negative feed offsets for each feeder group;

[0048] Step 141: Initialize array fr0, with 1 row and G columns, where all elements are M, to store the minimum positive pick-up offset of each feeder group; initialize array fr1, with 1 row and G columns, where all elements are -M, to store the maximum negative pick-up offset of each feeder group; initialize the pick-up cycle count variable k = 1.

[0049] Step 142: If k > K, proceed to step 15; otherwise, initialize the suction rod counter variable h = 1 and proceed to step 143.

[0050] Step 143: If h > H, update the counter variable k = k + 1 and return to Step 142; otherwise, execute Step 144.

[0051] Step 144: Obtain the current feeder group number g = FG(k,h); check if g = 0; if yes, update the suction rod count variable h = h + 1 and return to step 143; otherwise, execute step 145.

[0052] Step 145: If fr0(g) > FR(k, h), update fr0(g) = FR(k, h); otherwise, do nothing and proceed to Step 146;

[0053] Step 146: If fr1(g) < FR(k, h), update fr1(g) = FR(k, h); otherwise, do nothing and proceed to Step 147;

[0054] Step 147: Update the suction rod count variable h = h + 1 and return to Step 143;

[0055] Step 15: Initialize the pick-and-place cycle count k = 1; for each type of component c ∈ [1,..., C], initialize an array PL{c} with n(c) rows of all zeros and 2 columns, which is used to store the candidate positions of the placement points for each type of component. PL{c} is called the candidate position array for the c-th type of component; initialize a count array i with 1 row and C columns of all 1s, which is used as the index for the placement points in each type of component; proceed to Step 16;

[0056] Step 16: If k > K, it means that a traversal of all pick-and-place cycles has been completed, proceed to Step 19; otherwise, initialize the suction rod count variable h = 1 and proceed to Step 17;

[0057] Step 17: If h > H, it means that a traversal of all suction rods has been completed, update the loop variable k = k + 1 and return to Step 16; otherwise, proceed to Step 18;

[0058] Step 18: The type of component picked and placed by the h-th suction rod in the k-th pick-and-place cycle is c = CG(k, h). Determine whether c = 0; if so, it means that this suction rod does not perform any placement during this cycle; otherwise, assign PL{c}(i(c), 1) = k, PL{c}(i(c), 2) = h, and update the count variable i(c) = i(c) + 1; update the loop variable h = h + 1 and return to Step 17;

[0059] Note: To illustrate the retrieval of a one-dimensional array using PL as an example, PL{c} stores the candidate positions of the placement points for the c-th type of component. Among them, PL{c}(i(c), 1) is the row-wise candidate position of the i(c)-th placement point in the c-th type of component, and PL{c}(i(c), 2) is the column-wise candidate position of the i(c)-th placement point in the c-th type of component;

[0060] Step 19: Initialize a two-dimensional array PA with K rows and H columns, all elements of which are zero, to store the placement point allocation results. The element PA(k,h) represents the placement point number placed by the h-th picker in the k-th picking cycle, i.e., PA(k,h)∈[1,…,P]; Initialize a two-dimensional array PS with K rows and H columns, all elements of which are zero, to store the placement sorting results. The element PS(k,s) represents the picker number of the s-th picker in the k-th picking cycle. That is, PS(k,s)∈[1,…,H]; initialize a two-dimensional array FA with K rows and H columns, all elements of which are zero, to store the slot allocation results, where the element FA(k,h) represents the slot number picked up by the h-th suction rod in the k-th picking cycle; initialize a two-dimensional array FX with K rows and H columns, all elements of which are zero, where the element FX(k,h) is used to store the X coordinate of the patch carrier when the h-th suction rod picks up the patch in the k-th picking cycle; initialize the element A two-dimensional array FY with K rows and H columns, all elements of which are zero, is initialized. The element FY(k,h) stores the Y-coordinate of the patch carrier when the h-th pick-up rod picks up the patch during the k-th pick-up cycle. A two-dimensional array TX with K rows and H columns, all elements of which are zero, is initialized. The element TX(k,h) stores the X-coordinate of the patch carrier when the h-th pick-up rod places the patch during the k-th pick-up cycle. A two-dimensional array TY with K rows and H columns, all elements of which are zero, is initialized. TY(k,h) is used to store the Y coordinate of the patch carrier when the h-th picker is used for patching in the k-th pick-up cycle; a two-dimensional array FS with K rows and H columns, all elements of which are initialized, is used to store the pick-up sorting results, where the element FS(k,s) represents the number of the s-th picker in the k-th pick-up cycle, i.e., FS(k,s)∈[1,…,H]; an array FM with 1 row and G columns, all elements of which are initialized, is used to store the slot number assigned to each feeder group;

[0061] Note: The slot number assigned to the above feeder group refers to the slot number assigned to the leftmost feeder in the feeder group; for beam-type patch carriers, the pickup coordinates refer to the coordinates of the center point of suction rod No. 1 when picking up, and the mounting coordinates refer to the coordinates of the center point of suction rod No. 1 when mounting.

[0062] The other steps and parameters are the same as in Specific Implementation Method 1.

[0063] Specific Implementation Method Three: This implementation method differs from Specific Implementation Methods One and Two in that: Step Two encodes the multi-dimensional information of the pick-and-place location optimization problem to obtain a fully encoded chromosome population; the specific process is as follows:

[0064] Step 2: 1. Initialize the chromosome population size to W = 40, using w as the chromosome index, initialize the chromosome population U{w}∈[U{1},…,U{W}] as an empty array, initialize an array D with 1 row and W columns containing all zero elements to store the picking path length corresponding to each full-dimensional encoded chromosome; initialize the maximum variable inf = 100000, initialize the optimal picking path length DZb = inf; initialize the number of sub-chromosomes within a full-dimensional encoded chromosome to V = 6, using v as the sub-chromosome index, initialize the sub-chromosome u{v}∈[u{1},…,u{V}] as an empty array; initialize the chromosome population count w = 1.

[0065] Step 22: Obtain the mounting point allocation order sub-chromosome u{1} for each type of component; the specific operation is as follows:

[0066] Step 221: For each type of component c∈[1,…,C], initialize a metaarray pa{c}∈[pa{1},…,pa{C}] with n(c) rows and 1 column, where all elements are zero. This metaarray is used to store the mounting point allocation order of each type of component. pa{c} is called the allocation order chromosome of the c-th type of component. Initialize the component type count c=1.

[0067] Step 222: If c > C, proceed to Step 223; otherwise, proceed to Step 223.

[0068] Step 223: Assign pa{c} = randperm([1,…,n(c)]), where randperm represents a random permutation of the array within the parentheses; assign u{1}{c} = pa{c}; update the counter variable c = c + 1, and return to Step 222;

[0069] Note: u is a two-dimensional array, where u{1} is the first array in u, and u{1}{c} is the c-th array in u{1}, which is the allocation order chromosome of the c-th element;

[0070] Steps two and three: Obtain the mounted sorting sub-chromosome u{2}; the specific operations are as follows:

[0071] Step 231: Initialize an array ps with K rows and H columns, all elements of which are zero, to store the placement order of each pick-up cycle; initialize the pick-up cycle count k = 1;

[0072] Step 232: If k > K, assign u{2} = ps and execute Step 24; otherwise, execute Step 233.

[0073] Step 233: Obtain the mounted and sorted chromosomes ps(k,:) = randperm([1,…,H]); update the count variable k = k+1, and return to step 232;

[0074] Note: ":" represents retrieving all values ​​of this dimension in an auto-incrementing manner; ps(k,:) represents retrieving all elements of the k-th packed sort chromosome; further explanation follows:

[0075] "1:1:H" means that the array will be obtained by incrementing by 1 from the starting value 1 to the ending value H, i.e., [1,...,H]. "H:-1:1" means that the array will be obtained by incrementing by -1 from the starting value H to 1, i.e., [H,H-1,...,1]. Since the auto-increment (increment of 1) retrieval method is frequently used, 1:1:H is abbreviated as ps(k,1:H). When indexing the array, if the starting value is 1 and the ending value is exactly the number of elements in that dimension, it can be further abbreviated. For example, ps(k,1:H) can be abbreviated as ps(k,:).

[0076] Step 24: Obtain the selector chromosomes u{3}=randperm([1,…,2*G]) for the front and rear bases of the feeder;

[0077] The asterisk (*) is a multiplication sign.

[0078] Step 25: Obtain the feeder allocation sequence subchromosome u{4}=randperm([1,…,G]);

[0079] Step 26: Slot Encoding (Binary Bits) Among the symbols This indicates that the value inside is rounded up, and log2 indicates that the logarithm of the value inside the parentheses is calculated with base 2; the initial slot selection subchromosome u{5}=randperm([1,…,2*B]) is obtained; the initial slot selection subchromosome u{6}=randperm([1,…,2*B]) is obtained;

[0080] Step 27: Assign U{w} = u, and use u as input to execute Step 3 and Step 4. The output includes the corresponding pickup and location optimization results and the pickup path length DZ, D(w) = DZ.

[0081] Step 28: Determine if DZb > D(w); if yes, update the optimal picking path length DZb = D(w) and update the optimal solution index wb = w; if no, do not perform any processing.

[0082] Step 29: Update the counter variable w = w + 1. If w > W, proceed to step 5; otherwise, return to step 22.

[0083] Other steps and parameters are the same as in specific implementation method one or two.

[0084] Specific Implementation Method Four: This implementation method differs from Specific Implementation Methods One to Three in that: Step Three decodes the input full-dimensional encoded chromosome to obtain and output the corresponding pick-and-place addressing path optimization result; the specific process is as follows:

[0085] Step 3: Initialize and assign values ​​to PA0 = PA, PS0 = PS, FM0 = FM;

[0086] Step 3.2: Obtain the mounting point allocation result PA0 from u{1}; the specific operation is as follows:

[0087] Step 321: Initialize the component type count c = 1;

[0088] Step 322: If c > C, proceed to step 33; otherwise, assign pa{c} = u{1}{c}, initialize the mounting point count ii = 1 for the c-th type of component, and proceed to step 323.

[0089] Step 323: If ii>n(c), it means that a traversal of all mounting points of the c-th type of component has been completed. Update the counter variable c=c+1 and return to step 322. Otherwise, execute step 324.

[0090] Step 324: Obtain candidate positions k = PL{c}(ii,1) and h = PL{c}(ii,2), update the patch point allocation result PA0(k,h) = pa{c}(ii), update the counter variable ii = ii + 1, and return to step 323;

[0091] Wherein, PL is a one-dimensional array, and PL{c} stores the candidate positions of the mounting points contained in the c-th element, where PL{c}(ii,1) is the row-oriented candidate position of the ii-th mounting point in the c-th element, and PL{c}(ii,2) is the column-oriented candidate position of the ii-th mounting point in the c-th element; the allocation order chromosome pa is a one-dimensional array, and pa{c}(ii) is the number of the ii-th assigned mounting point in the c-th element;

[0092] Step 33: Obtain the mounting sorting result PS0 from u{2}; the specific operation is as follows:

[0093] Step 331: Initialize the pickup cycle count k=1, and assign ps=u{2};

[0094] Step 332: If k > K, proceed to step 34; otherwise, initialize the suction rod count s = 1, initialize the mounting sequence count s1 = 1, and proceed to step 333.

[0095] Step 333: If s > H, it means that one traversal has been completed for all the suction rods. Update the counter variable k = k + 1 and return to step 332. Otherwise, execute step 334.

[0096] Step 334: Obtain the current suction bar number h = ps(k,s), obtain the current placement point number ip = PA0(k,h); check if there is ip = 0; if yes, do not do anything; if no, PS0(k,s1) = h, update the placement order count s1 = s1 + 1; update the suction bar count s = s + 1, and return to step 333.

[0097] Steps 3 and 4: Obtain the selection results and sorting of the front and rear bases of the feeder from u{3} and u{4}; the specific operation is as follows:

[0098] Step 3-4: Initialize an array GE with 1 row and 2*G columns, where all elements are 1, to store the binary encoding library; update GE(1:G) = GE(1:G) - 1.

[0099] Step 342, GE = GE(u{3}); Initialize G0 = [], g0 = 0 to store and count the feeder order placed on the front feeder base, G1 = [], g1 = 0 to store and count the feeder order placed on the rear feeder base; Initialize feeder group count g2 = 1;

[0100] Step 343: If g2 > G, proceed to step 35; otherwise, proceed to step 344.

[0101] Step 344: Obtain the feeder group number g = u{4}(g2); determine if GE(g) = 0; if so, assign the feeder group to the front feeder base, G0 = [G0g], g0 = g0+1; otherwise, assign the feeder group to the rear feeder base, G1 = [G1g], g1 = g1+1; update the feeder group count g2 = g2+1, and return to step 343;

[0102] Note: u{4} is the 4th element in u, which is the feeder allocation order subchromosome, and g = u{4}(g2) is the g2th feeder group number in this subchromosome, indicating that the g2th feeder is assigned to the gth feeder group;

[0103] Step 35: Decode u{5} and u{6} to obtain the first slot assigned to the front and rear bases of the feeder; the specific operation is as follows:

[0104] Step 3.51: Initialize an array BE with 1 row and 2*B columns, where all elements are 1, to store the binary encoding library; update BE(1:B) = BE(1:B) - 1.

[0105] Where BE(1:B) represents the first B elements in the binary encoding library. For example, if there are M = 60 feeders, then... Then BE=[000000111111], BE(1:B)=[000000];

[0106] Step 352: BE0 = BE(u{5}), BE1 = BE(u{6}); initialize m0 = 0 and m1 = 0 to store the first slot assigned to the front and rear bases of the feeder, respectively; initialize the binary code counter variable b = 1;

[0107] Note: BE(u{5}) means retrieving an element from array u{5} using the index u{5}; BE(u{6}) means retrieving an element from array u{6} using the index u{6}. Please refer to the example for details.

[0108] Step 353: If b > B, proceed to step 36; otherwise, proceed to step 354.

[0109] Steps 3-54: m0 = m0 + BE0(b) * (2^(Bb)), m1 = m1 + BE1(b) * (2^(Bb)), where 2^(Bb) represents 2 raised to the power of (Bb); update the counter variable b = b + 1, and return to step 3-53;

[0110] Step 36: Obtain the slot allocation results for each feeder group on the front base; the specific operation is as follows:

[0111] Step 361: Initialize the feeder group counter variable f = 1; Initialize the penalty flag DP = 0;

[0112] Step 362: If f > g0, proceed to step 37; otherwise, proceed to step 363.

[0113] Step 363: Obtain the current feeder group number g = G0(f); initialize the slot count variable m = m0;

[0114] Step 364: If m > M, update the counter variable f = f + 1 and return to step 362; otherwise, execute step 365.

[0115] Step 365: If m+2*(H-1)-fr0(g)>60, it means that the feeder group cannot complete the allocation due to exceeding the limit. Update the penalty flag DP=DP+inf, update the count variable m=M+1, and return to step 364. Otherwise, initialize the slot count variable f0=1 and execute step 366.

[0116] Step 366: If f0 > FQ{g}, update the counter variable m = m + 1 and return to step 364; otherwise, execute step 367.

[0117] Step 367: Determine if fq{g}(f0) = 0; if yes, update the counter variable f0 = f0 + 1 and return to step 366; if no, obtain the current slot number f1 = m + f0 - 1, and then execute step 368.

[0118] Step 368: Determine if OM0(f1) = 1. If yes, it means that the current slot is occupied and the current feeder group cannot be placed. Update the counter variable m = m + 1 and return to step 364. If no, execute step 369.

[0119] Step 369: Determine if f0 = FQ{g}. If yes, it means that all slots required by the current feeder group can be allocated. Record the slot allocation result FM0(g) = m, update the slot occupancy information array OM0(m:f1) = OM0(m:f1)|fq{g}, update the counter variable m = M+1, and return to step 364. If no, update the counter variable f0 = f0+1 and return to step 366.

[0120] Note: The symbol | indicates bitwise OR operation on the preceding and following arrays; OM0(m:f1) represents the information on the occupation of slots from m to f1, and OM0(m:f1) = OM0(m:f1)|fq{g} means that slots from m to f1 will be occupied according to the information on the slots occupied by the g-th feeder group;

[0121] Step 37: Obtain the slot allocation results for each feeder group on the rear base;

[0122] Step 371: Initialize the feeder group counter variable f = g1;

[0123] Step 372: If f < 1, proceed to step 4; otherwise, proceed to step 373.

[0124] Step 373: Obtain the current feeder group number g = G1(f); initialize the slot count variable m = m1;

[0125] Step 374: If m > M, update the counter variable f = f - 1 and return to step 372; otherwise, execute step 375.

[0126] Step 375: Obtain the first element type c = fs{g}(1) in the current feeder group; if m-2*(H-1)+fr1(g)<1 or m+q(c)>60, it means that the feeder group cannot complete the allocation due to exceeding the limit. Update the penalty flag DP = DP+inf, update the count variable m = M+1, and return to step 374. Otherwise, initialize the slot count variable f0 = 1 and execute step 376.

[0127] Where q(c) represents the feeder width of the c-th type of element;

[0128] Step 376: If f0 > FQ{g}, update the counter variable m = m + 1 and return to step 374; otherwise, execute step 377.

[0129] Step 377: Determine if fq{g}(f0) = 0; if yes, update the counter variable f0 = f0 + 1 and return to step 376; if no, obtain the current slot number f1 = m + q(c) - f0 + 1, and then execute step 378.

[0130] Step 378: Determine if OM1(f1) = 1. If yes, it means that the current slot is occupied and the current feeder group cannot be placed. Update the counter variable m = m + 1 and return to step 374. If no, execute step 379.

[0131] Step 379: Determine if f0 = FQ{g}. If yes, it means that all slots required for the current feeder group can be allocated. Record the slot allocation result FM0(g) = m + M, calculate f2 = m + q(c), update the slot occupancy information array OM1(f2:-1:f1) = OM1(f2:-1:f1)|fq{g}, update the counter variable m = M + 1, and return to step 374. If no, update the counter variable f0 = f0 + 1 and return to step 376.

[0132] Note: OM1(f2:-1:f1) represents obtaining the information of the occupied slots from f2 to f1 in reverse order. OM1(f2:-1:f1)=OM1(f2:-1:f1)|fq{g} means that the slots from f2 to f1 will be occupied according to the information of the slot occupied by the g-th feeder group.

[0133] The other steps and parameters are the same as those in one of the specific implementation methods one to three.

[0134] Specific Implementation Method Five: This implementation method differs from Specific Implementation Methods One to Four in that: Step Four corresponds to the input pickup and placement path optimization result, calculating and outputting the corresponding pickup path length; the specific process is as follows:

[0135] Step 41: Based on the slot allocation results of each feeder group, obtain the pickup coordinates in each pickup cycle and determine the pickup order; the specific operation is as follows:

[0136] Step 4.11: Initialize and assign values ​​to FX0 = FX, FY0 = FY, FA0 = FA, FS0 = FS; initialize the pickup cycle count k = 1;

[0137] Step 412: If k > K, execute step 42; otherwise, initialize the suction bar counter variable h = 1, initialize the picking information array PQ with 3 rows and H columns of all zero elements, and execute step 413.

[0138] Step 413: If h > H, it means that one traversal has been completed for all the suction rods, and proceed to step 416; otherwise, proceed to step 414.

[0139] Step 414: Obtain the current feeder number g = FG(k,h); check if g = 0. If yes, update the counter variable h = h + 1 and return to step 413. If no, proceed to step 415.

[0140] Step 415: Obtain the pickup slot allocation result FA0(k,h)=FM0(g)+FR(k,h), obtain the first component type c=fs{g}(1) in the current feeder group; determine if there is g>60, if so, it means it is placed on the rear feeder base, FX0(k,h)=MX r1 -(2*(h-1)+FA0(k,h)-M-1)*DM-ox(c), FY0(k,h)=MY r1 -oy(c), if not, indicates that it is installed on the front feeder base, FX0(k,h)=MX f1 +(2*(h-1)+FA0(k,h)-1)*DM+ox(c),FY0(k,h)=MY f1 +oy(c); PQ(1,h)=FX0(k,h), PQ(2,h)=FY0(k,h), PQ(3,h)=h; Update the counter variable h=h+1, return to step four-one-three;

[0141] ox(c) and oy(c) represent the feeder pick-up offsets of the c-th type of component in the X and Y directions, respectively;

[0142] Step 416: Sort the columns of PQ in ascending order of the elements in PQ(1,:); Sort the columns of PQ in ascending order of the elements in PQ(2,:); Initialize the suction rod count variable s = 1, and the pick-up count variable s1 = 0;

[0143] Note: Since the Y coordinates of the mounting points on the same side of the feeder base are very close, the optimal picking order is to pick them according to the order after sorting by X coordinates. The picking order determined in step 416 will pick from the front feeder base first and then from the rear feeder base, and pick from the mounting point with smaller X first and then from the mounting point with larger X.

[0144] Step 417: If s > H, update the counter variable k = k + 1 and return to step 412; otherwise, obtain the current suction rod number h = PQ(3,s) and execute step 418.

[0145] Step 418: Determine if FX0(k,h) = 0; if yes, do nothing; if no, update the counter variable s1 = s1 + 1 and FS0(k,s1) = h; update the counter variable s = s + 1, and return to step 417.

[0146] Step 42: Calculate the picking path length; the specific steps are as follows:

[0147] Step 421: Initialize the pickup path length DQ = 0; initialize the K-row, 1-column arrays QX0 and QY0 to store the first pickup coordinate in each pickup cycle; initialize the K-row, 1-column arrays QX1 and QY1 to store the last pickup coordinate in each pickup cycle; initialize the pickup cycle count k = 1.

[0148] Step 422: If k>K, proceed to step 43; otherwise, obtain the suction rod number h0=FS0(k,1) for the first pick-up, update QX0(k)=FX0(k,h0) and QY0(k)=FY0(k,h0), initialize the suction rod count variable s=2, and proceed to step 423.

[0149] Step 423: If s > H, update QX1(k) = FX0(k,h0) and QY1(k) = FY0(k,h0), update the counter variable k = k + 1, and return to step 422; otherwise, execute step 424.

[0150] Step 424: Obtain the current suction rod number h1 = FS0(k,s), and determine if h1 = 0. If yes, then s = H + 1, and return to step 423; otherwise, execute step 425.

[0151] Step 425: Calculate the Chebyshev distance between the current pick coordinate and the previous pick coordinate as dq = max(|FX0(k,h0)-FX0(k,h1)|,|FY0(k,h0)-FY0(k,h1)|), where || indicates taking the absolute value of the values ​​within the brackets, and max indicates taking the larger of the values ​​within the brackets; update the pick path length DQ = DQ + dq, update the pick bar number h0 = h1, update the counter variable s = s + 1, and return to Step 423;

[0152] Note: The patch carrier is driven by a motor and moves simultaneously along the X and Y directions. Therefore, Chebyshev distance should be used, that is, the larger of the X movement path length and the Y movement path length should be taken as the equivalent movement path length.

[0153] Step 43: Obtain the placement coordinates in each pick-up cycle and calculate the placement path length; the specific operation is as follows:

[0154] Step 431: Initialize the placement path length DT=0; initialize and assign values ​​to TX0=TX, TY0=TY; initialize the K-row, 1-column arrays PX0 and PY0 to store the first placement coordinate in each pick-up cycle; initialize the K-row, 1-column arrays PX1 and PY1 to store the last placement coordinate in each pick-up cycle; initialize the pick-up cycle count k=1.

[0155] Step 432: If k > K, proceed to step 44; otherwise, initialize the suction rod counter variable h = 1 and proceed to step 433.

[0156] Step 433: If h > H, it means that one traversal has been completed for all the suction rods, and proceed to step 436; otherwise, proceed to step 434.

[0157] Step 434: Obtain the current component number p = PA0(k,h); check if there is p = 0. If so, update the counter variable h = h + 1 and return to step 433. If not, execute step 435.

[0158] Step 435: Update TX0(k,h) = xyt(p,1) - (h-1) * DI and TY0(k,h) = xyt(p,2); update the counter variable h = h + 1, and return to step 433;

[0159] Step 436: Obtain the suction bar number h0 = PS0(k,1) for the first placement, the corresponding placement point number p0 = PA0(k,h0), and the corresponding placement coordinates PX0(k) = xyt(p0,1) - (h0-1) * DI, PY0(k) = xyt(p0,2), initialize the suction bar count variable s = 2, and execute step 437;

[0160] Step 437: If s > H, update PX1(k) = xyt(p0,1) - (h0-1) * DI and PY1(k) = xyt(p0,2), update the counter variable k = k + 1, and return to step 432; otherwise, execute step 438.

[0161] Step 438: Obtain the current suction rod number h1 = PS0(k,s), and determine if h1 = 0. If yes, then s = H + 1 and return to step 437; otherwise, execute step 439.

[0162] Step 439: Obtain the current mounting point number p1 = PA0(k,h1), calculate the Chebyshev distance between the current mounting coordinate and the previous mounting coordinate as dt = max(|TX0(k,h0)-TX0(k,h1)|,|TY0(k,h0)-TY0(k,h1)|); update the mounting path length DT = DT + dt, update h0 = h1 and p0 = p1, update the counter variable s = s + 1, and return to step 437;

[0163] Step 4: Calculate the pickup path length; the specific steps are as follows:

[0164] Step 441: Pick-to-paste path length DU = 0, paste-to-pick path length DV = 0; initialize pick-to-paste cycle count k = 1;

[0165] Step 442: If k>K, calculate the picking path length DZ=DP+DQ+DT+DU+DV, and output DZ, PA0, PS0, FM0, FA0, FS0 to the original steps that call Step 3 and Step 4; otherwise, execute Step 443.

[0166] Step 443: Calculate the Chebyshev distance between the first placement coordinate and the last pickup coordinate in the current cycle as du=max(|PX0(k)-QX1(k)|,|PY0(k)-QY1(k)|); Determine if there is k+1>K. If yes, then dv=0. If not, calculate the Chebyshev distance between the last placement coordinate in the current cycle and the first pickup coordinate in the next cycle as dv=max(|PX1(k)-QX0(k+1)|,|PY1(k)-QY0(k+1)|).

[0167] Step 444: Update DU = DU + du and DV = DV + dv; update the counter variable k = k + 1, and return to step 442.

[0168] The other steps and parameters are the same as those in one of the specific implementation methods one to four.

[0169] Specific Implementation Method Six: This implementation method differs from Specific Implementation Methods One through Five in that step five sets the parameters and loop conditions of the genetic algorithm; the specific process is as follows:

[0170] Step 51: Calculate the number of genes in the chromosome NG = P + K * H + G + 2 * G + 2 * B + 2 * B; initialize the crossover probability RC = 0.6 and mutation probability RM = 0.02 for the genetic algorithm; calculate the upper limit of the number of crossover operations IC = RC * W, the upper limit of the number of mutation operations IM = RM * W * NG, and the upper limit of the number of searches without improvement. Initialize the no-improvement search counter variable it = 0;

[0171] Step 52: If it > IT, it means the maximum number of no-improvement searches has been reached. Proceed to Step 8. Otherwise, initialize the crossover operation count ic = 1 and proceed to Step 53.

[0172] Step 53: If ic > IC, it means that the number of crossover operations has reached the upper limit. Initialize the mutation operation count im = 1 and execute Step 54. Otherwise, execute Step 6.

[0173] Step 54: If im > IM, it means that the number of mutation operations has reached the limit, so proceed to step 55; otherwise, proceed to step 7.

[0174] Step 55: Obtain [db,wo] = min(D), where min represents the minimum value of the array within the parentheses. Therefore, db is the shortest picking path length found so far, and wo is the chromosome index that achieves the optimal picking path. Determine if DZb > db. If yes, update the optimal picking path length DZb = db, update the optimal solution index wb = wo, and update the counter variable it = 0. If no, update the counter variable it = it + 1. Return to Step 52.

[0175] The other steps and parameters are the same as those in one of the specific implementation methods one to five.

[0176] Specific Implementation Method Seven: This implementation method differs from Specific Implementation Methods One through Six in that: Step Six is ​​based on crossover operator operations on each full-dimensional encoded chromosome, and the optimal pick-and-place address path optimization result is updated through comparison and selection; the specific process is as follows:

[0177] Step 61: Select the two chromosomes to be crossed using the roulette wheel method; the specific steps are as follows:

[0178] Step 611: Initialize arrays E and SR with 1 row and W columns, where all elements are zero; iterate through each w∈[1,…,W}, assigning E(w)=1 / D(w) and assigning the selection probability of each chromosome SR(w)=E(w) / sum(E), where sum represents summing the array within the parentheses; initialize the two selected chromosomes with numbers w0=0 and w1=0.

[0179] Step 612: Determine if w0 = w1; if yes, proceed to step 613; otherwise, initialize a temporary chromosome population U1{w3}∈[U1{1},…,U1{4}], U1{1} = U{w0}, U1{2} = U{w1}, U1{3} = U{w0}, U1{4} = U{w1}; initialize a 1-row, 4-column array D1 and assign it the value D1 = [D(w0)D(w1)D(w0)D(w1)], then proceed to step 62.

[0180] Step 613: Generate selection probabilities sr0 = rand(1) and sr1 = rand(1), where rand(1) represents generating a random number between 0 and 1; initialize chromosome counting variable w2 = 1 and initialize probability accumulation variable sr = 0;

[0181] Step 614: If w2 > W, reset the chromosome count variable w2 = 1, clear the probability accumulation variable sr = 0, and proceed to step 616; otherwise, proceed to step 615.

[0182] Step 615: Update sr = sr + SR(w2); determine if sr < sr0. If so, update w2 = w2 + 1. If not, store w0 = w2, assign w2 = W + 1; return to Step 614;

[0183] Step 616: If w2 > W, return to Step 612. Otherwise, execute Step 617;

[0184] Step 617: Update sr = sr + SR(w2); determine if sr < sr1. If so, update w2 = w2 + 1. If not, store w1 = w2, assign w2 = W + 1; return to Step 616;

[0185] Step 62: In the selected two two - dimensional encoded chromosomes, perform crossover operations on the sub - chromosomes of the placement point allocation order for each type of component; the specific operations are as follows:

[0186] Step 621: Initialize the component type count c = 1;

[0187] Step 622: If c > C, execute Step 63. Otherwise, execute Step 623;

[0188] Step 623: Obtain two chromosome segments to be operated on, pu0 = U1{3}{1}{c}, pu1 = U1{4}{1}{c}, and the length of the chromosome segment is npu = n(c);

[0189] Note: U1 is a three - dimensional element array, where U1{3} represents the third chromosome in the temporary chromosome population, U1{3}{1} represents obtaining the first sub - chromosome in U1{3}, that is, the sub - chromosome of the placement point allocation order, and U1{3}{1}{c} represents obtaining the placement point allocation order of the c - type component in the U1{3}{1} sub - chromosome; U1{4} represents the fourth chromosome in the temporary chromosome population, U1{4}{1} represents obtaining the first sub - chromosome in U1{4}, that is, the sub - chromosome of the placement point allocation order, and U1{4}{1}{c} represents obtaining the placement point allocation order of the c - type component in the U1{4}{1} sub - chromosome;

[0190] Step 624: Use pu0, pu1, and npu as inputs to execute Step 65, and obtain pu2 and pu3 after crossover operations from the output. Assign U1{3}{1}{c} = pu2, U1{4}{1}{c} = pu3; update c = c + 1, and return to Step 622;

[0191] Step 63: In the selected two two - dimensional encoded chromosomes, perform crossover operations on the placement sorting sub - chromosomes; the specific operations are as follows:

[0192] Step 631: Randomly select the row number in the packed sorted sub-chromosome array that needs to be operated on.

[0193]

[0194] Step 632: Obtain the two chromosome segments to be operated on, pu0 = U1{3}{2}(k1,:) and pu1 = U1{4}{2}(k2,:), with a chromosome segment length of npu = H;

[0195] U1 is a two-dimensional array, U1{3} represents the fourth chromosome in the temporary chromosome population, U1{3}{2} represents the second sub-chromosome obtained from U1{3}, namely the mounting sorting sub-chromosome, and U1{3}{2}(k1,:) represents the suction rod mounting order in the k1th picking cycle of the sub-chromosome obtained from U1{3}{2);

[0196] U1{4} represents the fourth chromosome in the temporary chromosome population, U1{4}{2} represents the fourth sub-chromosome obtained from U1{4}, namely the mounting sorting sub-chromosome, and U1{4}{2}(k2,:) represents the suction rod mounting order in the k2th picking cycle of the sub-chromosome obtained from U1{4}{2.

[0197] Step 633: Using pu0, pu1, and npu as input, execute step 65. Obtain pu2 and pu3 after crossover from the output, and assign the values ​​U1{3}{2}(k1,:)=pu2 and U1{4}{2}(k2,:)=pu3.

[0198] Step 64: Perform a crossover operation on the other sub-chromosomes in the two selected full-dimensional coding chromosomes; the specific operation is as follows:

[0199] Step 641: Obtain the two chromosome segments to be operated on, pu0 = U1{3}{3} and pu1 = U1{4}{3}, with a chromosome segment length of npu = 2*G; Execute Step 65 with pu0, pu1, and npu as input, and obtain pu2 and pu3 after crossover operation from the output, and assign them to U1{3}{3} = pu2 and U1{4}{3} = pu3;

[0200] Step 642: Obtain the two chromosome segments to be operated on, pu0 = U1{3}{4} and pu1 = U1{4}{4}, with a chromosome segment length of npu = G; Execute Step 65 with pu0, pu1, and npu as input, and obtain pu2 and pu3 after crossover operation from the output, and assign them to U1{3}{4} = pu2 and U1{4}{4} = pu3;

[0201] Step 643: Obtain the two chromosome segments to be operated on, pu0 = U1{3}{5} and pu1 = U1{4}{5}, with a chromosome segment length of npu = 2*B; Execute step 65 with pu0, pu1, and npu as input, and obtain pu2 and pu3 after crossover operation from the output, and assign the values ​​U1{3}{5} = pu2 and U1{4}{5} = pu3;

[0202] Step 644: Obtain the two chromosome segments to be operated on, pu0 = U1{3}{6} and pu1 = U1{4}{6}, with a chromosome segment length of npu = 2*B; Execute Step 65 with pu0, pu1, and npu as input, and obtain pu2 and pu3 after crossover operation from the output, and assign them to U1{3}{6} = pu2 and U1{4}{6} = pu3;

[0203] Step 645, proceed to step 66;

[0204] Step 65: Perform a crossover operation on the two input chromosome segments; the specific operation is as follows:

[0205] Step 651: The number of elements to be crossed is nc0 = 3; the starting element number to be crossed is... Determine if nc0-1+nc1>npu. If yes, the termination element number for the crossover is nc2=nc1-nc0+1, and the array of elements to be operated on is NC0=nc2:nc1. If no, nc2=nc1+nc0-1, NC0=nc1:nc2; NC1=NC0, NC2=NC0, pu2=pu0, pu3=pu1; initialize the element count variable cc0=1 in the operation area, and the number of elements in the operation area is CC=nc0.

[0206] Step 652: If cc0 > CC, proceed to step 654; otherwise, proceed to step 653.

[0207] Step 653: Check if there is an element in array pu3(NC1) that is equal to pu2(NC0(cc0)). If so, store the index of the element in cc1, and update NC0(cc0) = [], NC1(cc1) = [], and CC = CC-1. If not, update cc0 = cc0+1; return to step 652.

[0208] Step 654: CC = numel(NC1), where numel represents the number of elements in the array within the parentheses; check if CC = 0. If yes, proceed to step 657; otherwise, initialize the counter variable cc0 = 1 and proceed to step 655.

[0209] Step 655: If cc0 > CC, proceed to step 657; otherwise, proceed to step 656.

[0210] Step 656: Denote the index of the element in array pu0 that is equal to pu3(NC1(cc0)) as cc1, and update pu2(cc1) = pu0(NC0(cc0)); denote the index of the element in array pu1 that is equal to pu2(NC0(cc0)) as cc1, and update pu3(cc1) = pu1(NC1(cc0)); update cc0 = cc0 + 1; return to step 655;

[0211] Step 657: pu2(NC2) = pu1(NC2), pu3(NC2) = pu0(NC2); Output pu2 and pu3 to the original step that called step 65;

[0212] Step 66: Decode the two chromosomes obtained after the crossover operation, calculate their corresponding pick-and-place path lengths, and if the lengths are better than the results before the crossover operation, replace them with the chromosome population; the specific operations are as follows:

[0213] Step 661: Using u=U1{3} as input, execute steps 3 and 4. The output obtained contains the corresponding pick-and-place addressing path optimization result and the pick-and-place path length DZ. Assign the value D1(3)=DZ.

[0214] Step 62: Using u = U1{4} as input, execute steps 3 and 4. The output obtained contains the corresponding pick-and-place addressing path optimization result and the pick-and-place path length DZ. Assign D1(4) = DZ.

[0215] Step 663: Sort array D1, where the indices of the two smallest elements are w4 and w5 respectively;

[0216] Step 664: Update chromosome population U{w0}=U1{w4}、U{w1}=U1{w5}, update D(w0)=D1(w4)、D(w1)=D1(w5); update ic=ic+1, return to step 53.

[0217] The other steps and parameters are the same as those in Specific Implementation Method 1 or 6.

[0218] Specific Implementation Method Eight: This implementation method differs from Specific Implementation Methods One through Seven in that: Step Seven is based on the mutation operator operation on each full-dimensional encoded chromosome, and the optimal pick-and-place address path optimization result is updated by comparison and selection; the specific process is as follows:

[0219] Step 71: Select chromosomes for mutation based on the roulette wheel method; the specific steps are as follows:

[0220] Step Seven One: Traverse each \(w\in[1,\ldots,W]\), assign \(E(w) = 1 / D(w)\), and assign the selection probability \(SR(w)\) of each chromosome as \(E(w) / \text{sum}(E)\); initialize the selected chromosome number as \(w_0 = 0\).

[0221] Step Seven Two: Generate a selection probability \(sr_0=\text{rand}(1)\); initialize the chromosome count variable \(w_2 = 1\) and the probability accumulation variable \(sr = 0\).

[0222] Step Seven Three: If \(w_2>W\), execute Step Seven Five; otherwise, execute Step Seven Four.

[0223] Step Seven Four: Update \(sr = sr + SR(w_2)\); determine if \(sr<sr_0\). If so, update \(w_2 = w_2 + 1\); if not, store \(w_0 = w_2\), assign \(w_2 = W + 1\); return to Step Seven Three.

[0224] Step Seven Five: Initialize the temporary chromosome \(u_0 = U\{w_0\}\); initialize and assign \(D_2 = D(w_0)\), and execute Step Seven Two.

[0225] Step Seven Two: Among the selected full - dimensional encoded chromosomes, perform mutation operations on the sub - chromosomes of the placement point assignment order for each type of component. The specific operations are as follows:

[0226] Step Seven Two One: Initialize the component type count \(c = 1\).

[0227] Step Seven Two Two: If \(c>C\), execute Step Seven Three; otherwise, execute Step Seven Two Three.

[0228] Step Seven Two Three: Obtain the chromosome segment \(p_{u_0}=u_0\{1\}\{c\}\) that needs to be operated on, and the length of the chromosome segment is \(n_{p_{u_0}}=n(c)\).

[0229] Step Seven Two Four: Use \(p_{u_0}\) and \(n_{p_{u_0}}\) as inputs to execute Step Seven Five, and obtain \(p_{u_1}\) after mutation operation from the output, and assign \(u_0\{1\}\{c\}=p_{u_1}\).

[0230] Step Seven Three: Among the selected full - dimensional encoded chromosomes, perform mutation operations on the placement sorting sub - chromosomes. The specific operations are as follows:

[0231] Step Seven Three One: Randomly select the row number \(k_1\) in the placement sorting sub - chromosome array that needs to be operated on.

[0232]

[0233] Step Seven Three Two: Obtain the chromosome segment \(p_{u_0}=u_0\{2\}(k_1,:)\) that needs to be operated on, and the length of the chromosome segment is \(n_{p_{u_0}}=H\).

[0234] Step 733: Execute step 75 with pu0 and npu as inputs, and obtain pu1 after the crossover operation from the output. Assign the value u0{2}(k1,:)=pu1;

[0235] Step 74: Perform a crossover operation on the other sub-chromosomes in the selected full-dimensional coding chromosome; the specific operation is as follows:

[0236] Step 741: Obtain the chromosome segment to be operated on, pu0 = u0{3}, with a length of npu = 2*G; Execute step 75 with pu0 and npu as input, and obtain pu1 after crossover operation from the output, and assign u0{3} = pu1;

[0237] Step 742: Obtain the chromosome segment pu0 = u0{4} to be operated on, with a chromosome segment length of npu = G; Execute step 75 with pu0 and npu as input, and obtain pu1 after crossover operation from the output, and assign u0{4} = pu1;

[0238] Step 743: Obtain the chromosome segment pu0 = u0{5} to be operated on, and the length of the chromosome segment is npu = 2*B; Execute step 75 with pu0 and npu as input, and obtain pu1 after crossover operation from the output, and assign u0{5} = pu1;

[0239] Step 744: Obtain the chromosome segment pu0 = u0{6} to be operated on, with a chromosome segment length of npu = 2*B; Execute step 75 with pu0 and npu as input, and obtain pu1 after crossover operation from the output, and assign u0{6} = pu1;

[0240] Step 745, proceed to step 76;

[0241] Step 75: Perform mutation operations on the input chromosome fragments; the specific operations are as follows:

[0242] Step 751: Assign pu1 = pu0, the number of elements to be mutated is... Initialize the mutated element count variable cc0 = 1;

[0243] Step 752: If cc0 > CC, return to the original step that called step 75; otherwise, execute step 753.

[0244] Step 753: The first element that needs to be mutated is The second element is nc1 = nc0;

[0245] Step 754: Determine if nc1 = nc0. If yes, proceed to step 755; otherwise, proceed to step 756.

[0246] Step Seven Five Five Return to Step Seven Five Four;

[0247] Step Seven Five Six: Update pu1(nc1)=pu0(nc0), pu1(nc0)=pu0(nc1); Update cc0 = cc0 + 1; Return to Step Seven Five Two;

[0248] Step Seven Six: Decode the chromosome obtained after the mutation operation, calculate the corresponding pick-and-place path length. If it is better than the result before the mutation operation, replace it into the chromosome population; the specific operations are as follows:

[0249] Step Seven Six One: Execute Step Three and Step Four with u = u0 as the input. The output contains the corresponding pick-and-place site selection path optimization result and the pick-and-place path length DZ. Assign D2 = DZ;

[0250] Step Seven Six Two: Judge whether there is D2 < D(w0). If so, update the chromosome population U{w0} = u0, update D(w0) = D2. If not, do nothing; Update im = im + 1, and return to Step Five Four.

[0251] Other steps and parameters are the same as those in the First Embodiment or the Seventh Embodiment.

[0252] Ninth Embodiment: The difference between this embodiment and the First to Eighth Embodiments is that: the Step Eight outputs the optimal pick-and-place site selection path optimization result; the specific process is as follows:

[0253] Step Eight One: Take out the optimal full-dimensional encoded chromosome u = U{wb} according to the optimal solution index wb (the optimal solution index wb in Step Eight is obtained in Step Five Five);

[0254] Step Eight Two: Execute Step Three and Step Four with u as the input. The output contains the optimal pick-and-place site selection path optimization result: the optimal placement point allocation result PA = PA0, the optimal placement sorting result PS = PS0, the slot numbers FM allocated to each feeder group, the optimal pick-up slot allocation result FA = FA0, and the optimal pick-up sorting result FS = FS0;

[0255] Step Eight Three: The mounter carries out placement production according to the optimal pick-and-place site selection path optimization result;

[0256] Other steps and parameters are the same as those in the First Embodiment or the Eighth Embodiment.

[0257] The beneficial effects of the present invention are verified by the following embodiments:

[0258] Embodiment One:

[0259] This embodiment of the method for optimizing the pick-and-place addressing path of a patching machine based on a full-dimensional encoded genetic algorithm is prepared according to the following steps:

[0260] Consider the following examples: Figure 1 The image shows the optimized pick-and-place process of a six-suction beam-type chip carrier chip mounter.

[0261] The circuit board production data that needs to be imported is listed in Table 1, which includes 31 types of components and a total of 54 mounting points.

[0262] Table 1 Circuit Board Production Data

[0263]

[0264]

[0265] Prior to implementing this invention, based on the component allocation method given in patent number 201810829630.8, the component allocation result CG, the feeder grouping result fs, the feeder group allocation result FG, and the feeder pick-up offset result FR have been obtained. Among them, the component allocation result is:

[0266]

[0267] There are a total of G = 16 feeder groups, namely: fs{1} =

[123] , fs{2} =

[14512] , fs{3} =

[629] , fs{4} =

[789] , fs{5} =

[146] , fs{6} = 30, fs{7} =

[10111] , fs{8} =

[1513] , fs{9} = 31, fs{10} =

[1816] , fs{11} = [101121], fs{12} =

[1917] , fs{13} = [232425], fs{14} = 20, fs{15} = [262728], fs{16} = 22.

[0268] The feeder group allocation results are as follows:

[0269]

[0270] The feeder pickup offset result is:

[0271]

[0272] Based on the above, this invention is implemented, and the optimal full-dimensional encoded chromosome obtained is u. Wherein, u{1}{1}=[62387145], u{1}{2}=

[3124] , u{1}{3}=

[4123] , u{1}{4}=

[312] , u{1}{5}=

[123] , u{1}{6}=

[21] , u{1}{7}=

[21] , u{1}{8}=

[21] , u{1}{9}=

[12] , u{1}{10}=

[21] , u{1}{11}=

[21] . Decoding u{1} yields the following patch point allocation result:

[0273]

[0274] u{2}=[123456;213456;345621;213645;543126;123456;543621;321546;412653;532164;312456;512436;412356], after decoding u{2}, the mounting sorting result is:

[0275]

[0276] u{3}=[1096114127321915731214131630202242982326222817521183125], combined with the binary encoding library GE=[000000000000000011111111111111111], we can get GE(u{3})=[0000001110000000], from which we can conclude that feeder groups fs{7}, fs{8}, and fs{9} will be placed on the rear base, and other feeder groups will be placed on the front base.

[0277] u{5}=[439712521186101]、u{6}=[251091114876312]、Combined with the binary encoding library BE=[000000111111]、we can get BE(u{5})=[001110011010]、BE(u{6})=[001110011001]、Converting the binary to decimal, we can get that the first slot assigned to the front base and the rear base of the feeder is 14. Combining the order of slot allocation of the feeder group given by u{4}=[11121551667413891014123]、we can get the slot allocation result of each feeder group as: FM=[49505737283485797443141938472332]. The corresponding pick slot allocation result FA and pick sorting result FS are:

[0278]

[0279]

[0280] The existing commercial software calculates the pickup path length as DZ0 = 8338.819 mm. This pickup path can be found in [link to relevant documentation]. Figure 4 The pickup path derived from the embodiments of the present invention is as follows: Figure 5 As shown, the pickup path length is DZb = 6518.74 mm, and the convergence process of the pickup path length is as follows. Figure 6 As shown. In the above embodiments, the present invention can improve the pickup path to 100%*(DZb-DZ0) / DZ0=21.83%.

[0281] This invention may have other embodiments. Without departing from the spirit and essence of this invention, those skilled in the art can make various corresponding changes and modifications according to this invention, but these corresponding changes and modifications should all fall within the protection scope of the appended claims.

Claims

1. A method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm, characterized in that: The specific process of the method is as follows: Step 1: Obtain the pick-and-place machine parameters, circuit board production data, and component allocation results; Step 2: Encode the information of each dimension of the pick-and-place location optimization problem to obtain a fully encoded chromosome population; Step 3: Decode the input full-dimensional encoded chromosome to obtain and output the corresponding optimized pick-and-place addressing path results; Step 4: Calculate and output the corresponding pickup path length based on the input pickup and selection path optimization results; Step 5: Set the parameters and loop conditions for the genetic algorithm; Step 6: Perform operations on each full-dimensional encoded chromosome based on the crossover operator, and update the optimized picking and pasting addressing path results by comparison and selection; Step 7: Perform operations on each full-dimensional encoded chromosome based on the mutation operator, and update the optimized picking and pasting addressing path results by comparison and selection; Step 8: Output the optimal pickup and placement path optimization results; Step two encodes the multi-dimensional information of the pick-and-place location optimization problem to obtain a fully encoded chromosome population; the specific process is as follows: Step 2: Initialize the chromosome population to W=40, using w as the chromosome index. U {w}∈[ U {1},…, U [{W}] is an empty array initialized with all elements equal to zero, containing 1 row and W columns. D This is used to store the picking path length corresponding to each fully coded chromosome; the maximum value variable inf is initialized to 100000, and the optimal picking path length is initialized. DZb =inf; initializes the number of sub-chromosomes within a fully coded chromosome to V=6, using v as the sub-chromosome index, and initializes the sub-chromosomes. u {v}∈[ u {1},…, u [{V}] is an empty array; initialize the chromosome population count w=1; Step 22: Obtain the mounting point allocation order of each type of component (sub-chromosome). u {1}; The specific operation is as follows: Step 221: For each type of element c∈[1,…,C], initialize the number of rows where all elements are zero. n (c) A tuple with 1 column pa {c}∈[ pa {1},…, pa {C}] is used to store the placement order of various components. pa {c} is called the allocation order chromosome of the c-th element; initialize the element type count c=1; Step 222: If c > C, proceed to Step 223; otherwise, proceed to Step 223. Steps 2 and 3: Assignment pa {c}=randperm([1,…, n (c)]), where randperm represents a random permutation of the array within the parentheses that follows; assignment u {1}{c}= pa {c}; Update the counter variable c = c + 1, and return to step two. Where: u is a two-dimensional element array, u{1} is the first element array in u, and u{1}{c} is the c-th element array in u{1}, which is the allocation order chromosome of the c-th element; Steps two and three: Obtaining the mounted sorting chromosomes u {2}; The specific operation is as follows: Step 231: Initialize an array with K rows and H columns, where all elements are zero. ps Used to store the placement order of each pickup cycle; initialize the pickup cycle count k=1; Step 232: If k > K, assign a value. u {2}= ps If the first step is to proceed to step two or four, proceed to step two or three. Steps 2-3: Obtaining the mounted and sorted chromosomes ps (k,:)=randperm([1,…,H]); Update the counter variable k=k+1, and return to step two three two; The colon ":" indicates that all values ​​for this dimension are retrieved in an auto-incrementing manner. ps (k,:) represents retrieving all elements in the kth packed sorted chromosome; Step 24: Obtain the selector chromosomes from the front and rear bases of the feeder. u {3}=randperm([1,…,2*G]); The asterisk (*) is a multiplication sign. Step 25: Obtain the feeder-assigned sequence chromosomes u {4}=randperm([1,…,G]); Step 26: The number of binary bits for slot encoding is B = ⌈log2(M)⌉, where ⌈⌉ indicates rounding up the value and log2 indicates taking the logarithm of the value in parentheses with base 2; this yields the initial slot selection subchromosome of the feeder front base. u {5}=randperm([1,…,2*B]); This obtains the initial slot selection subchromosomes for the base after the feeder is installed. u {6}=randperm([1,…,2*B]); Step 27: Assignment U {w}= u ,by u Steps three and four are executed as input, and the output includes the corresponding pickup and location optimization results and pickup path length. DZ , D (w)= DZ ; Step 28: Determine if there is DZb > D (w); if so, update the optimal pickup path length. DZb = D (w), update the optimal solution index wb =w, otherwise, no action is taken; Step 29: Update the counter variable w = w + 1. If w > W, proceed to step 5; otherwise, return to step 22.

2. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 1, characterized in that: Step one involves obtaining the pick-and-place machine parameters, circuit board production data, and component allocation results; the specific process is as follows: Step 11: Obtain the parameters of the pick-and-place machine; The pick-and-place machine parameters include the total number of pick-and-place bars H, with each pick-and-place bar indexed in ascending order along the X-axis as h∈[1,…,H], and the pick-and-place bar spacing. DI Slot spacing DM The number of slots in both the front and rear bases of the feeder is M; initialize an array with 1 row and M columns, all elements of which are zero. OM 0 and OM 1. These are used to store whether each slot on the front and rear bases is occupied; the X and Y coordinates of slot 1 on the front feeder base are respectively... MX f1 , MY f1 The X and Y coordinates of slot 1 on the rear feeder base are respectively MX r1 , MY r1 ; Steps 1 and 2: Obtain circuit board production data; The circuit board production data includes: the total number of component types C, the index number of each component being c∈[1,…,C], and the number of mounting points for each component being stored in an array with 1 row and C columns. n The pick-up X offset of the feeders used for various components is stored in an array with 1 row and C columns. ox The Y-offset of the feeders used for various components is stored in an array with 1 row and C columns. oy The number of slots occupied by the feeders used for various components is stored in an array with 1 row and C columns. q ; The total number of mounting points is P, and the index number of each mounting point is p∈[1,…,P]. The coordinates of the mounting points are stored in an array with P rows and 2 columns. xyt ; Step 13: Obtain component allocation results and feeder grouping information; The total number of pickup cycles is K, and the index number of each pickup cycle is k∈[1,…,K]; the component allocation result is stored in a two-dimensional array with K rows and H columns. CG , the elements CG (k,h) represents the type of component picked up by the h-th suction rod in the k-th pick-up cycle, i.e. CG (k,h)∈[1,…,C]; Corresponding to the component allocation result, the feeders are divided into G feeder groups, and the index number of each feeder group is g∈[1,…,G]. The number of slots occupied by each feeder group is stored in a tuple with 1 row and G columns. FQ Store each feeder group in a column with 1 row and 1 column. FQ The metaarray of {g} fs {g}, store the information about the slot occupied by each feeder group into a column with 1 row and 1 column. FQ The metaarray of {g} fq {g}; The feeder group allocation results are stored in a two-dimensional array with K rows and H columns. FG , the elements FG (k,h) represents the feeder group number picked up by the h-th suction rod in the k-th pickup cycle, i.e. FG (k,h)∈[1,…,G]; the feeder pick-up offset is stored in a two-dimensional array with K rows and H columns. FR , the elements FR (k,h) represents the h-th suction rod in the k-th pickup cycle, starting from the... FG The relative offset of (k,h) feeder groups when picking up; Step 14: Obtain the minimum positive and minimum negative feed offsets for each feeder group; Step 141: Initialize an array with 1 row and G columns, where all elements are M. fr0 Used to store the minimum positive feed offset of each feeder group; initialized as an array with 1 row and G columns, where all elements are -M. fr1 Used to store the maximum negative material pick-up offset of each feeder group; initialize the pick-up cycle count variable k=1; Step 142: If k > K, proceed to step 15; otherwise, initialize the suction rod counter variable h = 1 and proceed to step 143. Step 143: If h > H, update the counter variable k = k + 1 and return to Step 142; otherwise, execute Step 144. Step 144: Obtain the current feeder group number g= FG (k,h); Check if g=0; if yes, update the suction rod count variable h=h+1 and return to step 143; otherwise, execute step 145. Steps 1, 4, and 5, if fr0 (g)> FR (k,h), update fr0 (g)= FR (k,h), otherwise, do nothing; proceed to steps one through six. Step 146, if fr1 (g)< FR (k,h), update fr1 (g)= FR (k,h), otherwise, do nothing; proceed to step one four seven; Step 147: Update the suction rod count variable h = h + 1, then return to step 143; Step 1, Fifth: Initialize the picking cycle count k=1; for each type of element c∈[1,…,C], initialize the number of rows where all elements are zero. n (c) A tuple with 2 columns PL {c}∈[ PL {1},…, PL {C}] is used to store candidate locations for mounting points of various components. PL {c} is called the candidate position array for the c-th type of element; it is initialized with all elements set to 1, and the number of rows and columns is 1. C counting array i This serves as an index for mounting points in various components; proceed to step one six. Step 16: If k > K, it means that one traversal has been completed for all picking cycles. Proceed to Step 19. Otherwise, initialize the suction rod counter variable h = 1 and proceed to Step 17. Step 17: If h > H, it means that one traversal has been completed for all the suction rods. Update the loop variable k = k + 1 and return to step 16. Otherwise, execute step 18. Step 18: The component type picked up by the h-th suction rod in the k-th picking cycle is c= CG (k,h), determine if c=0; if yes, it means the suction rod will not be mounted during this period; otherwise, assign a value. PL {c}( i (c),1)=k、 PL {c}( i (c),2)=h, update the count variable i (c)= i (c)+1; Update the loop variable h=h+1, and return to step 17; PL {c} stores the candidate locations for the mounting points of the c-th type of component, where PL {c}( i (c),1) represents the first element in class c. i (c) Candidate positions for each decorative element in the row direction. PL {c}( i (c),2) represents the first element in the c-th class of elements. i (c) Candidate positions for each decorative point; Step 19: Initialize a two-dimensional array with K rows and H columns, all elements of which are zero. PA It is used to store the results of patch point assignment, and its elements PA (k,h) represents the placement point number applied by the h-th suction rod in the k-th pickup cycle, i.e. PA (k,h)∈[1,…,P]; initialize a two-dimensional array with K rows and H columns, all elements of which are zero. PS Used to store the placement sorting results, including the elements within them. PS (k,s) represents the number of the suction rod that is applied in the s-th application cycle of the k-th application cycle, i.e. PS (k,s)∈[1,…,H]; initialize a two-dimensional array with K rows and H columns, all elements of which are zero. FA It is used to store the results of the pick slot allocation, and its elements are... FA (k,h) represents the slot number picked up by the h-th suction rod in the k-th picking cycle; initialize a two-dimensional array with K rows and H columns, all elements set to zero. FX , the elements FX (k,h) is used to store the X coordinate of the patch carrier when the patch is picked up by the h-th suction rod in the k-th picking cycle; initialized as a two-dimensional array with K rows and H columns, all elements are zero. FY , the elements FY (k,h) is used to store the Y-coordinate of the patch carrier when the patch is picked up by the h-th suction rod in the k-th picking cycle; initialized as a two-dimensional array with K rows and H columns, all elements are zero. TX , the elements TX (k,h) is used to store the X-coordinate of the patch carrier when the patch is applied by the h-th pick-up bar in the k-th pick-up cycle; initialized as a two-dimensional array with K rows and H columns, all elements are zero. TY , the elements TY (k,h) is used to store the Y-coordinate of the patch carrier when the patch is applied by the h-th pick-up bar in the k-th pick-up cycle; initialized as a two-dimensional array with K rows and H columns, all elements are zero. FS It is used to store the picked and sorted results, including the elements within it. FS (k,s) represents the number of the suction rod that is picked up in the k-th picking cycle, i.e. FS (k,s)∈[1,…,H]; initialize an array with 1 row and G columns, all elements being zero. FM It is used to store the slot number assigned to each feeder group.

3. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 2, characterized in that: Step three decodes the input full-dimensional encoded chromosome, obtains and outputs the corresponding pick-and-place addressing path optimization result; the specific process is as follows: Step 3: Initialize and assign values PA0 = PA , PS0 = PS , FM0 = FM ; Step 32, from u {1} Obtain the mounting point allocation result PA0 The specific steps are as follows: Step 321: Initialize the component type count c=1; Step 322: If c > C, proceed to step 33; otherwise, assign a value. pa {c}= u {1}{c}, initialize the mounting point count for the c-th type of component. ii =1, proceed to step three, two, three; Step 3, if ii > n (c) indicates that a traversal of all mounting points of the c-th type of component has been completed. Update the counter variable c = c + 1 and return to step 322. Otherwise, execute step 324. Steps 3-4: Obtain candidate position k= PL {c}( ii ,1) h= PL {c}( ii 2) Update the decoration point allocation results PA0 (k,h)= pa {c}( ii Update the counter variable. ii = ii +1, return to step three; in, PL It is a one-dimensional array. PL {c} stores the candidate locations for the mounting points of the c-th type of component, where PL {c}( ii ,1) is the first element in the c-th class. ii Candidate locations for decorative elements PL {c}( ii ,2) is the first element in the c-th class. ii Each patch point is a candidate position in the column; the chromosome is assigned in order. pa It is a one-dimensional array. pa {c}( ii ) is the first in the c-th element ii One assigned mounting point number; Step 33, from u {2} Obtain the mounting sorting result PS0 The specific steps are as follows: Step 331: Initialize the pickup cycle count k=1 and assign a value. ps = u {2}; Step 332: If k > K, proceed to step 34; otherwise, initialize the suction rod count s = 1, initialize the mounting sequence count s1 = 1, and proceed to step 333. Step 333: If s > H, it means that one traversal has been completed for all the suction rods. Update the counter variable k = k + 1 and return to step 332. Otherwise, execute step 334. Step 334: Obtain the current suction rod number h= ps (k,s) retrieves the current mounting point number. IP = PA0 (k,h); Determine if there is (k,h); IP =0; if yes, then do nothing; otherwise, PS0 (k,s1)=h, update the mounting sequence count s1=s1+1; update the suction rod count s=s+1, return to step 3; Steps three and four, from u {3}、 u {4} Obtain the selection results and sorting of the front and rear bases of the feeder; the specific operation is as follows: Step 3-4: Initialize an array with 1 row and 2*G columns, where all elements are 1. GE Used to store binary encoding libraries; updates GE (1:G)= GE (1:G)-1; Steps 3 and 42 GE = GE ( u {3}); Initialization G0 =[], g0=0 are used to store and count the feeder sequence placed on the front feeder base. G1 =[], g1=0 is used to store and count the feeder sequence placed on the rear feeder base; initialize the feeder group count g2=1; Step 343: If g2 > G, proceed to step 35; otherwise, proceed to step 344. Step 3-4: Obtain the feeder group number g= u {4}(g2); Determine if there is a GE (g)=0; if so, then assign the feeder group to the front feeder base. G0 =[ G0 If g] and g0 = g0 + 1, then the feeder group is assigned to the rear feeder base. G1 =[ G1 g], g1=g1+1; Update the feeder group count g2=g2+1, return to step three-four-three; Where: u{4} is the 4th element in u, which is the feeder allocation order subchromosome, and g=u{4}(g2) is the g2th feeder group number in the subchromosome, indicating that the g2th feeder is assigned to the gth feeder group; Step 35, u {5}、 u {6} Decode the first slot assigned to the front and rear bases of the feeder; the specific operation is as follows: Step 3.51: Initialize an array with 1 row and 2*B columns, where all elements are 1. BE Used to store binary encoding libraries; updates BE (1:B)= BE (1:B)-1; in BE (1:B) represents the first B elements in the binary encoding library; Step 352 BE0 = BE ( u {5}) BE1 = BE ( u {6}); Initialize m0=0 and m1=0 to store the first slot assigned to the front and rear bases of the feeder, respectively; Initialize the binary code counter variable b=1; in: BE ( u {5}) indicates that an array u {5} is for index retrieval. BE Elements in; BE ( u {6}) indicates that an array u {6} is retrieved from the index. BE Elements in; Step 353: If b > B, proceed to step 36; otherwise, proceed to step 354. Steps three, five, and four: m0 = m0 + BE0 (b) * (2^(Bb)), m1=m1+ BE1 (b) * (2^(Bb)), where 2^(Bb) represents 2 raised to the power of (Bb); update the counter variable b = b + 1, and return to step 353; Step 36: Obtain the slot allocation results for each feeder group on the front base; the specific operation is as follows: Step 361: Initialize the feeder group counter variable f=1; Initialize the penalty flag. DP =0; Step 362: If f > g0, proceed to step 37; otherwise, proceed to step 363. Step 363: Obtain the current feeder group number g= G0 (f); Initialize the slot count variable m = m0; Step 364: If m > M, update the counter variable f = f + 1 and return to step 362; otherwise, execute step 365. Step 365, if m + 2*(H - 1) - fr0 (g)>60 indicates that the feeder group is unable to complete the distribution due to exceeding the limit, and the penalty flag is updated. DP = DP +inf, update the counter variable m=M+1, return to step 364; otherwise, initialize the slot counter variable f0=1, and execute step 366. Step 366, if f0> FQ {g}, update the counter variable m=m+1, return to step 364; otherwise, execute step 367; Steps 3, 6, and 7: Determine if there is any fq {g}(f0)=0; if yes, update the counter variable f0=f0+1 and return to step 366; if no, get the current slot number f1=m+f0-1 and execute step 368. Step 368: Determine if there is OM If 0(f1)=1, it means that the current slot is occupied and the current feeder group cannot be placed. Update the counter variable m=m+1 and return to step 364. If not, execute step 369. Step 369: Determine if f0= FQ {g}, if yes, it means that all slots required for the current feeder group allocation can be used, and the slot allocation result is recorded. FM0 (g)=m, update the slot occupancy information array. OM 0(m:f1)= OM 0(m:f1)| fq {g}, update the counter variable m=M+1, return to step 364; otherwise, update the counter variable f0=f0+1, return to step 366; Where: the symbol | represents bitwise OR operation on the preceding and following arrays; OM 0(m:f1) represents the information about the occupied slots from the mth to the f1th slot. OM 0(m:f1)= OM 0(m:f1)| fq {g} indicates that slots m to f1 will be occupied according to the information of slots occupied by the g-th feeder group; Step 37: Obtain the slot allocation results for each feeder group on the rear base; Step 371: Initialize the feeder group counter variable f=g1; Step 372: If f < 1, proceed to step 4; otherwise, proceed to step 373. Step 373: Obtain the current feeder group number g= G1 (f); Initialize the slot count variable m=m1; Step 374: If m > M, update the counter variable f = f - 1 and return to step 372; otherwise, execute step 375. Step 375: Obtain the first element type c in the current feeder group. fs {g}(1); if m-2*(H-1)+ fr1 (g) < 1 or m+ q (c)>60 indicates that the feeder group is unable to complete the distribution due to exceeding the limit, and the penalty flag is updated. DP = DP +inf, update the counter variable m=M+1, return to step 374; otherwise, initialize the slot counter variable f0=1, and execute step 376. in q (c) represents the feeder width of the c-th type of element; Step 376, if f0> FQ {g}, update the counter variable m=m+1, return to step 374; otherwise, execute step 377. Step 3.77: Determine if there is... fq {g}(f0)=0; if yes, update the counter variable f0=f0+1 and return to step 376; otherwise, obtain the current slot number f1=m+ q (c)-f0+1, then execute steps three, seven, and eight; Step 3.7.8: Determine if there is... OM If 1(f1)=1, it means that the current slot is occupied and the current feeder group cannot be placed. Update the counter variable m=m+1 and return to step 374. If not, execute step 379. Step 379: Determine if f0 = FQ {g}, if yes, it means that all slots required for the current feeder group allocation can be used, and the slot allocation result is recorded. FM0 (g) = m + M, calculate f2 = m + q (c) Update the slot occupancy information array OM 1(f2:-1:f1)= OM 1(f2:-1:f1)| fq {g}, update the counter variable m=M+1, return to step 374; otherwise, update the counter variable f0=f0+1, return to step 376; in, OM 1(f2:-1:f1) represents retrieving the occupied information of slots f2 to f1 in reverse order. OM 1(f2:-1:f1)= OM 1(f2:-1:f1)| fq {g} indicates that slots f2 to f1 will be occupied according to the information of slots occupied by the g-th feeder group.

4. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 3, characterized in that: Step four corresponds to the input pickup and location optimization result, calculating and outputting the corresponding pickup path length; the specific process is as follows: Step 41: Based on the slot allocation results of each feeder group, obtain the pick coordinates for each pick-up cycle and determine the pick-up order; the specific operation is as follows: Step 4.11: Initialize and assign values FX0=FX , FY0=FY , FA0 = FA , FS0 = FS Initialize the pickup cycle count k=1; Step 4.12: If k > K, proceed to step 4.2; otherwise, initialize the suction bar counter variable h = 1, and initialize the pickup information array with 3 rows and H columns where all elements are zero. PQ Proceed to step four one three; Step 413: If h > H, it means that one traversal has been completed for all the suction rods, and proceed to step 416; otherwise, proceed to step 414. Step 414: Obtain the current feeder number g =FG (k,h); Determine if g=0. If yes, update the counter variable h=h+1 and return to step 413. If no, execute step 415. Step 415: Obtain the pick slot allocation result FA0 (k,h)= FM0 (g)+ FR (k,h), retrieve the first element type c in the current feeder group. fs {g}(1); Determine if g>60. If yes, it means it is installed on the rear feeder base. FX0 (k,h)= MX r1 -(2*(h-1)+ FA0 (k,h)-M-1)* DM - ox (c), FY0 (k,h)= MY r1 - oy (c) If not, it indicates that it is installed on the front feeder base. FX0 (k,h)= MX f1 +(2*(h-1)+ FA0 (k,h)-1)* DM + ox (c), FY0 (k,h)= MY f1 + oy (c); PQ (1,h)= FX0 (k,h) PQ (2,h)= FY0 (k,h) PQ (3,h)=h; Update the counter variable h=h+1, return to step 413; ox (c) oy (c) represents the feeder pick-up offset of the c-th type of component in the X and Y directions, respectively; Step 416, according to PQ The elements in (1,:) are ordered from smallest to largest. PQ Sort the columns; according to PQ The elements in (2,:) are ordered from smallest to largest. PQ Sort each column; initialize the suction rod count variable s=1, and the pickup count variable s1=0; Step 417: If s > H, update the counter variable k = k + 1 and return to step 412; otherwise, obtain the current lever number h = PQ (3,s), execute step four one eight; Step 418: Determine if there is... FX0 (k,h)=0; if so, do nothing; otherwise, update the counter variable s1=s1+1. FS0 (k,s1)=h; Update the counter variable s=s+1, and return to step 417; Step 42: Calculate the picking path length; the specific steps are as follows: Step 421: Initialize the picking path length DQ =0; Initialize the array with K rows and 1 column. QX 0、 QY 0, used to store the first pickup coordinate in each pickup cycle; initialize a K-row, 1-column array. QX 1. QY 1. Used to store the last pickup coordinate in each pickup cycle; initialize the pickup cycle count k=1; Step 422: If k > K, proceed to step 43; otherwise, obtain the suction rod number h0 for the first pickup. FS0 (k,1), update QX 0(k)= FX0 (k,h0) QY 0(k)= FY0 (k,h0), initialize the suction rod count variable s=2, and execute steps four, two, and three; Step 423: If s > H, update QX 1(k)= FX0 (k,h0) QY 1(k)= FY0 If (k, h0) is found, update the counter variable k = k + 1 and return to step 422; otherwise, execute step 424. Step 424: Obtain the current suction rod number h1= FS0 (k,s), determine if h1=0. If yes, then s=H+1 and return to step 423. Otherwise, execute step 425. Step 425: Calculate the Chebyshev distance between the current picked coordinates and the previously picked coordinates. dq =max( |FX0 (k,h0)- FX0 (k,h1) | , |FY0 (k,h0)- FY0 (k,h1) | ), where the symbol || indicates taking the absolute value of the value within it, and max indicates taking the larger of the values ​​within the parentheses; update the picking path length. DQ = DQ + dq Update the suction rod number h0=h1, update the counter variable s=s+1, and return to steps four, two, and three; Step 43: Obtain the placement coordinates in each pick-up cycle and calculate the placement path length; the specific operation is as follows: Step 431: Initialize the mounting path length DT =0; initialize and assign values. TX0=TX , TY0=TY Initialize a K-row, 1-column array. PX 0、 PY 0, used to store the first placement coordinate in each pick-and-place cycle; initialize a K-row, 1-column array. PX 1. PY 1. Used to store the last placement coordinate in each pickup cycle; initialize the pickup cycle count k=1; Step 432: If k > K, proceed to step 44; otherwise, initialize the suction rod counter variable h = 1 and proceed to step 433. Step 433: If h > H, it means that one traversal has been completed for all the suction rods, and proceed to step 436; otherwise, proceed to step 434. Step 434: Obtain the current component number p =PA0 (k,h); Determine if p=0. If yes, update the counter variable h=h+1 and return to step 433. If no, execute step 435. Steps 4, 3, and 5: Update TX0 (k,h)= xyt (p,1)-(h-1)* DI , TY0 (k,h)= xyt (p,2); Update the counter variable h = h + 1, and return to step 433; Step 436: Obtain the suction cup number h0 for the initial mounting. PS0 (k,1), the corresponding mounting point number p0= PA0 (k,h0), whose corresponding mounting coordinates are PX 0(k)= xyt (p0,1)-(h0-1)* DI , PY 0(k)= xyt (p0,2), initialize the suction rod count variable s=2, and execute step four three seven; Step 437: If s > H, update PX 1(k)= xyt (p0,1)-(h0-1)* DI , PY 1(k)= xyt (p0,2), update the counter variable k=k+1, return to step 432; otherwise, execute step 438. Step 438: Obtain the current suction rod number h1= PS0 (k,s), determine if h1=0. If yes, then s=H+1 and return to step 437. Otherwise, execute step 439. Step 439: Obtain the current mounting point number p1= PA0 (k,h1), calculate the Chebyshev distance between the current mounting coordinates and the previous mounting coordinates. dt =max( |TX0 (k,h0)- TX0 (k,h1) | , |TY0 (k,h0)- TY0 (k,h1) | Update mount path length DT = DT + dt Update h0=h1 and p0=p1, update the counter variable s=s+1, and return to step 437; Step 4: Calculate the pickup path length; the specific steps are as follows: Step 441: Pick the repost path length DU =0, Paste pick path length DV =0; Initialize the pickup cycle count k=1; Step 442: If k > K, calculate the length of the picking path. DZ = DP + DQ + DT+DU + DV ,Will DZ , PA0 , PS0 , FM0 , FA0 , FS0 Output to the original steps that called steps three and four; otherwise, execute step four-four-three. Step 443: Calculate the Chebyshev distance between the first placement coordinate and the last pickup coordinate within the current cycle. du =max( |PX 0(k)- QX 1(k) | , |PY 0(k)- QY 1(k) | ); Determine if there exists k+1>K. If so, then dv =0, otherwise, calculate the Chebyshev distance between the last placement coordinate in the current cycle and the first pickup coordinate in the next cycle. dv =max( |PX 1(k)- QX 0(k+1) | , |PY 1(k)- QY 0(k+1) | ); Step 444, Update DU = DU + du , DV = DV + dv Update the counter variable k = k + 1, and return to step 442.

5. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 4, characterized in that: Step five sets the parameters and loop conditions for the genetic algorithm; the specific process is as follows: Step 51: Calculate the number of genes in the chromosome: NG = P + K * H + G + 2 * G + 2 * B + 2 * B; Initialize the crossover probability of the genetic algorithm. RC =0.6, Probability of Mutation RM =0.02, calculate the upper limit of the number of crossover operations IC= RC* W, the maximum number of mutation operations IM= RM* W*NG, no improved search limit IT = 2*⌈(NG) 0.5 ⌉; Initialize the no-improvement search counter variable it = 0; Step 52: If it > IT, it means the maximum number of no-improvement searches has been reached. Proceed to Step 8. Otherwise, initialize the crossover operation count ic = 1 and proceed to Step 53. Step 53: If ic > IC, it means that the number of crossover operations has reached the upper limit. Initialize the mutation operation count im = 1 and execute Step 54. Otherwise, execute Step 6. Step 54: If im > IM, it means that the number of mutation operations has reached the limit, so proceed to step 55; otherwise, proceed to step 7. Step 55, obtain [ db , wo ]=min( D ), min means taking the minimum value of the array within the parentheses that follows it, therefore db This is the shortest pickup path length found so far. wo To achieve the optimal picking path, the chromosome index is determined; it is then determined whether there is one. DZb > db If so, then update the optimal pickup path length. DZb = db Update the optimal solution index wb = wo If not, update the counter variable it=0; otherwise, update the counter variable it=it+1; return to step 52.

6. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 5, characterized in that: Step six involves operating on each full-dimensional encoded chromosome using the crossover operator, and updating the optimal picking and pasting location path optimization results through comparison; the specific process is as follows: Step 61: Select the two chromosomes to be crossed using the roulette wheel method; the specific steps are as follows: Step 611: Initialize an array with 1 row and W columns, where all elements are zero. E With SR; iterate through each w∈[1,…,W} and assign values. E (w)=1 / D (w), assigning the selection probability SR(w) to each chromosome. E (w) / sum( E ), where sum represents summing the array within the parentheses; initialize the two selected chromosomes with numbers w0=0 and w1=0; Step 612: Determine if w0 = w1; if yes, proceed to step 613; otherwise, initialize the temporary chromosome population. U 1{w3}∈[ U 1{1},…, U 1{4}], U 1{1}= U {w0}、 U 1{2}= U {w1}、 U 1{3}= U {w0}、 U 1{4}= U {w1}; Initializes a 1x4 array. D 1, and assign a value. D 1=[ D (w0) D (w1) D (w0) D (w1)], proceed to step six two; Step 613: Generate selection probabilities sr 0 = rand(1), sr 1 = rand(1), where rand(1) represents generating a random number between 0 and 1; initialize the chromosome count variable w2 = 1, and initialize the probability accumulation variable sr = 0; Step 614: If w2 > W, reset the chromosome count variable w2 = 1, clear the probability accumulation variable sr = 0, and execute step 616; otherwise, execute step 615. Step 615: Update sr = sr + SR(w2); check if sr < 0. sr If 0, update w2=w2+1; otherwise, store w0=w2 and assign w2=W+1; return to step 614. Step 616: If w2 > W, return to step 612; otherwise, proceed to step 617. Step 617: Update sr = sr + SR(w2); check if sr < 0. sr 1. If yes, update w2=w2+1; otherwise, store w1=w2 and assign w2=w+1. Return to step 616; Step 62: In the selected two full-dimensional coding chromosomes, perform a crossover operation on the sub-chromosomes that assign mounting points to each type of element; the specific operation is as follows: Step 621: Initialize the component type count c=1; Step 622: If c > C, proceed to step 63; otherwise, proceed to step 623. Step 623: Obtain the two chromosome fragments to be operated on. pu 0= U 1{3}{1}{c}、 pu 1= U 1{4}{1}{c}, chromosome segment length is npu = n (c); in: U 1 is a three-dimensional tuple, where U 1{3} represents the third chromosome in the temporary chromosome population. U 1{3}{1} represents obtaining U The first sub-chromosome in 1{3}, namely the sub-chromosome of the mounting point allocation order, U 1{3}{1}{c} represents obtaining U The order of mounting site allocation for class c elements in subchromosome 1{3}{1}; U 1{4} represents the fourth chromosome in the temporary chromosome population. U 1{4}{1} represents obtaining U The first sub-chromosome in 1{4}, namely the sub-chromosome of the mounting point allocation order, U 1{4}{1}{c} represents obtaining U The order of mounting site allocation for class c elements in subchromosome 1{4}{1}; Step 624, with pu 0、 pu 1. npu As input, execute step six five, and obtain the result after the crossover operation from the output. pu 2. pu 3. Assignment U 1{3}{1}{c}= pu 2. U 1{4}{1}{c}= pu 3; Update c = c + 1, return to step 622; Step 63: Perform a crossover operation on the mounted sorting sub-chromosomes from the two selected full-dimensional coding chromosomes; the specific operation is as follows: Step 631: Randomly select the row numbers to be operated on in the patch sorting sub-chromosome array as k1=⌈rand(1)*K⌉ and k2=⌈rand(1)*K⌉; Step 632: Obtain the two chromosome fragments to be operated on. pu 0= U 1{3}{2}(k1,:), pu 1= U 1{4}{2}(k2,:), the length of the chromosome segment is npu =H; U 1 is a two-dimensional element array. U 1{3} represents the fourth chromosome in the temporary chromosome population. U 1{3}{2} represents obtaining U The second sub-chromosome in 1{3}, namely the patch-sorted sub-chromosome, U 1{3}{2}(k1,:) represents obtaining U The order of suction rod attachment in the k1st pickup cycle of the subchromosome 1{3}{2}; U 1{4} represents the fourth chromosome in the temporary chromosome population. U 1{4}{2} represents obtaining U The fourth sub-chromosome in 1{4}, namely the patch-sorted sub-chromosome, U 1{4}{2}(k2,:) represents obtaining U The order of suction rod attachment in the k2th pickup cycle of the 1{4}{2} subchromosome; Step 633, with pu 0、 pu 1. npu As input, execute step six five, and obtain the result after the crossover operation from the output. pu 2. pu 3. Assignment U 1{3}{2}(k1,:)= pu 2. U 1{4}{2}(k2,:)= pu 3; Step 64: Perform a crossover operation on the other sub-chromosomes in the two selected full-dimensional coding chromosomes; the specific operation is as follows: Step 641: Obtain the two chromosome fragments to be operated on. pu 0= U 1{3}{3}、 pu 1= U 1{4}{3}, chromosome segment length is npu =2*G; with pu 0、 pu 1. npu As input, execute step six five, and obtain the result after the crossover operation from the output. pu 2. pu 3. Assignment U 1{3}{3}= pu 2. U 1{4}{3}= pu 3; Step 642: Obtain the two chromosome fragments to be operated on. pu 0= U 1{3}{4}、 pu 1= U 1{4}{4}, chromosome segment length is npu =G; with pu 0、 pu 1. npu As input, execute step six five, and obtain the result after the crossover operation from the output. pu 2. pu 3. Assignment U 1{3}{4}= pu 2. U 1{4}{4}= pu 3; Step 643: Obtain the two chromosome fragments to be operated on. pu 0= U 1{3}{5}、 pu 1= U 1{4}{5}, chromosome segment length is npu =2*B; with pu 0、 pu 1. npu As input, execute step six five, and obtain the result after the crossover operation from the output. pu 2. pu 3. Assignment U 1{3}{5}= pu 2. U 1{4}{5}= pu 3; Step 644: Obtain the two chromosome fragments to be operated on. pu 0= U 1{3}{6}、 pu 1= U 1{4}{6}, chromosome segment length is npu =2*B; with pu 0、 pu 1. npu As input, execute step six five, and obtain the result after the crossover operation from the output. pu 2. pu 3. Assignment U 1{3}{6}= pu 2. U 1{4}{6}= pu 3; Step 645, proceed to step 66; Step 65: Perform a crossover operation on the two input chromosome segments; the specific operation is as follows: Step 651: The number of elements to be crossed is nc 0=3; the starting element number for the crossover is... nc 1 = ⌈rand(1) * npu ⌉; Determine if there is nc 0-1+ nc 1> npu If so, the termination element number for the crossover is... nc 2= nc 1- nc 0+1, the array of elements to be operated on is NC 0= nc 2: nc 1. If not, nc 2= nc 1+ nc 0-1, NC 0= nc 1: nc 2; NC 1= NC 0、 NC 2= NC 0、 pu 2= pu 0、 pu 3= pu 1; Initialize the element count variable within the operand region. cc 0=1, the number of elements in the operation region is CC = nc 0; Step 652, if cc 0> CC If the above steps are not executed, proceed to step 654; otherwise, proceed to step 653. Step 653: View the array pu 3( NC 1) Does any element equal to...? pu 2( NC 0( cc If 0), store the index of that element in cc 1. Update NC 0( cc 0)=[]、 NC 1( cc 1) = []、 CC=CC -1, if not, update cc 0= cc 0+1; Return to step six-five-two; Step 654 CC= numel( NC 1), where numel represents the number of elements in the array within the parentheses; check if there is a value. CC =0, if yes, proceed to steps six, five, and seven; otherwise, initialize the counter variable. cc 0=1, proceed to step six five five; Step 655, if cc 0> CC If not, proceed to step six five seven; otherwise, proceed to step six five six. Step 656: Memorize the array pu 0 and pu 3( NC 1( cc The index of the element that is equal to 0 is 0. cc 1. Update pu 2( cc 1)= pu 0( NC 0( cc 0)); Note the array pu 1 in and pu 2( NC 0( cc The index of the element that is equal to 0 is 0. cc 1. Update pu 3( cc 1)= pu 1( NC 1( cc 0)); Update cc 0= cc 0+1; Return to step six five five; Steps six, five, and seven. pu 2( NC 2)= pu 1( NC 2) pu 3( NC 2)= pu 0( NC 2); will pu 2. pu 3. Output to the original step of calling step six five; Step 66: Decode the two chromosomes obtained after the crossover operation, calculate their corresponding pick-and-place path lengths, and if the lengths are better than the results before the crossover operation, replace them with the chromosome population; the specific operations are as follows: Step 661, with u = U 1{3} is used as input to execute steps three and four. The output includes the corresponding pickup and location optimization results and pickup path length. DZ Assignment D 1(3)= DZ ; Step 662, with u = U 1{4} is used as input to execute steps three and four. The output includes the corresponding pickup and location optimization results and pickup path length. DZ Assignment D 1(4)= DZ ; Step 663: For the array D 1. Sort the elements, where the indices of the two smallest elements are w4 and w5. Step 664: Update the chromosome population U {w0}= U 1{w4}、 U {w1}= U 1{w5}, Update D (w0)= D 1(w4) D (w1)= D 1(w5); Update ic=ic+1, return to step 53.

7. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 6, characterized in that: Step seven involves operating on each fully encoded chromosome using mutation operators, and updating the optimized pick-and-place address path results through comparison and selection; the specific process is as follows: Step 71: Select chromosomes for mutation based on the roulette wheel method; the specific steps are as follows: Step 711: Traverse each w∈[1,…,W} and assign values. E (w)=1 / D (w), assigning the selection probability SR(w) to each chromosome. E (w) / sum( E Initialize the selected chromosome number to w0=0; Step 712: Generate selection probabilities sr 0 = rand(1); Initialize chromosome count variable w2 = 1, initialize probability accumulation variable sr = 0; Step 713: If w2 > W, proceed to step 715; otherwise, proceed to step 714. Step 714: Update sr = sr + SR(w2); check if sr < 0. sr If the value is 0, update w2 = w2 + 1; otherwise, store w0 = w2 and assign w2 = W + 1. Return to step 713; Step 715: Initialize temporary chromosomes u 0= U {w0}; Initialize and assign values D 2= D (w0), proceed to step seven two; Step 72: In the selected full-dimensional encoded chromosome, perform mutation operations on the sub-chromosomes for assigning mounting points to each type of element; the specific operations are as follows: Step 721: Initialize the component type count c=1; Step 722: If c > C, proceed to step 73; otherwise, proceed to step 723. Step 723: Obtain the chromosome fragment to be operated on. pu 0= u 0{1}{c}, chromosome segment length is npu = n (c); Step 724, with pu 0、 npu As input, execute step seven five, and obtain the result after mutation from the output. pu 1. Assignment u 0{1}{c}= pu 1; Step 73: Perform mutation operations on the mounted sorting sub-chromosomes within the selected full-dimensional coding chromosomes; the specific operations are as follows: Step 731: Randomly select the row number to be operated on in the patch sorting sub-chromosome array as k1=⌈rand(1)*K⌉; Step 732: Obtain the chromosome fragment to be operated on. pu 0= u 0{2}(k1,:), the length of the chromosome segment is npu =H; Step 733, with pu 0、 npu Step 75 is executed as input, and the output yields the result after the crossover operation. pu 1. Assignment u 0{2}(k1,:)= pu 1; Step 74: Perform a crossover operation on the other sub-chromosomes in the selected full-dimensional coding chromosome; the specific operation is as follows: Step 741: Obtain the chromosome fragment to be operated on. pu 0= u 0{3}, chromosome segment length is npu =2*G; with pu 0、 npu Step 75 is executed as input, and the output yields the result after the crossover operation. pu 1. Assignment u 0{3}= pu 1; Step 742: Obtain the chromosome fragment to be operated on. pu 0= u 0{4}, chromosome segment length is npu =G; with pu 0、 npu Step 75 is executed as input, and the output yields the result after the crossover operation. pu 1. Assignment u 0{4}= pu 1; Step 743: Obtain the chromosome fragment to be operated on. pu 0= u 0{5}, chromosome segment length is npu =2*B; with pu 0、 npu Step 75 is executed as input, and the output yields the result after the crossover operation. pu 1. Assignment u 0{5}= pu 1; Step 744: Obtain the chromosome fragment to be operated on. pu 0= u 0{6}, chromosome segment length is npu =2*B; with pu 0、 npu Step 75 is executed as input, and the output yields the result after the crossover operation. pu 1. Assignment u 0{6}= pu 1; Step 745, proceed to step 76; Step 75: Perform mutation operations on the input chromosome fragments; the specific operations are as follows: Step 751: Assignment pu 1= pu 0, the number of elements undergoing mutation is CC =⌈rand(1)* npu ⌉; Initialize the mutated element count variable cc 0 = 1; Step 752, if cc 0> CC Otherwise, return to the original step that called step 75; otherwise, execute step 753. Step 753: The first element that needs to be mutated is nc 0 = ⌈rand(1) * npu ⌉, the second element is nc 1= nc 0; Step 754: Determine if there is nc 1= nc 0. If yes, proceed to step 755; otherwise, proceed to step 756. Step 755 nc 1 = ⌈rand(1) * npu ⌉, Return to step 754; Steps 7, 5, and 6: Update pu 1( nc 1)= pu 0( nc 0) pu 1( nc 0)= pu 0( nc 1); Update cc 0= cc 0+1; Return to step 752; Step 76: Decode the chromosome obtained after the mutation operation, calculate its corresponding pick-and-place path length, and if it is better than the result before the mutation operation, replace it in the chromosome population; the specific operation is as follows: Step 761, with u = u Taking 0 as input, steps three and four are executed. The output includes the corresponding optimized pickup and location path and the pickup path length. DZ Assignment D 2= DZ ; Step 762: Determine if there is D 2< D (w0), if so, update the chromosome population. U {w0}= u 0, Update D (w0) = D 2. If not, no action will be taken; Update im = im + 1, then return to step five four.

8. The method for optimizing the pick-and-place addressing path of a chip mounter based on a full-dimensional encoded genetic algorithm according to claim 7, characterized in that: Step eight outputs the optimal pickup and placement path optimization result; the specific process is as follows: Step 81: Indexing based on the optimal solution wb Extract the optimal fully encoded chromosome as u = U { wb }; Step 82, with u The inputs from steps three and four result in the output containing the optimal pick-and-place location optimization results: optimal placement point allocation results. PA = PA0 Optimal placement sorting results PS = PS0 The slot numbers assigned to each feeder group FM = FM0 Optimal Slot Allocation Results FA = FA0 Optimal picking and sorting results FS = FS0 ; Step 83: The pick-and-place machine carries out placement production according to the optimal pick-and-place location optimization results.

Images