Creating a tablet or phone case with FreeCad for 3d Printing

This is an article how to create a simple tablet or phone case with FreeCad for 3d printing.

Completed Tablet Case

I needed this as a phone case broke, and I have learned the hard way with out a protective case, a phone screen can be easily broken from an accident.  Some of the measurements were taken from the broken case, and this design has not been shock tested to see how well it actually protects a device.  I figure it is better than nothing.

I am still relatively new to FreeCad, so created this blog to help me remember what I did for when I want to create another one.

For this project you need to know how to do basic operations in FreeCad such as how to create a simple sketch and move the drawing around.   There are plenty of YouTube videos on how to learn FreeCad.

The result will be a a generic phone or tablet base project, and then a project to customize it for a specific phone.

In addition to FreeCad software, I need something to measure with, I use a digital caliper to get better precision, and I recommend a text editor to take notes and keep a record of you measurements and the steps.

FreeCad is used for making parametric design.  That means that the dimensions of the finish product can be adjusted with in some reasons and for the finished model.  However there are limits to how much you can adjust.

FreeCad creates the model a layer at a time, so you can generally make any changes to the latest level of the model, making significant changes to the lower levels can break the model from being recomputed, and you may have to rebuild the model from the layer that you changed.

Because of that it is good to make keep notes of how you are building your model for each step and important to keep records of the critical dimensions.

Generally though you can change dimensions of parts of the inner layers to some degree, such as the length and width of the device.

So the first step in creating the cover is to get measurements of the device and of what the final cover is going to be.  For this I create a text document, where I also keep some design notes.

These measurements names will also be used in creating the design so that you can easily find them and adjust them.   FreeCad also has a way to use an external source such as a spreadsheet to pass the values into a design.   That option will not be covered in this article.

 Some definitions for consistency.

• The prefix "case" will be used for dimensions for the case being created.
• The prefix "device" will be used for dimensions for the device that it is being created for.
• The term "thickness" refers to how thick a component or section.
  
• The term "back" corresponds to the back of the device or the case.
• The term "width" is how wide the item.
• The term "length" is how tall the item.
  
• The term "top" is the top edge of the device or case.
• The term "bottom" is the bottom edge of the device or case.
• The X axis is aligned with the length of the device and zero is the middle.
• The Y axis is aligned with the width of the device and zero is the middle.
• The Z axis is aligned with the base of the device and zero is the outer back surface.

Device dimensions measured for a Samsung SMJ337A phone were used for for defining the generic case size.  While I got some test prints done with for the case with out the lid, as my wife found a new case she liked, I did not complete the phone devices, and instead did a print case for of a Samsung Galaxy Tab A 2017 SM-T380.  The tablet is the largest cover that I could print on my printer.

• device_thickness: 8.7 mm
• device_width: 68.5 mm
• device_height: 140.6 mm
• device_corner_radius: 8.41 mm.
• device_lip_support: 5 mm.  This supports the small overhang of the case that grips the front of the device.
• device_center_support: 10 mm.  This is used for 3D printer to zero the Z axis on before it starts printing the top of the case on top of the bottom of the case.

Printed TPU on my printer was not strong enough to support building the small lip as to hold the device in using bridging, and auto-generated supports do not seem to work, or are too much trouble to cut out.  To solve this, I break up the print into 3 prints, a dummy device for support, the bottom and sides of the case, and then the top of the case.

You do not actually need to print the dummy device if you want to use a flexible glue to glue the top lid on.  It just seems like that would take some precise gluing.  Also none of the stores in my area seem to stock a flexible superglue.   A caulk of clear or a compatible color may also work as a flexible glue,  I have not tried that.

Start by creating a new application in FreeCad.   Set some of the properties of the part.  This is important since I plan to publish it..  I should set the Created by for my name, and decide what type of license and copyright I want to use.  I have been using the license of "Creative Commons Attribution" and its associated URL.  Use save as and give it a name.  I used phone_case_in_sections.

I recommend saving periodically at various steps.

From these dimensions in FreeCad, I start my case by creating a sketch for the a device place holder as a rectangle with curved corners.   The device place holder will be used as a support for printing the top part of the case in TPU.

Depending on how steady your hand is, the sketcher by default will try to guess at some of the constraints, such as horizontal, vertical, and coincident constraints.  You may have to fix up some of them after.

