Widefield Triple Imaging Rig

[Gina]

I have been trying to find a way to check the threads for the other adapters.  Problem is that both threads are the same size so there is no possibility of bringing both threads out at one end like I did with the 42-48mm OAG adapter.  Measuring the size with my digital calipers doesn't seem to be accurate enough.

[Gina]

Hi Gina,

Nice ! You will be feeling pleased with your efforts....and so you should!

Boyd

Thank you Boyd   Yes, it's coming along  

In view of the weather forecast of cloudy skies for the next five days I have dismantled my current rig from the EQ8 so that it's available to start testing my new WF rig.  (I'm also setting up my medium FOV triple setup.)  The EQ8 is already polar aligned and there is all the equipment ready for imaging and guiding.  I don't want too many variables to sort out at a time   I can do a lot of testing in daytime in cloudy conditions by pointing at the trees on the next hill.  Things like checking that the FOVs match and sort out any alignment problems, if they exist.

[Gina]

Lodestar attached to OAG with home-made adapter.

[Horwig]

Nice 

Huw

[bluemaxroe]

Amazing work Gina!!  

[Gina]

Thank you

[Gina]

With three lenses we need three focussing systems.  Actually, one system with three stepper motors and their timing belt drives to the focus sleeves of the lenses.  Arduino Unos and Nanos can only handle two so the Arduino Mega is needed.  Like my dual focussing system, the triple will be controlled initially by a series of push button switches that move the focus as follows :-

1. Fast Backwards
2. 10 steps Backwards
3. One step Backwards
4. One step Forwards
5. Fast Forward

Another control chooses which focuser to operate.  In the two focuser system I used a simple on/off toggle switch and digital input to the Arduino but with three to control a three position switch will be used.  This may be a toggle switch or rotary.

To reduce the number of wires connecting the remote control box to the Arduino at the imaging rig, a single analogue voltage is used rather than multi-wire digital.  The focus movement uses 6 voltage levels with 0v being off and voltages 1 2 3 4 5 representing the 5 operations listed above.  Similarly, the focuser is selected by a varying voltage, in this case 0v, 2.5v and 5v.

Because mechanical switches produce contact bounce, code is use to counteract this.  The off state is detected and then a delay introduced to allow all bouncing to finish before the next operation is allowed.  This prevents the switch button press producing multiple actions for the single step and 10 backwards modes.  This also stops a wrong action as the voltage decays from a higher level to zero due to interference suppression on the analogue lines.

[Gina]

Here is the Arduino sketch that provides the above.

