Handheld Laser Wire Stripper

Novel Handheld Wire Stripper using lasers

Why a handheld laser wire stripper? Not just because it’s cool, but because it has real practical use. There is an issue, particularly in the aerospace industry, known as “Red Plague“. Essentially, if you nick, scratch, or cut into a silver-plated copper wire when you strip it, then you risk causing oxidation in the wire which will eventually lead to a hollow silver wire as all of the copper is oxidized away. It’s a big problem with millions being spent on fixing it.

While I don’t know if my handy little laser wire stripper will ever get into the hands of someone in industry, for those of you who already have every tool in your tool box, you might want to add this, too.

TODO:

  • Identify proper battery power based on the requirements of the laser
  • Implement efficient power supply circuitry
  • Implement a laser driver board
  • Implement a CPLD with appropriate drive circuitry
  • Determine if the laser needs active cooling, if so, identify appropriate Peltier devices considering power available

TODO:

  • Continue to add details to the model so that it is well defined.
  • 3D print test parts and see how they go together

I’m using the very easy to use OpenSCad program, which allows more software-oriented people like myself to easily create things. While I’m familiar with the AutoDesk card of products and can use them effectively, their cost makes them prohibitive for my little hobby projects. Find the current code below the image.

Handheld Laser Wire Stripper
Handheld Laser Wire Stripper
include <roundedcube.scad>
include <Polygon.scad>
include <Parabola.scad>

squarebody = true;
showassembled = false;
facets = 255;
postlength = 152.4;
length = 228.6;
//k = 0.0145;
k = 0.01666656;
wirediameter = 2;

module body(){
    
    //bottom half
    if(squarebody){

          rotate([90, 0, 90]) {
            
            difference() {
                
                roundedcube(size = [length,55,55], center = true, radius = 0.6, apply_to = "all");
                
                //hollow rectangle
                translate([1,0,0]) roundedcube(size = [(length + 10),45,45],center = true, radius = 0.6, apply_to = "all");
                
                if(showassembled == false){
                    
                    //cuts in half
                    rotate ([90,90,0]) translate([0,0,-13.76]) roundedcube(size = [56,(length + 0.1),27.5],  center=true, radius = 0.6, apply_to = "all");
                }
                
               //TODO: Finish this. 
                translate([-25.4,-25.4,]){
          
                    translate([0,0,6.5]) post(15,5,5);
                 
                    translate([0,0,-6.5]) post(15,5,5);
                    
                    rotate([90,0,0]) translate([0,-6.5,.6]) Polygon(N=6,A=3,h=3,debug = false);
                    
                    rotate([90,0,0]) translate([0,6.5,.6]) Polygon(N=6,A=3,h=4,debug = false);
               
                } 
            }
            
        }   
        
    }else{
        
        rotate([90, 0, 0]) {
              
            difference() {
                
                cylinder(h = length, d1 = 65, d2=65, center = true, $fn = facets);
                
                //hollow
                rotate ([0,0,90]) translate([.5,0,0]) cylinder(h=(length + 0.1), d1=55, d2=55, center=true, $fn = facets);
                
                if(showassembled == false){
                    //cuts in half
                    rotate ([90,0,90]) translate([101.6,0,0]) cube((length + 0.1),  true);
                }
            }
        }   
    }
}



module laser(){
    
    translate([0,70,0]) roundedcube(size=[36.5,61.5,29.5],center=true,radius=0.3,apply_to="all");
    
    translate([0,38,0]) roundedcube(size=[5,5,5],center=true, radius=0.6,apply_to="all");
    
}   

module post(x=1,y=1,z=1,pos1=0,pos2=0,pos3=0){
    
    rotate([90,-90,0]){
    
        translate([pos1,pos2,pos3]){
            
            difference([]){
                
                cylinder(h=x, d1=y, d2=z, center=true, $fn = facets);
                
                //post holes at the ends
                translate([0,0,74]) cylinder(h=6, d1=4, d2=4, center=true, $fn = facets);
                
                translate([0,0,-74]) cylinder(h=6, d1=4, d2=4, center=true, $fn = facets);
            }
        }
    }
}

module plate(width=40.6,depth=8.9,height=40.6,pos1=0,pos2=0,pos3=0){
    
