A method for online optimization of pick-up and placement paths during chip placement machine production

Abstract

A method for online optimization of a pick-up and paste path while a chip mounter is in production relates to a method for optimizing the pick-up and paste path of a chip mounter. In order to solve the problem that the pick-up and paste path is too long due to the poor optimal solution search capability of the existing chip mounter scheduling software based on the heuristic algorithm for optimization. The present invention first obtains the initial mounting process optimization result according to the chip mounter mounting optimization solver, and transmits the result to the chip mounter industrial computer to start surface mounting production; at the same time, the pick-up and paste path optimization results are compared and selected based on the taboo search, and then the newly found optimal result is transmitted to the chip mounter industrial computer, and starting from the next circuit board, subsequent surface mounting production is carried out based on the result; a neighborhood search operation is performed on the allocation order array of each type of component, and the allocation order array after the operation is decoded to obtain a new mounting point allocation result, and correspondingly, the optimal mounting sorting result is obtained based on dynamic programming.

Description

Technical Field

[0001] The invention belongs to the field of electrical technology and electrical engineering, and in particular relates to a method for optimizing a pick-up path of a chip placement machine. Background Art

[0002] In modern production and life, people cannot live without all kinds of electronic products. The key link in the assembly process of electronic products is circuit board assembly, which must use surface mounting technology. The core equipment to realize this technology is the placement machine. The placement machine quickly picks up electronic components, electronic devices and chips, and quickly and accurately mounts them on the surface of the circuit board. For the sake of simplicity, "electronic components, electronic devices and chips" are collectively referred to as "components", and "pick up and place" is referred to as "pick up and place".

[0003] At present, the placement machines on the market are all based on Figure 1 On the gantry-type three-dimensional motion platform shown: a number of suction rods for suction and blowing are equidistantly installed in the patch carrier, and each suction rod is driven by the motor in the patch carrier to move up and down in the Z direction, and the patch carrier is driven by the translation guide and the fixed guide to move in the horizontal plane in the X and Y directions. With the help of the above-mentioned motion mechanism, the picking, moving and mounting of components can be completed. Before the picking and mounting process begins, the circuit board will be pressed and fixed after being conveyed to the stop position by the circuit board conveyor belt. During the picking and mounting process, the feeder fixedly installed on the feeder base will automatically replenish the components to be supplied, and the supplied components will appear at the picking point at the front end of the feeder, waiting to be picked up.

[0004] The pick-up process of the placement machine is as follows Figure 2 As shown. Since the number of suction rods is limited and significantly less than the number of placement points, the patch carrier needs to complete the placement of an entire circuit board in multiple picking and placement cycles (pick-and-place cycles). The picking and placement process within a pick-and-place cycle can be summarized as follows: the patch carrier first moves to the base of the feeder; each suction rod on the patch carrier moves to the corresponding picking point in turn to pick up components; after all suction rods have completed component picking, the patch carrier moves to the circuit board; each suction rod on the patch carrier moves to the corresponding placement point in turn to place components. After all suction rods have completed component placement, the picking and placement process of the next pick-and-place cycle begins.

[0005] Optimizing the pick-and-place process of the placement machine can significantly shorten the time consumed by surface placement. This optimization problem includes three sub-problems, namely, "component allocation problem", "feeder position allocation problem" and "pick-and-place path optimization problem". "Component allocation" requires determining the type of components mounted by each suction rod in each pick-and-place cycle; "feeder position allocation" requires determining the installation position of each feeder on the feeder base. "Pick-and-place path optimization" is completed in two steps: first, under the constraints of component allocation, "mounting point allocation" is performed to determine the mounting points mounted by each suction rod in each pick-and-place cycle; then, the "mounting sorting" is optimized, that is, the order in which each suction rod performs mounting in each pick-and-place cycle is determined.

[0006] An important goal of the pick-and-place process optimization is to minimize the length of the pick-and-place path. During the pick-and-place process, the movement path of the patch carrier is called the pick-and-place path of the patch machine. According to the starting and ending point types of each path segment, the pick-and-place path in any pick-and-place cycle can be divided into four categories: 1) Pick-up path, that is, the path along which each suction rod completes component picking in turn in the current cycle, and its starting point and end point are both pick-up points; 2) Pick-to-place path, that is, the path along which all suction rods complete picking in the current cycle and move from the feeder base to the circuit board, and its starting point is the last pick-up point in the current cycle, and its end point is the first placement point in the current cycle; 3) Placement path, that is, the path along which each suction rod completes component placement in turn in the current cycle, and its starting point and end point are both placement points; 4) Placement-to-pick path, that is, the path along which all suction rods complete placement in the current cycle and move from the circuit board to the feeder base, and its starting point is the last placement point in the current cycle, and its end point is the first pick-up point in the next cycle.

[0007] After determining the "component allocation" and "feeder position allocation", the picking path will be uniquely determined, and the minimization of the pick-to-stick path, the mounting path, and the mounting-to-pick path will depend on the "pick-to-stick path optimization". In the mounting production process of the placement machine, the "component allocation results" and "feeder position allocation results" cannot be changed, while the "pick-to-stick path optimization results" can be continuously improved along with the production process. The present invention proposes for the first time that in the production process, the length of the picking-to-stick path can be minimized by continuously improving the "mounting point allocation" and "mounting sorting", and accordingly provides an effective optimization method. Summary of the invention

[0008] The present invention aims to solve the problem that the existing placement machine scheduling software has poor optimal solution search capability based on heuristic algorithm optimization, resulting in a long pick-up and paste path, and the optimization results used in production are fixed and cannot be optimized and updated online. A method for online optimization of the pick-up and paste path during placement machine production is proposed.

[0009] A method for online optimization of a pick-up path during chip placement machine production comprises the following steps:

[0010] Step 1: Obtain the initial optimization result of the placement process according to the placement optimization solver of the placement machine, and transfer the result to the placement machine industrial computer to start surface mount production;

[0011] Step 2: Obtain placement machine parameters, circuit board production data, and initial pick-and-place path optimization results from the placement process optimization results;

[0012] Step 3: According to the imported initial pick-up path optimization result, the candidate positions of the mounting points contained in each type of component and the sorted array of the initial mounting points of each type of component are obtained;

[0013] Step 4: Initialize the taboo search;

[0014] Step 5: Compare and select the optimization results of the pick-up path based on taboo search, and then transfer the newly found optimal result to the placement machine industrial computer, and start from the next circuit board, and carry out subsequent surface mount production based on the result;

[0015] Step 6: Perform a neighborhood search operation on the allocation order array of each type of component, decode the allocation order array after the operation, and obtain a new placement point allocation result. Correspondingly, obtain the optimal placement sorting result based on dynamic programming. If the new optimization result corresponds to a better picking path, it will be stored as the optimal result.

[0016] Furthermore, the process of obtaining the placement machine parameters, circuit board production data and initial pick-up path optimization results includes the following steps:

[0017] Step 21, importing the parameters of the placement machine; the parameters of the placement machine include the total number of suction rods H, the index number of each suction rod is h∈[1,…,H] in increasing order along the X-axis, and the suction rod interval DI;

[0018] Step 22, importing circuit board production data; the circuit board production data includes: the total number of component types C, the index number of each type of component is c∈[1,…,C], the number of mounting points n{c}∈[n{1},…,n{C}], the total number of mounting points P, the index number of each mounting point is p∈[1,…,P], the coordinates of the mounting points are stored in a two-dimensional array xyt with P rows and 2 columns, wherein the X coordinate and Y coordinate of the pth mounting point are xyt(p,1) and xyt(p,2) respectively; the coordinates of the mounting point need to be converted to the fixed reference point coordinates on the patch carrier to obtain the mounting coordinates corresponding to the mounting point;

[0019] Step 23, import the initial pick-up path optimization results; the total number of pick-up cycles is K, and the index number of each pick-up cycle is k∈[1,…,K]; the component allocation results are stored in a two-dimensional array CG with K rows and H columns, where the element CG(k,h) represents the component type picked up by the h-th suction rod in the k-th pick-up cycle, that is, CG(k,h)∈[1,…,C]; the placement point allocation results are stored in a two-dimensional array PA0 with K rows and H columns, where the element PA0(k,h) represents the placement point number placed by the h-th suction rod in the k-th pick-up cycle, that is, PA0(k,h)∈[1,…,P]; the placement sorting results are stored in a two-dimensional array PS0 with K rows and H columns. In which the element PS0(k,s) represents the number of the s-th pick rod for placement in the k-th pick-and-stick cycle, that is, PS0(k,s)∈[1,…,H]; the pick-and-stick path length DZ0, the pick-and-stick path length DQ; the pick-and-stick coordinates corresponding to the first and last pick-and-stick points in each pick-and-stick cycle are stored in the two-dimensional arrays xyqf and xyql with K rows and 2 columns, wherein the elements xyqf(k,1) and xyqf(k,2) represent the X coordinate and Y coordinate of the pick-and-stick coordinates corresponding to the first pick-and-stick point in the k-th pick-and-stick cycle, and the elements xyql(k,1) and xyql(k,2) represent the X coordinate and Y coordinate of the pick-and-stick coordinates corresponding to the last pick-and-stick point in the k-th pick-and-stick cycle.