// This Arduino example demonstrates bidirectional operation of a // 28BYJ-48, which is readily available on eBay, using a ULN2003 // interface board to drive the stepper. The 28BYJ-48 motor is a 4-// phase, 8-beat motor, geared down by a factor of 64. One bipolar // winding is on motor pins 1 & 3 and the other on motor pins 2 & 4. // Refer to the manufacturer's documentation of  Changzhou Fulling // Motor Co., Ltd., among others.  The step angle is 5.625/64 and the // operating Frequency is 100pps. Current draw is 92mA for the 5v version. ////////////////////////////////////////////////// Arduino Sketch for triple imaging rig focus control using stepper motors type 28BYJ-48 5v driven by ULN2003 driver modules// This uses an Arduino Mega 2560// Half step micro-stepping used for finer control////declare variables for the motor pinsint motorPin1a = 31;	// Blue   - 28BYJ48 pin 1int motorPin2a = 33;	// Pink   - 28BYJ48 pin 2int motorPin3a = 35;	// Yellow - 28BYJ48 pin 3int motorPin4a = 37;	// Orange - 28BYJ48 pin 4                        // Red    - 28BYJ48 pin 5 (VCC)int motorPin1b = 39;	// Blue   - 28BYJ48 pin 1int motorPin2b = 41;	// Pink   - 28BYJ48 pin 2int motorPin3b = 43;	// Yellow - 28BYJ48 pin 3int motorPin4b = 45;	// Orange - 28BYJ48 pin 4                        // Red    - 28BYJ48 pin 5 (VCC)int motorPin1c = 47;	// Blue   - 28BYJ48 pin 1int motorPin2c = 49;	// Pink   - 28BYJ48 pin 2int motorPin3c = 51;	// Yellow - 28BYJ48 pin 3int motorPin4c = 53;	// Orange - 28BYJ48 pin 4////////////////////////////int motorSpeed = 1200;  //variable to set stepper speedint count = 0;          // count of steps madeint countsperrev = 512; // number of steps per full revolutionint lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};//////////////////////////////////int wfPin = 10;  // Which focuser select switchint controlPin = 0;  //  Input control line pinint wf =0; // which focuserint focusCount = 0;  // focus countint val = 0;  //  value of control input voltage - functionint wfval = 0;  //  value of control input voltage for which focuserint opCode = 0;  //  corresponding operation codeint stepSize = 5;  // how many motor steps correspond to one focussing stepboolean busy = false;  // used to counteract contact bounce - wait for "up" before continuing//////////////////////////////////////////////////////////////////////////////void setup() {  //declare the motor pins as outputs  pinMode(motorPin1a, OUTPUT);  pinMode(motorPin2a, OUTPUT);  pinMode(motorPin3a, OUTPUT);  pinMode(motorPin4a, OUTPUT);  pinMode(motorPin1b, OUTPUT);  pinMode(motorPin2b, OUTPUT);  pinMode(motorPin3b, OUTPUT);  pinMode(motorPin4b, OUTPUT);  pinMode(motorPin1c, OUTPUT);  pinMode(motorPin2c, OUTPUT);  pinMode(motorPin3c, OUTPUT);  pinMode(motorPin4c, OUTPUT);  Serial.begin(9600);}////////////////////////////////////////////////////////////////////////////////set pins to ULN2003 high in sequence from 1 to 4//delay "motorSpeed" between each pin setting (to determine speed)void serialDisplay(){  Serial.print ("Focus No."), (wf+1);  Serial.println(focusCount);}void moveBackward(){  for (int s = 0; s < stepSize; s++) {    for(int i = 0; i < 8; i++)    {      setOutput(i);      delayMicroseconds(motorSpeed);    }  }  focusCount--;  serialDisplay();}///////////////////////////void moveForward(){  for (int s = 0; s < stepSize; s++) {    for(int i = 7; i >= 0; i--)    {      setOutput(i);      delayMicroseconds(motorSpeed);    }  }  focusCount++;  serialDisplay();}////////////////////////void setOutput(int out){  switch(wf) {    case 0 :  {      digitalWrite(motorPin1a, bitRead(lookup[out], 0));      digitalWrite(motorPin2a, bitRead(lookup[out], 1));      digitalWrite(motorPin3a, bitRead(lookup[out], 2));      digitalWrite(motorPin4a, bitRead(lookup[out], 3));  }    case 1 :  {      digitalWrite(motorPin1b, bitRead(lookup[out], 0));      digitalWrite(motorPin2b, bitRead(lookup[out], 1));      digitalWrite(motorPin3b, bitRead(lookup[out], 2));      digitalWrite(motorPin4b, bitRead(lookup[out], 3)); }    case 2 :  {      digitalWrite(motorPin1c, bitRead(lookup[out], 0));      digitalWrite(motorPin2c, bitRead(lookup[out], 1));      digitalWrite(motorPin3c, bitRead(lookup[out], 2));      digitalWrite(motorPin4c, bitRead(lookup[out], 3)); }  }}///////////////////////void moveB10() {   if (busy == false) {  // do it once then wait for button release     for (int i = 9; i >= 0; i--) {    moveBackward(); }    busy = true; }}////////////////////////////void moveB1() {    if (busy == false) {    moveBackward();    busy = true; }}//////////////////////////void moveF1() {    if (busy == false) {    moveForward();    busy = true; }}///////////////////////void loop() {  wfval = analogRead(wfPin);  // Select which focuser to control// Break points 333 and 666  if (val < 333) {  //  allow for small variations in control line voltage by separating into bands    wf = 0;  } else if (val < 666) {    wf = 1;  } else {    wf = 2;  }  val = analogRead(controlPin);// Break points 102, 307, 512, 717 and 922  if (val < 102) {  //  allow for small variations in control line voltage by separating into bands    opCode = 0;  } else if (val < 307) {    opCode = 1;  } else if (val < 512) {    opCode = 2;  } else if (val < 717) {    opCode = 3;  } else if (val < 922) {    opCode = 4;  } else {    opCode = 5;  }//  switch(opCode) {    case 0 : busy = false; delay(100); break;  // clear busy flag and wait for button state to settle (switch bounce)    case 1 : moveBackward(); break;    case 2 : moveB10(); break;    case 3 : moveB1(); break;    case 4 : moveF1(); break;    case 5 : moveForward(); break;  }}