    translate([pos1,pos2,pos3]){
        
        difference(){
            
            roundedcube(size=[width,depth,height], center=true, radius=0.2,apply_to="all");
            
            post(9,6,6,13.4,15,0);
            
            post(9,6,6,-13.4,15,0);
            
            post(9,6,6,13.4,-15,0);
            
            post(9,6,6,-13.4,-15,0);
            
            //lens
            rotate([90,0,0]) cylinder(h=10, d1=25.4, d2=25.4, center=true, $fn = facets);
            
            //bevels on corners
            rotate([45,0,90]) translate([0,-30,0]) cube(size = [10,5,5],center=true);
    
            rotate([45,0,90]) translate([0,0,30]) cube(size = [10,5,5],center=true);
        
            rotate([45,0,90]) translate([0,30,0]) cube(size = [10,5,5],center=true);

            rotate([45,0,90]) translate([0,0,-30]) cube(size = [10,5,5],center=true);
      }
        //Adds a end-stop for the optic
        translate([0,-3.9,0]) difference(){
            
            rotate([90,0,0]) cylinder(h=1, d1=25.6, d2=25.6, center=true, $fn = facets);
            
            rotate([90,0,0]) cylinder(h=1.1, d1=22.5, d2=22.5, center=true, $fn = facets);
            
        }
   } 
}


module cagemount(){
    translate([0,-25.4,-17.3]){ //do not remove this, it positions the mount
        
        difference(){
            
            //cube(size=[40.6,14,10.5],center=true);
            roundedcube(size = [40.6,14,10.5], center = true, radius = 0.6, apply_to = "all");
            //center 
            rotate([90,0,0]) translate([0,15.7,0]) cylinder(h = 15, d1 = 25.4, d2 = 25.4, center = true, $fn = facets);
            
            //notches under rod        
            rotate([90,0,0]) translate([15,-0.5,0]) cylinder(h = 15, d1=2, d2=2, center = true, $fn = facets);
            
            translate([15,0,-3.25]) cube(size = [2,15,5.5], center = true);
            
            rotate([90,0,0]) translate([-15,-0.5,0]) cylinder(h = 15, d1 = 2, d2 = 2, center = true, $fn = facets);
            
            translate([-15,0,-3.25]) cube(size =[2,15,5.5], center = true);
            
            //add the first slot
            translate([-7,0,3]) cylinder(h = 6, d1 = 8, d2 = 8, center = true, $fn = facets); 
            
            translate([7,0,3]) cylinder(h = 6, d1 = 8, d2 = 8, center = true, $fn = facets); 
           
           translate([0,0,3]) cube(size = [14,8,6], center = true); 
           
           //add the second slot
            translate([-7,0,0]) cylinder(h = 10.5, d1 = 5, d2 = 5, center = true, $fn = facets); 
            
            translate([7,0,0]) cylinder(h = 10.5, d1 = 5, d2 = 5, center = true, $fn = facets); 
           
           translate([0,0,0]) cube(size = [14,5,50.5], center = true); 
           
           //hollow out the bar path
           post(length,6,6,3.9,-15);
                
           post(length,6,6,3.9,15);
           
           //trim the sharp edges x 4
            translate([-18.04,0,4.9]) roundedcube(size=[1,14,1], center=true, radius=0.2,apply_to="all");
            
            translate([-12,0,5]) roundedcube(size=[1,14,1], center=true, radius=0.2,apply_to="all");
            
            translate([18.04,0,4.9]) roundedcube(size=[1,14,1], center=true, radius=0.2,apply_to="all");
            
            translate([12,0,5]) roundedcube(size=[1,14,1], center=true, radius=0.2,apply_to="all");
           
        }
        //the grabber
        hull(){
            
            post(14.0,1,1,3.5,18.8,0);
            
            post(14.0,1,1,5.5,18.15,0);
   
        }
        //the grabber opposite
        hull(){
            
            post(14.0,1,1,4.6,11.15,0);
            
            post(14.0,1,1,4.9,11.65,0);
   
        }
        
        //the grabber
        hull(){
            
            post(14.0,1,1,3.5,-18.8,0);
            
            post(14.0,1,1,5.5,-18.15,0);
   
        }
        //the grabber opposite
        hull(){
            
            post(14.0,1,1,4.6,-11.15,0);
            
            post(14.0,1,1,4.9,-11.65,0);
   
        }
        
        
    }
}

module parabola(width=40.6,depth=8.9,height=40.6){
    
    echo(str("Focal length = ", focal_length(k)));