[0020] Furthermore, the process of obtaining candidate positions of mounting points contained in each type of component and the sorted array of initial mounting points of each type of component includes the following steps:

[0021] Step 31. Initialize the pick-up cycle count k=1; corresponding to each type of component c∈[1,…,C], initialize the array PL{c}∈[PL{1},…,PL{C}] with n{c} rows and 2 columns, which are all zero, to store the candidate positions of the mounting points contained in each type of component, and call PL{c} the candidate position array of the c-th type of component; corresponding to each type of component c∈[1,…,C], initialize the array ps0{c}∈[ps0{1},…,ps0{C}] with n{c} rows and 1 columns, which are all zero, to store the mounting point allocation order of each type of component, and call ps0{c} the allocation order array of the c-th type of component; corresponding to each type of component c∈[1,…,C], initialize the counting variable i{c}=1 as the index of the mounting point in each type of component;

[0022] Step 32: If k>K, it means that all the picking cycles have been traversed once, and step 4 is executed; otherwise, the sucking rod counting variable h=1 is initialized, and step 33 is executed;

[0023] Step 33: If h>H, it means that all suction rods have been traversed once, update the loop variable k=k+1, and return to step 32; otherwise, execute step 34;

[0024] Step 34: The type of component picked up by the h-th suction rod in the k-th picking cycle is c=CG(k,h), and whether c=0 is determined; if so, it means that the suction rod does not perform any placement in this cycle, and the loop variable h=h+1 is updated, and the process returns to step 33; otherwise, step 35 is executed;

[0025] Step 35. Assign PL{c}(i{c},1)=k, PL{c}(i{c},2)=h, assign ps0{c}(i{c})=PA0(k,h), update the counting variable i{c}=i{c}+1, update the loop variable h=h+1, and return to step 33.

[0026] Furthermore, the initialization process of performing tabu search includes the following steps:

[0027] Step 41: Initialize and assign the upper limit of local search times The symbol Indicates that the value inside it is rounded up; initializes the component type count c=1;

[0028] Step 42: If c>C, it means that all component types have been traversed once, and step 48 is performed; otherwise, step 43 is performed;

[0029] Step 43: The number of times the c-th type component can be exchanged is SWN{c}=0.5*n{c}*(n{c}-1); initialize the array SWL{c} with 2 rows and 2 columns, which are all zero elements, to store the exchange operations that the c-th type component can perform; initialize the exchange operation count swn=0; initialize the previous mounting point count ni=1;

[0030] Step 44: If ni>n{c}-1, it means that all previous placement points have been traversed once, and step 47 is performed; otherwise, the count of the subsequent placement points nj=ni+1 is initialized, and step 45 is performed;

[0031] Step 45: If nj>n{c}, it means that a traversal is completed for all the post-mounting points, and the counting variable ni=ni+1 is updated, and the process returns to step 44; otherwise, the process goes to step 46;

[0032] Step 46: Update the counting variable swn = swn + 1, SWL{c}(swn,:) = [ni,nj], update the counting variable nj = nj + 1, and return to step 45;

[0033] Step 47. Initialize an array TC{c} with the number of rows being SWN{c} and the number of columns being 1, all elements of which are zero, as the tabu list for the c-th type of component. Each element in this array indicates whether the corresponding swap operation is prohibited and the number of times it is prohibited, and the upper limit of the number of times it is prohibited is Update the counting variable c = c + 1, and return to Step 42;

[0034] Step 48. Initialize an array swb with the number of rows being C and the number of columns being 1, all elements of which are zero, to store the optimal swap operations for various types of components; Initialize an array swt with the number of rows being C and the number of columns being 1, all elements of which are zero, to store the non-prohibited optimal swap operations for various types of components.

[0035] Furthermore, compare and select the optimal result from the optimized results of the pick-and-place path based on the tabu search, then pass the newly found optimal result into the industrial control computer of the pick-and-place machine, and start from the next circuit board, and perform subsequent surface mount production based on this result; The specific process includes the following steps:

[0036] Step 51. Initialize the historical optimal pick-and-place path length DZ, the pick-and-place path length DZb of the current solution, the placement point allocation result PAb of the current solution, and the placement sorting result PSb of the current solution, and assign values DZ = DZ0, DZb = DZ0, PAb = PA0, PSb = PS0. For each type of component c ∈ [1,..., C], initialize and assign ps{c} = ps0{c}, psb{c} = ps{c} to store the optimal allocation order, initialize and assign pst{c} = ps{c} to store the non-prohibited optimal allocation order; Initialize and assign the non-improvement search counting variable IM = 0;

[0037] Step 52. If IM > IT, it means that the number of non-improvement searches has reached the upper limit, execute Step 51 to start the next round of search. Otherwise, initialize the non-prohibited shortest path length DZt to infinity, initialize the local search counting variable it = 1, and execute Step 53;

[0038] Step 53. If it > IT, it means that the number of local searches has reached the upper limit, execute Step 54. Otherwise, for each type of component c1 ∈ [1,..., C], initialize and assign psn{c1} = ps{c1}, initialize the component type counting c = 1, and execute Step 6;

[0039] Step 54. Judge whether DZb < DZ; if so, it means that a better pick-and-place path has been found, and perform Step 55. Otherwise, execute Step 56;

[0040] Step 55. Update the optimal result, and pass this optimal result into the industrial control computer of the pick-and-place machine, and start from the next circuit board, and perform subsequent surface mount production based on this result;

[0041] Step 56: Update the best results that are not banned.

[0042] Furthermore, the updating of the optimal result described in step 55 and the transmission of the optimal result to the industrial computer of the placement machine, starting from the next circuit board, the process of subsequent surface mount production based on the result includes the following steps:

[0043] Step 551, update IM=0, update the optimal results DZ=DZb, PA=PAb, PS=PSb, corresponding to each type of component c1∈[1,…,C], update ps{c1}=psb{c1}, transfer the optimal result to the SMT industrial computer, start from the next circuit board, and perform subsequent surface mount production based on the result; initialize the component type count c=1;

[0044] Step 552: If c>C, it means that all component types have been traversed once, update the counting variable IM=IM+1, and return to step 52; otherwise, initialize the exchange operation count swn=1, and execute step 553;

[0045] Step 553: If swn>SWN{c}, it means that all swap operations have been traversed once, and the counting variable c=c+1 is updated, and the process returns to step 552; otherwise, the process goes to step 554;

[0046] Step 554, update the element TC{c}(swn) in the taboo table: determine whether swn=swb(c), if so, update TC{c}(swn)=TL{c}, otherwise, TC{c}(swn)=max(TC{c}(swn)-1,0), where max represents the larger one in the array in the brackets; after the judgment is completed, update the counting variable swn=swn+1 and execute step 553.

[0047] Furthermore, the process of updating the optimal result that is not prohibited in step five or six includes the following steps:

[0048] Step 561: For each type of component c1∈[1,…,C], update ps{c1}=pst{c1}; initialize the component type count c=1;

[0049] Step 562: If c>C, it means that all component types have been traversed once, update the counting variable IM=IM+1, and return to step 52; otherwise, initialize the exchange operation count swn=1, and execute step 563;

[0050] Step 563: If swn>SWN{c}, it means that all swap operations have been traversed once, and the counting variable c=c+1 is updated, and the process returns to step 562; otherwise, the process goes to step 564;

[0051] Step 564, update the element TC{c}(swn) in the taboo table: determine whether swn=swt(c), if so, update TC{c}(swn)=TL{c}, otherwise, TC{c}(swn)=max(TC{c}(swn)-1,0); after the judgment is completed, update the counting variable swn=swn+1 and execute step 563.

[0052] Furthermore, the allocation order array of each type of component is subjected to a neighborhood search operation, and the allocation order array after the operation is decoded to obtain a new placement point allocation result, and accordingly, the optimal placement sorting result is obtained based on dynamic programming. If the new optimization result corresponds to a more optimal pick-up path, it is stored as the optimal result. The specific process includes the following steps:

[0053] Step 61: If c>C, it means that all component types have been traversed once, update the counting variable it=it+1, and return to step 53; otherwise, execute step 62;

[0054] Step 62: Randomly select the operation swi∈[1,…,SWN{c}] to be performed, then the two elements to be exchanged are ni=SWL{c}(swi,1) and nj=SWL{c}(swi,2), and the exchange is as follows psn{c}(ni)=ps{c}(nj) and psn{c}(nj)=ps{c}(ni);

[0055] Step 63: Decode the allocation order array after the exchange to obtain a new placement point allocation result;

