Jingyan Ling

09/04/2019

• Paper Outlines

An Accessible way to rapidly build foldable robots from automatic electromechanical design

I. Introduction (1)

• 1. Robot functionality highly depends on electrical component it carries
• 2. Personalized robot needs technical experience
• 3. Work based on previous work of RoCo mechanical design
• 4. Bullet points of contributions

II. Related Work (1-2)

• 1. Roco mechanical design for foldable robot
• 2. Freerouting software for auto-router

III. Design Strategies (2-5)

• A. Design as a PCB
• B. Mechanical drawing processing
• C. Circuit pattern
• D. Fabrication

IV. Result (5-6)

• Pipeline of the system
• Show results through each step in the pipeline
• State time and cost

V. Conclusion (6)

• A. Contributions
  • Accessible
  • Fast
• B. Future Work
  • Stability
  • Durability

Contribution A (Design as a PCB)

What

• An integrated method to do PCB design from simple user input

How

• building dsnwritter python library
  • module, footprint lib, wiring options...

Solves issue

• 1. Experience of using PCB design software (KiCAD/EAGLE) is needed for typical PCB design; Causal user need time to learn software.
• 2. Manually routing takes long time and requires technical experience

Why solving this issue

• 1. Electrical design is necessary for building a robot
• 2. Having circuit on the surface of foldable robot instead of doing external wires makes it more accessible

For

• Accessible and fast

Approve

• exported file (.dsn) can be viewed in Auto-router software directly (fig)
• input table vs. output (fig)
• Auto-router can read the file generated and proceed auto-routing (fig)

Contribution B (Mechanical Drawing processing)

What

• A module can take arbitrary 2D-mechanical design for automatic electrical design

How

• mechanical drawing pre-processing
  • line stroked to path
  • polylines provides continuous closed shape for lines

Solves issue

• Extra effort is needed for a complex CAD drawing to be recognized as electrical board outlines (provide example fig)

Why solving this issue

• Specific type and style of CAD drawings are required to use open-source auto-routing software
• Learning specification and drawing software would waste time and effort of causal users

For

• Accessible

Approve

• Show different line properties in inkscape between mechanical design and after pre-processing (fig)
• Such shape can be viewed in Auto-router and routing treat drawings as obstacles properly (fig)

Contribution C (Circuit Pattern)

What

• A module generates fabrication file for materials based on electromechanical design

How

• Fabrication drawing post-process
  • parse wiring information
  • parallel traces/ isolation boundaries/ pin insertion

Solves issue

• Design of patterns of wiring is required based on material of foldable robot for proper electrical performance. It would need technical experience.

Why solving this issue

• Patterns are necessary to ensure there is no short or open circuit for circuit on the surface of robot
• Change design of such pattern can consume a lot effort

Approve

• different circuit pattern can be output for materials (fig: direct wire vs parallel traces)
• pic of direct wire fabrication by using conductive pen on paper
• pic of showing isolation well for parallel trace pattern
• pic of showing pin insertion pattern can conducts well

For

• Accessible

Contribution D (Fabrication)

What

• Foldable robot with functional electrical components on surface
  • A. Fabrication
  • B. Result

How

• Describe fabrication process (pic/reference/experiment)

Solves Issue

• 1. A. Traditional printable circuit requires more cost/equipment/time (depends on reference search)
• 2. B. Traditional PCB can not be folded to a robot
• 3. B. Traditional PCB does not have arbitrary shape/holes inside

Why solving this issue

• Traditional robot and PCB making takes a long time, special equipment and technical experience. While most of soft PCB are simple routing instead of taking complex mechanical design

Approve

• circuit can work properly on folded surface (fig)
• circuit can go around holes and working properly (fig)
• pic of a foldable robot with circuit working
• Time it takes to do the whole robot
• Price of copper + plastic paper

For

• Low cost & Fast

until 09/03/2019

• Testing on physical prototype
• Fabrication process
• 
• Result from cutter
• 
• Test before fully folding the robot
• 
• Appearance after fully folded
• 

08/29/2019

• Fixing issues:

  • better performance with multiple wires connecting to single pin
  • changed a lot details in drawing_processing script:
    • pop for endpoints at each wire will be executed before parallel traces
    • pop and whether the point is connected to a pin is based a rule more restricted so even the wire does not connect to a pin without 0, 90 or 45 degree, it will still pop correctly