[Gina]

Been looking at this a bit closer and I think a Nano will just do it using all the digital outputs to drive the three steppers.  Analogue inputs can be used for manual control as shown above or the USB can be used for computer control either with manual control using a specially coded interface or automatically via ASCOM as designed and described by teckydave in another thread.

[Gina]

The Arduino sketch above will do with the stepper data pins and control pins reallocated.

D2  \

D3  |   Stepper

D4  |   One

D5  /

D6  \

D7  |   Stepper

D8  |   Two

D9  /

D10  \

D11  |   Stepper

D12  |   Three

D13  /

[Gina]

I've modified the Arduino sketch to use the Nano as described above.  I haven't been able to test it as yet.

// Gina's triple remote focussing system using manual control// with resistor values selected by toggle switches to select // which focus stepper motor to control and push buttons to choose// Fast Backwards// 10 Steps Back// One Step Back// One Step Forwards// Fast Forwards// No button pressed represents no action//// Stepper motors used are 28BYJ-48 with ULN2003 drivers// 4 phase, 8-beat motor, geared down by a factor of 64. // Step angle is 5.625/64 degrees.//////////////////////////////////////////////////declare variables for the motor pinsint motorPin1a = 2;	// Blue   - 28BYJ48 pin 1int motorPin2a = 3;	// Pink   - 28BYJ48 pin 2int motorPin3a = 4;	// Yellow - 28BYJ48 pin 3int motorPin4a = 5;	// Orange - 28BYJ48 pin 4                        // Red    - 28BYJ48 pin 5 (VCC)int motorPin1b = 6;	// Blue   - 28BYJ48 pin 1int motorPin2b = 7;	// Pink   - 28BYJ48 pin 2int motorPin3b = 8;	// Yellow - 28BYJ48 pin 3int motorPin4b = 9;	// Orange - 28BYJ48 pin 4//int motorPin1c = 10;	// Blue   - 28BYJ48 pin 1int motorPin2c = 11;	// Pink   - 28BYJ48 pin 2int motorPin3c = 12;	// Yellow - 28BYJ48 pin 3int motorPin4c = 13;	// Orange - 28BYJ48 pin 4////////////////////////////int motorSpeed = 1200;  //variable to set stepper speedint count = 0;          // count of steps madeint countsperrev = 512; // number of steps per full revolutionint lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};//////////////////////////////////int wfPin = 1;  // Widefield focuser select switchint controlPin = 0;  //  Input control line pinint wf=0; // Which focuser int focusCount = 0;  // focus count for WF // int focusCount_b = 0;  // focus count for scope// int focusCountPrev_a = 0;// int focusCountPrev_b = 0;int val = 0;  //  value of control input voltageint wfval = 0;  //  value of control input voltage for which focuserint opCode = 0;  //  corresponding operation codeint stepSize = 5;  // how many motor steps correspond to one focussing stepboolean busy = false;  // used to provide single action buttons - wait for "up" before continuing//////////////////////////////////////////////////////////////////////////////void setup() {  //declare the motor pins as outputs  pinMode(motorPin1a, OUTPUT);  pinMode(motorPin2a, OUTPUT);  pinMode(motorPin3a, OUTPUT);  pinMode(motorPin4a, OUTPUT);  pinMode(motorPin1b, OUTPUT);  pinMode(motorPin2b, OUTPUT);  pinMode(motorPin3b, OUTPUT);  pinMode(motorPin4b, OUTPUT);  pinMode(motorPin1c, OUTPUT);  pinMode(motorPin2c, OUTPUT);  pinMode(motorPin3c, OUTPUT);  pinMode(motorPin4c, OUTPUT);  Serial.begin(9600);}////////////////////////////////////////////////////////////////////////////////set pins to ULN2003 high in sequence from 1 to 4//delay "motorSpeed" between each pin setting (to determine speed)void serialDisplay(){  Serial.print (digitalRead(wfPin));  Serial.println(focusCount);}void moveBackward(){  for (int s = 0; s < stepSize; s++) {    for(int i = 0; i < 8; i++)    {      setOutput(i);      delayMicroseconds(motorSpeed);    }  }  focusCount--;  serialDisplay();}///////////////////////////void moveForward(){  for (int s = 0; s < stepSize; s++) {    for(int i = 7; i >= 0; i--)    {      setOutput(i);      delayMicroseconds(motorSpeed);    }  }  focusCount++;  serialDisplay();}////////////////////////void setOutput(int out){  switch(wf) {    case 0 :  {      digitalWrite(motorPin1a, bitRead(lookup[out], 0));      digitalWrite(motorPin2a, bitRead(lookup[out], 1));      digitalWrite(motorPin3a, bitRead(lookup[out], 2));      digitalWrite(motorPin4a, bitRead(lookup[out], 3));  }    case 1 :  {      digitalWrite(motorPin1b, bitRead(lookup[out], 0));      digitalWrite(motorPin2b, bitRead(lookup[out], 1));      digitalWrite(motorPin3b, bitRead(lookup[out], 2));      digitalWrite(motorPin4b, bitRead(lookup[out], 3)); }    case 2 :  {      digitalWrite(motorPin1c, bitRead(lookup[out], 0));      digitalWrite(motorPin2c, bitRead(lookup[out], 1));      digitalWrite(motorPin3c, bitRead(lookup[out], 2));      digitalWrite(motorPin4c, bitRead(lookup[out], 3)); }  }}///////////////////////void moveB10() {   if (busy == false) {  // do it once then wait for button release     for (int i = 9; i >= 0; i--) {    moveBackward(); }    busy = true; }}////////////////////////////void moveB1() {    if (busy == false) {    moveBackward();    busy = true; }}//////////////////////////void moveF1() {    if (busy == false) {    moveForward();    busy = true; }}///////////////////////void loop() {  wfval = analogRead(wfPin);  // Select which focuser to control// Break points 333 and 666  if (val < 333) {  //  allow for small variations in control line voltage by separating into bands    wf = 0;  } else if (val < 666) {    wf = 1;  } else {    wf = 2;  }  val = analogRead(controlPin);// Break points 102, 307, 512, 717 and 922  if (val < 102) {  //  allow for small variations in control line voltage by separating into bands    opCode = 5;  } else if (val < 307) {    opCode = 4;  } else if (val < 512) {    opCode = 3;  } else if (val < 717) {    opCode = 2;  } else if (val < 922) {    opCode = 1;  } else {    opCode = 0;  //  no buttons pressed  }//  switch(opCode) {    case 0 : busy = false; delay(100); break;  // clear busy flag and wait for button state to settle (switch bounce)    case 1 : moveBackward(); break;    case 2 : moveB10(); break;    case 3 : moveB1(); break;    case 4 : moveF1(); break;    case 5 : moveForward(); break;  }}