The sketch is created with a box that had filets added for each corner.  Sides are constrained to be vertical and horizontal as needed, and the distance between the sides constrained to be symmetrical to the axis that they cross.

The first named constraint to set is the device_corner_radius.  Otherwise when you set the other named constraints, the automatic calculation can come up with an illegal negative value.  This will pop up a message box with the error, but worse will leave the sketch in a state that you need to an edit undo in order to fix that mistake.   I put the device_length on the X axis just out of a personal preference.

For clarity I have hidden all the unnamed constraints on these sketches.  The visible parameters have names that can be viewed in the constraints section of the sketch.   You can toggle the visibility of each constraint as desired.

For the dummy device, I do not need a solid device, I just need enough to support printing the top part of the case with TPU.  And when slicking it, it does not have to be very strong, so you can go with a minimal fill percentage to save filament and speed up the print.

I have a center section because I have a BLTouch auto-leveler instead of a Z axis limit switch.
This center section needs to be sized so that the BLTouch sensor marks the top of the device placeholder as a build plate.  The BLTouch test point is a about 5 mm to the left of centerline.

If you do not have something similar to the BLTouch, then you can set a positive Z offset to move the offset from zero manually.  I have not tried the homing cycle with that though.   This trick may not work with out a BLTouch.

For that two boxes are used to create holes.  The boxes are constrained to be the same size, and to be Symmetric to the X axis.  The distance between the boxes is constrained to be symmetric to the Y axis.

The device_lib_support I set to 5mm.  To keep from entering it in twice, I used a formula for it.

This sketch is named device_support_sketch.   A pad is created with a length equal to the thickness of the device.  The pad is named  device_support_pad.  The body is is given a name of "device_support".

On the body I used the option to set a random color so it will stand out from constructing the case.

I then created a mesh, and 3d printed the the device support to verify that all the dimensions work.  I have a small piece of painters tape on the front edge of my build plate to remind me where the BLTouch sensor will come down, so I can see if that dimension is right with out waiting to for the entire print to complete.

Next I make the back of the case.  It will have the same outer dimensions as the device.
I use create a filleted box and then I use the formula setting to re-used the named dimensions from the device_support_sketch.

This results in no actual named constraints.  I save and name this sketch case_base_sketch.

The next step is to pad the image into a solid back.  This is done with the "Pad" function, and that sets the length of the pad to be how thick I want the case to be.

The first pad created will be named Pad.  I set the length of it to be 2 mm.   As this is to fit under the device_support part, the "reversed" box is set.  I name the this case_base_pad  for a case parameter that can be referenced from for other components of this part.

• case_base_pad.Length: 2.0 mm.  Thickness of case back.

Additional generic case parameters from looking at another phone case. These can be adjusted as needed.   This is where you can customize a bit.  I am just making a basic protective case.

• case_lip: 1.5 mm.  This is the small overhang of the case that grips the front of the device.
• case_lip_thickness: 1.4 mm.  This is how thick the overhang is.  This is also the implied radius of the case lip arc, so that radius is not set.
• case_base_arc: 90 degrees.  This is the curve from the back of the case to the sides of the case.
• case_side_thickness: <<case_base_pad>>.Length.  How thick the sides are.  Using the case_base_pad seems to work well.  This is a separate named parameter in case I want them to be different.
• case_top_bevel: 1.5 mm.  This was calculated as the last constraint just based on how it looked in the sketch I created below.

In FreeCad, to make the sides and top lid of the case, an "additive pipe" is used.  This takes a sketch for each pipe and then wraps the sketch around the pad.

I make a second sketch by selecting the left top edge of the pad, which highlights it in the picture below as light green.  It is important to make sure that you select the proper side and edge, otherwise FreeCad can make the wrong assumption about the sketch orientation.

I use create sketch on the XZ plane.  You can customize this quite a bit to suit your tastes.  I would recommend naming and documenting the dimensions of any elements added.

The parts of the sketch need to be added the right order or it will be harder to correctly set the constraints for future updates.

The part of the pad is to create two vertical lines that are connected to each other.   The top line must  be constrained to the device pad thickness.  The bottom line must be constrained to the case_base_pad length.  The lower end of the second line is the attachment point to the pad edge.  Just for convenience, I name those constraints with names that match the constraints with the angle brackets removed and the dot replaced with an underscore.

