1. iorodeo
  2. capillary_sensor_enclosure

Commits

jorodeo  committed e3d6247

Further work on new capillary array sensor enclosure design. Added mounting holes for
guide plates, led pcb, diffuser, and diffuser standoffs.

  • Participants
  • Parent commits 6849a09
  • Branches default

Comments (0)

Files changed (2)

File capillary_enclosure.py

View file
     def __init__(self,params):
         self.params = params
         self.add_sensor_cutout()
-        #self.add_sensor_cable_hole()
         self.add_capillary_holes()
-        #self.add_capillary_clamp_holes()
-        #self.add_led_cable_hole()
+        self.add_guide_tap_holes()
+        self.add_led_tap_holes()
         super(Capillary_Enclosure,self).__init__(self.params)
 
     def make(self):
         super(Capillary_Enclosure,self).make()
-        #self.make_rubber_band_notch()
-        self.make_backlight_standoffs()
-        self.make_led_plate()
-        self.make_diffuser_plate()
         self.make_sensor()
-        #self.make_clamp_standoffs()
-        self.make_clamp_plates()
-        self.make_led_standoffs()
-        self.make_diffuser_standoffs()
         self.make_capillary()
         self.make_guide_plates()
+        self.make_led_pcb()
+        self.make_diffuser()
+        self.make_led_standoffs()
 
     def get_assembly(self,**kwargs):
         """
         Get enclosure assembly
         """
         try:
-            show_led_plate = kwargs['show_led_plate']
-        except KeyError:
-            show_led_plate = True
-        try:
-            show_diffuser_plate = kwargs['show_diffuser_plate']
-        except KeyError:
-            show_diffuser_plate = True
-        try:
             show_sensor = kwargs['show_sensor']
         except KeyError:
             show_sensor = True
         try:
-            show_clamp_standoffs = kwargs['show_clamp_standoffs']
+            show_capillary = kwargs['show_capillary']
         except KeyError:
-            show_clamp_standoffs = True
+            show_capillary = True
         try:
-            show_clamp_plates = kwargs['show_clamp_plates']
+            show_guide_plates = kwargs['show_guide_plates']
         except KeyError:
-            show_clamp_plates = True
+            show_guide_plates = True
         try:
-            show_led_standoffs = kwargs['show_led_standoffs']
+            show_led_pcb = kwargs['show_led_pcb']
         except KeyError:
-            show_led_standoffs = True
+            show_led_pcb = True
+        try:
+            show_diffuser = kwargs['show_diffuser']
+        except KeyError:
+            show_diffuser = True
         try:
             show_diffuser_standoffs = kwargs['show_diffuser_standoffs']
         except KeyError:
             show_diffuser_standoffs = True
         try:
-            show_capillary = kwargs['show_capillary']
-        except KeyError:
-            show_capillary = True
-        try:
-            show_guide_plate = kwargs['show_guide_plate']
-        except KeyError:
-            show_guide_plate = True
-        try:
             explode = kwargs['explode']
         except KeyError:
             explode = (0,0,0)
+
         explode_x, explode_y, explode_z = explode
 
-
         parts_list = super(Capillary_Enclosure,self).get_assembly(**kwargs)
-
-        # Add led plate
         x,y,z = self.params['inner_dimensions']
         wall_thickness = self.params['wall_thickness']
-        led_standoff_length = self.params['led_standoff_length']
-        led_plate = self.led_plate
-        z_shift = 0.5*z - led_standoff_length - 0.5*wall_thickness 
-        z_shift += explode_z
-        led_plate = Translate(led_plate,v=(0,0,z_shift))
-        if show_led_plate:
-            parts_list.append(led_plate)
-
-        # Add diffuser plate
-        diffuser_standoff_length = self.params['diffuser_standoff_length']
-        diffuser_plate = self.diffuser_plate
-        z_shift = 0.5*z - 1.5*wall_thickness -  led_standoff_length - diffuser_standoff_length
-        z_shift += explode_z
-        diffuser_plate = Translate(diffuser_plate, v=(0,0,z_shift))
-        if show_diffuser_plate:
-            parts_list.append(diffuser_plate)
 
         # Add sensor
         sensor_x, sensor_y, sensor_z = self.params['sensor_dimensions']
         if show_sensor:
             parts_list.append(sensor)
 