[Knight of Clear Skies]

Will be very interesting to see this in operation. I do think multiple lenses are a good approach, especially in dodgy UK weather where clear skies are at a premium. Further down the road I'd like to get two DSLRs up and running on a mount.

[gingergeek]

Loving the details of the journey ! Superb work

[Gina]

Thank you

[Gina]

In view of the success I have had with 3D printed spur gears I am considering changing from timing belt drive to spur gears for focussing.  I can get a higher step down ratio this way and also have less sideways force on the lens.  Since I already have the mechanicals arranged for timing belt drive I will be trying this first though.

This project has taken a back seat lately in favour of my main larger rig with telescopes but I'm hoping to have that finished soon and then this widefield rig will get priority.

[astro mick]

Hi Gina.

I have just picked up this thread,yes I know but there it is.

I am putting to-gether a 3 scope imaging system myself,but using commercial scopes.

I am in total awe of your capabilities,and ingenious thinking.

You deserve to succeed,and wish you all the best.

What a great thread to follow.

Mick.

[Gina]

Thank you Mick

[Gina]

Picking this up again - I need to find a Nano, a piece of stripboard and two ULN2003A chips and then I can make up the focuser control unit.  The focus sleeves on the three lenses are presently driven be timing belts from three small stepper motors mounted on a circular mounting plate as shown above.  But as I've said I shall be looking at 3D printed spur gears.  Previously, timing belts have caused slight changes in alignment between imaging units in the past design.