To attach the sketch to the pad, I use the eternal geometry tool and select the very left edge of the pad as is shown in the orange highlighting below.  This will create one of the attachment point on the base pad.  The two points with the blue highlighting are then made coincident.  I label that constraint to be base_attachment_point so that I can find it later.

It makes it easier to work on the sketch with that constraint deactivated with the sketch moved slightly away from the pad.

I then add a top horizontal line to the sketch which is constrained to be the desired case side thickness.

For starters, I set that constraint to be the formula case_base_path_Length initially.  It turns out that it needs a fudge factor of +.5 mm to deal with various things, like having to put painter's tape on the device support.  A future case may want these thicknesses to be different.  I label this constraint case_side_thickness.  If you make the case_side_thickness larger, it may provide better protection on edge hits.

The remaining parts for to close the sketch can be customized to tastes.  I am going with a simple design of a of a horizontal line for the outer wall, and then a 90 degree arc at the bottom.

The arc is constrained to have a 90 degree angle and I name the constraint case_base_arc.

Now the only things unconstrained on the sketch are the arc radius and the length of the outer edge, setting a constraint on either one of them will lock the shape.  I choose to make the outer edge equal to the inner edge.   With out that constraint, you can adjust that length and see some interesting effects it has on the how the arc radius is set.  Keep in mind the limits that TPU has for making an unsupported curve.  A 90 degree curve seems to work well for me.

I name the constraint for the outer line to be case_edge_outer_height.  I then uncheck the visible button for it and all the unnamed constraints to clean up how the sketch looks.

I reactivate the base_attachment_point constraint and that results in sketch being fully constrained.

Resulting named dimensions:

• device_support_pad_Length: <<device_support_pad>>.Length + 0.5mm
• case_base_pad_Length: <<case_base_pad>>.Length
• case_side_thickness: .Constraints.case_base_pad_Length

Rename this sketch to be case_edge_sketch.

Now I use this sketch and additive pipe.  To make things easier, I toggle visibility on the device_support to temporally make it invisible.

First select the case_edge_sketch (highlight 1) from the Model View window, and then on the main window hold the control key down while selecting each of the 8 upper edges of the case_base_pad, which are shown below in green.

Then select additive pipe, and it should make a border around the entire pad.  If it looks good, then select close to commit the diagram.  I renamed the Additive Pipe to case_edge_pipe.

A third part is made for the edge lid.  For ease of creating that, the body for the case and the device_support are made invisible.

Create a new body and name it case_lip.  Create a sketch on the x-y plane.

By now I am getting good a making boxes with rounded corners.  For this three concentric ones are needed.

I start by toggling construction geometry and creating a copy of the case_base_sketch using the same dimensions for constraints.   Construction geometry puts in objects that will not show up in the actual part, and is used to help with creating the part.  I use the same names for the constraints as for the device support for local reference, and then hid the constraints on the drawing.

A rounded box for the inner edge of the lip is created next.  Toggle construction mode off.

The constraints for this will be done differently.  I start with a horizontal constraint of the distance between the top of the left outer line and left inner line.  I set it to the desired lip size, initially 1.5 mm as above, and name the constraint case_lip.

Changing the case_lip parameter may require temporarily disabling one or more constraints as I got an error printout when I tried to make it 4mm for the tablet.  Deactivating the constraint allowed me to change the case lip and then I could activate it to save close the sketch.

Now I add a vertical constraint for the left ends of the upper inner and outer top lines and use the formula to set it to be Contraints.case_lip.  I repeat to that for the distance between the bottom two lines.

I create a distance constraint between the centers of the arcs for one of the corners, again as Constraints.case_lip.   The final constraint is to set the bottom two inner arc centers to be symetrical with the Y axis.   This should turn the inner rounded box green.  The device outline is blue as it is construction geometry.

I create an outer box next.  Instead of using Constraints.case_lip for the offset, I will be using the case_edge_sketch.Constraintes.case_side_thickness.

For the device dimensions I ended up with these dimensions as the side thickness must be added needed to be added to actual width and size of the device as to make the size come out right.

• device_height: Sketch.Constraints.device_height + <<case_edge_sketch>>.Constraints.case_side_thickness
• device_width: <<device_support_sketch>>.Constraints.device_width + <<case_edge_sketch>>.Constraints.case_side_thickness
• device_corner_radius: <<device_support_sketch>>.Constraints.device_corner_radius

