SVBony SV205 - Using as All-Sky

Post Reply
brenski
Posts: 82
Joined: Mon Aug 10, 2020 4:01 pm

SVBony SV205 - Using as All-Sky

#1

Post by brenski »

I've an SV Bony Sv205 planetary which I'd like to try using as an allsky? is this possible? I can't seem to locate a suitable adapter for the lenses I have.

Here's the equipment I was hoping to get working together:

8MP SV205 USB3.0 for Planetary
https://www.svbony.com/sv205-astronomy-camera with either of the following two lenses:
https://astronomy-imaging-camera.com/pr ... egree-lens
or
https://www.ebay.co.uk/itm/402026850723
IR Board HD 5mp 16mm Lens For Security IP Camera
standard M12x0.5 thread

is there an adapter that will do this?
I'd like to try and rig this up with sharpcap for the Perseids in 3 weeks' time
Attachments
Untitled-3.jpg
Untitled-3.jpg (78.05 KiB) Viewed 3754 times
User avatar
admin
Site Admin
Posts: 13173
Joined: Sat Feb 11, 2017 3:52 pm
Location: Vale of the White Horse, UK
Contact:

Re: SVBony SV205 - Using as All-Sky

#2

Post by admin »

Hi,

unfortunately the SV205 doesn't have a standard lens thread on the front like the SV305. Instead I think the 205 has a 1.25" filter thread, which is going to be a problem. If you take the black ring off the front of the camera then you get yet another different thread, again not one that is a standard lens thread (like a C/CS thread).

My guess is that an adapter that screws into the 1.25" front thread of the black ring will not work (even if such a thing can be found), as it will probably push the lens too far away from the sensor to get focus at infinity.

I wonder if you are fighting a bit of a losing battle here? The high megapixel sensor on the 205 isn't really well suited for the longer exposures needed for an all sky camera. Something like the SV305 will connect directly to the and will accept the lens of the type ZWO sell (you can buy those a bit cheaper on ebay by the way...).

cheers,

Robin
brenski
Posts: 82
Joined: Mon Aug 10, 2020 4:01 pm

Re: SVBony SV205 - Using as All-Sky

#3

Post by brenski »

cheers Robin

it was more of a hopeful reach than anything else. nowhere (anywhere) on the net could I find anything about the threads on the SV205. the only "standard" part of the whole thing is the outer edges of the adapter itself fits a scope.

the situation is further compounded (for me) as my 183mc pro cooled (although i can get a lens to fit) also does not focus at infinity. going to have to bit the bullet and reinvest in the 178mc. wish i'd never sold my original now. the 178 will (at least) be a decent jack-of-all-trades, allsky, planetary and some bright DSOs.
User avatar
admin
Site Admin
Posts: 13173
Joined: Sat Feb 11, 2017 3:52 pm
Location: Vale of the White Horse, UK
Contact:

Re: SVBony SV205 - Using as All-Sky

#4

Post by admin »

Hi,

just to say that the small screw in lenses that are frequently used for all sky cameras can either be 'C' mount or 'CS' mount. C mount lenses require a distance of 17.5mm from the front of the thread to the sensor, CS require 12.5mm.

If the distance from the front of the C thread back to the sensor is 17.5mm then you will need to use a C lens as a CS one will never focus at infinity.
If the distance is 12.5mm then you can either use a CS lens directly or a C lens by adding a 5mm spacer (widely available).

Your camera manufacturer will probably have diagrams that show the position of the sensor relative to the front of the camera.

cheers,

Robin
brenski
Posts: 82
Joined: Mon Aug 10, 2020 4:01 pm

Re: SVBony SV205 - Using as All-Sky

#5

Post by brenski »

SVBony have kindly confirmed the actual sizes:

Adapter collar (inner) - M28.5x0.6
Camera base (outer) - M26.5x05

so the big question is does an adapter either
M28.5x0.6 > M12
or M26.5x05 to M12
actually exist?

as per Robin's last reply:
the distance to sensor (with standard adapter collar) is > 17mm
the distance without the collar is likely to significantly less than 12mm.

Will this affect the infinity focus of the M12 cctv lens?
ie, this one:
HD 5mp 16mm Lens IR Board CCTV Lens M12x0.5
https://www.ebay.co.uk/itm/373645491389 ... SwAnJg6QkS

thanks
User avatar
admin
Site Admin
Posts: 13173
Joined: Sat Feb 11, 2017 3:52 pm
Location: Vale of the White Horse, UK
Contact:

Re: SVBony SV205 - Using as All-Sky

#6

Post by admin »

Hi,

my guess is that the M12 (S mount) lenses will need a very short distance from the lens to the sensor to get focus properly - this might be a problem as the IR blocking filter in front of the sensor puts a limit on how close the lens can go.