[0056] Step 64: Initialize the dynamic programming, including the following steps:

[0057] Step 641: If k>K, proceed to step 67; otherwise, initialize the suction rod count h=1, initialize the placement coordinate count variable S=0, initialize the placement suction rod array hs to an empty array, initialize the placement coordinate array pt to an empty array, and execute step 642 to calculate all placement coordinates in this cycle;

[0058] Step 642: If h>H, execute step 644; otherwise, execute step 643;

[0059] Step 643: Get the placement point p=PAn(k,h) placed by the h-th suction rod in the k-th pick-up cycle. If p=0, do nothing. Otherwise, update the placement suction rod array hs=[hs h], update the counting variable S=S+1, update the placement coordinates pt(S,1)=xyt(p,1)–(h-1)*DI, pt(S,2)=xyt(p,2); update the counting variable h=h+1, and return to step 642;

[0060] Step 644, initialize the array dt with all zero elements and the number of rows and columns S, which is used to store the distance between each placement coordinate, and dt is called the placement distance array; initialize the array df with all zero elements and the number of rows and columns 1 and S, which is used to store the distance between each placement coordinate and the last pick-up coordinate in the k-th pick-up cycle, and df is called the pick-to-pick distance array; initialize the array dw with all zero elements and the number of rows and columns 1 and S, which is used to store the distance between each placement coordinate and the first pick-up coordinate in the k+1-th pick-up cycle, and dw is called the pick-to-pick distance array; initialize the previous placement point count s1=1;

[0061] Step 645: If s1>S, it means that all previous placement points have been traversed once, and step 640 is executed; otherwise, the count of the subsequent placement points s2=s1+1 is initialized, and step 646 is executed;

[0062] Step 646, calculate dx = |pt(s1,1)-xyql(k,1)|, dy = |pt(s1,2)-xyql(k,2)|, the symbol || means taking the absolute value of the value within it, calculate the pick-up distance df(s1) = max(dx,dy);

[0063] Step 647, calculate dx = |pt(s1,1)-xyqf(k+1,1)|, dy = |pt(s1,2)-xyqf(k+1,2)|, calculate the pick-up distance dw(s1) = max(dx,dy);

[0064] Step 648: If s2>S, it means that all the subsequent mounting points have been traversed once, and the counting variable s1=s1+1 is updated, and the process returns to step 645; otherwise, the process goes to step 649;

[0065] Step 649, calculate dx = |pt(s1,1)-pt(s2,1)|, dy = |pt(s1,2)-pt(s2,2)|, calculate the mounting distance dt(s1,s2) = dt(s2,s1) = max(dx,dy), update the counting variable s2 = s2+1, and return to step 648;

[0066] Step 640, initialize and assign the number of dynamic programming columns V = max(1, S-2); generate the full permutation from 1 to S as M, initialize and assign the array U = [1! ,…, S! ], where the symbol ! represents the factorial of the previous value; initialize the array dd with all zero elements, the number of rows, U(S), and the number of columns, V, to store the path lengths corresponding to each node of the dynamic programming, and call dd the dynamic programming distance array, and update dd(:, 1) = df(M(:, 1)) + dw(M(:, S)); initialize the permutation count u = 0, and initialize the updated leftmost column count V1 = 1; initialize the array J with all zero elements, the number of rows, 1, and the number of columns, V, as the leftmost column mark array; execute step 65;

[0067] Step 65: Obtain the optimal placement sequence in the kth pick-and-place cycle based on dynamic programming.

[0068] Furthermore, the process of decoding the swapped allocation order array to obtain a new placement point allocation result in step 63 includes the following steps:

[0069] Step 631, initialize component type count c1=1; initialize the updated placement point allocation result PAn, the updated placement sorting result PSn, and the updated pick-up path length DZn, and assign PAn=PAb, PSn=PSb, DZn=DQ to store the newly searched pick-up path optimization result;

[0070] Step 632: If c1>C, it means that all component types have been traversed once, and the pick-up cycle count k=1 is initialized, and step 64 is executed; otherwise, the placement point count ii=1 for the c1-th component is initialized, and step 633 is executed;

[0071] Step 633: If ii>n{c1}, it means that all mounting points of the c1-th type component have been traversed once, and the counting variable c1=c1+1 is updated, and the process returns to step 632; otherwise, the process goes to step 634;

[0072] Step 634: Obtain candidate positions k = PL{c1}(ii,1) and h = PL{c1}(ii,2), update the mounting point allocation result PAn(k,h) = psn{c1}(ii), update the counting variable ii = ii+1, and return to step 633.

[0073] Furthermore, the process of obtaining the optimal placement sequence in the kth pick-up and placement cycle based on dynamic programming described in step 65 includes the following steps:

[0074] Step 651: If u>U(S), it means that all permutations have been traversed once, and step 66 is executed; otherwise, step 652 is executed;

[0075] Step 652: Update the count variable u = u + 1, and initialize the updated column count v = V1;

[0076] Step 653: If v > V, it means that a traversal of all columns has been completed, execute Step 657; otherwise, execute Step 654;

[0077] Step 654: The two pick - and - place coordinate indices for which the distance is to be calculated are s1 = M(u, v) and s2 = M(u, v + 1) respectively; the maximum row number of the dynamic programming distance array to be updated is U1 = u + U(V + 1 - v) - 1; initialize u1 = u;

[0078] Step 655: If u1 > U1, update s1 = M(u, S - 1), s2 = M(u, S), dd(u, V) = dd(u, V)+dt(s1, s2), update the count variable v = v + 1, and return to Step 653; otherwise, execute Step 656;

[0079] Step 656: The minimum column number of the dynamic programming distance array to be summed is v1 = max(1, v - 1), update dd(u1, v) = sum(dd(u1, v1:v))+dt(s1, s2), where sum represents summing the array within the subsequent parentheses, update the count variable u1 = u1 + 1, and return to Step 655;

[0080] Step 657: Update J(1) = J(1)+1; initialize the updated column count v = 1;

[0081] Step 658: If v > V, V1 = V + 1 - v2, return to Step 651; otherwise, execute Step 659;

[0082] Step 659: If J(v) ≤ U(v), v2 = v, v = V + 1, return to Step 658; otherwise, execute Step 650;

[0083] Step 650: If v < V, update J(v + 1) = J(v + 1)+U(v), J(v) = 0; otherwise, do nothing; update the count variable v = v + 1, and return to Step 658;

[0084] Step 66: Obtain [dm, um] = min(dd(:, V)), where min represents taking the minimum value of the array within the subsequent parentheses, dm is the minimum pick - and - place path, um is the permutation index to achieve the minimum pick - and - place path, the optimal pick - and - place order for the k - th pick - and - place cycle is PSn(k, 1:S) = hs(M(um, :)), DZn = DZn+dm; update the count variable k = k + 1, and return to Step 641;

[0085] Step 67: Determine whether DZn < DZb; if so, update DZb = DZn, swb(c) = swi, PAb = PAn, PSb = PSn, and for each type of component c1 ∈ [1, …, C], update psb{c1} = psn{c1}; if not, do nothing;

[0086] Step 68: Determine whether TC{c}(swi) = 0 and DZn < DZt; if so, it indicates that the current swapping operation is not prohibited and the obtained result is better than the shortest path that is not prohibited. Update DZt = DZn, swt(c) = swi, and for each type of component c1 ∈ [1, …, C], update pst{c1} = psn{c1}; if not, do nothing;

[0087] Step 69: Update the counting variable c = c + 1, and return to Step 61.

[0088] The beneficial effects of the present invention are as follows:

[0089] The present invention discloses a method for online optimization of pick - and - place paths during the production of a pick - and - place machine. After quickly starting pick - and - place production based on the initial optimization result, the method optimizes the allocation order of pick - and - place points within each type of component based on the tabu search algorithm. On the basis of the obtained pick - and - place point allocation result, dynamic programming is used to obtain the optimal pick - and - place sorting result. If this result corresponds to a better pick - and - place path, subsequent surface mount production is carried out based on this result, and the above optimization is continuously performed during the production of the pick - and - place machine to maximize the pick - and - place production efficiency. It can not only solve the problem of too long pick - and - place paths caused by poor search ability for the optimal solution in the prior art, but also perform online optimization and update. Experiments show that the method provided by the present invention can significantly improve the production efficiency of the pick - and - place machine, with the maximum efficiency improvement reaching 11.78%. The optimization method provided by the present invention is generally applicable to various pick - and - place machines equipped with different pick - and - place carriers. Brief Description of the Drawings

[0090] For ease of explanation, the present invention is described in detail by the following specific embodiments and accompanying drawings.

[0091] Figure 1 Schematic diagram of a pick - and - place machine equipped with a beam - type pick - and - place carrier;

[0092] Figure 2 Flowchart of the pick - and - place process of the pick - and - place machine;