I close and rename this sketch case_lip_sketch.

Next I make a pad with length of case_lip_thickness and name it case lid pad.

Now for some niceties, I use the control key to select the upper inner edges of the pad, and use the fillet tool to make a rounded edge with a 1mm radius, and rename this to case_lid_inner_fillet.  I then use the control key to select the upper outer edges of the pad and use the chamfer tool with a 1 mm size and named it case_lid_outer_chamfer.

At 1mm, I doubt if I will be able see to much difference in the chamfer and the fillet.  This is something that can also be adjusted.

So at this point I do a save as to save this as "phone_case_in sections:"  Once the final design is tested, I will also export the body as a "Step with colors" type and create an STL mesh, before uploading them to my GitHub wb8tyw freecad project.  GitHub will show a preview of the object with the STL mesh.

The result now if 3d printed should be able to hold the device, but I would not be able to plug anything into the device, the back cameras are blocked and nothing indicates where the side buttons are.

This can also be used to make generic covers possible for some types of rectangular cans with rounded edges.

Hopefully I will not need to make more changes to this.  As it is starter base, the actual dimensions are not critical.

Now to create the case for the first specific device.  I do a save as for "phone_case_mybrand_mymodel" to not make more changes to this template base.

I now need to get more dimensions based on the device.  In most cases, I have to make them a little bigger than on the actual device.

For the bottom I need to create a sketch attached to the bottom edge.

There is needs to be a rounded rectangular hole for the power plug to go into this device.

• power_height: 7.0 mm.  Needed for the hole to accommodate the connector.
• power_width: 12.75 mm.  Needed for the hole to accommodate the connector.
• power_arc: 90 degrees
• power_corner_radius: 1.25 mm
• power_y_loc: Symmetrical on Y axis.
• power_z_bottom:  <<case_base_pad>>.Length.  Flush with top of case back.

This was a similar design to the original pad for a rectangle with rounded corners.

In this case, I started out with a rectangle and then added the fillets to the corner.

I then constrained all the angles to be equal, and constrained the height and width per above.

Then constrained the bottom, and set the vertical sides to be symmetric to the Z axis.

Then the radius of the filets was constrained to the power_corner_radius.

Then once I set the radius for one of the arcs, and set all the other arcs as equal to it.  Now I can try different radiuses for the arc to see how it affects the look of the hole.

There also needs to be a round hole for an audio jack.  I can best measure it position relative to the edge of the hole for the power plug.

• audio_diameter: 6.52 mm
• audio_y_center: 5.12 mm + (.Constraints.power_width - .Constraints.audio_diameter) / 2
• audio_z_center: <<case_base_pad>>.Length + <<case_edge_sketch>>.Constraints.device_thickness / 2

There is also a microphone hole on the bottom.  Its exact location can also be based relative to the power jack.

• bottom_mike_diameter: 3.82 mm
• bottom_mike_y_center: 5.68 mm + .Constraints.bottom_mike_diameter / 2
• bottom_mike_z_center: 6.08 mm + <<case_base_pad>>.Length

The tablet has a simpler bottom, a power jack and a sound opening.

• power_width: 11 mm
• power_height: 7.5 mm
• power_y_loc: Symmetric on Y axis
• power_z_offset: 0.75 mm
• power_corner_radius: 1.25 mm
• bottom_sound_width: 14 mm
• bottom_sound_height: 3.1 mm
• bottom_sound_y_loc: 3.15 mm
• bottom_sound_z_offset: 2.5 mm

After a test print of the tablet, it appears that TPU, at least the way I printed it could not bridge the 14mm gap.

Once all the objects are constrained, the sketch is renamed case_bottom_sketch, and will look like this:

Now to create the holes, I select the sketch and then select the pocket button.  Set the type to "To first".

This will will create hole as soon as I close it.  I rename the pocket to be case_bottom_pocket.

Now to do the buttons.  A button set will take at least three sketches, depending on the arrangement.

The first two sketches are for the pocket, but unlike the other pockets, it does not go all the way through, just 1/2 the way through.  It will be constructed very similar to speaker hole with create slot.

The height constraint is the height of the actual button with a generous fudge factor for the outer pocket.

