paperbot_ee_autoroute/dwg_w_layers.dxf → EEME_design/dwg_w_layers.dxf

@@ -53,7 +53,7 @@ $HANDLING
   9
 $TDUPDATE
  40
-2458725.597546296
+2458726.6778472224
   9
 $HANDSEED
   5

paperbot_ee_autoroute/ee_dwg_processing.py → EEME_design/ee_dwg_processing.py

@@ -148,7 +148,7 @@ class post_process():
         self.cross_cut_size=cross_size#mm
         self.trace_cut_width=0.25 #mm
         self.convert_unitfrom_ses()
-        self.draw_wires()
+
         
         ## flatten pin_at_array
         self.pin_at=[]
@@ -157,9 +157,7 @@ class post_process():
                 self.pin_at.append(pin)
         
         self.remove_redun_wire(0.4)
-        print(self.wiring)
         self.modify_wire_and_merge()
-        print(self.wiring)
         
         if not self.cross_cut_size==0:
             self.draw_cross_cut(self.cross_cut_size)
@@ -172,7 +170,7 @@ class post_process():
                 raise Exception ('Isolation box size is required as long as trace width is not equal to zero')
             else:    
                 self.draw_complete_traces()
-                self.draw_wires()
+
                 self.draw_rest_iso(self.iso_size,self.trace_cut_width)
 
         self.dwg.saveas('dwg_w_circuit.dxf')
@@ -227,12 +225,21 @@ class post_process():
             endpoints=[path[0],path[-1]]
             for j in range(len(endpoints)):
                 ept=endpoints[j]
-                if j==1:k=-1
-                else:k=0              
-                for pin in self.pin_at:
-                    if distance_between_pts(ept,pin)<=(self.iso_size/2)*sqrt(2):
-                        self.wiring[i][k]=pin
-                        break
+                if j==1:
+                    k=-1
+                    kk=-2
+                else:
+                    k=0
+                    kk=1
+                if len(path)>1:
+                    further_ept=path[kk]              
+                    for pin in self.pin_at:
+                        if point_within_pinbox(ept,pin,self.iso_size):
+                            self.wiring[i][k]=pin
+                            if point_within_pinbox(further_ept,pin,self.iso_size):
+                                self.wiring[i].pop(kk)
+                            break
+               
         path_list=copy.deepcopy(self.wiring)
         self.wiring=[]
         while len(path_list)!=0:
@@ -332,8 +339,9 @@ class post_process():
                                     dis=[]
                                     for off_line in offset_lines:
                                         inter=find_intersect(l2,off_line)
-                                        dis_=distance_between_pts(further_ept,inter)
-                                        dis.append(dis_)
+                                        if type(inter)!=type(None):
+                                            dis_=distance_between_pts(further_ept,inter)
+                                            dis.append(dis_)
                                     off_l=offset_lines[np.argmin(dis)]
                                     off_l2in,off_l2out=find_offset(l2,width)
                                     s_=find_intersect(off_l2in,off_l)
@@ -370,51 +378,6 @@ class post_process():
             path_cp=copy.deepcopy(path)
             constrain_s,constrain_e=True,True
             
-            # pop and constrain
-            if [path_index,0] in self.path_at_pin:
-                connect_index=self.path_at_pin.index([path_index,0])
-                pin=self.connected_pins[connect_index]
-                if not distance_between_pts(path[0],pin)==0:
-                    constrain_s=False
-                    warnings.warn('Found wire endpoint not connected to pin exactly, check wire modify in post-process if error')
-                
-                pop_flag=True
-                lt=find_line_eq(path[0],path[1])
-                iso_l_pts=isolation_box_linepts(self.iso_size,pin)
-                for l_pts in iso_l_pts:
-                    pt1=l_pts[0]
-                    pt2=l_pts[1]
-                    l=find_line_eq(pt1,pt2)
-                    inter=find_intersect(l,lt)
-                    if type(inter)!=type(None) and if_pts_on_interval(inter,path[0],path[1]):
-                        pop_flag=False
-                        break
-                if pop_flag:
-                    path.pop(1)
-                    # constrain_s=False
-
-            if [path_index,-1] in self.path_at_pin:
-                connect_index=self.path_at_pin.index([path_index,-1])
-                pin=self.connected_pins[connect_index]
-                if not distance_between_pts(path[-1],pin)==0:
-                    constrain_e=False
-                    warnings.warn('Found wire endpoint not connected to pin exactly, check wire modify in post-process if error')
-                
-                if len(path)>2:
-                    pop_flag=True
-                    lt=find_line_eq(path[-1],path[-2])
-                    iso_l_pts=isolation_box_linepts(self.iso_size,pin)
-                    for l_pts in iso_l_pts:
-                        pt1=l_pts[0]
-                        pt2=l_pts[1]
-                        l=find_line_eq(pt1,pt2)
-                        inter=find_intersect(l,lt)
-                        if type(inter)!=type(None) and if_pts_on_interval(inter,path[-1],path[-2]):
-                            pop_flag=False
-                            break
-                    if pop_flag:
-                        path.pop(-2)
-
             if len(path)==1:
                 continue
             ######        