-
-        # Add led standoffs
-        led_standoff_length = self.params['led_standoff_length']
-        z_shift = 0.5*z - 0.5*led_standoff_length
-        z_shift += explode_z
-        for standoff in self.led_standoff_list:
-            standoff = Translate(standoff,v=(0,0,z_shift))
-            if show_led_standoffs:
-                parts_list.append(standoff)
-
-        # Add diffuser standoffs
-        diffuser_standoff_length = self.params['diffuser_standoff_length']
-        z_shift = 0.5*z - led_standoff_length - wall_thickness - 0.5*diffuser_standoff_length
-        z_shift += explode_z
-        for standoff in self.diffuser_standoff_list:
-            standoff = Translate(standoff,v=(0,0,z_shift))
-            if show_diffuser_standoffs:
-                parts_list.append(standoff)
-
         # Add capillary
         cap_offset_x, cap_offset_y = self.params['capillary_hole_offset']
         cap_hole_diam = self.params['capillary_diam']
         y_shift = cap_offset_x
         z_shift = -0.5*z + 1.5*guide_z 
         guide_plate_top = Translate(self.guide_plate_top,v=[0,y_shift,z_shift])
-
-        if show_guide_plate:
+        if show_guide_plates:
            parts_list.extend([guide_plate_pos,guide_plate_neg,guide_plate_top])
 
+        # Add led pcb
+        pcb_x, pcb_y, pcb_z = self.params['led_pcb_dimensions']
+        z_shift = 0.5*z - 0.5*pcb_z
+        led_pcb = Translate(self.led_pcb,v=(0,0,z_shift))
+        if show_led_pcb:
+            parts_list.append(led_pcb)
+
+        # Add diffuser
+        diff_x, diff_y, diff_z = self.params['diffuser_dimensions']
+        diffuser_standoff_height = self.params['diffuser_standoff_height']
+        z_shift = 0.5*z - pcb_z - 0.5*diff_z -  diffuser_standoff_height
+        diffuser = Translate(self.diffuser,v=(0,0,z_shift))
+        if show_diffuser:
+            parts_list.append(diffuser)
+
+        # Add diffuser standoffs
+        led_hole_tuples = self.get_led_holes()
+        z_shift = 0.5*z - pcb_z- 0.5*self.params['diffuser_standoff_height']
+        for x_shift,y_shift, dummy in led_hole_tuples:
+            if x_shift < 0:
+                standoff = self.diffuser_standoff_neg
+            else:
+                standoff = self.diffuser_standoff_pos
+            standoff = Translate(standoff,v=(x_shift,y_shift,z_shift))
+            if show_diffuser_standoffs:
+                parts_list.append(standoff)
+
         return parts_list
 
+
     def get_opaque_projection(self,show_ref_cube=True, spacing_factor=4):
         """
         Get 2D projected layout of parts for laser cutting.
         x,y,z = self.params['inner_dimensions']
         wall_thickness = self.params['wall_thickness']
         spacing = spacing_factor*wall_thickness
-        
-        # Add led plate - two in case of mistakes
-        led_plate_x, led_plate_y = self.params['led_plate_xy']
-        led_plate = self.led_plate
-        x_shift = 0.5*self.bottom_x + 0.5*led_plate_x + spacing
-        y_shift = 0.5*self.bottom_y + 0.5*led_plate_y + spacing
-        led_plate0 = Translate(led_plate,v=(x_shift,y_shift,0))
-        led_plate1 = Translate(led_plate,v=(-x_shift,y_shift,0))
-        led_plate0 = Projection(led_plate0)
-        led_plate1 = Projection(led_plate1)
-        parts_list.append(led_plate0)
-        parts_list.append(led_plate1)
-
-        # Add clamping plates
-        clamp_x, clamp_y, clamp_z = self.params['capillary_clamp_plate_dimensions']
-        for i in range(0,2):
-            for clamp_plate, sgn in zip(self.clamp_plate_list,(-1,1)):
-                x_shift = sgn*(0.5*self.bottom_x + 0.5*clamp_x + spacing)
-                y_shift = -0.5*self.bottom_y -0.5*clamp_y - spacing - i*(spacing + clamp_y)
-                clamp_plate = Translate(clamp_plate,v=(x_shift,y_shift,0))
-                clamp_plate = Projection(clamp_plate)
-                parts_list.append(clamp_plate)
 
         return parts_list
 
-    def get_diffuser_projection(self,ref_cube=True,spacing_factor=4):
-        """
-        Get 2D projection for diffuser - projection is separate because different 
-        materials will be used.
-        """
-        parts_list = []
-        wall_thickness = self.params['wall_thickness']
-        spacing = spacing_factor*wall_thickness
 
-        # Add diffuer plate projection
-        diffuser_plate = self.diffuser_plate
-        diffuser_plate = Projection(diffuser_plate)
-        parts_list.append(diffuser_plate)
 
-        # Add reference cube
-        diffuser_x, diffuser_y = self.params['diffuser_plate_xy']
-        cube = Cube(size=(INCH2MM, INCH2MM, INCH2MM))
-        x_shift = 0.0
-        y_shift = 0.5*diffuser_y + 0.5*INCH2MM + spacing
-        cube = Translate(cube,v=(x_shift,y_shift,0))
-        cube = Projection(cube)
-        if ref_cube:
-            parts_list.append(cube)
-
-        return parts_list 
 
     def add_capillary_holes(self):
         """
             hole_list.append(hole)
         self.params['hole_list'].extend(hole_list)
 