[0093] Figure 3 Schematic diagram of a pick - and - place machine equipped with a rotary pick - and - place carrier;

[0094] Figure 4 Flowchart of the pick - and - place path optimization method of the pick - and - place machine of the present invention;

[0095] Figure 5A schematic diagram of an initial picking path according to an embodiment of the present invention;

[0096] Figure 6 A schematic diagram of an improved picking path according to an embodiment of the present invention;

[0097] Figure 7 Graph showing the convergence curve of the pick-up path length according to an embodiment of the present invention. DETAILED DESCRIPTION

[0098] In order to make the purpose, technical scheme and advantages of the present invention clearer, the present invention is described below by the specific embodiments shown in the accompanying drawings. However, it should be understood that these descriptions are only exemplary and are not intended to limit the scope of the present invention. In addition, in the following description, the description of well-known structures and technologies is omitted to avoid unnecessary confusion of the concept of the present invention.

[0099] It should also be noted that, in order to avoid obscuring the present invention due to unnecessary details, only structures and / or processing steps closely related to the solutions according to the present invention are shown in the accompanying drawings, while other details that are not closely related to the present invention are omitted.

[0100] It is worth mentioning that patch carriers can be divided into two categories: beam-type patch carriers (see Figure 1 ) and rotary chip carrier (see Figure 3 ). The placement optimization of the chip mounter when using the two types of chip mount carriers is different, but both need to solve the above three problems. The present invention is applicable to both chip mounters using the two types of chip mount carriers. Figure 1 The beam-type patch carrier shown provides an example.

[0101] Specific implementation method 1: Combination Figure 4 To explain this embodiment,

[0102] This embodiment is a method for online optimization of the pick-up path while the placement machine is producing, comprising the following steps:

[0103] Step 1: Get the initial mounting process optimization result, and start surface mounting production based on the result;

[0104] The process of obtaining the initial mounting process optimization result and starting the surface mounting production based on the result includes the following steps:

[0105] Step 11, obtaining an initial placement process optimization result according to an existing placement optimization solver;

[0106] Step 1 and 2: The result is transmitted to the industrial computer of the placement machine, and surface mount production is started based on the result;

[0107] Step 13: The result is transmitted to the central processor of the non-production scheduling, and step 2 is executed, so that the pick-up path optimization result is continuously improved while the surface mount production is being carried out;

[0108] The non-production scheduling central processor may be another central processor in the industrial computer equipped with the placement machine, or may be a server or other industrial computer that is networked with the industrial computer equipped with the placement machine;

[0109] Step 2: Obtain placement machine parameters, circuit board production data, and initial pick-and-place path optimization results from the placement process optimization results;

[0110] The process of obtaining placement machine parameters, circuit board production data and initial pick-up path optimization results comprises the following steps:

[0111] Step 21, importing the parameters of the placement machine; the parameters of the placement machine include the total number of suction rods H, the index number of each suction rod is h∈[1,…,H] in increasing order along the X-axis, and the suction rod interval DI;

[0112] Step 22: Import the circuit board production data; 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 n{c}∈[n{1},…,n{C}], 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 a two-dimensional array xyt with P rows and 2 columns, wherein the X coordinate and Y coordinate of the pth mounting point are xy respectively. t(p,1) and xyt(p,2); It should be noted that the coordinates of the mounting point need to be converted to the coordinates of the fixed reference point on the mounting carrier to obtain the mounting coordinates corresponding to the mounting point; for the beam-type mounting carrier in the example of the present invention, its fixed reference point is the center point of the No. 1 suction rod. Then, when the h-th suction rod is located above the above-mentioned mounting point for mounting, the X coordinate in the mounting coordinate is xyt(p,1)–(h-1)*DI, and the Y coordinate is xyt(p,2);

[0113] Step 23, import the initial pick-up path optimization results; the total number of pick-up cycles is K, and the index number of each pick-up cycle is k∈[1,…,K]; the component allocation results are stored in a two-dimensional array CG with K rows and H columns, where the element CG(k,h) represents the component type picked up by the h-th suction rod in the k-th pick-up cycle, that is, CG(k,h)∈[1,…,C]; the placement point allocation results are stored in a two-dimensional array PA0 with K rows and H columns, where the element PA0(k,h) represents the placement point number placed by the h-th suction rod in the k-th pick-up cycle, that is, PA0(k,h)∈[1,…,P]; the placement sorting results are stored in a two-dimensional array PS0 with K rows and H columns. In which the element PS0(k,s) represents the number of the sth pick rod for placement in the kth pick-up cycle, that is, PS0(k,s)∈[1,…,H]; the pick-up path length DZ0, the pick-up path length DQ; the pick-up coordinates corresponding to the first and last pick-up points in each pick-up cycle are stored in a two-dimensional array xyqf and xyql with K rows and 2 columns, wherein the elements xyqf(k,1) and xyqf(k,2) represent the X coordinate and Y coordinate of the pick-up coordinates corresponding to the first pick-up point in the kth pick-up cycle, and the elements xyql(k,1) and xyql(k,2) represent the X coordinate and Y coordinate of the pick-up coordinates corresponding to the last pick-up point in the kth pick-up cycle;

[0114] Step 3: According to the imported initial pick-up path optimization result, the candidate positions of the mounting points contained in each type of component and the sorted array of the initial mounting points of each type of component are obtained;

[0115] The process of obtaining candidate positions of mounting points contained in various types of components and the sorted array of initial mounting points of various types of components includes the following steps:

[0116] Step 31. Initialize the pick-up cycle count k=1; corresponding to each type of component c∈[1,…,C], initialize the array PL{c}∈[PL{1},…,PL{C}] with n{c} rows and 2 columns, which are all zero, to store the candidate positions of the mounting points contained in each type of component, and call PL{c} the candidate position array of the c-th type of component; corresponding to each type of component c∈[1,…,C], initialize the array ps0{c}∈[ps0{1},…,ps0{C}] with n{c} rows and 1 columns, which are all zero, to store the mounting point allocation order of each type of component, and call ps0{c} the allocation order array of the c-th type of component; corresponding to each type of component c∈[1,…,C], initialize the counting variable i{c}=1 as the index of the mounting point in each type of component;

[0117] Step 32: If k>K, it means that all the picking cycles have been traversed once, and step 4 is executed; otherwise, the sucking rod counting variable h=1 is initialized, and step 33 is executed;

[0118] Step 33: If h>H, it means that all suction rods have been traversed once, update the loop variable k=k+1, and return to step 32; otherwise, execute step 34;

[0119] Step 34: The type of component picked up by the h-th suction rod in the k-th picking cycle is c=CG(k,h), and whether c=0 is determined; if so, it means that the suction rod does not perform any placement in this cycle, and the loop variable h=h+1 is updated, and the process returns to step 33; otherwise, step 35 is executed;

[0120] Step 35, assign PL{c}(i{c},1)=k, PL{c}(i{c},2)=h, assign ps0{c}(i{c})=PA0(k,h), update the counting variable i{c}=i{c}+1, update the loop variable h=h+1, and return to step 33;

[0121] Step 4: Initialize the taboo search;

[0122] The initialization process of performing tabu search comprises the following steps:

[0123] Step 41: Initialize and assign the upper limit of local search times The symbol Indicates that the value inside is rounded up; initializes the component type count c=1;

[0124] Step 42: If c>C, it means that all component types have been traversed once, and step 48 is performed; otherwise, step 43 is performed;

[0125] Step 43: The number of times the c-th type component can be exchanged is SWN{c}=0.5*n{c}*(n{c}-1); initialize the array SWL{c} with 2 rows and 2 columns, which are all zero elements, to store the exchange operations that the c-th type component can perform; initialize the exchange operation count swn=0; initialize the previous mounting point count ni=1;

[0126] Step 44: If ni>n{c}-1, it means that all previous placement points have been traversed once, and step 47 is performed; otherwise, the count of the subsequent placement points nj=ni+1 is initialized, and step 45 is performed;

[0127] Step 45: If nj>n{c}, it means that a traversal is completed for all the post-mounting points, and the counting variable ni=ni+1 is updated, and the process returns to step 44; otherwise, the process goes to step 46;

[0128] Step 46: Update the counting variable swn = swn + 1, SWL{c}(swn,:) = [ni,nj], update the counting variable nj = nj + 1, and return to step 45;

[0129] Step 47: Initialize an array TC{c} with rows SWN{c} and columns 1, which is all zero, as the taboo table of the c-th type element. Each element in the array indicates whether the corresponding exchange operation is forbidden and the number of times it is forbidden. The upper limit of the number of forbidden times is Update the counting variable c=c+1, and return to step 42;

[0130] Step 48, initialize an array swb with C rows and 1 columns whose elements are all zero, for storing the optimal exchange operation of each type of component; initialize an array swt with C rows and 1 columns whose elements are all zero, for storing the optimal exchange operation of each type of component that is not prohibited;