• Complete design for demo that has paperbot with an IMU, a touch sensor connecting to LED and Resistor

• 

• Fixing inkscape unit and scale issue:

  • Save as svg
  • Select every entities in the drawing
  • Lock the width and height scale
  • Times (90/96) to either height or width

08/28/2019

• Solving issue:

  • The way mark pin as connected pin (solved)
  • Changed way reading path
  • Connect wire directly to pin after remove redundant small wires
  • Group wires that has same connection point and same slop for branch drawing

• 

08/27/2019

• Solving issue:

  • multiple wires connecting to single pin
    • Partially solved by
      • Merge paths through pin as a single path in sesreader
      • If such path passes a pin, mark this pin as connected pin (partially working, fix needed)
      • Add a filter that remove intervals inside a path which is shorter than 0.5mm

• TODO:

  • Solve the way mark pin as connected pin
  • Branch intersect sometimes is not draw correctly
  • Issues screenshot:
    • 
    • 
    • 

• Current status:

• 

08/26/2019

• Fixed issue:

  • roco_dsn now reads flip argument to get correct pin locations

• Solving issue in progress:

  • When multiple wires are connecting to single pin. Isolation box is not draw correctly
  • Have Done:
    • Redo sesreader so paths will not be continued to merge if it reach one of the pin location

• 

08/22/2019

• Try to solve issues:

  • get_pin_loc function takes flip parameter incorrectly
  • a wiring path is connected to another path (fixed)
    • The contact point cannot contain more than two path intervals

• 

08/21/2019

• TODO:
  • Find solution to deal with inkscape pixel scale bug
  • Read prototype csv file
• Fabricate prototype
  • Bug reported : (fixed)
  • 

Noticed Issue:

• If two wiring paths are connected to one pin, it might generate a open circuit

• If a wiring path is connected to another path instead of pin, an error will occur b/c it cannot find a pin connected to the tip of one of the path

• 

• Bug reported:

  • get_pin_loc function in roco_dsn does not consider flip situation, pin read wrong if filp='back'

08/20/2019

• Add multiple cut to parallel traces, get outer and inner helper diagonal cut so the isolation will work well

• Making prototype cut from the output of software

• Issue reported:

  • Footprint size and actual cut size not consistent

08/19/2019

• Remove the endpoint of a path if the last segment is inside the isolation box

• Rodo the loop dealing with parallel traces

• Add code that does isolation box for non-connected pin

• 

• When reading dwg file for dsn. It should know which is the boundary automatically.

• Changed internal boundary index finder, so user won't need to type the boundary line index manually. A value will be parsed from pre-process class to dsn writter.

• Merged and modified dxf to path function

• Changed function does bi-sector in post-processing so it can fits the way we do line to path successfully

• Whole process and pipeline works well now

• Building high-level functions

• Edit sesreader again and add a filter that removes redundant points

• TODO:

  • put new drawings on dxf version >=12
  • so the width of drawing lines can be changed
  • Isolation box and parallel traces requires multiple parallel cut, changing width makes drawing easier to see

08/16/2019

• Record of Tips:
  • changing the clearance defined in dsn file changes the rule of routing
  • useful to change it according wire length and isolation box size
  • This will output multiple path
  • Redo sesreader so that it will merge paths those connect to each other

08/15/2019

• Solving issue: Connection between isolation box and parallel traces

input: endpoints of a path (each endpoints has i+1 for finding a line), iso_size, trace_width
output: intersect points*2 , draw isolation box in the process

input= contact_ept, further_ept, size, width

for pin_loc in all pin locations:
  if the distance between endpoint1 and pin_loc is less than tolerance:
    l=line(contact_ept,further_ept)
    parallel_traces=find_offset(l,width)
    iso_l_pts=isolation_box_linepts(size,pin_loc)
    contact_list=[]
    for l in parallel_traces:
      contact=find_contact_iso_trace(l,iso_l_pts,further_ept)
      contact_list.append(contact)
    
    draw_list=[]
    draw_list.append(contact_list[0])
    while len(iso_boundary)!=0:
      for points in iso_boundary:
        find a point that is closest to last point of draw_list
        if not such point is inside of two contacts:
          draw_list.append(points)
        iso_boundary.remove(point)
    
    draw draw_list in order
    return contact_list

