Affordable Flying Probe-Inspired In-Circuit-Tester for Printed Circuit Boards Evaluation with Application in Test Engineering Education

/*
* Author: Sorin Liviu Jurj
* This code is part of a paper called „Affordable Flying Probe-Inspired In-Circuit-Tester for Printed Circuit Boards Evaluation with Application in Test Engineering Education“. More information about the paper you can find here: https://jurj.de/affordable-flying-probe-inspired-in-circuit-tester-for-printed-circuit-boards-evaluation-with-application-in-test-engineering-education
*
*/

#include <Stepper.h>

#define STEPS_PER_REVOLUTION 2048 //steps takes for the stepper motor for one complete revolution (refer stepper motor manual/doc)
#define MOTOR_SPEED1 15 //speed of motor X
#define MOTOR_SPEED2 15 //speed of motor Y
#define MOTOR_SPEED3 13 //speed of motor Z
#define MM_PER_STEP 0.10 //mm the arm moves for one step of stepper (do trial and run testing for finding this value) initial 7
#define TOTAL_VOLTAGE_PARAMS 5 //total number of voltage parameters to be tested
#define TOTAL_CURRENT_PARAMS 0 //total number of current parameters to be tested
#define RES_CUR_MEASURE 100 //Resistance in ohms between test points for Current measurement
#define STEPS_PER_MM 100 // This is an average value, not completely accurate

/*ENUM to configure stepper directiobn*/
typedef enum{
STEPPER_MOVE_FORWARD,
STEPPER_MOVE_BACKWARD,
}Stepper_Dir_t;

/*
configuration structure declaration for checking voltage
*/
typedef const struct {
int Dist_X_mm; //X distance in mm from reference point to test point
int Dist_Y_mm; //Y distance in mm from reference point to test point
int Dist_Z_mm; //Z distance in mm from reference point to test point
float volExpectedL; //expected voltage lower value in volts
float volExpectedH; //expected voltage higher value in volts
char param[25]; //parameter description
}configStruct_vol;

/*
configuration structure final with exact steps and counts from mm and voltage value
*/
typedef struct {
int Dist_X_step; //no of steps for motor to reach test point from reference point – X
int Dist_Y_step; //no of steps for motor to reach test point from reference point – Y
int Dist_Z_step; //no of steps for motor to reach test point from reference point – Z
int CountExpectedL; //expected voltage lower value in count
int CountExpectedH; //expected voltage higher value in count
}configFinalStructVol_t;

/*
configuration structure declaration for checking current
*/
typedef const struct {
int Dist_X1_mm; //X distance in mm from reference point to first test point
int Dist_Y1_mm; //Y distance in mm from reference point to first test point
int Dist_X2_mm; //X distance in mm from reference point to second test point
int Dist_Y2_mm; //Y distance in mm from reference point to second test point
int Dist_Z_mm; //Z distance in mm from reference point to test point
int curExpectedL; //expected current lower value in milliamps
int curExpectedH; //expected current higher value in milliamps
char param[25]; //parameter description
}configStruct_cur;

/*
configuration structure final with exact steps and counts from mm and current value
*/
typedef struct {
int Dist_X1_step; //no of steps for motor to reach first test point from reference point – X
int Dist_Y1_step; //no of steps for motor to reach first test point from reference point – Y
int Dist_X2_step; //no of steps for motor to reach second test point from reference point – X
int Dist_Y2_step; //no of steps for motor to reach second test point from reference point – Y
int Dist_Z_step; //no of steps for motor to reach test point from reference point – Z
}configFinalStructCur_t;

/*
configuration structure for each params for voltage measurement
User should configure this structure
*/

configStruct_vol myConfigStruct_vol[TOTAL_VOLTAGE_PARAMS] = {
{16.98,11.95,15,4.5,5.0,“param1″}, //Pinul 7 – cu o valoare standard de 5V – Atmega328
{19.99,8.0,15,4.5,5.0,“param2″}, //Pinul 20 – cu o valoare standard de 5V – Atmega328
{19.96,8.0,15,4.5,5.0,“param3″}, //Pinul 21 – cu o valoare standard de 5V – Atmega328
{36.90,17.95,15,4.5,5.0,“param4″}, //Pinul 31 – cu o valoare standard de 5V – Atmega16u2
{38.02,18.60,15,4.5,5.0,“param5″}, //Pinul 32 – cu o valoare standard de 5V – Atmega16u2
};