[0131] Step 5: Compare and select the optimization results of the pick-up path based on taboo search, and then transfer the newly found optimal result to the placement machine industrial computer, and start from the next circuit board, and carry out subsequent surface mount production based on the result;

[0132] The method compares and selects the optimization results of the pick-up and placement paths based on the taboo search, and then transmits the newly found optimal result to the placement machine industrial computer, and starts from the next circuit board, and performs subsequent surface placement production based on the result; the specific process includes the following steps:

[0133] Step 51: Initialize the historical optimal pick-up path length DZ, the current solution pick-up path length DZb, the current solution placement point allocation result PAb, the current solution placement sorting result PSb, and assign DZ=DZ0, DZb=DZ0, PAb=PA0, PSb=PS0. For each type of component c∈[1,…,C], initialize and assign ps{c}=ps0{c}, psb{c}=ps{c} to store the optimal allocation sequence, initialize and assign pst{c}=ps{c} to store the optimal allocation sequence that is not prohibited; initialize and assign the non-improved search count variable IM=0;

[0134] Step 52: If IM>IT, it means that the number of unimproved searches has reached the upper limit, and step 51 is executed to start the next round of search. Otherwise, the length of the shortest path DZt that is not prohibited is initialized to infinity, and the local search count variable it=1 is initialized, and step 53 is executed;

[0135] Step Five Three: If it > IT, it indicates that the local search times have reached the upper limit. Execute Step Five Four. Otherwise, for each type of component c1 ∈ [1, …, C], initialize and assign psn{c1} = ps{c1}, initialize the component type count c = 1, and execute Step Six;

[0136] Step Five Four: Determine whether DZb < DZ; if so, it indicates that a better pick-and-place path has been found. Proceed to Step Five Five. Otherwise, execute Step Five Six;

[0137] Step Five Five: Update the optimal result and transfer this optimal result to the industrial control computer of the pick-and-place machine. Starting from the next circuit board, perform subsequent surface mount production based on this result:

[0138] Step Five Five One: Update IM = 0, update the optimal result DZ = DZb, PA = PAb, PS = PSb. For each type of component c1 ∈ [1, …, C], update ps{c1} = psb{c1}. Transfer this optimal result to the industrial control computer of the pick-and-place machine. Starting from the next circuit board, perform subsequent surface mount production based on this result; initialize the component type count c = 1;

[0139] Step Five Five Two: If c > C, it indicates that a traversal of all component types has been completed. Update the counting variable IM = IM + 1, and return to Step Five Two. Otherwise, initialize the swap operation count swn = 1, and execute Step Five Five Three;

[0140] Step Five Five Three: If swn > SWN{c}, it indicates that a traversal of all swap operations has been completed. Update the counting variable c = c + 1, and return to Step Five Five Two. Otherwise, execute Step Five Five Four;

[0141] Step Five Five Four: Update the element TC{c}(swn) in the taboo list: Determine whether swn = swb(c); if so, update TC{c}(swn) = TL{c}. Otherwise, TC{c}(swn) = max(TC{c}(swn) - 1, 0), where max represents taking the larger value in the array within the subsequent parentheses; after the determination, update the counting variable swn = swn + 1, and execute Step Five Five Three;

[0142] Step Five Six: Update the optimal result that is not prohibited:

[0143] Step Five Six One: For each type of component c1 ∈ [1, …, C], update ps{c1} = pst{c1}; initialize the component type count c = 1;

[0144] Step Five Six Two: If c > C, it indicates that a traversal of all component types has been completed. Update the counting variable IM = IM + 1, and return to Step Five Two. Otherwise, initialize the swap operation count swn = 1, and execute Step Five Six Three;

[0145] Step 563: If swn>SWN{c}, it means that all swap operations have been traversed once, and the counting variable c=c+1 is updated, and the process returns to step 562; otherwise, the process goes to step 564;

[0146] Step 564, update the element TC{c}(swn) in the taboo table: determine whether swn=swt(c), if so, update TC{c}(swn)=TL{c}, otherwise, TC{c}(swn)=max(TC{c}(swn)-1,0); after the determination is completed, update the counting variable swn=swn+1, and execute step 563;

[0147] Step 6: Perform a neighborhood search operation on the allocation order array of each type of component, decode the allocation order array after the operation, and obtain a new placement point allocation result. Correspondingly, obtain the optimal placement sorting result based on dynamic programming. If the new optimization result corresponds to a better picking path, it will be stored as the optimal result.

[0148] The allocation order array of each type of component is subjected to a neighborhood search operation, and the allocation order array after the operation is decoded to obtain a new placement point allocation result, and accordingly, the optimal placement sorting result is obtained based on dynamic programming. If the new optimization result corresponds to a more optimal pick-up path, it is stored as the optimal result; the specific process includes the following steps:

[0149] Step 61: If c>C, it means that all component types have been traversed once, update the counting variable it=it+1, and return to step 53; otherwise, execute step 62;

[0150] Step 62: Randomly select the operation swi∈[1,…,SWN{c}] to be performed, then the two elements to be exchanged are ni=SWL{c}(swi,1) and nj=SWL{c}(swi,2), and the exchange is as follows psn{c}(ni)=ps{c}(nj) and psn{c}(nj)=ps{c}(ni);

[0151] Step 6.3: Decode the swapped allocation order array to obtain a new placement point allocation result:

[0152] Step 631, initialize component type count c1=1; initialize the updated placement point allocation result PAn, the updated placement sorting result PSn, and the updated pick-up path length DZn, and assign PAn=PAb, PSn=PSb, DZn=DQ to store the newly searched pick-up path optimization result;

[0153] Step 632: If c1>C, it means that all component types have been traversed once, and the pick-up cycle count k=1 is initialized, and step 64 is executed; otherwise, the placement point count ii=1 for the c1-th component is initialized, and step 633 is executed;

[0154] Step 633: If ii>n{c1}, it means that all mounting points of the c1-th type component have been traversed once, and the counting variable c1=c1+1 is updated, and the process returns to step 632; otherwise, the process goes to step 634;

[0155] Step 634, obtain candidate positions k = PL{c1}(ii,1), h = PL{c1}(ii,2), update the mounting point allocation result PAn(k,h) = psn{c1}(ii), update the counting variable ii = ii+1, and return to step 633;

[0156] Step 64: Initialize dynamic programming:

[0157] Step 641: If k>K, it means that all the pick-up cycles have been traversed once, and step 67 is performed; otherwise, the suction rod count h=1 is initialized, the placement coordinate count variable S=0 is initialized, the placement suction rod array hs is initialized as an empty array, the placement coordinate array pt is initialized as an empty array, and step 642 is performed to calculate all the placement coordinates in this cycle;

[0158] Step 642: If h>H, it means that all suction rods have been traversed once, and step 644 is executed; otherwise, step 643 is executed;

[0159] Step 643: Get the placement point p=PAn(k,h) placed by the h-th suction rod in the k-th pick-up cycle. If p=0, do not process it. Otherwise, update the placement suction rod array hs=[hs h], that is, add a new element h to the current placement suction rod array hs, update the counting variable S=S+1, update the placement coordinates pt(S,1)=xyt(p,1)–(h-1)*DI, pt(S,2)=xyt(p,2); update the counting variable h=h+1, and return to step 642;

[0160] Step 644, initialize the array dt with all zero elements and the number of rows and columns S, which is used to store the distance between each placement coordinate, and dt is called the placement distance array; initialize the array df with all zero elements and the number of rows and columns 1 and S, which is used to store the distance between each placement coordinate and the last pick-up coordinate in the k-th pick-up cycle, and df is called the pick-to-pick distance array; initialize the array dw with all zero elements and the number of rows and columns 1 and S, which is used to store the distance between each placement coordinate and the first pick-up coordinate in the k+1-th pick-up cycle, and dw is called the pick-to-pick distance array; initialize the previous placement point count s1=1;

[0161] Step 645: If s1>S, it means that all previous placement points have been traversed once, and step 640 is executed; otherwise, the count of the subsequent placement points s2=s1+1 is initialized, and step 646 is executed;

[0162] Step 646, calculate dx = |pt(s1,1)-xyql(k,1)|, dy = |pt(s1,2)-xyql(k,2)|, the symbol || means taking the absolute value of the value within it, calculate the pick-up distance df(s1) = max(dx,dy);

[0163] Step 647, calculate dx = |pt(s1,1)-xyqf(k+1,1)|, dy = |pt(s1,2)-xyqf(k+1,2)|, calculate the pick-up distance dw(s1) = max(dx,dy);

[0164] Step 648: If s2>S, it means that all the subsequent mounting points have been traversed once, and the counting variable s1=s1+1 is updated, and the process returns to step 645; otherwise, the process goes to step 649;

[0165] Step 649, calculate dx = |pt(s1,1)-pt(s2,1)|, dy = |pt(s1,2)-pt(s2,2)|, calculate the mounting distance dt(s1,s2) = dt(s2,s1) = max(dx,dy), update the counting variable s2 = s2+1, and return to step 648;