• Connection between isolation and parallel traces solved!!!
• 
• TODO:
  • Merge DXF to path code
  • Issue exposed: after changing wire width, box still not quite correct
  • roco_ee_dwg_processing.py line 132

08/14/2019

• Preparing software demo

• High level of whole project package

• 

• Pipeline of drawing changes

• 

• Package module and classes breakdown

• 

• Structure of customized package dsnwriter

• 

• Structure of customized package roco_ee_dwg

• 

• Demo Video at here

• Solving issue: Connection between isolation box and parallel traces

08/13/2019

• Rearrange the package and draw the path directly on original drawing from old roco

• dsn module placement match:

  • instead of getting pin locations from old roco. set pin location based on footprint when user place modules
  • Reason:
    • 1. no mechanical design needed for pins (especial will turn it to cross cut anyway)
    • 2. make sure the electrical board design and drawings will always be consistent
    • 3. easier to add new electrical components
    • 4. easier to do drawing post processing (dealing with traces and isolation boxes)

• Completed: a cross cut will be drawn at pin locations and that is automatically read from circuit design. The package will only need to load module once when design circuit

• 

• Draw isolation boxes and connect one edge with parallel traces without causing open circuit (fail)

• 

• TODO:

  • Connect traces to isolation box
  • Merge pre-processing code
  • Demo

08/12/2019

• Finally figure out geometry algorithm on paper

• Coding for parallel trace in following steps:

  • 1. find start point and end point of a path, compute 4 points that vertical to end points based on width
  • 2. find the angle bisector between each segment
  • 3. Offset original path based on given width
  • 4. find intersect between paths with offset and angle bisectors
  • 5. connect intersect points and 4 end-points

• Separate file paperbot_draw to a general useful file roco_ee_dwg_processing.py and operations specifically for paperbot paperbot_draw.py

  • functions and classes in roco_ee_dwg_processing.py will be useful for future foldable robot project.

• Finally complete the parallel trace drawing. Now any path exported from auto-router will draw parallel trace with desired width to make sure the copper type surface can conduct well.

• 

• TODO:

  • Connect traces to isolation box
  • Merge pre-processing code
  • Clean up script
  • Read trace width from Net Class

08/09/2019

• Potential problem:

  • drawing pre-processing has two goals: 1. put different intensity cuts on different layers for accurate fabrication 2. make line to 4 nodes path for auto-router treating as obstacles.
  • Two goal may conflict within single process
  • potential solution: send 4 nodes path to auto-router and draw wiring paths on drawing with signed layers.

• Solving parallel traces math computation

08/08/2019

• block class in ezdxf generates symbol in inkscape. Check if it can be made to path from script

• 

• Changed the way of drawing cross-cut to path directly instead of using inserting block class (see paperbot_draw.py for detail)

• Parallel traces are not computed correctly

• 

08/07/2019

• Working on drawing details regarding fabrication for electrical design
  • A block was created for 'cross cut' to fit pin insertions
  • Parallel traces are hard to get
  • A challenge that trimming isolation boxes with parallel traces occurs

08/06/2019

• Successfully parse the wiring information from ses file to array
  • A little "hacky" way, not using any parsing package but going through string and looking for path section
  • For ses file only
• Create new scripts and Re-arrange all packages
  • User will be able to execute fab_drawing.py directly to get drawing for paperbot including electrical wiring design and ready to send to fabrication
  • If user wants to change electrical connection, one can edit paperbot_dsn.py
  • dsnwriter and sesreader source code are located here
• New script:
  • paperbot_draw.py has two classes:
    • pre-process
      • process the mechanical design drawing to correct format that can be taken by dsnwriter and autorouter
    • post-process
      • process the drawing file and draw wires based on ses file generated from autorouter
• Milestone:
  • Now user can generate dsn file from script and confirm auto-routing.
  • A parser can pull information for wiring
  • Able to draw such wiring back on dxf drawings
  • 