If you have (or know someone with) a 3D printer, you may be able to design and print an adapter. Small pitch threads are going to be tough for most printers, but the C thread is possible (I've done it before) and it may be enough to have a correctly sized non-threaded adapter that pushes snugly into the front 28.5mm aperture...

Here's an OpenSCAD file that defines a T2 to CS adapter for 3D printing that works well enough to be usable. Note that the bulk of it is a thread generating library that I found online - the first section actually defines the adapter based on the 32tpi CS thread and the 0.75mm pitch T thread. The scalings of 1.02 and 0.9891 were determined by trial and error (print, test, adjust, repeat) until the thread size worked.

cheers,

Robin
Capture.JPG
Capture.JPG (54.7 KiB) Viewed 3716 times

Code: Select all

union ()
{
    difference()
    {
        cylinder(7,15,15);
        translate([0,0,-1]) scale([1.02, 1.02, 1]) english_thread (diameter=1, threads_per_inch=32, length=14/25.4, internal = true);
    }
    difference()
    {
        scale([0.9891,0.9891, 1]) metric_thread(diameter=42, pitch=0.75, length=7, internal = false);
        translate ([0,0,-1]) cylinder(15,15,15);
        translate ([17,0,7]) sphere(2, $fn=18);
        translate ([-17,0,7]) sphere(2, $fn=18);
    }
    translate ([-1.5,17,7]) cube([3,3,2]);
    translate ([-1.5,-20,7]) cube([3,3,2]);

}

/*
 * ISO-standard metric threads, following this specification:
 *          http://en.wikipedia.org/wiki/ISO_metric_screw_thread
 *
 * Dan Kirshner - dan_kirshner@yahoo.com
 *
 * You are welcome to make free use of this software.  Retention of my
 * authorship credit would be appreciated.
 *
 * Version 1.9.  2016-07-03  Option: tapered.
 * Version 1.8.  2016-01-08  Option: (non-standard) angle.
 * Version 1.7.  2015-11-28  Larger x-increment - for small-diameters.
 * Version 1.6.  2015-09-01  Options: square threads, rectangular threads.
 * Version 1.5.  2015-06-12  Options: thread_size, groove.
 * Version 1.4.  2014-10-17  Use "faces" instead of "triangles" for polyhedron
 * Version 1.3.  2013-12-01  Correct loop over turns -- don't have early cut-off
 * Version 1.2.  2012-09-09  Use discrete polyhedra rather than linear_extrude ()
 * Version 1.1.  2012-09-07  Corrected to right-hand threads!
 */

// Examples.
//
// Standard M8 x 1.
// metric_thread (diameter=8, pitch=1, length=4);

// Square thread.
// metric_thread (diameter=8, pitch=1, length=4, square=true);

// Non-standard: long pitch, same thread size.
//metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true);

// Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm,
// depth 1 mm.
//metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6, 
//               groove=true, rectangle=0.333);

// English: 1/4 x 20.
//english_thread (diameter=1/4, threads_per_inch=20, length=1);

// Tapered.  Example -- pipe size 3/4" -- per:
// http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html
// english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16);

// Thread for mounting on Rohloff hub.
//difference () {
//   cylinder (r=20, h=10, $fn=100);
//
//   metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6);
//}


// ----------------------------------------------------------------------------


//english_thread (diameter=1, threads_per_inch=32, length=0.15);

function segments (diameter) = min (50, ceil (diameter*6));


// ----------------------------------------------------------------------------
// internal -    true = clearances for internal thread (e.g., a nut).
//               false = clearances for external thread (e.g., a bolt).
//               (Internal threads should be "cut out" from a solid using
//               difference ()).
// n_starts -    Number of thread starts (e.g., DNA, a "double helix," has
//               n_starts=2).  See wikipedia Screw_thread.
// thread_size - (non-standard) size of a single thread "V" - independent of
//               pitch.  Default: same as pitch.
// groove      - (non-standard) subtract inverted "V" from cylinder (rather than
//               add protruding "V" to cylinder).
// square      - Square threads (per
//               https://en.wikipedia.org/wiki/Square_thread_form).
// rectangle   - (non-standard) "Rectangular" thread - ratio depth/width
//               Default: 1 (square).
// angle       - (non-standard) angle (deg) of thread side from perpendicular to
//               axis (default = standard = 30 degrees).
// taper       - diameter change per length (National Pipe Thread/ANSI B1.20.1
//               is 1" diameter per 16" length).
module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1,
                      thread_size=-1, groove=false, square=false, rectangle=0,
                      angle=30, taper=0)
{
   // thread_size: size of thread "V" different than travel per turn (pitch).
   // Default: same as pitch.
   local_thread_size = thread_size == -1 ? pitch : thread_size;
   local_rectangle = rectangle ? rectangle : 1;

   n_segments = segments (diameter);
   h = (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size * cos (angle);

   h_fac1 = (square || rectangle) ? 0.90 : 0.625;

   // External thread includes additional relief.
   h_fac2 = (square || rectangle) ? 0.95 : 5.3/8;

   if (! groove) {
      metric_thread_turns (diameter, pitch, length, internal, n_starts,
                           local_thread_size, groove, square, rectangle, angle,
                           taper);
   }

   difference () {

      // Solid center, including Dmin truncation.
      tapered_diameter = diameter - length*taper;
      if (groove) {
         cylinder (r1=diameter/2, r2=tapered_diameter/2,
                   h=length, $fn=n_segments);
      } else if (internal) {
         cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1,
                   h=length, $fn=n_segments);
      } else {

         // External thread.
         cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2,
                   h=length, $fn=n_segments);
      }

      if (groove) {
         metric_thread_turns (diameter, pitch, length, internal, n_starts,
                              local_thread_size, groove, square, rectangle,
                              angle, taper);
      }
   }
}