[0166] Step 640, initialize and assign the number of dynamic programming columns V = max(1, S-2); generate the full permutation from 1 to S as M, initialize and assign the array U = [1! ,…, S! ], where the symbol ! represents the factorial of the previous value (taking S = 3 as an example, M = [12 3; 1 32; 2 1 3; 2 3 1; 3 1 2; 3 2 1], U = [1, 2, 6]); initialize the array dd with the number of rows and columns of all zero elements as U(S) and V, which is used to store the path lengths corresponding to each node of the dynamic programming, and dd is called the dynamic programming distance array, and update dd(:, 1) = df(M(:, 1)) + dw(M(:, S)); initialize the permutation count u = 0, and initialize the updated leftmost column count V1 = 1; initialize the array J with the number of rows and columns of all zero elements as 1 and V as the leftmost column mark array; execute step 65;

[0167] Step 65: Get the optimal placement sequence in the kth pick-up cycle based on dynamic programming:

[0168] Step 651: If u>U(S), it means that all permutations have been traversed once, and step 66 is executed; otherwise, step 652 is executed;

[0169] Step 652: Update the counting variable u = u + 1, and initialize the updated column count v = V1;

[0170] Step 653: If v > V, it means that a traversal of all columns has been completed, execute Step 657; otherwise, execute Step 654;

[0171] Step 654: The two pick - and - place coordinate indices for which the distance is to be calculated are s1 = M(u, v) and s2 = M(u, v + 1) respectively; the maximum row number to be updated in the dynamic programming distance array is U1 = u + U(V + 1 - v)-1; initialize u1 = u;

[0172] Step 655: If u1 > U1, update s1 = M(u, S - 1), s2 = M(u, S), dd(u, V)=dd(u, V)+dt(s1, s2), update the counting variable v = v + 1, and return to Step 653; otherwise, execute Step 656;

[0173] Step 656: The minimum column number for which the sum in the dynamic programming distance array is to be calculated is v1 = max(1, v - 1), update dd(u1, v)=sum(dd(u1, v1:v))+dt(s1, s2), where sum represents the sum of the array in the subsequent parentheses, update the counting variable u1 = u1 + 1, and return to Step 655;

[0174] Step 657: Update J(1)=J(1)+1; initialize the updated column count v = 1;

[0175] Step 658: If v > V, V1 = V + 1 - v2, return to Step 651; otherwise, execute Step 659;

[0176] Step 659: If J(v)≤U(v), v2 = v, v = V + 1, return to Step 658; otherwise, execute Step 650;

[0177] Step 650: If v < V, update J(v + 1)=J(v + 1)+U(v), J(v)=0; otherwise, do nothing; update the counting variable v = v + 1, and return to Step 658;

[0178] Step 66: Obtain [dm, um]=min(dd(:, V)), where min represents taking the minimum value of the array in the subsequent parentheses, dm is the minimum pick - and - place path, um is the permutation index to achieve the minimum pick - and - place path, the optimal pick - and - place order for the k - th pick - and - place cycle is PSn(k, 1:S)=hs(M(um, :)), DZn = DZn+dm; update the counting variable k = k + 1, and return to Step 641;

[0179] Step 67: Determine whether DZn < DZb; if so, update DZb = DZn, swb(c) = swi, PAb = PAn, PSb = PSn, and for each type of component c1 ∈ [1,…,C], update psb{c1} = psn{c1}; if not, do nothing;

[0180] Step 68: Determine whether TC{c}(swi) = 0 and DZn < DZt; if so, it means that the current exchange operation is not prohibited and the obtained result is better than the shortest path that is not prohibited. Update DZt = DZn, swt(c) = swi, and for each type of component c1 ∈ [1,…,C], update pst{c1} = psn{c1}; if not, do nothing;

[0181] Step 69: Update the counting variable c = c + 1 and return to Step 61.

[0182] Example 1:

[0183] A method for online optimization of the pick-and-place path during the production of a pick-and-place machine in this example is specifically prepared according to the following steps:

[0184] The example considers the pick-and-place optimization process of a six-nozzle beam-type pick-and-place head on a pick-and-place machine.

[0185] The production data of the circuit board that needs to be imported is listed in Table 1, where there are two types of components, and each type of component has 50 placement points.

[0186] Table 1 Circuit board production data

[0187]

[0188]

[0189] In the initial pick-and-place path optimization result, the placement point allocation result PA0 and the placement sorting result PS0 are as follows:

[0190]

[0191] It can be obtained therefrom that the placement point allocation order arrays of the two types of components are

[0192] ps0{1} = [36 22 27 31 10 29 46 9 30 41 5 26 32 25 28 37 21 23 33 24 438 3 15 42 14 8 47 16 2 39 13 7 34 17 1 43 12 6 48 18 50 40 45 11 35 19 20 4449]

[0193] ps0{2}=[79 77 90 80 75 85 78 60 98 71 76 93 73 74 84 55 72 8954 598365 53 8858 64 92 52 66 97 57 63 87 51 67 82 56 62 91 100 68 96 61 95 86 7069 81 99 94]

[0194] The initial pick-up path is as follows Figure 5 As shown, its length is DZ0=6308.7mm.

[0195] Based on the method of the present invention, after ten rounds of searching, the optimal pick-up and placement path results, the placement point allocation result PA and the placement sorting result PS are as follows:

[0196]

[0197] Correspondingly, the order array of placement point allocation for the two types of components is

[0198] ps{1}=[17 42 14 34 37 25 31 6 22 39 43 27 46 50 24 15 38 30 47 7 2845 12 21 49 16 29 4140 1 36 13 26 35 9 2 48 8 4 19 44 5 33 20 23 32 11 3 1810]

[0199] ps{2}=[74 88 70 71 65 100 54 66 82 55 67 89 53 86 56 63 84 85 80 5899 64 92 95 72 6897 76 94 91 51 93 87 77 90 98 79 59 96 78 69 83 73 57 62 5261 81 75 60]

[0200] Pick up the path such as Figure 6 As shown, its length is DZ=5565.5mm.

[0201] In the process of search improvement, the change of the picking path length is as follows Figure 7 In the above embodiment, the present invention can improve the pick-up path by 100%*(DZ-DZ0) / DZ0=11.78%.

[0202] The results of the online optimization of the picking and pasting path by the present invention are as follows: Figures 5 to 7 As shown, Figure 5 is a schematic diagram of the initial picking path. Figure 6 This is a schematic diagram of the improved picking path; Figure 7 Graph showing the convergence curve of the pick-up path length according to an embodiment of the present invention.

[0203] After the present invention quickly carries out the mounting production based on the initial optimization results, the taboo search algorithm is used to optimize the mounting point allocation order in each type of component. Based on the searched mounting point allocation results, dynamic programming is used to obtain the optimal mounting sorting result. If the result corresponds to a more optimal pick-up path, subsequent surface mounting production is carried out based on the result. The above optimization is continuously performed while the mounting machine is in production to maximize the mounting production efficiency. Experiments show that the method provided by the present invention can greatly improve the production efficiency of the mounting machine, with the maximum efficiency improvement reaching 11.78%. The optimization method provided by the present invention is generally applicable to various types of mounting machines equipped with different mounting carriers.

[0204] Specifically, the present invention has the following two characteristics:

[0205] (1) The present invention proposes an online optimization framework for the pick-and-stick path, which realizes the continuous improvement of the pick-and-stick path to achieve the optimal solution during the surface mount production process without having to interrupt production to adjust resource allocation and reduce the requirements for real-time calculation, thereby continuously improving subsequent production efficiency.

[0206] (2) The present invention has a stronger optimal solution search capability. It optimizes the placement point allocation order within each type of component through taboo search, and directly finds the optimal placement sorting result using dynamic programming. It can more robustly approach the global optimal solution on the basis of narrowing the search space.

[0207] The present invention may also have many other embodiments. Without departing from the spirit and essence of the present invention, those skilled in the art may make various corresponding changes and modifications based on the present invention, but these corresponding changes and modifications should all fall within the scope of protection of the claims attached to the present invention.

Claims

1. A method for online optimization of the pick-up and placement path during production of a placement machine, characterized in that: The following steps are involved: Step 1: Obtain the initial optimization result of the mounting process according to the mounting optimization solver of the mounting machine, and transfer the optimization result of the mounting process to the industrial computer of the mounting machine to start the surface mounting production; Step 2: Obtain placement machine parameters, circuit board production data, and initial pick-and-place path optimization results from the placement process optimization results; Step 3: According to the imported initial pick-up path optimization result, the candidate positions of the mounting points contained in each type of component and the sorted array of the initial mounting points of each type of component are obtained; including the following steps: Step 3.