    translate([0, -105, 0]){ 
        
        translate([0,-5.4,0]) difference(){
            
            roundedcube(size=[width,depth,height], center=true, radius=0.6,apply_to="all");
                
            post(9,6,6,13.4,15,0);
            
            post(9,6,6,-13.4,15,0);
            
            post(9,6,6,13.4,-15,0);
            
            post(9,6,6,-13.4,-15,0);
            
            rotate ([-90,0,0]) cylinder (h = 55.4, r=wirediameter, center = true, $fn=facets);
        }
        
        rotate([-90,0,0]) {
            
            difference() {
                
                parabolic_dish(17, k, 90);
                
                 rotate ([0,0,90]) cylinder (h = 25.4, r=wirediameter, center = true, $fn=facets);
            }
        }
    }
}


color("CornflowerBlue", 1.0) laser();
 
color("DimGray",1.0) body();

color( "Gainsboro", 1.0 ){
    
    post(postlength,6,6,13.4,15,38);
    post(postlength,6,6,-13.4,15,38);
    post(postlength,6,6,13.4,-15,38);
    post(postlength,6,6,-13.4,-15,38);
}
color("AliceBlue",1){
    //Axicon 1
    plate();

    //Axicon 2
    plate(pos2=-50);

    //Window
    plate(pos2=-59);
}
color("Silver",1.0) cagemount();

color("Gainsboro",1.0) parabola();
    
   



//Standard parabola
function parabolaPoint(x, k) = k * x * x;

//Focal point equals Y where derivative of parabolaPoint is 1.
function focal_length(k) = parabolaPoint(0.5 / k, k);

//Cup shape
module outer_parabola(width, k, segments, base_thickness = 1) {
    for(i = [-segments:1:segments - 1]) {
        let(x1 = i * width / segments)
        let(x2 = (i + 1) * width / segments)
        polygon([[x1, -base_thickness], [x1, parabolaPoint(x1, k)],
            [x2, parabolaPoint(x2, k)], [x2, -base_thickness]],
            [[3, 2, 1, 0]]);
    }
}

//Bulge shape
module inner_parabola(width, k, segments) {
    let(max_y = parabolaPoint(width, k))
    for(i = [-segments:1:segments - 1]) {
        assign(x1 = i * width / segments)
        assign(x2 = (i + 1) * width / segments)
        polygon([[x1, max_y], [x1, parabolaPoint(x1, k)],
            [x2, parabolaPoint(x2, k)], [x2, max_y]],
            [[0, 1, 2, 3]]);
    }
}

module parabolic_trough (length, width, k, segments) {
    rotate([90, 0, 90])
    linear_extrude(length, $fn = segments * 4)
    outer_parabola(width, k, segments);
}

module parabolic_dish (width, k, segments) {
    rotate_extrude($fn = segments * 4)
    intersection() {
        outer_parabola(width, k, segments);
        translate([0, -1])
        square([width + 1, parabolaPoint(width, k) + 2]);
    }
}

////////////////////////////////



// Higher definition curves
$fs = 0.01;

module roundedcube(size = [1, 1, 1], center = false, radius = 0.5, apply_to = "all") {
	// If single value, convert to [x, y, z] vector
	size = (size[0] == undef) ? [size, size, size] : size;

	translate_min = radius;
	translate_xmax = size[0] - radius;
	translate_ymax = size[1] - radius;
	translate_zmax = size[2] - radius;

	diameter = radius * 2;

	module build_point(type = "sphere", rotate = [0, 0, 0]) {
		if (type == "sphere") {
			sphere(r = radius);
		} else if (type == "cylinder") {
			rotate(a = rotate)
			cylinder(h = diameter, r = radius, center = true);
		}
	}

	obj_translate = (center == false) ?
		[0, 0, 0] : [
			-(size[0] / 2),
			-(size[1] / 2),
			-(size[2] / 2)
		];