/*
configuration structure for each params for current measurement
User should configure this structure

SW should check voltage on test point 1 and 2 and find the drop across the resister(user configured) between these two points
to find the current through the path
*/
configStruct_cur myConfigStruct_cur[TOTAL_CURRENT_PARAMS] = {
//{20,20,30,20,20,30,23,“param6″}, // ex: test point1 – (50,60,40) , test point2 – (30,10,40) , expected current range 15-23 mA
//{20,20,30,20,20,30,25,“param7″},
//{20,20,30,25,20,30,25,“param8″},
//{20,20,30,25,20,30,25,“param9″},
};

configFinalStructVol_t configFinalStructVol[TOTAL_VOLTAGE_PARAMS]; //structure for storing test point info (steps and count) for voltage
configFinalStructCur_t configFinalStructCur[TOTAL_CURRENT_PARAMS]; //structure for storing test point info in steps for current

/*stepper motors initialised

IO pins used for stepper motors
X – 22,23,24,25
Y – 26,27,28,29
Z – 30,31,32,33
*/

Stepper stepperX(STEPS_PER_REVOLUTION, 22, 23, 24, 25);
Stepper stepperY(STEPS_PER_REVOLUTION, 26, 27, 28, 29);
Stepper stepperZ(STEPS_PER_REVOLUTION, 30, 31, 32, 33);

int i;

/*
* End point object
*/
class endpoint_t{
uint8_t pin;
Stepper* stepper;

public:
endpoint_t(int p, Stepper* mystepper): pin(p), stepper(mystepper) {} ;

void to_endpoint(void){
//Serial.println(„Starting endpoint localization …“);
while(digitalRead(pin)){ // move until we have reached the endpoint
stepper->step(-100);
}
//Serial.println(„Localization complete …“);
}

};

#define x_endpoint 46 // pin definitions
#define y_endpoint 47
#define z_endpoint 48

endpoint_t* x_axis_endpoint; // define endpoints
endpoint_t* y_axis_endpoint;
endpoint_t* z_axis_endpoint;

void setup() {
//Initialise serial
Serial.begin(9600);
while(!Serial);

// set speed of stepper motors
stepperX.setSpeed(MOTOR_SPEED1);
stepperY.setSpeed(MOTOR_SPEED2);
stepperZ.setSpeed(MOTOR_SPEED3);

x_axis_endpoint = new endpoint_t(x_endpoint, &stepperX);
y_axis_endpoint = new endpoint_t(y_endpoint, &stepperY);
z_axis_endpoint = new endpoint_t(z_endpoint, &stepperZ);

toReferencePoint();

/*
convert arm movement distance to steps and voltage to count
*/
Serial.println(„Converting distances to steps: „);
for (i = 0; i < TOTAL_VOLTAGE_PARAMS ; i ++){
configFinalStructVol[i].Dist_X_step = (myConfigStruct_vol[i].Dist_X_mm) * STEPS_PER_MM;
configFinalStructVol[i].Dist_Y_step = (myConfigStruct_vol[i].Dist_Y_mm) * STEPS_PER_MM;
configFinalStructVol[i].Dist_Z_step = (myConfigStruct_vol[i].Dist_Z_mm) * STEPS_PER_MM;
configFinalStructVol[i].CountExpectedL = (1023 * (myConfigStruct_vol[i].volExpectedL)) / 5;
configFinalStructVol[i].CountExpectedH = (1023 * (myConfigStruct_vol[i].volExpectedH)) / 5;

}

/*
convert arm movement distance to steps for tesing current at testing points
*/
for (i = 0; i < TOTAL_CURRENT_PARAMS ; i ++){
configFinalStructCur[i].Dist_X1_step = (myConfigStruct_cur[i].Dist_X1_mm) * STEPS_PER_MM;
configFinalStructCur[i].Dist_Y1_step = (myConfigStruct_cur[i].Dist_Y1_mm) * STEPS_PER_MM;
configFinalStructCur[i].Dist_X2_step = (myConfigStruct_cur[i].Dist_X2_mm) * STEPS_PER_MM;
configFinalStructCur[i].Dist_Y2_step = (myConfigStruct_cur[i].Dist_Y2_mm) * STEPS_PER_MM;
configFinalStructCur[i].Dist_Z_step = (myConfigStruct_cur[i].Dist_Z_mm) * STEPS_PER_MM;
}

Serial.println(„Setup complete.“);
}

String str ;
String startstr = String(„START“) ;

int count ;
float voltage1,voltage2;
int cur_mA;