1. Initialize the pick-up cycle count k=1; corresponding to each type of component c∈[1 ,…, C], the total number of component types is C, and the number of rows with all initialized elements zero is n {c}, array with 2 columns PL {c}∈[ PL {1} ,…,PL {C}], used to store candidate locations of mounting points for various components. PL {c} is called the candidate position array of the c-th type element; corresponding to each type of element c∈[1 ,…, C], the number of rows whose initialization elements are all zero is n {c}, array with 1 column ps0 {c}∈[ ps0 {1} ,…,ps0 {C}], used to store the order of placement points of various components. ps0 {c} is called the allocation order array of the c-th type of components; corresponding to each type of component c∈[1 ,…, C], initialize the count variable i {c}=1, as the index of the mounting point in each type of component; Step 32: If k>K, it means that all the picking cycles have been traversed once, and step 4 is executed; otherwise, the sucking rod counting variable h=1 is initialized, and step 33 is executed; Step 33: If h>H, it means that all suction rods have been traversed once, update the loop variable k=k+1, and return to step 32; otherwise, execute step 34; Step 3 and 4: The type of component picked up by the hth suction rod in the kth picking cycle is c= CG (k,h), determine whether c=0; if so, it means that the suction rod does not perform any placement in this cycle, update the loop variable h=h+1, and return to step 33; otherwise, execute step 35; Step 35: Assignment PL {c}( i {c},1)=k, PL {c}( i {c},2)=h, assignment ps0 {c}( i {c})= PA0 (k,h), update the count variable i {c}= i {c}+1, update loop variable h=h+1, and return to step 33; Step 4: Initialize the taboo search; including the following steps: Step 41: Initialize and assign the local search limit IT=⌈(P) 0.5 ⌉, where the symbol ⌈⌉ means rounding up the value inside it; initialize the component type count c=1; Step 42: If c>C, it means that all component types have been traversed once, and step 48 is performed; otherwise, step 43 is performed; Step 4.3: The number of times the c-th type element can be exchanged is SWN {c}=0.5* n {c}*( n {c}-1); the number of rows whose initialization elements are all zero is SWN {c}, array with 2 columns SWL {c}, used to store the exchange operations that can be performed on the c-th type of components; initialize the exchange operation count swn =0; Initialize the previous placement point count ni =1; Step 44: If ni > n {c}-1, indicating that all previous placement points have been traversed once, and step 47 is performed. Otherwise, the count of the subsequent placement points is initialized. nj = ni +1, execute steps 4 and 5; Step 4.5: If nj > n {c}, indicating that a traversal has been completed for all the post-installation points, and the count variable is updated ni = ni +1, return to step 44, otherwise, execute step 46; Step 46: Update the count variable swn = swn +1, SWL {c}( swn ,:)=[ ni , nj ], update the count variable nj = nj +1, return to step 4 and 5; Step 47: The number of rows with all initialized elements set to zero is SWN {c}, array with 1 column TC {c}, as the taboo table of the c-th type element, each element in the array indicates whether the corresponding exchange operation is forbidden and the number of times it is forbidden. The upper limit of the number of forbidden times is TL{c}=⌈( n {c}) 0.5 ⌉; Update the counting variable c = c + 1, and return to step 42; Step 48: Initialize an array with C rows and 1 columns with all zero elements swb , used to store the optimal swap operations for various components; initialize an array with C rows and 1 columns with all zero elements swt , used to store the optimal exchange operations of various components that are not prohibited; Step 5: Compare and select the optimization results of the pick-up path based on taboo search, and then transfer the newly found optimal result to the placement machine industrial computer, and start from the next circuit board, and carry out subsequent surface mount production based on the result; including the following steps: Step 51: Initialize the historical optimal picking path length DZ , the length of the current solution's path ZGar , the current solution of the mounting point allocation result PAb , the current solution of the placement sorting result PsB , and assign DZ = ZO , ZGar = ZO , PAb = PA0 , PsB = PS0 , corresponding to each type of element c∈[1 ,…, C], initialize and assign ps {c}= ps0 {c}, psb {c}= ps {c}, used to store the optimal allocation order, initialize and assign values pst {c}= ps {c} is used to store the optimal allocation order that is not prohibited; initialize and assign the non-improved search count variable IM=0; Step 52: If IM>IT, it means that the number of unimproved searches has reached the upper limit, and step 51 is executed to start the next round of search. Otherwise, initialize the shortest path length that is not banned. ZGar is infinite, initialize the local search count variable it=1, and execute step 53; Step 53: If it>IT, it means that the number of local searches has reached the upper limit, and execute step 54; otherwise, for each type of component c1∈[1 ,…, C], initialize and assign psn {c1}= ps {c1}, initialize the component type count c=1, and execute step 6; Step 54: Determine whether there is ZGar < DZ ; If yes, it means that a better path for picking up stickers has been found, and step 55 is performed; otherwise, step 56 is performed; Step 55: Update the optimal result and transfer it to the SMT industrial computer. Starting from the next circuit board, subsequent surface mount production is carried out based on the result. Step 56: Update the best results that are not banned; Step 6: Perform a neighborhood search operation on the allocation order array of each type of component, decode the allocation order array after the operation, and obtain a new placement point allocation result. Correspondingly, obtain the optimal placement sorting result based on dynamic programming. If the new optimization result corresponds to a better picking path, it will be stored as the optimal result.

2. The method for online optimization of the pick-up and placement path during production of a placement machine according to claim 1, characterized in that: The process of obtaining placement machine parameters, circuit board production data and initial pick-up path optimization results comprises the following steps: Step 21: Import the placement machine parameters; the placement machine parameters include the total number of suction rods H, and the index number of each suction rod is h∈[1 ,…, H], suction rod spacing DI ; Step 22: Import the circuit board production data; 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 n {c}∈[ n {1} ,…,n {C}], 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 point are stored in a two-dimensional array with P rows and 2 columns xyt , where the X coordinate and Y coordinate of the pth mounting point are xyt (p,1) and xyt (p,2); The coordinates of the mounting point need to be converted to the coordinates of the fixed reference point on the mounting carrier, which is the mounting coordinates corresponding to the mounting point; Step 2 and 3: Import the initial pick-up path optimization result; the total number of pick-up cycles is K, and the index number of each pick-up cycle is k∈[1 ,…, K]; the component allocation results are stored in a two-dimensional array with K rows and H columns CG , where the elements CG (k,h) represents the type of component picked up by the h-th suction rod in the k-th picking cycle, that is, CG (k,h)∈[1 ,…, C]; the placement point allocation results are stored in a two-dimensional array with K rows and H columns PA0 The elements PA0 (k,h) represents the placement point number placed by the h-th suction rod in the k-th pick-up cycle, that is, PA0 (k,h)∈[1 ,…, P]; the placement sorting results are stored in a two-dimensional array with K rows and H columns PS0 The elements PS0 (k,s) represents the number of the sth pick rod for placement in the kth pick-up cycle, that is, PS0 (k,s)∈[1 ,…, H]; Pick-up path length ZO , pick path length DQ ; The picking coordinates corresponding to the first and last picking points in each picking cycle are stored in a two-dimensional array with K rows and 2 columns. xy and xyq The elements xy (k,1) and xy (k,2) represents the X and Y coordinates of the first pick-up point in the kth pick-up cycle. xyq (k,1) and xyq (k, 2) represents the X coordinate and Y coordinate of the picking coordinate corresponding to the last picking point in the kth picking cycle.

3. The method for online optimization of the pick-up and placement path during production of a placement machine according to claim 1, characterized in that: Step 55: updating the optimal result and transferring the optimal result to the SMT industrial computer. Starting from the next circuit board, the process of subsequent surface mount production based on the result includes the following steps: Step 551: Update IM=0 and update the optimal result DZ = ZGar , PA = PAb , PS = PsB , corresponding to each type of element c1∈[1 ,…, C], Update ps {c1}= psb {c1}, transfer the optimal result to the SMT industrial computer, and start from the next circuit board, and carry out subsequent surface mount production based on the result; initialize the component type count c=1; Step 552: If c>C, it means that all component types have been traversed once, update the counting variable IM=IM+1, and return to step 52; otherwise, initialize the exchange operation count. swn =1, execute step 553; Step 553: If swn > SWN {c}, indicating that a traversal of all exchange operations has been completed, the counting variable c=c+1 is updated, and the process returns to step 552; otherwise, the process executes step 554; Step 554: Update the elements in the taboo table TC {c}( swn ): Determine whether there is swn = swb (c) If yes, update TC {c}( swn )=TL{c}, otherwise, TC {c}( swn )=max( TC {c}( swn )-1,0), where max means taking the larger one in the array in the brackets; after the judgment is completed, update the count variable swn = swn +1, execute step 553.