	translate(v = obj_translate) {
		hull() {
			for (translate_x = [translate_min, translate_xmax]) {
				x_at = (translate_x == translate_min) ? "min" : "max";
				for (translate_y = [translate_min, translate_ymax]) {
					y_at = (translate_y == translate_min) ? "min" : "max";
					for (translate_z = [translate_min, translate_zmax]) {
						z_at = (translate_z == translate_min) ? "min" : "max";

						translate(v = [translate_x, translate_y, translate_z])
						if (
							(apply_to == "all") ||
							(apply_to == "xmin" && x_at == "min") || (apply_to == "xmax" && x_at == "max") ||
							(apply_to == "ymin" && y_at == "min") || (apply_to == "ymax" && y_at == "max") ||
							(apply_to == "zmin" && z_at == "min") || (apply_to == "zmax" && z_at == "max")
						) {
							build_point("sphere");
						} else {
							rotate = 
								(apply_to == "xmin" || apply_to == "xmax" || apply_to == "x") ? [0, 90, 0] : (
								(apply_to == "ymin" || apply_to == "ymax" || apply_to == "y") ? [90, 90, 0] :
								[0, 0, 0]
							);
							build_point("cylinder", rotate);
						}
					}
				}
			}
		}
	}
}
//============================================================
// OpenSCAD
// Regular Convex Polygon Library
// Last Modified : 2015/10/28
//============================================================
/*

	Definition

	N = Number of Side N >=3
	A = apothem
		radius of inside circle
	R = circumradius
		Radius of outside circle
	S = Side
		Lenght of a side

	Build polygon with the Apothem :
	N and A is known
	Need to calculate S then R
	use $fn

	Build Polygon with Circumradius
	N and R known
	use $fn

	Build Polygon with Side
	N and S Known
	Need to calculate R and optionaly A
	use $fn	

	TO DO
    Control result

	For more information :
	http://en.wikipedia.org/wiki/Regular_polygon

*/

//------------------------------------------------------------
//
//------------------------------------------------------------
//Demo();

//------------------------------------------------------------
// Demo
//------------------------------------------------------------
module Demo()
{
	inch = 25.4;	// 25.4mm
	// A = apothem - it's a RADIUS !
	// For a bolt of 4 inches spécify A=2*inch
	//Polygon(N=7,A=2*inch,h=0);	// 4 inches radius Polygon
	//Polygon(N=7,A=49.8365,h=0);
	//Trigon(A=50,h=10);			// N=3
	//Dodecagon(A=50,h=0);			// N=12

    //rotate([0,0,360/7/2])
	//Nonagon(R=55.3144,h=10,debug=true);

	Polygon(N=6,A=60,h=40,debug=false);
	//Polygon(N=6,A=60,h=5,debug=true);

    //Enneagon(A=10);
}


//------------------------------------------------------------
// Polygon : 
//------------------------------------------------------------
module Polygon(N=3,A=0,R=0,S=0,h=0,debug=false)
{
	N = ( N < 3 ? 3 : N );

	angle = 360/N;
	angleA = angle/2;

	if (debug)
	{
		echo("N = ", N);
		echo("A = ", A);
		echo("S = ", S);
		echo("R = ", R);
	}

	if ( A > 0 )		// if A assign R and S
	{
        S = 2 * A * tan(angleA);							// assign
		//R = (S/2) / sin(angleA);						// no assign ???
		R = ( A * tan(angleA) ) / sin(angleA);		// asign
		_Build_Polygon(N=N,R=R,h=h);
		if (debug)
		{
			echo("aN = ", N);
			echo("aA = ", A);
			echo("aS = ", S);
			echo("aR = ", R);
			#cylinder(r=A,h=h+1,center=true,$fn=150);
			%cylinder(r=R,h=h+1,center=true,$fn=150);
		}
	}
	else
	{
		if ( S > 0 )		// if S assign R and A
		{
			R = (S/2) / sin(angleA);			// assign
			A = S / ( 2 * tan(angleA) );		// assign
            _Build_Polygon(N=N,R=R,h=h);
			if (debug)
			{
				echo("sN = ", N);
				echo("sA = ", A);
				echo("sS = ", S);
				echo("sR = ", R);
				#cylinder(r=A,h=h+1,center=true,$fn=150);
				%cylinder(r=R,h=h+1,center=true,$fn=150);
			}
		}
		else
		{
			if ( R == 0 )		// default
			{
				S = 2 * R * sin(angleA);			// no assign ???
				A = S / ( 2 * tan(angleA) );		// no assign ???
				_Build_Polygon(N=N,h=h);
				if (debug)
				{
					echo("0N = ", N);
					echo("0A = ", A);
					echo("0S = ", S);
					echo("0R = ", R);
					#cylinder(r=A,h=h+1,center=true,$fn=150);
					%cylinder(r=R,h=h+1,center=true,$fn=150);
				}
			}
			else		// build with R
			{
				S = 2 * R * sin(angleA);
				A = S / ( 2 * tan(angleA) );			// no assign ???
				//A = R * ( sin(angleA) / tan(angleA) )	// no assign ???
				_Build_Polygon(N=N,R=R,h=h);
				if (debug)
				{
					echo("rN = ", N);
					echo("rA = ", A);
					echo("rS = ", S);
					echo("rR = ", R);
					%cylinder(r=R,h=h+1,center=true,$fn=150);
				}
			}
		}
	}