The width constraint can be calculated based on the width needed for the actual pocket and to have the 2x the radius of the circles removed from it.   That 2x radius is the same as the pocket height.  Or you can just use the width of the button.  The second sketch will just be a copy of the first.

For the x_offset, the closest reference point is center point of the device height.   So you measure from

the device edge to the start of the device button and do a calculation.
You will need add case_base_sketch to the External Geometry.

• right_button_pocket_height: 5.5 mm
• right_button_pocket_width: 12.9mm - .Constraints.right_button_pocket_height
• right_button_pocket_x_offset: (<<case_base_sketch>>.Constraints.device_height - .Constraints.right_button_pocket_height) / 2 - 41.3mm
• right_button_z_offset: 4.75 mm + Constraints.right_button_pocket_height /2

For the larger tablet it made more sense to measure differently since I did not have a broken case

to take measurements from.  I have to use the device height divided by 2 so I can get the offset from measuring from the top of the device.

• right_button_pocket_height: 5.5 mm
• power_button_width: 11.00 mm
• volume_button_width: 21.00 mm
• power_button_x_offset: <<device_support_sketch>>.Constraints.device_height / 2 - 36mm
• volume_button_x_offset: <<device_support_sketch>>.Constraints.device_height / 2 - 70mm
• right_button_z_offset: <<device_support_pad>>.Length / 2

Once the outer sketch is constrained, Complete by closing the sketch, renaming it to right_button_pocket_sketch, select it and select pocket.

Set the pocket Length parameter to formula <<case_edge_sketch>>.Constraints.case_side_thickness / 4.  Close the pocket and rename it to right_button_outside_pocket.

Unfortunately I can not find a way in FreeCad to simply re-use a copy of this sketch on the opposite side of the edge surface.  So just need to recreate it, on the inner edge for the right side.

• right_button_pocket_height: <<right_button_pocket_sketch>>.Constraints.right_button_pocket_height
• right_button_pocket_width: <<right_button_pocket_sketch>>.Constraints.right_button_pocket_width
• right_button_pocket_x_offset: <<right_button_pocket_sketch>>.Constraints.right_button_pocket_x_offset
• right_button_z_offset: <<right_button_pocket_sketch>>.Constraints.right_button_z_offset

For the tablet, I had to use different parameters for the inner volume and power buttons because of where the x origin ended up,

power_button_inner_x_offset: <<device_support_sketch>>.Constraints.device_height - 36mm
volume_button_inner_x_offset: <<right_button_pocket_sketch>>.Constraints.volume_button_x_offset + <<device_support_sketch>>.Constraints.device_height / 2

By using these parameters, if I need to make adjustments, I only need to make them for the sketch attached to the outer right edge.

Once the inner sketch is constrained, Complete by closing the sketch, renaming it to right_button_pocket_inside_sketch, select it and select pocket.

Set the pocket Length parameter to formula <<case_edge_sketch>>.Constraints.case_side_thickness / 4.  Close the pocket and rename it to right_button_inside_pocket.

Creating the right button is just a smaller copy of the right_button_pocket_inside_sketch.

Except that we want it centered in the pocket.

For that I need to know the center of the long portion of the pocket.  I use the select the external geometry (Highlight 1) and then select both arcs (Highlight 2) for the pocket.  This also gives me the center points for those arcs.

Then I use the toggle construction mode (Highlight 3) on to create some helper lines.

Connect lines between each of the closest center points for the arcs, and then constrain the two lines to be equal.  Constrain one of the two lines to be horizontal.  (Highlight 4)  After that toggle the construction mode off.

A good space for the top and bottom of the button appears to be 1.35 mm, or 2.7 mm doubled, so that is used to constrain the button height.

Constraining the length of one of the construction lines to 0.25 mm appears to set the width of the button to be a good value also.   This means that the dimensions of the outer pocket now completely control the button dimensions.

• right_button_height: <<right_button_pocket_sketch>>.Constraints.right_button_pocket_height - 2.7 mm
• button_width_offset: 0.25 mm.  Length of one of the construction lines.
• right_button_x_offset: Constrained by hidden lines to outer pocket for button.
• right_button_z_offset: Constrained by having one hidden line horizontal.

Once the button sketch is constrained, Complete by closing the sketch, renaming it to right_button_sketch,