// ----------------------------------------------------------------------------
// Input units in inches.
// Note: units of measure in drawing are mm!
module english_thread (diameter=0.25, threads_per_inch=20, length=1,
                      internal=false, n_starts=1, thread_size=-1, groove=false,
                      square=false, rectangle=0, angle=30, taper=0)
{
   // Convert to mm.
   mm_diameter = diameter*25.4;
   mm_pitch = (1.0/threads_per_inch)*25.4;
   mm_length = length*25.4;

   echo (str ("mm_diameter: ", mm_diameter));
   echo (str ("mm_pitch: ", mm_pitch));
   echo (str ("mm_length: ", mm_length));
   metric_thread (mm_diameter, mm_pitch, mm_length, internal, n_starts, 
                  thread_size, groove, square, rectangle, angle, taper);
}

// ----------------------------------------------------------------------------
module metric_thread_turns (diameter, pitch, length, internal, n_starts, 
                            thread_size, groove, square, rectangle, angle,
                            taper)
{
   // Number of turns needed.
   n_turns = floor (length/pitch);

   intersection () {

      // Start one below z = 0.  Gives an extra turn at each end.
      for (i=[-1*n_starts : n_turns+1]) {
         translate ([0, 0, i*pitch]) {
            metric_thread_turn (diameter, pitch, internal, n_starts, 
                                thread_size, groove, square, rectangle, angle,
                                taper, i*pitch);
         }
      }

      // Cut to length.
      translate ([0, 0, length/2]) {
         cube ([diameter*3, diameter*3, length], center=true);
      }
   }
}


// ----------------------------------------------------------------------------
module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size,
                           groove, square, rectangle, angle, taper, z)
{
   n_segments = segments (diameter);
   fraction_circle = 1.0/n_segments;
   for (i=[0 : n_segments-1]) {
      rotate ([0, 0, i*360*fraction_circle]) {
         translate ([0, 0, i*n_starts*pitch*fraction_circle]) {
            current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle);
            thread_polyhedron (current_diameter/2, pitch, internal, n_starts, 
                               thread_size, groove, square, rectangle, angle);
         }
      }
   }
}


// ----------------------------------------------------------------------------
// z (see diagram) as function of current radius.
// (Only good for first half-pitch.)
function z_fct (current_radius, radius, pitch, angle)
   = 0.5* (current_radius - (radius - 0.875*pitch*cos (angle)))
                                                       /cos (angle);