	if (debug)
	{
		echo("fN = ", N);
		echo("fA = ", A);
		echo("fS = ", S);
		echo("fR = ", R);
	}
}

//------------------------------------------------------------
// Build
//------------------------------------------------------------
module _Build_Polygon(N=3,R=1,h=0)
{
	if (h > 0)
	{
		// 3D primitive h>0
		cylinder(r=R,h=h,$fn=N,center=true);
	}
	else
	{
		// 2D primitive h=0
		circle(r=R,$fn=N,center=true);
	}
}

//------------------------------------------------------------
// Building lots from N=3, N=N+1
// http://en.wikipedia.org/wiki/Polygon
//------------------------------------------------------------

// 3 sides
module Trigon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=3,A=A,R=R,S=S,h=h,debug=debug);}

module Triangle(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=3,A=A,R=R,S=S,h=h,debug=debug);}

// 4 sides
module Tetragon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=4,A=A,R=R,S=S,h=h,debug=debug);}

module Quadrilateral(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=4,A=A,R=R,S=S,h=h,debug=debug);}

module Quadrangle(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=4,A=A,R=R,S=S,h=h,debug=debug);}

// 5 sides
module Pentagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=5,A=A,R=R,S=S,h=h,debug=debug);}

// 6 sides
module Hexagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=6,A=A,R=R,S=S,h=h,debug=debug);}

// 7 sides
module Heptagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=7,A=A,R=R,S=S,h=h,debug=debug);}

// 8 sides
module Octagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=8,A=A,R=R,S=S,h=h,debug=debug);}

// 9 sides
module Enneagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=9,A=A,R=R,S=S,h=h,debug=debug);}

module Nonagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=9,A=A,R=R,S=S,h=h,debug=debug);}

// 10 sides
module Decagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=10,A=A,R=R,S=S,h=h,debug=debug);}

// 11 sides
module Handecagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=11,A=A,R=R,S=S,h=h,debug=debug);}

// 12 sides
module Dodecagon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=12,A=A,R=R,S=S,h=h,debug=debug);}

// ...

// 100 sides
module Hectogon(A=0,R=0,S=0,h=0,debug=false)
	{Polygon(N=100,A=A,R=R,S=S,h=h,debug=debug);}

//==EOF=======================================================

TODO:

  • Identify the appropriate laser for this project
  • Identify the correct Axicon apex angle (I think 140°)
  • Locate affordable suppliers of 25.4mm diameter Axicons
  • Locate affordable suppliers of BK7 windows with AR coating for 400nm to 460nm, at least.
Handheld Laser Wire Stripper
The ray trace using the Optical Ray Tracer program.

Laser Wire Stripper CPLD Verilog Code

TODO:

  • Extend the existing HDL to incorporate all elements
  • Test the HDL with an appropriate CPLD

This code is not tested and not complete.

`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: 
// Engineer: 
// 
// Create Date:    11:01:49 09/06/2018 
// Design Name: 
// Module Name:    main_top 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//////////////////////////////////////////////////////////////////////////////////
module main_top(
    input wire clk,
    input wire switch1,
    input wire switch2,
    input wire binswitch1,
    input wire binswitch2,
    input wire binswitch3,
    input wire binswitch4,
    output wire ledred,
    output wire ledyellow,
    output wire ledgreen,
    output wire laserenable,
    output wire laseron,
    output wire relay1,
    output wire relay2
    );

reg [3:0] binswitch;
reg [3:0] bincnt = 0;
reg binout;	 
reg [25:0] accum = 0;
wire pps = (accum == 0);

assign laserenable = switch1;
assign ledyellow = laserenable;
assign laseron = switch1 & switch2 & binout;
assign ledred = laseron;
assign ledgreen = ~laseron & ~laserenable;
assign relay1 = laserenable & laseron;
assign relay2 = laserenable & laseron;

always @(posedge clk) begin

    accum <= (pps ? 32_000_000 : accum) - 1;
	 
    if (pps) begin
	 
        bincnt <= bincnt + 1;
		  
		  binswitch <= {binswitch4,binswitch3,binswitch2,binswitch1};
		  
		  if (bincnt == binswitch) begin
		  
				bincnt <= 0;
				
				if (laserenable == 1'b1) begin
				
					binout <= 1'b1;
				
				end else begin
				
					binout <= 1'b0;
				
				end
		  end
    end
end

endmodule

If you’d like to contribute to this project in some way, please contact me.