void loop() {

/*check if user inputs via serial*/
if(Serial.available()>0){
str = Serial.readString();

/*check if user inputs START via serial*/
if(str.equals(startstr))
{
Serial.println(„STARTING UP….“);

for (i = 0; i < TOTAL_VOLTAGE_PARAMS ; i ++){
Serial.print(myConfigStruct_vol[i].param);

/*locate the arm to pogo pin position from reference point*/
stepperMove(
configFinalStructVol[i].Dist_X_step,
configFinalStructVol[i].Dist_Y_step,
configFinalStructVol[i].Dist_Z_step,
STEPPER_MOVE_FORWARD,
STEPPER_MOVE_FORWARD,
STEPPER_MOVE_FORWARD
);
delay(500);

/*read the analog value from the test point*/
count = analogRead(A0);
delay(1000); // delay before we start retracting probe

/*retract arm to reference point*/
toReferencePoint();
delay(50);

/*checks if the voltage is beyond expected range*/
if((count < configFinalStructVol[i].CountExpectedL) || (count > configFinalStructVol[i].CountExpectedH)){
Serial.println(“ : FAILED“);
//continue;
}
else{
Serial.println(“ : SUCCESS“);
}
Serial.println(„finished parameter: “ + String(i));
}

/*
check if voltage values tested successfully at test points
*/
if(i == TOTAL_VOLTAGE_PARAMS){

/*Current values testing on the test points*/
for (i = 0; i < TOTAL_CURRENT_PARAMS ; i ++){

Serial.print(myConfigStruct_cur[i].param);

/*locate the arm to test point 1 from reference point*/
stepperMove(configFinalStructCur[i].Dist_X1_step,configFinalStructCur[i].Dist_Y1_step,configFinalStructCur[i].Dist_Z_step,STEPPER_MOVE_FORWARD);
delay(10);

/*read the voltage value from the test point*/
voltage1 = (float)(analogRead(A0) * 5) / 1023;

/*retract arm to reference point*/
stepperMove(configFinalStructCur[i].Dist_X1_step,configFinalStructCur[i].Dist_Y1_step,configFinalStructCur[i].Dist_Z_step,STEPPER_MOVE_BACKWARD);
delay(10);

/*locate the arm to test point 2 from reference point*/
stepperMove(configFinalStructCur[i].Dist_X2_step,configFinalStructCur[i].Dist_Y2_step,configFinalStructCur[i].Dist_Z_step,STEPPER_MOVE_FORWARD);
delay(10);

/*read the voltage value from the test point*/
voltage2 = (float)(analogRead(A0) * 5) / 1023;

/*retract arm to reference point*/
stepperMove(configFinalStructCur[i].Dist_X2_step,configFinalStructCur[i].Dist_Y2_step,configFinalStructCur[i].Dist_Z_step,STEPPER_MOVE_BACKWARD);
delay(10);

/*Find current across the resistor*/
cur_mA = ((voltage2 – voltage1)/RES_CUR_MEASURE) * 1000 ;

/*checks if the current is beyond expected range*/
if((cur_mA < myConfigStruct_cur[i].curExpectedL) || (cur_mA > myConfigStruct_cur[i].curExpectedH)){
Serial.println(“ : FAILED“);
break;
}
else{
Serial.println(“ : SUCCESS“);
}
}

/*
check if voltage values tested successfully at test points
*/
if(i == TOTAL_CURRENT_PARAMS){
Serial.println(„FINAL TEST STATUS : SUCCESS“);
}
/*
ERROR in tesing current values
*/
else{
Serial.println(„FINAL TEST STATUS : FAILED“);
Serial.println(„ENTER START TO INITIALIZE.. „);
}
}
/*
ERROR in tesing voltage values
*/
else{
Serial.println(„FINAL TEST STATUS : FAILED“);
Serial.println(„ENTER START TO INITIALIZE.. „);
}

}else{
Serial.println(„INVALID COMMAND.. „);
}
}
}

/*
Funtion to Move stepper forward and backward
*/
void stepperMove(int x,int y, int z , Stepper_Dir_t xdir, Stepper_Dir_t ydir, Stepper_Dir_t zdir){
if(xdir == STEPPER_MOVE_FORWARD){
stepperX.step(x);
}else{
stepperX.step(-x);
}

if(ydir == STEPPER_MOVE_FORWARD){
stepperY.step(y);
}else{
stepperY.step(-y);
}

delay(2000);
if(zdir == STEPPER_MOVE_FORWARD){
stepperZ.step(z);
}else{
stepperZ.step(-z);
}
}

void stepperMove(int x,int y, int z , Stepper_Dir_t dir){
switch (dir){
case STEPPER_MOVE_FORWARD:
stepperX.step(x);
stepperY.step(y);
stepperZ.step(z);
break;

case STEPPER_MOVE_BACKWARD:
stepperZ.step(-z);
stepperY.step(-y);
stepperX.step(-x);
break;

default:
break;
}
}

/*
* Function that returns probe to reference point
*/
void toReferencePoint(){
z_axis_endpoint->to_endpoint();
x_axis_endpoint->to_endpoint();
y_axis_endpoint->to_endpoint();

}