- 
     def add_sensor_cutout(self):
         """
         Add cutout for sensor
         """
         hole_list = [] 
-
         sensor_width = self.params['sensor_width']
         sensor_length = self.params['sensor_length']
         hole_offset = self.params['sensor_hole_offset']
-        
         x_pos = 0;
         y_pos = -hole_offset;
-            
         hole = {
                     'panel'    : 'bottom', 
                     'type'     : 'square', 
         hole_list.append(hole)
         self.params['hole_list'].extend(hole_list)
 
-
     def add_capillary_clamp_holes(self):
         """
         Add holes for clamping capillary in place
 
         self.add_holes(hole_list)
 
-
-    def make_backlight_standoffs(self):
-        hole_list = []
-        hole_diam = self.params['standoff_hole_diameter']
-        x_pos_list = [x for x,y in self.standoff_xy_pos]
-
-        
-        self.backlight_standoff_xy = []
-        for x_pos in x_pos_list:
-            y_pos = 0
-            self.backlight_standoff_xy.append((x_pos,y_pos))
-            hole = {
-                    'panel'    : 'top',
-                    'type'     : 'round',
-                    'location' : (x_pos, y_pos),
-                    'size'     : hole_diam,
-                    }
-            hole_list.append(hole)
-
-        self.add_holes(hole_list)
-
-    def make_led_plate(self):
-        wall_thickness = self.params['wall_thickness']
-        plate_x, plate_y = self.params['led_plate_xy']
-        hole_diam = self.params['standoff_hole_diameter']
-        sensor_length = self.params['sensor_length']
-        led_num = self.params['led_num']
-        led_slot_x, led_slot_y = self.params['led_slot_xy']
-
-        self.led_plate = Cube(size=(plate_x,plate_y,wall_thickness))
-
-        # Add standoff holes
-        hole_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            hole = {
-                    'panel'    : 'led_plate',
-                    'type'     : 'round',
-                    'location' : (x_pos, y_pos),
-                    'size'     : hole_diam,
-                    }
-            hole_list.append(hole)
-
-        # Add led holes
-        x_pos_array = scipy.linspace(-0.5*sensor_length + 1.0, 0.5*sensor_length -1.0, led_num)
-        for x_pos in x_pos_array:
-            y_pos = 0.0
-            hole = {
-                    'panel'    : 'led_plate',
-                    'type'     : 'rounded_square',
-                    'location' : (x_pos, y_pos),
-                    'size'     : (led_slot_x, led_slot_y, 0.5*led_slot_y),
-                    }
-            hole_list.append(hole)
-        
-        self.add_holes(hole_list)
-
-    def make_diffuser_plate(self):
-        wall_thickness = self.params['wall_thickness']
-        plate_x, plate_y = self.params['diffuser_plate_xy']
-        hole_diam = self.params['standoff_hole_diameter']
-
-        self.diffuser_plate = Cube(size=(plate_x,plate_y,wall_thickness))
-
-        # Add standoff holes
-        hole_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            hole = {
-                    'panel'    : 'diffuser_plate',
-                    'type'     : 'round',
-                    'location' : (x_pos, y_pos),
-                    'size'     : hole_diam,
-                    }
-            hole_list.append(hole)
-        self.add_holes(hole_list)
-
     def make_sensor(self):
         sensor_x, sensor_y, sensor_z = self.params['sensor_dimensions']
         hole_offset = self.params['sensor_hole_offset']
         sensor = plate_w_holes(sensor_x, sensor_y, sensor_z, hole_list)
         self.sensor = Translate(sensor,v=(0,-hole_offset,0))
 
-    def make_clamp_standoffs(self):
-        hole_space = self.params['sensor_mount_hole_space']
-        standoff_diam = self.params['capillary_clamp_standoff_diam']
-        standoff_length = self.params['capillary_clamp_standoff_length']
-        standoff_hole_diam = self.params['capillary_clamp_hole_diam']
-
-        r = 0.5*standoff_diam
-        standoff_template = Cylinder(h=standoff_length, r1=r, r2=r)
-        r = 0.5*standoff_hole_diam
-        cut_cyl = Cylinder(h=2*standoff_length, r1=r, r2=r)
-        standoff_template = Difference([standoff_template,cut_cyl])
-        
-        self.clamp_standoff_list = []
-        for x_pos, y_pos in self.capillary_clamp_holes_xy:
-            standoff = Translate(standoff_template, v=(x_pos, y_pos,0))
-            self.clamp_standoff_list.append(standoff)
-
-    def make_clamp_plates(self):
-        plate_x, plate_y, plate_z = self.params['capillary_clamp_plate_dimensions']
-        clamp_hole_space = self.params['capillary_clamp_hole_space']
-        hole_diam = self.params['capillary_clamp_hole_diam']
-
-        # Create hole list
-        hole_list = []
-        for i in (-1,1):
-            x_pos = 0.0
-            y_pos = i*0.5*clamp_hole_space 
-            hole = (x_pos, y_pos, hole_diam)
-            hole_list.append(hole)
-
-        # Create clamp plates
-        self.clamp_plate_list = []
-        for i in (0,2):
-            clamp_plate = plate_w_holes(plate_x, plate_y, plate_z,hole_list)
-            self.clamp_plate_list.append(clamp_plate)
-
-    def make_led_standoffs(self):
-        standoff_diam = self.params['led_standoff_diam']
-        standoff_length = self.params['led_standoff_length']
-
-        r = 0.5*standoff_diam
-        standoff_template = Cylinder(h=standoff_length,r1=r,r2=r)
-
-        self.led_standoff_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            standoff = Translate(standoff_template,v=(x_pos, y_pos, 0))
-            self.led_standoff_list.append(standoff)
-
-
-    def make_diffuser_standoffs(self):
-        standoff_diam = self.params['diffuser_standoff_diam']
-        standoff_length = self.params['diffuser_standoff_length']
-        r = 0.5*standoff_diam
-        standoff_template = Cylinder(h=standoff_length,r1=r,r2=r)
-        self.diffuser_standoff_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            standoff = Translate(standoff_template,v=(x_pos,y_pos,0))
-            self.diffuser_standoff_list.append(standoff)
-
     def make_capillary(self):
         diameter = self.params['capillary_diam']
         length = self.params['capillary_length']
         capillary = Rotate(capillary, a=90, v=(0,1,0))
         self.capillary = capillary
 
-
     def make_guide_plates(self):
         guide_x, guide_y, guide_z = self.params['guide_plate_dimensions']
-        self.guide_plate_pos = Cube(size=(guide_x, guide_y, guide_z))
-        self.guide_plate_neg = Cube(size=(guide_x, guide_y, guide_z))
+        hole_diam = self.params['guide_thru_hole_diam']
+        hole_offset = self.params['guide_hole_offset']
+
+        # Create pos and neg guide plates
+        hole_list_pos = []
+        hole_list_neg = []
+        for i in (-1,1):
+            x_pos = i*(0.5*guide_x - hole_offset) 
+            y_pos = 0.5*guide_y - hole_offset 
+            hole_pos = (x_pos, y_pos, hole_diam)
+            hole_neg = (x_pos, -y_pos, hole_diam)
+            hole_list_pos.append(hole_pos)
+            hole_list_neg.append(hole_neg)
+        self.guide_plate_pos = plate_w_holes(guide_x, guide_y, guide_z, holes=hole_list_pos)
+        self.guide_plate_neg = plate_w_holes(guide_x, guide_y, guide_z, holes=hole_list_neg)
+
+        # Create top guide plate
+        top_x, top_y, top_z = self.get_guide_plate_top_dim()
+        hole_list_top = self.get_guide_plate_holes(hole_type='through')
+        self.guide_plate_top = plate_w_holes(top_x,top_y,top_z,holes=hole_list_top)
+
+    def add_guide_tap_holes(self):
+        hole_tuples = self.get_guide_plate_holes(hole_type='tap')
+        hole_list = []
+        for x,y,diam in hole_tuples:
+            hole = {
+                    'panel'    : 'bottom',
+                    'type'     : 'round',
+                    'location' : (x,y),
+                    'size'     : diam,
+                    }
+            hole_list.append(hole)
+        self.params['hole_list'].extend(hole_list)
+
+    def get_guide_plate_holes(self,hole_type='through'):
+        guide_x, guide_y, guide_z = self.params['guide_plate_dimensions']
+        hole_offset = self.params['guide_hole_offset']
+        if hole_type == 'through':
+            hole_diam = self.params['guide_thru_hole_diam']
+        else:
+            hole_diam = self.params['guide_tap_hole_diam']
+        hole_list = []
+        top_x, top_y, top_z = self.get_guide_plate_top_dim()
+        for i in (-1,1):
+            for j in (-1,1):
+                x_pos = i*(0.5*top_x - hole_offset)
+                y_pos = j*(0.5*top_y - hole_offset)
+                hole = (x_pos, y_pos, hole_diam)
+                hole_list.append(hole)
+        return hole_list
+
+    def get_guide_plate_top_dim(self):
+        guide_x, guide_y, guide_z = self.params['guide_plate_dimensions']
         top_x = guide_x
         top_y = 2*guide_y + self.params['capillary_diam']
         top_z = guide_z
-        self.guide_plate_top = Cube(size=(top_x,top_y,top_z))
+        return top_x, top_y, top_z
 
+    def make_led_pcb(self):
+        led_x, led_y, led_z = self.params['led_pcb_dimensions']
+        hole_list = self.get_led_holes(hole_type='through')
+        self.led_pcb = plate_w_holes(led_x, led_y, led_z, holes=hole_list)
 
+    def make_diffuser(self):
+        diff_x, diff_y, diff_z = self.params['diffuser_dimensions']
+        hole_list = self.get_led_holes(hole_type='through')
+        self.diffuser = plate_w_holes(diff_x, diff_y, diff_z, holes=hole_list)
+
+    def add_led_tap_holes(self):
+        hole_tuples = self.get_led_holes(hole_type='tap')
+        hole_list = []
+        for x,y,diam in hole_tuples:
+            hole = {
+                    'panel'    : 'top',
+                    'type'     : 'round',
+                    'location' : (x,y),
+                    'size'     : diam,
+                    }
+            hole_list.append(hole)
+        self.params['hole_list'].extend(hole_list)
+
+    def get_led_holes(self, hole_type='through'):
+        led_x, led_y, led_z = self.params['led_pcb_dimensions']
+        hole_offset = self.params['led_pcb_hole_offset']
+        if hole_type == 'through':
+            diam = self.params['led_pcb_thru_hole_diam']
+        else:
+            diam = self.params['led_pcb_tap_hole_diam']
+        hole_list = []
+        for i in (-1,1):
+            x_pos = i*(0.5*led_x - hole_offset)
+            y_pos = 0.5*led_y - hole_offset
+            hole = (x_pos, y_pos, diam)
+            hole_list.append(hole)
+        return hole_list
+
+    def make_led_standoffs(self):
+        height = self.params['diffuser_standoff_height']
+        diam = self.params['diffuser_standoff_diam']
+        radius = 0.5*diam
+        self.diffuser_standoff_pos = Cylinder(h=height,r1=radius,r2=radius)
+        self.diffuser_standoff_neg = Cylinder(h=height,r1=radius,r2=radius)
+
+
+
+
+
+

File make_enclosure.py

View file
 INCH2MM = 25.4
 
 # Inside dimensions
-x,y,z = 61.25, 45.0, 0.75*INCH2MM 
+x,y,z = 61.4, 45.0, 0.75*INCH2MM 
 hole_list = []
 
 params = {
         'inner_dimensions'                 : (x,y,z), 
         'wall_thickness'                   : 3.0, 
         'lid_radius'                       : 1.5,  
-        'top_x_overhang'                   : 1.0,
-        'top_y_overhang'                   : 1.0,
+        'top_x_overhang'                   : 1.5,
+        'top_y_overhang'                   : 1.5,
         'bottom_x_overhang'                : 8.0,
         'bottom_y_overhang'                : 3.0, 
         'lid2front_tabs'                   : (0.25,0.75),
         'capillary_hole_diam'              : 0.85,  
         'capillary_hole_offset'            : (0.25,0),
         'capillary_length'                 : 5*INCH2MM,
-        'rubber_band_notch_width'          : 2.0, 
-        'led_plate_xy'                     : (x-3.0,y-17.0),
-        'led_slot_xy'                      : (3.02,1.5), 
-        'led_standoff_diam'                : 0.25*INCH2MM,
-        'led_standoff_length'              : (1.0/4.0)*INCH2MM,
-        'led_num'                          : 10, 
-        'led_cable_hole_width'             : 3.0,
         'sensor_width'                     : 12.95,
         'sensor_length'                    : 61.33,
-        'diffuser_standoff_length'         : (1.0/4.0)*INCH2MM,
-        'diffuser_standoff_diam'           : 0.25*INCH2MM,
-        'diffuser_plate_xy'                : (x-3.0,y-17.0),
         'sensor_dimensions'                : (61.33,12.95,3.3),
         'sensor_hole_offset'               : 0.685,
-        'sensor_cable_hole_width'          : 5.0, 
-        'sensor_mount_hole_diam'           : 0.11*INCH2MM,
         'sensor_mount_hole_space'          : 57.40, 
-        'capillary_clamp_hole_space'       : 22.0,
-        'capillary_clamp_hole_diam'        : 0.11*INCH2MM,
-        'capillary_clamp_standoff_diam'    : 0.25*INCH2MM, 
-        'capillary_clamp_standoff_length'  : (5.0/32.0)*INCH2MM,
-        'capillary_clamp_plate_dimensions' : (6.35,28.35,1.5),
+        'sensor_mount_hole_diam'           : 0.11*INCH2MM, 
+        'led_pcb_dimensions'               : (61.0, 25.4, 1.7),
+        'led_pcb_thru_hole_diam'           : 0.0890*INCH2MM,
+        'led_pcb_tap_hole_diam'            : 0.0641*INCH2MM,
+        'led_pcb_hole_offset'              : 0.15*INCH2MM,
+        'diffuser_dimensions'              : (61.0 ,25.4, 1.5),
+        'diffuser_standoff_height'         : (7/32.0)*INCH2MM,
+        'diffuser_standoff_diam'           : (3/16.0)*INCH2MM,
         'hole_list'                        : hole_list,
         'guide_plate_dimensions'           : (x-0.2, 0.5*INCH2MM, 0.0625*INCH2MM),
+        'guide_thru_hole_diam'             : 0.0890*INCH2MM,
+        'guide_tap_hole_diam'              : 0.0641*INCH2MM,
+        'guide_hole_offset'                : 0.15*INCH2MM,
         }
 
 
         show_top=True,
         show_bottom=True, 
         show_front=True,
-        show_back=True,
-        show_left=True,
-        show_right=True,
-        show_led_plate=False,
-        show_diffuser_plate=False,
+        show_back=False,
+        show_left=False,
+        show_right=False,
         show_standoffs=True,
-        show_led_standoffs=False,
-        show_diffuser_standoffs=False,
         show_capillary=True,
         show_sensor=True,
-        show_clamp_plates=False,
-        show_clamp_standoffs=False,
-        show_guide_plate=True,
+        show_diffuser=True,
+        show_led_pcb=True,
+        show_guide_plates=True,
         explode=(0,0,0),
         )
 
 
 opaque_part_projection = enclosure.get_opaque_projection()
-diffuser_projection = enclosure.get_diffuser_projection()
 
 prog_assembly = SCAD_Prog()
 prog_assembly.fn = 50
 prog_assembly.add(part_assembly)
 prog_assembly.write('enclosure_assembly.scad')
 
-prog_opaque_projection = SCAD_Prog()
-prog_opaque_projection.fn = 50
-prog_opaque_projection.add(opaque_part_projection)
-prog_opaque_projection.write('enclosure_opaque_projection.scad')
-
-prog_diffuser_projection = SCAD_Prog()
-prog_diffuser_projection.fn = 50
-prog_diffuser_projection.add(diffuser_projection)
-prog_diffuser_projection.write('enclosure_diffuser_projection.scad')
+#prog_opaque_projection = SCAD_Prog()
+#prog_opaque_projection.fn = 50
+#prog_opaque_projection.add(opaque_part_projection)
+#prog_opaque_projection.write('enclosure_opaque_projection.scad')
+#
+#prog_diffuser_projection = SCAD_Prog()
+#prog_diffuser_projection.fn = 50
+#prog_diffuser_projection.add(diffuser_projection)
+#prog_diffuser_projection.write('enclosure_diffuser_projection.scad')