• TODO:
  • Merge pre drawing processing script with Daniel
  • Details:
    • add 'cross-cut' block in ezdxf for pin insertion cut
    • add 'parallel-trace' block in ezdxf for circuit trace on copper tape

08/05/2019

• Working on parsing routed (wiring section) text information.
  • Ref: pyparsing
• Parsing generated dsn file back to DSN class
  • Fail
• Parsing generated kicad_pcb file back to pykicad package - pcb class
  • Success
• Working on:
  • debug dsn library so it can read file.
  • pykicad uses pyparsing internally
  • Rebuild ses file schema. Not working well

08/01/2019

• Scripting Auto-router from python
  • Run .jar package through python
  • Can open GUI with imported file
  • Cannot run auto-routing function from script
  • Manually click on auto-routing and save is needed (manual approval)

07/31/2019

• Use dsnwriter in RoCo

Mechanical drawings (dxf/svg)------------|
                                         |
Module Footprints -----------------------|
                                         |----> board design (dsn) 
Electrical schematic design (netlist)----|
                                         |
Board design details(rules,parameters)---|



----> board design (dsn)----> Auto-router (FreeRouting)----> routed board design (dsn) 
----> wiring section ----> drawings with mechanical and electrical design (dxf/svg)

• The package now can auto-detect padstack information with multiple files

07/30/2019

• Record of Tips:

  • Use @classmethod in class to parse information pull out from files (netlist,drawings,footprint) to original class

• Package Dependencies:

  • pykicad
  • numpy

• Class Footprint now can call function from_file(path,ref) to load footprint from a .kicad_mod file

• Class Padstack now can call function 'auto_detact(path)` to guess information of pads and save as padstack class

  • Via information need to be defined by users. (default=None)

• Placement class can be defined after footprint is loaded and able to define the position of each component by calling ref of module.

• 

• 

• Netclass is easy to write from script.

• Test auto-routing on generated dsn

• 

• Test on wire width change

• 

• TODO: Easier API to generate netlist.

07/29/2019

• Was working on 'dsn_python' Python Library.
• Latest package can be found at personal github
• Class tree:

        |--dsnwritter.py (top and second level structure)
              |--dsn_module.py
                    |--module class
                    |--load module functions
              |--dsn_rule.py
              |--dsn_geo.py
                    |--boundary class
                    |--keepout class
                    |--load drawing functions
              |--dsn_net.py
                    |--net class
                    |--netclass class
                    |--load netlist functions

• Text tree structure is done.

  • Documentation and notes for code needed

• Functions are needed to help user use library.

  • Function that load dxf file
  • Function that load footprint file
  • Function that load netlist file

• For board outline/footprint/netlist not loaded from file but define through this library manually, it works very well for now.

• Pull out those information from low-level file and convert it to proper text for dsn file

• Record of Tips:

  • Freerouting cannot take more than one boundary. (error: exact 1 bounding expected)

• Able to use functions to load dxf drawings

• "internal cut issue" solved

  • Treat every line individually as polygon and labeled as keepout in dsn library
  • 
  • 

07/24/2019

• Pipeline change: (skipping KiCAD)

  • Use (dxf+ pretty (footprint library) + net information ) to generate dsn file
  • Send dsn file to auto-router, save as new dsn file
  • Read dsn file wiring information and draw it back on dxf

• Analysis on dsn file format:

        |--pcb
        |   |--parser
        |   |--resolution
        |   |--unit
        |   |--structure
        |   |     |--layer 1
        |   |     |-- ...
        |   |     |--boundary
        |   |     |--keepout 1
        |   |     |-- ...
        |   |     |--via
        |   |     |--rule
        |   |--placement
        |   |     |--component 1
        |   |     |-- ...
        |   |--library
        |   |     |--image [ref**] 1
        |   |     |     |--outline
        |   |     |     |--pin
        |   |     |-- ...
        |   |     |--padstack
        |   |     |--...
        |   |--network
        |   |     |--net [name] 1
        |   |     |   |--pins
        |   |     |-- ...
        |   |--wiring
        |   |     |--wire

• TODO: functions that load modules and footprints

07/23/2019

• Solving issue: export .kicad_brd file to dsn file for auto-router

• No known Python API so far.

• schematic-file-converter

  • Take .sch file from KiCAD instead of .kicad_brd file