4. The method for online optimization of the pick-up and placement path during production of a placement machine according to claim 3, characterized in that: The process of updating the optimal result that is not banned as described in step five or six includes the following steps: Step 561. For each type of component c1∈[1 ,…, C], Update ps {c1}= pst {c1}; Initialize component type count c=1; Step 562: If c>C, it means that all component types have been traversed once, update the counting variable IM=IM+1, and return to step 52; otherwise, initialize the exchange operation count. swn =1, execute step 563; Step 563: If swn > SWN {c}, indicating that all exchange operations have been traversed once, the counting variable c=c+1 is updated, and the process returns to step 562. Otherwise, the process executes step 564. Step 564: Update the elements in the taboo table TC {c}( swn ): Determine whether there is swn = swt (c) If yes, update TC {c}( swn )=TL{c}, otherwise, TC {c}( swn )=max( TC {c}( swn )-1,0); judgment completed, update the count variable swn = swn +1, execute step 563.

5. A method for online optimization of the pick-up and placement path during production of a placement machine according to claim 1, 3 or 4, characterized in that: The allocation order array of each type of component is subjected to a neighborhood search operation, and the allocation order array after the operation is decoded to obtain a new placement point allocation result, and accordingly, an optimal placement sorting result is obtained based on dynamic programming. If the new optimization result corresponds to a more optimal pick-up path, it is stored as the optimal result; The specific process includes the following steps: Step 61: If c>C, it means that all component types have been traversed once, update the counting variable it=it+1, and return to step 53; otherwise, execute step 62; Step 62: Randomly select the operation to be performed swi ∈[1 ,…,SWN {c}], the two elements to be swapped are ni = SWL {c}( swi ,1), nj = SWL {c}( swi ,2), the exchange is as follows psn {c}( ni )= ps {c}( nj ), psn {c}( nj )= ps {c}( ni ); Step 63: Decode the allocation order array after the exchange to obtain a new placement point allocation result; Step 64: Initialize the dynamic programming, including the following steps: Step 641: If k>K, proceed to step 67; otherwise, initialize the suction rod count h=1, initialize the placement coordinate count variable S=0, and initialize the placement suction rod array. hs It is an empty array, which initializes the mounting coordinate array. pt If it is an empty array, execute step 642 to calculate all the placement coordinates in this cycle; Step 642: If h>H, execute step 644; otherwise, execute step 643; Step 643: Get the placement point p placed by the hth suction rod in the kth pick-up cycle = PAn (k,h), if p=0, no processing, otherwise, update the placement suction rod array hs =[ hs h], update the count variable S=S+1, and update the placement coordinates pt (S,1)= xyt (p,1)– (h-1)* DI , pt (S,2)= xyt (p,2); Update the counting variable h=h+1, and return to step 642; Step 644: Initialize an array with all zero elements and S rows and columns dt , used to store the distance between each mounting coordinate, dt It is called the mounting distance array; the array with 1 row and S columns whose elements are initialized to all zeros df , used to store the distance between each placement coordinate and the last pick coordinate in the kth pick cycle. df It is called the pick-up-and-paste distance array; the array with 1 row and S columns whose elements are initialized to all zeros dw , used to store the distance between each placement coordinate and the first pick-up coordinate in the k+1th pick-up cycle. dw It is called the paste-to-pickup distance array; initialize the first paste point count s1=1; Step 645: If s1>S, it means that all previous placement points have been traversed once, and step 640 is executed; otherwise, the count of the subsequent placement points s2=s1+1 is initialized, and step 646 is executed; Step 646: Calculation dx =| pt (s1,1)- xyq (k,1)|, dy =| pt (s1,2)- xyq (k,2)|, the symbol || means taking the absolute value of the value inside it and calculating the pick-up and transfer distance df (s1)=max( dx , dy ); Step 647: Calculation dx =| pt (s1,1)- xy (k+1,1)|、 dy =| pt (s1,2)- xy (k+1,2)|, calculate the distance between sticking and picking up dw (s1)=max( dx , dy ); Step 648: If s2>S, it means that all the subsequent mounting points have been traversed once, and the counting variable s1=s1+1 is updated, and the process returns to step 645; otherwise, the process goes to step 649; Step 649: Calculation dx =| pt (s1,1)- pt (s2,1)|, dy =| pt (s1,2)- pt (s2,2)|, calculate the mounting distance dt (s1,s2)= dt (s2,s1)=max( dx , dy ), update the counting variable s2=s2+1, and return to step 648; Step 640: Initialize and assign the number of dynamic programming columns V=max(1,S-2); generate the full permutation from 1 to S as M, initialize and assign the array U=[1! ,…, S!], where the symbol ! means factorial of the previous value; initialize the array with all zero elements, the number of rows is U(S), and the number of columns is V dd , used to store the path length corresponding to each node in the dynamic programming, dd It is called the dynamic programming distance array, and updates dd (:,1)= df (M(:,1))+ dw (M(:,S)); Initialize the permutation count u=0, initialize the updated leftmost column count V1=1; Initialize the array J with 1 row and V columns whose elements are all zero as the leftmost column mark array; Execute step 65; Step 65: Obtain the optimal placement sequence in the kth pick-and-place cycle based on dynamic programming.

6. The method for online optimization of the pick-up and placement path during production of a placement machine according to claim 5, characterized in that: The process of decoding the swapped allocation order array to obtain a new placement point allocation result as described in step 63 includes the following steps: Step 631: Initialize component type count c1 = 1; Initialize the updated placement point allocation result PAn , Update the placement sorting results Psn , Update the length of the path to pick up the sticker ZGar , and assign PAn = PAb , Psn = PsB , ZGar = DQ , used to store the newly searched picking path optimization results; Step 632: If c1>C, it means that all component types have been traversed once, and the pick-up cycle count k=1 is initialized, and step 64 is executed. Otherwise, the placement point count of the c1th component is initialized. ii =1, execute step 633; Step 633: If ii > n {c1}, indicating that all mounting points of the c1-th type component have been traversed once, the counting variable c1=c1+1 is updated, and the process returns to step 632; otherwise, the process executes step 634; Step 634: Get candidate position k= PL {c1}( ii ,1) h= PL {c1}( ii ,2), Update the mounting point allocation results PAn (k,h)= psn {c1}( ii ), update the count variable ii = ii +1, return to step 633.

7. The method for online optimization of the pick-up and placement path during production of a placement machine according to claim 6, characterized in that: The process of obtaining the optimal placement sequence in the kth pick-up cycle based on dynamic programming described in step 65 includes the following steps: Step 651: If u>U(S), it means that all permutations have been traversed once, and step 66 is executed; otherwise, step 652 is executed; Step 652: Update the count variable u=u+1, and initialize the update column count v=V1; Step 653: If v>V, it means that all columns have been traversed once, and step 657 is executed; otherwise, step 654 is executed; Step 654, the two mounting coordinate indexes of the spacing to be calculated are s1=M(u,v) and s2=M(u,v+1); the maximum row number to be updated in the dynamic programming distance array is U1=u+U(V+1-v)-1; initialize u1=u; Step 655: If u1>U1, update s1=M(u,S-1), s2=M(u,S), dd (u,V)= dd (u,V)+ dt (s1, s2), update the counting variable v = v + 1, return to step 653, otherwise, execute step 656; Step 656: Dynamically program the distance array to be summed up to find the minimum column number v1=max(1,v-1), update dd (u1,v)=sum( dd (u1,v1:v))+ dt (s1, s2), where sum represents the sum of the array in the brackets behind it, updates the counting variable u1=u1+1, and returns to step 655; Step 657: Update J(1) = J(1) + 1; Initialize the update column count v = 1; Step 658: If v > V, V1 = V + 1 - v2, return to Step 651, otherwise, execute Step 659; Step 659: If J(v) ≤ U(v), v2 = v, v = V + 1, return to Step 658, otherwise, execute Step 660; Step 660: If v < V, update J(v + 1) = J(v + 1) + U(v), J(v) = 0, otherwise, do nothing; Update the count variable v = v + 1, return to Step 658; Step 66: Get dm , um ]=min( dd (:,V)), min means taking the minimum value of the array in the brackets. dm is the minimum picking path, um To achieve the minimum permutation index of the pick-up path, the optimal placement order for the kth pick-up cycle is PSn (k,1:S)= hs (M( um ,:)), DZn = DZn + dm ; Update the counting variable k = k + 1, and return to step 641; Step 67: Determine whether there is DZn < DZb If yes, update DZb = DZn, swb (c)= swi, PAb = PAn , PSb = PSn , corresponding to each type of element c1∈[1 ,…, C], Update psb {c1}= psn {c1}, if not, no processing is done; Step 68: Determine whether there is TC {c}( swi )=0 and DZn < DZt If yes, it means that the current exchange operation is not prohibited, and the result is better than the shortest path that is not prohibited, update DZt = DZn, swt (c)= swi , corresponding to each type of element c1∈[1 ,…, C], Update pst {c1}= psn {c1}, if not, no processing is done; Step 69: Update the count variable c = c + 1, return to Step 61.

Images