// ----------------------------------------------------------------------------
module thread_polyhedron (radius, pitch, internal, n_starts, thread_size,
                          groove, square, rectangle, angle)
{
   n_segments = segments (radius*2);
   fraction_circle = 1.0/n_segments;

   local_rectangle = rectangle ? rectangle : 1;

   h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size * cos (angle);
   outer_r = radius + (internal ? h/20 : 0); // Adds internal relief.
   //echo (str ("outer_r: ", outer_r));

   // A little extra on square thread -- make sure overlaps cylinder.
   h_fac1 = (square || rectangle) ? 1.1 : 0.875;
   inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with
                                // cylinder.

   translate_y = groove ? outer_r + inner_r : 0;
   reflect_x   = groove ? 1 : 0;

   // Make these just slightly bigger (keep in proportion) so polyhedra will
   // overlap.
   x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02;
   x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02;
   z_incr = n_starts * pitch * fraction_circle * 1.005;

   /*
    (angles x0 and x3 inner are actually 60 deg)

                          /\  (x2_inner, z2_inner) [2]
                         /  \
   (x3_inner, z3_inner) /    \
                  [3]   \     \
                        |\     \ (x2_outer, z2_outer) [6]
                        | \    /
                        |  \  /|
             z          |[7]\/ / (x1_outer, z1_outer) [5]
             |          |   | /
             |   x      |   |/
             |  /       |   / (x0_outer, z0_outer) [4]
             | /        |  /     (behind: (x1_inner, z1_inner) [1]
             |/         | /
    y________|          |/
   (r)                  / (x0_inner, z0_inner) [0]

   */

   x1_outer = outer_r * fraction_circle * 2 * PI;

   z0_outer = z_fct (outer_r, radius, thread_size, angle);
   //echo (str ("z0_outer: ", z0_outer));

   //polygon ([[inner_r, 0], [outer_r, z0_outer], 
   //        [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]);
   z1_outer = z0_outer + z_incr;

   // Give internal square threads some clearance in the z direction, too.
   bottom = internal ? 0.235 : 0.25;
   top    = internal ? 0.765 : 0.75;

   translate ([0, translate_y, 0]) {
      mirror ([reflect_x, 0, 0]) {

         if (square || rectangle) {

            // Rule for face ordering: look at polyhedron from outside: points must
            // be in clockwise order.
            polyhedron (
               points = [
                         [-x_incr_inner/2, -inner_r, bottom*thread_size],         // [0]
                         [x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1]
                         [x_incr_inner/2, -inner_r, top*thread_size + z_incr],    // [2]
                         [-x_incr_inner/2, -inner_r, top*thread_size],            // [3]

                         [-x_incr_outer/2, -outer_r, bottom*thread_size],         // [4]
                         [x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5]
                         [x_incr_outer/2, -outer_r, top*thread_size + z_incr],    // [6]
                         [-x_incr_outer/2, -outer_r, top*thread_size]             // [7]
                        ],

               faces = [
                         [0, 3, 7, 4],  // This-side trapezoid

                         [1, 5, 6, 2],  // Back-side trapezoid

                         [0, 1, 2, 3],  // Inner rectangle

                         [4, 7, 6, 5],  // Outer rectangle

                         // These are not planar, so do with separate triangles.
                         [7, 2, 6],     // Upper rectangle, bottom
                         [7, 3, 2],     // Upper rectangle, top

                         [0, 5, 1],     // Lower rectangle, bottom
                         [0, 4, 5]      // Lower rectangle, top
                        ]
            );
         } else {

            // Rule for face ordering: look at polyhedron from outside: points must
            // be in clockwise order.
            polyhedron (
               points = [
                         [-x_incr_inner/2, -inner_r, 0],                        // [0]
                         [x_incr_inner/2, -inner_r, z_incr],                    // [1]
                         [x_incr_inner/2, -inner_r, thread_size + z_incr],      // [2]
                         [-x_incr_inner/2, -inner_r, thread_size],              // [3]

                         [-x_incr_outer/2, -outer_r, z0_outer],                 // [4]
                         [x_incr_outer/2, -outer_r, z0_outer + z_incr],         // [5]
                         [x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6]
                         [-x_incr_outer/2, -outer_r, thread_size - z0_outer]    // [7]
                        ],

               faces = [
                         [0, 3, 7, 4],  // This-side trapezoid

                         [1, 5, 6, 2],  // Back-side trapezoid

                         [0, 1, 2, 3],  // Inner rectangle

                         [4, 7, 6, 5],  // Outer rectangle

                         // These are not planar, so do with separate triangles.
                         [7, 2, 6],     // Upper rectangle, bottom
                         [7, 3, 2],     // Upper rectangle, top

                         [0, 5, 1],     // Lower rectangle, bottom
                         [0, 4, 5]      // Lower rectangle, top
                        ]
            );
         }
      }
   }
}



brenski
Posts: 82
Joined: Mon Aug 10, 2020 4:01 pm

Re: SVBony SV205 - Using as All-Sky

#7

Post by brenski »

that's really helpful Robin.
my son & I co-own a 3d printer - and he's a CAD tech, so we'll give that a go.
Really never considered printing it prior to this as I'd assumed the plastic would wear away pretty easily
User avatar
admin
Site Admin
Posts: 13173
Joined: Sat Feb 11, 2017 3:52 pm
Location: Vale of the White Horse, UK
Contact:

Re: SVBony SV205 - Using as All-Sky

#8

Post by admin »

Hi,

I wouldn't rate the thread for repeated use, but if you plan to screw the lens in once and leave it alone you should be fine.

You will need to print in black and have a fair number of top and bottom layers, otherwise the light will leak through your adapter and ruin your images!

cheers,

Robin
Post Reply