• Official bug report has been requested. Not targeted in current KiCAD scripting version

  • bug report

• Potential Solutions:

  • 1. Explore existing supported export API, and see if modification can be made based on existing API structure
  • 2. Learn dsn file specification and python library to generate dsn file based on design information

07/22/2019

• Research on multiple KiCAD Python packages

• package 3rd party list

• None can import dxf into pcbnew

• To import dxf into pcbnew automatically:

  • Create a python API by myself based on the c++ code
  • Draw lines directly in pcbnew by using line information in dxf

• Create a python script serving as Python API by drawing everything on pcbnew

• Dependencies:

  • ezdxf
  • pykicad

• Successfully import dxf as outlines from script

• 

07/18/2019

• Research on pcbnew API

  • Using package pykicad

  • Record of Tips:

    • Do not add segments, which will route connections
    • Different reference name need to be set for dsn export

  • Able to add footprint and net list into pcbnew.

  • TODO:

    • Import dxf as outlines from script
    • Export board as dsn

07/17/2019

• Notice that even the drawings cannot be imported onto 'wiring' layer, but can be changed manually to 'wiring' layer after importing onto 'edge.cut' layer

  • Freerouting does not recognize wires that does not connect to any pins as obstacles.
  • 
  • 

• Work on script doing board design

  • Create New Board
  • Import DXF
  • Load Netlist .net file
  • Place modules
  • Export to .dsn file

07/16/2019

• Fill and Stroke (Shift + Ctrl + F)

• Stroke to Path

• Union

• Break Apart

• Remove each outer layer (manually)

• Export

• 

• 

• 

• Consider success when export for auto-routing manually. Huge challenge expected when doing it from script.

• Work on script doing schematic design

  • Assume symbol and footprint downloaded
  • Package Using: skidl
  • Record of Tips:
    • Add custom library path that contains all symbols of electrical devices needed (NodeMCU)
    • Use attribute footprint to add footprint for such symbol
    • footprint syntax: 'footprint= libname.pretty: foot_print_name
    • footprint directory should be under the same directory where .lib file is.

07/15/2019

• 3 potential ways to solve the issue on KiCAD with internal cut

• Assume the position of each internal cut line is known

  • 1. Make internal cut a closed shape (original cut with thickness)
    • Pro: Easy to import routed circuit back to dxf cutter file
    • Con: Hard to make the cut itself a closed shape.
  • 2. Make internal cut outlines a block on certain layer and treat it as obstacle in auto-router
    • Pro: Easy to generate a block as obstacle in drawing
    • Con: Hard to import routed circuit back to dxf cutter file
  • 3. Put internal cut on different layer in KiCAD that can be read as obstacle in auto-router
    • Best solution for now if the auto-router will be able to read single cut line, but cannot be edge.cut layer for sure, otherwise board outlines cannot be found by KiCAD.

• Cut lines causing issues are marked in red.

• 

• Inkscape :

  • Object stroke to path can make everything looks like a bounding box

• Attempts:

• 1. Stroke every line, auto-router shows nothing, no error

• 

• 

• 2. Stroke every line, but has a larger boundary. auto-router shows nothing, error: cannot start a route inside of keepout area or boundary outlines

• 

• 

• 3. Stroke every line but make the boundary outlines not closed, and draw a larger outline. Auto-router shows nothing, no error

• 

• 

• 4. Stroke only outline but make the boundary outlines not closed, and draw a larger outline. Auto-router shows properly. (no way to do it from script)

• 

• 

• 

07/11/2019

• Solved Error unable to find segment with an endpoint

  • DSN file can only be exported for continuous closure outlines

  • 

  • Drawings like this drawing for paper cut is not acceptable for dsn file.

  • Change it either to close shape or remove it when import to KiCAD

• Solving Issue: FreeRouting is not reading edge cut layer from dsn

  • Work well on a sample dsn file
  • Issue with KiCAD output
    • Sample KiCAD project can output outlines properly.

• Issue found:

  • KiCAD cannot take single line cut. Closed shape needed.

07/10/2019

Approach A

• Import to PCBnew issue:

  • Dimension of board outlines are incorrect
  • Pins does not fit in original drawings
  • (solved. Microcontroller footprint was incorrect)