@@ -865,5 +828,19 @@ def three_ptw_on_one_line(pt1,pt2,pt3):
     if if_pts_on_line(l1,pt3):
         return True
 
+def point_within_pinbox(pt,pin,box_size):
+    """
+    pt=further point
+    pin= pin_location
+    """
+    x,y=pt[0],pt[1]
+    size=box_size/2
+    xmin=pin[0]-size
+    xmax=pin[0]+size
+    ymin=pin[1]-size
+    ymax=pin[1]+size
 
+    if x>xmin and x<xmax and y>ymin and y<ymax:
+        return True
+    else: return False
 

paperbot_ee_autoroute/paperbot_ee.ses → EEME_design/paperbot_ee.ses

@@ -10,7 +10,7 @@
       (place U1 1040000 461000 front 90)
     )
     (component T1
-      (place T1 870000 900000 back 0)
+      (place T1 870000 900000 front 0)
     )
     (component L1
       (place L1 670000 410000 front 90)
@@ -33,108 +33,111 @@
       (net 3v3
         (wire
           (path F.Cu 20000
-            1207429 826494
-            872710 826494
-            870000 823784
+            1208927 769036
+            1208927 581620
           )
         )
         (wire
           (path F.Cu 20000
-            1253824 971276
-            1253824 872889
-            1207429 826494
+            1251600 929529
+            1208927 886856
+            1208927 769036
           )
         )
         (wire
           (path F.Cu 20000
-            1205100 565218
-            1205101 565218
-            1207429 567546
-            1207429 826494
+            1208927 769036
+            889067 769036
+            889067 769037
           )
         )
         (wire
           (path F.Cu 15238
-            870000 823784
             870000 798400
+            870000 788103
+            889067 769037
           )
         )
         (wire
           (path F.Cu 15238
-            1205100 565218
+            1208927 581620
+            1205100 577793
             1205100 575300
           )
         )
         (wire
           (path F.Cu 15238
-            1253824 971276
             1251600 973500
+            1251600 929529
           )
         )
       )
       (net GND
         (wire
           (path F.Cu 20000
-            1226200 956878
-            1191566 922244
-            936727 922244
-            837766 823283
-            837766 805234
+            897207 826443
+            824970 826443
+            670000 671473
+            670000 435400
           )
         )
         (wire
           (path F.Cu 20000
-            670000 435400
-            670000 662768
-            812466 805234
-            837766 805234
+            897207 826443
+            1104527 826443
+            1226200 948116
+          )
+        )
+        (wire
+          (path F.Cu 20000
+            897207 816057
+            897207 826443
           )
         )
         (wire
           (path F.Cu 15238
-            1226200 956878
+            895400 798400
+            897207 800207
+            897207 816057
+          )
+        )
+        (wire
+          (path F.Cu 15238
+            1226200 948116
             1226200 973500
           )
         )
         (wire
           (path F.Cu 20000
-            1001900 558678
-            799944 356722
-            670883 356722
-            642357 385248
-            642357 409364
-            668393 435400
             670000 435400
+            668555 435400
+            642308 409153
+            642308 385925
+            671949 356284
+            808268 356284
+            1001900 549916
           )
         )
         (wire
           (path F.Cu 15238
-            1001900 558678
+            1001900 549916
             1001900 575300
           )
         )
-        (wire
-          (path F.Cu 15238
-            837766 805234
-            844600 798400
-          )
-        )
       )
       (net NET1
         (wire
           (path F.Cu 20000
+            837017 790817
+            825375 790817
+            720000 685442
             720000 422700
-            720000 681209
-            801893 763102
-            873853 763102
-            897624 786873
-            897624 796176
           )
         )
         (wire
           (path F.Cu 15238
-            897624 796176
-            895400 798400
+            844600 798400
+            837017 790817
           )
         )
       )
@@ -149,26 +152,26 @@
       )
       (net SCL
         (wire
-          (path F.Cu 15238
+          (path F.Cu 20000
+            1200800 988622
+            1213751 1001573
+            1262669 1001573
+            1279703 984539
+            1279703 610226
+            1216911 547434
+            1055182 547434
             1052700 549916
-            1052700 575300
           )
         )
         (wire
-          (path F.Cu 20000
-            1200800 990122
-            1212083 1001405
-            1263132 1001405
-            1279548 984989
-            1279548 607923
-            1214718 543093
-            1059523 543093
+          (path F.Cu 15238
             1052700 549916
+            1052700 575300
           )
         )
         (wire
           (path F.Cu 15238
-            1200800 990122
+            1200800 988622
             1200800 973500
           )
         )
@@ -176,28 +179,28 @@
       (net SDA
         (wire
           (path F.Cu 20000
-            1027300 559154
-            1027300 543297
-            1049610 520987
-            1224236 520987
-            1302018 598769
-            1302018 994154
-            1272397 1023775
-            1203172 1023775
-            1175400 996003
-            1175400 987696
+            1027300 549505
+            1027300 539917
+            1045031 522186
+            1227572 522186
+            1304811 599425
+            1304811 995273
+            1272940 1027144
+            1203241 1027144
+            1175400 999303
+            1175400 990546
           )
         )
         (wire
           (path F.Cu 15238
             1175400 973500
-            1175400 987696
+            1175400 990546
           )
         )
         (wire
           (path F.Cu 15238
             1027300 575300
-            1027300 559154
+            1027300 549505
           )
         )
       )

paperbot_ee_autoroute/roco_dsn.py → EEME_design/roco_dsn.py

@@ -15,7 +15,7 @@ class brd_design():
         self.module_list=[
             ['mpu-9250.kicad_mod','J1',[115000,91000],'front',270],
             ['ESP12F-Devkit-V3.kicad_mod','U1',[104000,46100],'front',90],
-            ['touch_sensor.kicad_mod','T1',[87000,90000],'back',0],
+            ['touch_sensor.kicad_mod','T1',[87000,90000],'front',0],
             ['LED_D3.0mm.kicad_mod','L1',[67000,41000],'front',90],
             ['Resistor.kicad_mod','R1',[72000,41000],'front',270],
             
@@ -34,7 +34,7 @@ class brd_design():
  
         # ]
         self.netclass_list=[
-            ['default',['3v3','GND','NET1','NET2','SCL','SDA'],'',2000,200]
+            ['default',['3v3','GND','NET1','NET2','SCL','SDA'],'',2000,500]
         ]
         # self.module_list,self.netlist,self.netclass_list=self.read_from_csv(netlist_csv)
         

paperbot_ee_autoroute/roco_electrical.py → EEME_design/roco_electrical.py

@@ -31,14 +31,14 @@ def roco_add_ee(me_drawing,netlist_csv,module_libpath,dsnwritier_dir,
 
     ready_for_autorouter=pre_process(me_drawing) #get dwg_for_autorouter.dxf
     ee_design=brd_design(ready_for_autorouter.bry_ind,module_libpath,netlist_csv)#,dwgfile='dwg_for_autorouter_temp.dxf') #get paperbot_ee.dsn 
-    # subprocess.call(['java','-jar','freeRouting.jar','-de',ee_design.savename+'.dsn','-white','-s'])
+    subprocess.call(['java','-jar','freeRouting.jar','-de',ee_design.savename+'.dsn','-white','-s'])
     wiring_path=find_wire(ee_design.savename,ee_design.pins_at) #read ses file
     post_process(me_drawing,wiring_path,ee_design.pins_at,trace_width,iso_size,cross_size) # draw for fabrication 
 
-    # os.remove(ready_for_autorouter.savename)
-    # os.remove(ee_design.savename+'.dsn')
+    os.remove(ready_for_autorouter.savename)
+    os.remove(ee_design.savename+'.dsn')
     # os.remove(ee_design.savename+'.ses')
-    # os.remove(ee_design.savename+'.rules')
+    os.remove(ee_design.savename+'.rules')
 
 def test():
     from read_old_paperbot import read_old_paperbot

auto_router_ondxf/auto_router_ondxf.py

-#!/usr/bin/env python
-
-import numpy as np
-import ezdxf 
-import random
-from math import sqrt
-import cv2
-import os
-from pathfinding.core.diagonal_movement import DiagonalMovement
-from pathfinding.core.grid import Grid
-from pathfinding.finder.a_star import AStarFinder
-import copy
-import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-from matplotlib import cm
-
-
-class auto_rounter:
-    def __init__(self,path,dxf_file):
-        self.dwg=ezdxf.readfile(path+dxf_file)
-        self.msp=self.dwg.modelspace()
-        self.dxf_name='silhouette_ele.dxf'
-        self.fail_flag=False #return True when path not found
-        
-        
-        self.create_layer('Cut',5)
-        self.create_layer('Circuit',1)
-        self.create_layer('Label',3)
-        self.create_layer('Fold',4)
-        self.create_layer('Pin_temp',6)
-
-        self.layer_rearrange() ## reagrrange cut and fold lines to corresponding layers
-        self.remove_wheels() ##remove wheel drawings for this design, no need to call for other designs
-        self.find_pin()
-
-        isolength=2.6 #mm
-        # self.draw_on_pin(isolength)
-
-        self.matrix_shape=(270,210)
-        self.read_dxf_as_matrix()
-        
-
-
-        # self.connections_list=np.array([[0,0],[0,0]]).reshape(1,2,2)
-        # connection_amount=4
-        # for i in range(connection_amount):
-        #     s=random.randint(0,len(self.center_arr)-1)
-        #     e=random.randint(0,len(self.center_arr)-1)
-        #     connections=np.array([[self.center_arr[s],self.center_arr[e]]]).reshape(1,2,2)
-        #     self.connections_list=np.append(self.connections_list,connections,axis=0)
-        
-        # self.connections_list=np.rint(self.connections_list)[1:]
-
-        ############for testing and demo purpose #############
-        self.connections_list=self.test_connections()
-        
-        
-
-                
-        # self.matrix_temp=copy.deepcopy(self.matrix)
-        # self.img=plt.imshow(self.matrix_temp,interpolation='nearest',cmap=cm.Spectral)
-        # ani=animation.FuncAnimation(self.fig,self.find_multi_path,interval=10)
-        # plt.show()
-
-        self.find_multi_path(1)
-        self.dwg.saveas(self.dxf_name)
-
-
-
-    def create_layer(self,layer_name,color):
-        if not layer_name in self.dwg.layers:
-            self.dwg.layers.new(name=layer_name,dxfattribs={'color':color})
-
-    def layer_rearrange(self):
-        # put fold lines to the new layer 'Fold'
-        # put cut lines to the new layer 'Cut
-        for e in self.msp.query('LINE'):
-            if e.dxf.color!=5:
-                e.dxf.layer='Fold'
-            else:
-                e.dxf.layer='Cut'
-
-    def find_pin(self):
-        tolerance=0.05 #mm
-        pincutsize=1 #mm
-        pin_edge_arr=np.array([[0,0],[0,0]]).reshape(1,2,2)
-        self.center_arr=np.array([[0,0]])
-
-        for e in self.msp.query('LINE[layer=="Cut"]'):
-            length= sqrt((e.dxf.start[0]-e.dxf.end[0])**2+(e.dxf.start[1]-e.dxf.end[1])**2)
-            if length > pincutsize-tolerance and length < pincutsize + tolerance:
-                e.dxf.layer='Pin_temp'
-                if e.dxf.start[1]==e.dxf.end[1]: ##this line is horizontal
-                    pin_edge=np.array([e.dxf.start,e.dxf.end])[:,:2]
-                    pin_edge_arr=np.concatenate((pin_edge_arr,pin_edge.reshape(1,2,2)),axis=0)
-        pin_edge_arr=pin_edge_arr[1:]
-        # print(pin_edge_arr)
-        
-        for i in range(len(pin_edge_arr)):
-            for e in np.delete(pin_edge_arr,i,axis=0):
-                if pin_edge_arr[i][0,1]-e[0,1]==1.0:
-                    center_x=pin_edge_arr[i][0,0]-0.5
-                    center_y=pin_edge_arr[i][0,1]-0.5
-                    center=np.array([center_x,center_y]).reshape(1,2)
-                    self.center_arr=np.append(self.center_arr,center,axis=0)
-
-        self.center_arr=np.unique(self.center_arr,axis=0)
-        self.center_arr=self.center_arr[1:]
-        # print(self.center_arr)
-    def remove_wheels(self):
-        #no need to call this function for other design
-        for e in self.msp.query('Arc LINE[layer=="Cut"]'):
-            if e.dxf.start[0]>=179:
-                self.msp.delete_entity(e)
-    
-
-    def draw_on_pin(self,fulllength): #isolation
-        iso=self.dwg.blocks.new(name='ISO_BLK')
-        isolength=fulllength/2
-        trace_w=0.8
-        iso.add_line((-isolength,isolength),(isolength,isolength),dxfattribs={'linetype':'DASHDOT'})
-        iso.add_line((-isolength,-isolength),(isolength,-isolength),dxfattribs={'linetype':'DASHDOT'})
-        iso.add_line((-isolength,-isolength),(-isolength,isolength),dxfattribs={'linetype':'DASHDOT'})
-        iso.add_line((isolength,-isolength),(isolength,isolength),dxfattribs={'linetype':'DASHDOT'})
-
-        iso.add_line((-isolength,-trace_w/2),(-(isolength+5),-trace_w/2),dxfattribs={'linetype':'DASHDOT'})
-        iso.add_line((-isolength,trace_w/2),(-(isolength+5),trace_w/2),dxfattribs={'linetype':'DASHDOT'})            
-        for center_point in self.center_arr:    
-            self.msp.add_blockref('ISO_BLK',center_point,dxfattribs={'layer':'Circuit'})
-
-    
-    def read_dxf_as_matrix(self): 
-        """unit: mm 
-            accuracy issue expected atm (mm round up)
-        """
-        self.matrix=np.ones(self.matrix_shape)
-
-        for line in self.msp.query('LINE[layer!="Fold" & layer!="Label" & layer!="Pin_temp"]'):
-            start=np.rint(line.dxf.start)
-            end=np.rint(line.dxf.end)
-            i=int(start[0])
-            j=int(start[1])
-            #can draw horizontal or vertical lines only
-            if j==end[1]: #this line is a horizontal line
-                self.matrix[j,i]=0
-                while i!=end[0]:
-                    if i<end[0]:
-                        i+=1
-                    else:
-                        i-=1
-                    self.matrix[j,i]=0
-            elif i==end[0]: #this line is a vertical line
-                self.matrix[j,i]=0
-                while j!=end[1]:
-                    if j<end[1]:
-                        j+=1
-                    else:
-                        j-=1
-                    self.matrix[j,i]=0
-        
-    def find_a_path(self,matrixws,start_point,end_point):
-        """
-        find a path between two points on img=matrix
-        start_point and end_point shape: (2,)
-        """
-        #DEBUG:
-        # if not np.array_equal(matrixws,self.matrix):
-        #     print('Map updated')
-
-        grid = Grid(matrix=matrixws)
-        start=grid.node(int(start_point[0]),int(start_point[1]))
-        end=grid.node(int(end_point[0]),int(end_point[1]))
-        finder = AStarFinder(diagonal_movement=4)
-        path, runs = finder.find_path(start, end, grid)
-
-        return path
-    def draw_a_path(self,path,matrix,dxf=False):
-        """ draw a path on img=matrix, or on dxf file too"""
-        #draw on matrix:
-        for point in path:
-            matrix[point[1],point[0]]=0
-        #draw on dxf:
-        if dxf:
-            
-            for i in range(len(path)-1):
-                self.msp.add_line(path[i],path[i+1],dxfattribs={
-                    'layer':'Circuit',
-                    'linetype':'DASHDOT'})
-    
-    def get_cost(self,path):
-        if len(path)==0: #if no path found
-            print('one path not found')
-            self.fail_flag=True
-            cost=1000
-        else: cost=len(path)
-
-        return cost        
-
-
-    def find_multi_path(self,i):
-        """connection list shape : NX2X2 """
-        E=20
-        print("==========Auto rounting start===========")
-        
-        for episode in range(E):
-            print 'episode:',episode+1,'(/',E,')==========='
-            self.matrix_temp=copy.deepcopy(self.matrix)
-            self.Q=0
-            self.fail_flag=False
-
-            random_ix=random.randint(0,len(self.connections_list)-1)
-            init_s=self.connections_list[random_ix]
-            current_solving=np.array([init_s]).reshape(1,2,2)
-            con_list_temp=np.delete(self.connections_list,random_ix,axis=0)
-            
-            cur_path=self.find_a_path(self.matrix_temp,init_s[0],init_s[1])
-            self.draw_a_path(cur_path,self.matrix_temp)
-            # self.img.set_array(self.matrix_temp)
-            
-            cost=self.get_cost(cur_path)
-            self.Q=self.Q+cost
-            
-            curpath_temp=[cur_path]
-            while len(con_list_temp)!=0:
-                random_ix=random.randint(0,len(con_list_temp)-1)
-                next_conn=con_list_temp[random_ix]
-                current_solving=np.append(current_solving,next_conn.reshape(1,2,2),axis=0)
-                con_list_temp=np.delete(con_list_temp,random_ix,axis=0)
-                
-                curpath=self.find_a_path(self.matrix_temp,next_conn[0],next_conn[1])
-                self.draw_a_path(curpath,self.matrix_temp)
-                curpath_temp.append(curpath)
-                # self.img.set_array(self.matrix_temp)
-               
-                cost=self.get_cost(curpath)
-                self.Q=self.Q+cost
-
-            if episode==0:
-                self.Q_buff=copy.deepcopy(self.Q)
-            if self.Q<=self.Q_buff:
-                self.Q_buff=copy.deepcopy(self.Q)
-                self.final_solving=current_solving
-                self.final_path=curpath_temp
-                self.final_fail=self.fail_flag
-                
-            print 'Current cost:',self.Q,'Best cost',self.Q_buff
-            episode+=1 
-        if not self.final_fail:
-            for i in range(len(self.final_path)):
-                self.draw_a_path(self.final_path[i],self.matrix,True)
-        else:
-            print 'One or more path cannot be solved'
-        
-    def test_connections(self):
-        y=97
-        x=90
-        arti_pin_array=np.empty((1,2))
-        center_pin_conn=np.empty((1,2))
-        pin_conn=np.empty((1,2,2))
-
-        for i in range(10):
-            arti_pin=(x+i,y)
-            arti_pin_array=np.append(arti_pin_array,[arti_pin],axis=0)
-        arti_pin_array=arti_pin_array[1:]
-        
-        for i in range(len(self.center_arr)):
-            if self.center_arr[i][1]<60:
-                center_pin_conn=np.append(center_pin_conn,self.center_arr[i].reshape(1,2),axis=0)
-            if len(center_pin_conn)>10: break
-        center_pin_conn=center_pin_conn[1:]
-        
-        for i in range(10):
-            pin_conn_temp=np.array([arti_pin_array[i],center_pin_conn[i]]).reshape(1,2,2)
-            pin_conn=np.append(pin_conn,pin_conn_temp,axis=0)
-        pin_conn=pin_conn[1:]
-
-        return pin_conn
-
-# def main():
-path='/home/jingyan/Documents/summer_intern_lemur/roco_electrical/'
-dxf_file='graph-silhouette.dxf'
-router=auto_rounter(path,dxf_file)
-# animation.FuncAnimation(edit.fig,plt.imshow(edit.matrix_temp))
-# plt.show()
-
-
-# if __name__ == '__main__':
-#     main()
-