The next step is to create a pad for the sketch, For me, selecting the pad and clicking on the pad button puts up an window with two "recompute fail" messages, until I change the Pad Type to Two dimensions.

The first pad Length parameter to formula "<<case_edge_sketch>>.Constraints.case_side_thickness / 4" .  The 2nd length is set to "<<case_edge_sketch>>.Constraints.case_side_thickness".
Close pad and rename it to right_button_pad.

On the left side the device has two volume buttons inside of one pocket.  This will be close to what was done for the right button.

Create a sketch for the outer button pocket.  The 

• left_button_pocket_height: <<right_button_pocket_sketch>>.Constraints.right_button_pocket_height
• left_button_pocket_width: 26.45mm - .Constraints.left_button_pocket_height
• left_button_pocket_x_offset: (<<case_base_sketch>>.Constraints.device_height - .Constraints.left_button_pocket_height) / 2 - 21.3 mm
• left_button_z_offset: <<right_button_pocket_sketch>>.Constraints.right_button_z_offset

Once the outer sketch is constrained, Complete by closing the sketch, renaming it to left_button_pocket_sketch, select it and select pocket.

Set the pocket Length parameter to formula <<case_edge_sketch>>.Constraints.case_side_thickness / 4.
Close the pocket and rename it to left_button_outside_pocket.

Now recreate the same sketch on the inner side.

• left_button_pocket_height: <<left_button_pocket_sketch>>.Constraints.left_button_pocket_height
• left_button_pocket_width: <<left_button_pocket_sketch>>.Constraints.left_button_pocket_width
• left_button_pocket_x_offset: <<left_button_pocket_sketch>>.Constraints.left_button_pocket_x_offset
• left_button_z_offset: <<left_button_pocket_sketch>>.Constraints.left_button_z_offset

Once the inner sketch is constrained, Complete by closing the sketch, renaming it to left_button_pocket_inside_sketch, select it and select pocket.

Set the pocket Length parameter to formula <<case_edge_sketch>>.Constraints.case_side_thickness / 4.  Close the pocket and rename it to left_button_inside_pocket.

The final sketch should now be for the two buttons.  This time I will make sure that I base it off the the edge and not the pocket.

As with for the right button, the external geometry and the construction lines were needed in order to make sure that the proper distance between the pocket and the buttons were maintained.

With two buttons, I needed to find a center to to make sure that the buttons would stay symmetrical if the outer pocket sketch width was changed.  This was done by adding 4 construction lines to form an X, and by forcing the two bottom lengths to be equal, it forces the intersection point to be in the center.

A symmetrical constraint forces the edge of the two buttons to be always the same difference from the center.  An additional distance constraint then sets the distance for the buttons.  The width of the buttons is now controlled by the outer pocket sketch.  Depending on the reason for changing the width, the button separation factor may need to also be fixed.

• left_button_height: <<left_button_pocket_sketch>>.Constraints.left_button_pocket_height - 2.7 mm
• Unnamed other button height: .Constraints.left_button_height
• button_width_offset: 0.25 mm.  Length of one of the construction lines.
• left_button_separation: 3mm + .Constraints.left_button_height
• left_button_x_offset: Constrained by hidden lines to outer pocket for button.
• left_button_z_offset: Constrained by having one hidden line

Once the inner sketch is constrained, Complete by closing the sketch, renaming it to left_buttons_sketch, select it and select pad.

Again, I got the two recompute failed messages until I selected "Two dimensions"

The first pad Length parameter to formula "<<right_button_pad>>.Length".  The 2nd length is set to "<<right_button_pad>>.Length2".  This gives me one place to make a global change to the buttons.
Close pad and rename it to right_button_pad.

On the tablet, since the buttons on the side were about 1 mm wider than the body, I had to pad differently than on a phone.   That was done by setting Length2 to be "<<case_edge_sketch>>.Constraints.case_side_thickness - 1mm" so that the inner pocket had room for the buttons with out having them accidentally pressed.

Next on the top there is another microphone hole this should be simple.  Originally I did this using the external geometry feature.  It seemed easier to just get the dimension from the case_base_sketch constraints.

• top_mike_diameter: <<case_bottom_sketch>>.Constraints.bottom_mike_diameter
• top_mike_y_center:  <<case_base_sketch>>.Constraints.device_width / 2 - 22.5 mm
• top_mike_z_center: <<case_bottom_sketch>>.Constraints.bottom_mike_z_center