• pipeline confirmed:

  • 1. Build symbol and footprint library for all required electrical element
  • 2. Sketch schematic design
    • .sch file
  • 3. Place elements in required position
    • .dsn file
  • 4. Import dsn file into FreeRouting and do auto-routing
    • .ses file
  • 5. Import ses file back to KiCAD and export as dxf file
    • .dxf file

• Manually tested pipeline till step 4

• Step 3

• 

• Step 4

• 

  • ISSUE:

    • Board outlines are not exported correctly to FreeRouting
    • Error: unable to find segment with an endpoint

  • Record of Tips:

    • To run FreeRouting from command line:

      java -jar freeRouting.jar [proj.dsn]

• TODO:

  • Finish with testing the pipeline manually
  • Achieve steps directly from script (Python API)

07/09/2019

• Finish up path-finding approach (Approach B)

• Only draw the best path on dxf when solution is found for every route.

• 

• Throw warning once a route cannot be found

• 

• Research on Approach A

  • KiCAD 5 does not have built-in auto-router

    • Have to use FreeRouting

  • FreeRouting does not have python API

  • Parent package of FreeRouting, LayoutEditor has multiple editions

    • Part of LayoutEditor is open- source
    • A large amount of of its website are broken, source and interface are unavailable

• Other auto-routers are not open-source

Approach A

• 1. Use LayoutEditor python API to use FreeRouting
• 2. Use KiCAD 5 python API to sue FreeRouting
• 3. Use KiCAD 4 python API to use builtin auto-routing

1

• FreeRouting input format: dsn, lef, def

• FreeRouting output format: ses, def

• FreeRouting can take arbitrary board outlines shape

• Edit library manually and test routing

• 

• TODO:

  • If can run KiCAD 4 from python
  • Check FreeRouting API, see if a acceptable file can be generated from things on hand

07/08/2019 (Mon)

• Debug multi-node path finding:
  • some obstacles are ignored
  • too close to each other
• Able to show the learning process:
  • Trying different combination of solving order
  • Try to give the best order of solving multiple path

Auto-routing learning process:

• 

• Comparison between episodes and choose best combo of paths

• 

Issues and TODO

• Path export from optimization is messed up
• Obstacles setting are incorrect

07/05/2019 (Fri)

• Write out algorithm for multi-node path finding
  • pseudo code:

 for (episode in E):
    set initial state s (choose first pair of nodes to connect randomly)
    find a path
    update map
    while not every connection is built:
      choose next connection
      find a path
      update map
      retrieve cost (length of path)
    update Q (as sum of all cost)  
	

• Q here represents total cost of certain choice of path finding order.

  • Cost defined by length of path
  • If path cannot be found, cost 1000

• Input: NX2X2 array specifies desired pin connections

• Research on KiCAD import needs and python API

07/03/2019 (Wed)

• dxf processing completed

• Convert dxf to matrix with resolution (270X210) (mm)

  • Potential issue:
    • the pathfinding package is based on pixel
    • When round up the line's start and end point, the accuracy of pin position is low

• Apply single point to point path finding

  • Able to draw the path on matrix
  • Able to draw the path on original dxf file

• 

• TODO:

  • Write out algorithm for multi-node path finding
  • break single circuit trace to parallel traces
  • solve the accuracy problem

07/02/2019 (Tue)

• Continue the dxf processing

• Following tasks can be completed by running the code:

  • Able to detect pin center coordinate
  • Able to draw arbitrary shape around the pin center
  • 

• • Issue & TODO

  • Convert dxf image to matrix

  • Explore pathfinding package

  • pathfinding package solve path finding problem by shortest path algorithm, one point to another

  • To solve multiple nodes problem, use concept from reinforcement learning

    • Build Q function that represents total reward of choosing certain path to be solved first
    • Update Q function in a loop with certain amount of episodes
    • Choose the order of solving paths randomly, and add possibility of choosing it from Q function
    • Exploration-exploitation method

• To solve the problem "convert dxf to matrix" for pathfinding:

  • Have tried:
    • Export to png and read file by OpenCV
      • Resolution problem: single point does not represented as a pixel in png
    • TODO:
      • create an empty matrix and fill in numbers with the information of each lines' start and end point