However, the next part of this project I am working on will be the focus electronics.  Unlike the telescope triple imaging rig which uses the separate ULN2003A driver modules, here I'll be using just the chips to save space.  12 data lines are required for the three stepper motors so with the ULN2003A chips handling 7 driver transistors, two chips are required rather than three modules.

[Gina]

Here is a sketch of the circuit board layout for the Remote Focussing System.  It works out that stepper line drivers use 7 from the first ULN2003A and 5 from the second.  The Arduino Nano uses USB power and will have PC control using a VB app and possibly later on, ASCOM automatic focussing.  The stepper motors will be hard wired to the circuit board - using the wire colours as shown.

[Gina]

As a result of the way the wiring works out we need a small modification to the Arduino sketch.

//declare variables for the motor pinsint motorPin1a = 2;	// Blue   - 28BYJ48 int motorPin2a = 3;	// Pink   - 28BYJ48 int motorPin3a = 4;	// Yellow - 28BYJ48 int motorPin4a = 5;	// Orange - 28BYJ48                         // Red    - 28BYJ48  (Vcc)int motorPin1b = 6;	// Blue   - 28BYJ48 int motorPin2b = 7;	// Pink   - 28BYJ48 int motorPin3b = 8;	// Yellow - 28BYJ48 int motorPin4b = 10;	// Orange - 28BYJ48 //int motorPin1c = 11;	// Blue   - 28BYJ48 int motorPin2c = 12;	// Pink   - 28BYJ48 int motorPin3c = 13;	// Yellow - 28BYJ48 int motorPin4c = 9;	// Orange - 28BYJ48 

[Gina]

Here's an improved circuit layout sketch showing the Arduino pin labels and tidied uo a bit.

[Davey-T]

New you couldn't stay idle for long 

Dave

[Gina]

You are dead right there

[Gina]

Layout and wiring diagram for the Arduino Nano and stepper drivers.

[Gina]

Here's the Arduino sketch for this remote focussing system, modified to use my computer VB app for control.  This has NOT been tested yet.