Complete by closing the sketch, renaming it to case_top_sketch, select it and select pocket.  Set the Pocket type to "to first".  Close the pocket and rename it to case_top_pocket.

On the base there is a camera hole.  This will need another sketch and a pocket.

The camera hole is another one of the rounded rectangular boxes, and must be at least 1.5 the base thickness wider than the the actual camera on the phone so it will not obstruct the lens.

More measurements, based on existing broken case:

• camera_hole_arc: 90 mm
• camera_hole_length: 24.7 mm
• camera_hole_width: 18.0 mm
• camera_hole_arc_radius: 6.57 mm
• camera_hole_y_loc: Symmetrical on X axis
• camera_hole_x_offset:  <<case_base_sketch>>.Constraints.device_height / 2 - 10.13 mm

For the tablet the changes are:

• camera_hole_length: 27.00 mm
• camera_hole_width: 16.00 mm
• camera_hole_x_offset: <<device_support_sketch>>.Constraints.device_height / 2 - 22mm

This should be similar to the top edge sketch.

The box is made like the other two, and the width was made symmetrical to the X axis.

Need updated picture

Once the sketch is fully constrained,  complete by closing the sketch, renaming it to camera_hole_sketch, select it and select pocket.  

On the Pocket, set Length to be formula  <<case_base_pad>>.Length.  Set Taper angle to be 30 degrees.  Close the pocket and rename it to camera_hole_pocket.

On the right side there is a speaker hole, and the power button on the X/Z plane.  This will take multiple sketches.  The first sketch will for the speaker hole.  Start by attaching a sketch to the right side.

Then select "create slot", an oval with two dots in it, and draw it about where the speaker slot is and then start to constrain it.  A lot easier than the other sketches.

Still need to get the same external geometry set as for the camera.  This time it will show up as a point.

When using a slot, I have to base the dimension based on the radius of the slot, which is 1/2 of the height of the slot.

• right_speaker_height: 3.95 mm
• right_speaker_width: 8.9 mm - .Constraints.right_speaker_height / 2
• right_speaker_x_offset:
    (<<case_base_sketch>>.Constraints.device_height - .Constraints.right_speaker_height) / 2 - 14.65 mm
• right_speaker_base_z_offset: 4.78 mm + <<case_base_pad>>.Length

Once the sketch is fully constrained, Complete by closing the sketch, renaming it to speaker_hole_sketch, select it and select pocket.  Set the pocket Type to "To first", close the pocket and rename it to speaker_hole_pocket.

At this point it is ready to make a test print.

The tablet base takes 13 hours to print, and at first was too small, and I did not notice that on one end width of the case was too thin.   I incorrectly assumed an error in my initial measurements so I made the height of the tablet larger.   When I went to print it again, I noticed that it was printing the same small size, so I stopped the print.

The Cura slicer program was positioning the object beyond the range of the printer.   So I moved the location of the model in the Cura so that it was in range.  That was also wrong and I ended up with an oversize case.

I found that Cura specifications for my model of printer showed that it had a 235 x 235 bed, which my printer has, however the printer it self has internal limits of 220 x 220.   I fixed up my Cura printer profile to match the printer.  This resulted in the base being properly printed.

When I had previously printed the device support, it printed the correct size as that version of Cura positioned differently.

I then a test print of the lid, I found that I needed to use painter's tape to keep the printed TPU from bonding with the support.   At first I was trying just a glue stick, which mostly worked but in some cases parts of the support were bonded to the lip.  The lip however did not bond to the base print much at all, so was easily removed for me to try again.

This increased the thickness of the support, so that the case lip did not reach the case.  I compensated for that by using a power file and ground down the un-taped bottom of the support before trying again, and also made slight Z offset adjustments for the first layer.

I adjusted the parameters to compensate for the device support thickness difference for a future print should I need to create a replacement cover.

I used a putty knife to carefully separate the case lip from the device support.  I found a few spots where the lid did not bond to the base, but it is now good enough to use.   I could try using some flexible super glue or sealing type clear caulk on it in the future.

So now my tablet has better protection.

Printing something larger should be possible if I can figure out how to print TPU sections that can connect to each other possibly with buttons and button holes.

But now I can easily create simple protective cases, and hopefully someone will find this useful for creating there own covers.