07/01/2019 (Mon)

• Continue the dxf processing with 'graph-silhouette.dxf'

Record of tips:

• Put circuit design on a new layer of dxf drawing

  • check doc about layers here

• Use block feature to draw similar pattern

  • check doc about block here

• Blocks are symbol in Inkscape. Convert symbol to path

  • Edit > Clone > Unlink Clone (Shift+Alt+D), and you have a group, ungroup (Object > Ungroup, or Shift+Ctrl+G) and edit

• Convert text to path

  • Path combine (Ctrl+K)

• msp.delete_enetity('__') to remove existing entity

• Test fabrication with different drawing settings

  • Layers can be cut separately by toggling visibility
  • Set cuts with same intensity and feedrate on same layer
  • Entities' layer can be changed through Entity.dxf.layer

06/29 & 06/30/2019 (Sat & Sun)

Approach B

• Potential needed functions of packages

  • A package draws on DXF file through script
  • A script that pulls out pins' coordinate on paper chassis
    • Or a image process package (OpenCV) that reads pins' coordinate on paper chassis
  • A package solves multi-node path finding problem*

Record of Research

• Python Pathfinding package:
  • pathfinding
• Python DXF editor:
  • ezdxf
  • dxfgrabber
    • Note: able to grab simple geometry from file
  • sdxf
• Going through tutorials of ezdxf
  • All lines on paper spacelayer0

06/28/2019 (Fri)

Connection and fabrication approach confirmed !

• Confirm that copper tape has better conductivity than aluminum sheet when attaching microcontroller pins through H-shape cut

  • Copper tape is harder to be scratched, which provides less risk of disconnection during assembly.

• Etching on copper type isolates connections

• Research on PCB editor

  • EAGLE
    • EAGLE cannot import .pcb file
    • svg can be exported but not imported
    • Custom library needed if doing schematic design
  • KiCad
    • Can import .pcb file
    • svg can be exported but not imported
  • LayoutEditor
    • support multiply file type
    • svg can be exported with different color makers as multiple layers
    • include open-sourced auto-router freerouting

• Auto-routing package:

  • TopoR
  • Python-PCB
  • FreeRouting

• Approaches:

  • A. convert SVG/DXF file to schematic/board design of PCB. Use KiCAD or EAGLE to do auto routing.
  • B. develop algorithm on auto routing for single layer svg/dxf file. (path finding problem)

Approach A

• Use regular shape board for PCB in EAGLE/KiCAD

  • image processing: divide the shape of paperbot to multiple rectangles (ezdxf)

  • Pull required connections and place additional header pins around edges of each rectangle

• Make each connection pin to be two parallel connections so auto-router does parallel trace for each wiring.

  • Etching a pair of parallel trace provides isolation, and leave the space between traces to be conductible.

• Build Library for schematic design

  • Schematic design helps with router to know desired connection
  • Additional header pins at each side of kink mark

06/27/2019 (Thur)

• Compile OldRoCo repo
  • Record of modification:
    • ++line 8 of vstart.sh
    • --> pip install -r requirements.txt --user
• Export paperbot dxf file : graph-silhouette.dxf to OnShape
  • Record of Tips:
    • Onshape does not read dxf file as its own saved unit. Manual settings needed when import.
    • 
• Draw circuit diagram as CAD on Onshape
  • Multiple connection approaches:
    • Cross shape of 0.039 in
    • Cross shape of 0.049 in
    • Octangular shape of 0.049 in
    • 
    • 
  • Note and issue:
  • Octangular shape is the best connection approach so far, but none of approach has stable conductivity. More research is needed.
  • Scratches can be made easily when attaching microcontroller to the sheet. Potential disconnection may occur due to such scratches on metal layer.
• Export 2D CAD drawing with PCB to SVG for silhouette cameo
  • Record of Tips:
    • OnShape unit need to be consisted with unit setting in Inkscape (default: mm)
  • Plugin Inkscape-silhouette cannot take multiple types of trace for cutting.
    • Different trace (especially cut and etching) need to be sent separately. Use coordinate tool of Inkscape to ensure separated cuts have same origin.
  • TODO:
    • Cut and etching from same Inkscape file