ultrafast laser micromachining system

current state

user quick start

1. initialize stage so it's position is absolute
2. find focus using MCS controls
3. take note fo the position
4. turn the stage off / on and re-initialize
5. move to noted position - you may need to adjust by a few microns.

UI improvements to do:

• control stage without arrow keys or buttons instead of inputing numerical value each time
• figure out how to allow stage control from the UI and MCS Joysticks in the same power cycle
• laser power control over serial to access to it from the toolpathing
• multithread console output so that it write as the toolpath goes instead of waiting until the end

Optics improvements to do:

• realign the camera and/or laser so that the laser is in the center of the camera frame and the motion matches stage movement IRL
• verify that the camera and laser have the same focus point - or determine reproducible offset for correcting toolpaths.
• clean optical elements and check for aberrations in the beam path - it's been a couple years since anything's been adjusted

CAM improvements to do:

• . . . hmm . . everything . . .
• i think before I can commit to a solution here, I need to figure out how committed I am to the MCS controller - would it be possible and beneficial to drive the piezo stages from a lower level ??

piezo stage controls

      
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#include <Windows.h>

#include "include\MCSControl.h"
#include "include\stage_utils.h"

void delay(int sec) {
  int ms = sec * 1000;
  clock_t start = clock();
  while (clock() < start + ms) {
    ;
  }
}

void findReference(SA_INDEX handle) {
  for (int i = 0; i < 3; i++) {
    checkErr( SA_FindReferenceMark_S(handle, i, SA_BACKWARD_DIRECTION, 0, 1));
  }
}

int main() {
  SA_STATUS error = SA_OK;
  SA_INDEX mcsHandle = openSystem();

  // check all three channels are awake
  unsigned int numChannels;
  checkErr( SA_GetNumberOfChannels(mcsHandle, &numChannels) );
  if(numChannels != 3){
    printf("%d channels found. Should be 3 . . . exiting!\n", numChannels);
    closeSystem(mcsHandle);
    return 1;
  }

  // check if position is known
  // ch 2 = Z
  // ch 1 = Y (perpendicular to source of laser)
  // ch 0 = X (parallel to source of laser)
  boolean needInit = checkReference(mcsHandle);

  if(needInit == false) {
    printf("Stage already initialized! \n");
    closeSystem(mcsHandle);
    return 0;
  } else {
    printf("Stage position unknown. Initializing . . . \n");
  }

  // set the channel reference speed value to automatically optimize
  for (int i = 0; i < 3; i++) {
    checkErr(
      SA_SetChannelProperty_S(
        mcsHandle,
        i,
        SA_EPK(
          SA_SENSOR,
          SA_REFERENCE_SIGNAL,
          SA_REFERENCE_SPEED),
        -1
      )
    );
  }

  // find reference points
  findReference(mcsHandle);

  delay(10);


  needInit = checkReference(mcsHandle);
  if(needInit == true){
    printf("waiting 10 more seconds . . . \n");
    delay(10);
    needInit = checkReference(mcsHandle);
    if (needInit == true){
      printf("searching for reference point again . . . \n");
      findReference(mcsHandle);
      delay(10);
      needInit = checkReference(mcsHandle);
      if (needInit == true){
        printf("Initialization failed. Exiting. . . \n");
        closeSystem(mcsHandle);
      }
    }
  }

  printf("reference point found and set to origin. \n");

  // setup closed loop max
  //    frequency (18500 Hz),
  //    acceleration (10,000,000 um/sec^2),
  //    speed (100,000,000 um/sec)

  for (int i = 0; i <3; i++) {
    checkErr( SA_SetClosedLoopMaxFrequency_S(mcsHandle, i, 18500));
    checkErr( SA_SetClosedLoopMoveAcceleration_S(mcsHandle, i, 10000000));
    checkErr( SA_SetClosedLoopMoveSpeed_S(mcsHandle, i, 100000000));
  }

  // move to origin
  G1(mcsHandle, 0, 0, 0);

  // set jogging speed to 10 mm/s
  F(mcsHandle, 10);

  float x, y, z;
  getPositionmm(mcsHandle, true, &x, &y, &z);

  closeSystem(mcsHandle);
  return 0;

}


      
    

      
def __init__(self):
    # open library
    self.lib = cdll.LoadLibrary(".\\lib\\MCSControl")

    self.handle = self.openSystem()

def openSystem(self):
    handle = c_int()
    status = self.lib.SA_OpenSystem(byref(handle), b"usb:ix:0", b"sync")
    if status != 0:
        print("Could not connect to stage")
        return handle
    print("Stage opened.")
    return handle
      
    

      
PyQt5 interface
|-- StageMCS
    |-- openSystem()                         : connects to stage over USB
    |-- closeSystem()                        : disconnects from stage
    |-- init()                               : initialize stage
    |-- G1(x, y, z)                          : move to position (x, y, z) in mm
    |-- F(speed)                             : set speed of all axes in units of mm/s
    |-- getPosition(*pprint)                 : return current x, y, z position in mm.
                                               pprint is an optional boolean input to
                                               print the results as well as return
    |-- getSpeed(*pprint)                    : return speed in mm/s of stage.
                                               pprint same as getPosition.
    |-- G92(x, y, z)                         : overrides current stage position to be
                                               equal to (x, y, z) input in mm.
|-- PharosComs
    |-- init()                               : ping laser serial line for version
                                               to verify connection
    |-- laserOn()                            : open shutter and turn on pulse picker
    |-- laserOff()                           : turn off pulse picker and close shutter
    |-- close()                              : close serial connection to laser
|-- BtnCommands
    |-- rectangle(xlen, ylen, speed, passes) : machine rectangle with x and y
                                               input length and current position
                                               bottom left corner
    |-- line(xlen, ylen, speed, passes)      : machine line from current position
                                               to given (xlen, ylen) point
    |-- origin()                             : move stage to orign
      
    

websocket application

Async I/O

• asyncio in python with async/await keywords - the whole app needs to be run asynchronously because it needs to do things while the commands are sent to the stage so re-writing the stage and laser classes to un asynchronously and send messages over the websocket
• async/await syntax it's not true parallel programming or concurency becuase there's only ever one thread and a single CPU core is used, but it allows the active process to be passed off to other tasks for the most efficient completion of tasks.
• functions or loops are prefixed with async to flag it as a co-routine which can be waited on with the await flag. So if there's a long process, wrap it with async and then call it with await prefixed . . .

more on concurrency

1. the consumer task which receives websocket messages and decodes them into button commands for the stage and laser
2. the producer task which sends console messages to the client as they are written to a queue
3. a continuous task which sends a "heartbeat" style update to the client giving the current stage position and speed

threading

asyncio

multiprocessing

race condition debugging

laser characterization

• What is the laser spot size?
• Is the camera focus point aligned with the alser focus point?

• laser power
• pulse repetition rate
• scanning speed
• focus offset

• ablation depth (confocal, AFM?)
• kerf (SEM)
• surface roughness (SEM)
• material removal rate (abaltion depth / machining time)

focus optimization

speed optimization

table wobble

material testing

0.0005" stainless steel

0.001" copper