// Gina's triple remote focussing system using PC control - 2014-12-22 1830// File name - astro_focuser_half_step_triple_WF_02//// Stepper motors used are 28BYJ-48 with ULN2003A drivers// 4 phase, 8-beat motor, geared down by a factor of 64. // Step angle is 5.625/64 degrees.//////////////////////////////////////////////////declare variables for the motor pinsint motorPin1a = 2;	// Blue   - 28BYJ48 pin 1int motorPin2a = 3;	// Pink   - 28BYJ48 pin 2int motorPin3a = 4;	// Yellow - 28BYJ48 pin 3int motorPin4a = 5;	// Orange - 28BYJ48 pin 4                        // Red    - 28BYJ48 pin 5 (VCC)int motorPin1b = 6;	// Blue   - 28BYJ48 pin 1int motorPin2b = 7;	// Pink   - 28BYJ48 pin 2int motorPin3b = 8;	// Yellow - 28BYJ48 pin 3int motorPin4b = 10;	// Orange - 28BYJ48 pin 4//int motorPin1c = 11;	// Blue   - 28BYJ48 pin 1int motorPin2c = 12;	// Pink   - 28BYJ48 pin 2int motorPin3c = 13;	// Yellow - 28BYJ48 pin 3int motorPin4c = 9;	// Orange - 28BYJ48 pin 4////////////////////////////int incomingByte = 0;   // for incoming serial dataint Focuser = 0;int FocusSpeed = 1;int motorSpeed = 1200;  //variable to set stepper speedint lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};//////////////////////////////////int focusCount[3] = {0, 0, 0};  // int stepSize = 5;  // how many motor steps correspond to one focussing step - this may need changing after testing//////////////////////////////////////////////////////////////////////////////void setup() {  //declare the motor pins as outputs  pinMode(motorPin1a, OUTPUT);  pinMode(motorPin2a, OUTPUT);  pinMode(motorPin3a, OUTPUT);  pinMode(motorPin4a, OUTPUT);  pinMode(motorPin1b, OUTPUT);  pinMode(motorPin2b, OUTPUT);  pinMode(motorPin3b, OUTPUT);  pinMode(motorPin4b, OUTPUT);  pinMode(motorPin1c, OUTPUT);  pinMode(motorPin2c, OUTPUT);  pinMode(motorPin3c, OUTPUT);  pinMode(motorPin4c, OUTPUT);  Serial.begin(9600);}////////////////////////////////////////////////////////////////////////////////set pins to ULN2003 high in sequence from 1 to 4//delay "motorSpeed" between each pin setting (to determine speed)void moveBackward(){  for (int s = 0; s < stepSize; s++) {    for(int i = 0; i < 8; i++)    {      setOutput(i);      delayMicroseconds(motorSpeed);    }  }  focusCount[Focuser]--;//  sendFocusCount ();}///////////////////////////void moveForward(){  for (int s = 0; s < stepSize; s++) {    for(int i = 7; i >= 0; i--)    {      setOutput(i);      delayMicroseconds(motorSpeed);    }  }  focusCount[Focuser]++;//  sendFocusCount ();}////////////////////////void setOutput(int out){  switch(Focuser) {    case 0 :  {      digitalWrite(motorPin1a, bitRead(lookup[out], 0));      digitalWrite(motorPin2a, bitRead(lookup[out], 1));      digitalWrite(motorPin3a, bitRead(lookup[out], 2));      digitalWrite(motorPin4a, bitRead(lookup[out], 3));  }    case 1 :  {      digitalWrite(motorPin1b, bitRead(lookup[out], 0));      digitalWrite(motorPin2b, bitRead(lookup[out], 1));      digitalWrite(motorPin3b, bitRead(lookup[out], 2));      digitalWrite(motorPin4b, bitRead(lookup[out], 3)); }    case 2 :  {      digitalWrite(motorPin1c, bitRead(lookup[out], 0));      digitalWrite(motorPin2c, bitRead(lookup[out], 1));      digitalWrite(motorPin3c, bitRead(lookup[out], 2));      digitalWrite(motorPin4c, bitRead(lookup[out], 3)); }  }}///////////////////////void moveManyF(count) {    for (int i = (count -1); i >= 0; i--) { moveForward(); }  sendFocusCount ();}   //void moveManyB(count) {    for (int i = (count -1); i >= 0; i--) { moveBackward(); }  sendFocusCount ();}   ///////////////////////void sendFocusCount (){  Serial.println(focusCount[Focuser]);}void loop() {  if (Serial.available())  {  incomingByte = Serial.read();  switch (incomingByte) {    case 49://      Serial.println("Ha Focuser Selected");      Focuser = 0;      sendFocusCount ();      break;    case 50://      Serial.println("OIII Focuser Selected ");      Focuser = 1;      sendFocusCount ();      break;    case 51://      Serial.println("SII Focuser Selected");      Focuser = 2;      sendFocusCount ();      break;    case 52: //     Serial.println("Unused Focuser Selected");  // Not used in this version (only in 4 focuser maodel)      break;    case 53: //     Serial.println("Single Step Focussing");      FocusSpeed = 1;      break;    case 54: //     Serial.println("10 Step Focussing");      FocusSpeed = 10;            break;    case 55://      Serial.println("100 Step Focussing");      FocusSpeed = 100;      break;    case 56://      Serial.print("< ");      moveManyB(FocusSpeed);      break;    case 57://      Serial.print("> ");      moveManyF(FocusSpeed);      break;    default:       // if nothing else matches, do the default      // default is optional      Serial.print("Unrecognised Command: ");      Serial.println(incomingByte, DEC); }