Build a CanSat Payload

Build a CanSat payload that streams telemetry and passes a CAD fit check.

Introduction

30 Second Summary

Small devices can work perfectly on a bench. Trouble starts when they must fit inside a tight shell without losing the evidence that proves they work.

In this project, you will build a hand-held CanSat engineering model that streams pressure, temperature, humidity, and acceleration telemetry from an Arduino sensor board. You will use SOLIDWORKS to expose a deliberate fit failure before turning the corrected design into verification evidence.

What You'll Build

Picture holding the cardstock CanSat while its environmental and motion telemetry updates once per second on your computer.

By the end of this project, you'll have:

  • A live sensor payload you can warm, tilt, and shake gently while watching its environmental and motion readings respond.
  • A structured CSV telemetry stream that produces a new row approximately once per second.
  • A SOLIDWORKS assembly that demonstrates a failed fit before the corrected placement passes Interference Detection. A preliminary center-of-mass view gives you another piece of aerospace verification evidence.
  • Secret Mission: Add onboard detection that marks high-acceleration test events directly in the telemetry stream.

Are there any prerequisites?

No prior embedded-systems experience is required because the guide covers Arduino IDE and SOLIDWORKS setup on a compatible Windows PC. For the physical test, you need an Arduino Nano 33 BLE Sense Rev2 with headers, a Micro-B USB data cable, a metric ruler, cardstock, scissors, and removable tape.

Before We Start

Before the hands-on work begins, commit to the engineering story that every project artifact needs to support. This mission statement keeps your payload measurements, mechanical fit check, and portfolio evidence focused on one aerospace goal.

Set Up the Payload Workbench

Your mission statement connects every artifact to one engineering story. This step prepares the workbench that turns that story into evidence.

The electronics need Arduino IDE to recognize the Arduino Nano 33 BLE Sense Rev2. The mechanical work needs a licensed SOLIDWORKS environment.

In this step, get ready to:
  • Prepare the physical bench materials.
  • Verify the SOLIDWORKS environment with a blank part.
  • Prepare the Arduino software stack for a Blink upload.
Prepare the physical and CAD workbench

A complete bench keeps the later fit check tied to the real hardware. A blank part confirms that your CAD license can support the integration work.

  • Place the Nano board on a clear work surface.
  • Place the Micro-B USB data cable beside the board.
  • Arrange the metric ruler with the cardstock.
  • Place the scissors beside the removable tape.
  • Match your SOLIDWORKS access to one of the paths below.

✔️ SOLIDWORKS opens

  • Press the Windows key to open Windows search.
  • Type SOLIDWORKS into Windows search.
  • Press Enter to start SOLIDWORKS.
  • Click File in the menu bar.
  • Click New.
  • Select the Part template.
  • Click OK.

You should see an empty part document with the standard reference planes available.

ⓧ SOLIDWORKS is unavailable

This option starts an automatically renewing subscription at $15 USD/month before tax. You can cancel renewal if you only need the software for this project.

The installation is complete when SOLIDWORKS is available through Windows search.

  • Press the Windows key to open Windows search.
  • Type SOLIDWORKS into Windows search.
  • Press Enter to start SOLIDWORKS.
  • Click File in the menu bar.
  • Click New.
  • Select the Part template.
  • Click OK.

You should see an empty part document with the standard reference planes available.

SOLIDWORKS not opening?

  • Restart Windows if the installer completed but SOLIDWORKS does not appear in search.
  • Confirm that your existing license is active if SOLIDWORKS opens to a licensing screen.
  • Use the Makers Windows desktop installation if your existing access has expired.

Help me troubleshoot why SOLIDWORKS cannot create a blank part on my Windows PC. Share the result in the NextWork community if the licensing issue continues.

The blank part proves that your CAD environment is licensed. It also proves that the part-document workflow is available for the CanSat models.

Install Arduino IDE and board support

Arduino IDE provides the editor that compiles each sketch. A board package supplies the files needed to upload that sketch to the Nano.

  • Choose the tab that matches the Arduino IDE version available through Windows search.

✔️ I see version 2.3.10

  • Press the Windows key to open Windows search.
  • Type Arduino IDE into Windows search.
  • Press Enter to start Arduino IDE.
  • Click Help in the menu bar.
  • Click About Arduino IDE.
  • Confirm that the dialog shows version 2.3.10.
  • Close the version dialog.

Arduino IDE is open at the pinned version.

ⓧ I see an older version

Windows may request permission when the installer starts. Approving that request allows the guided installation to continue.

  • Double-click arduino-ide_2.3.10_Windows_64bit.exe in your Downloads folder.
  • Approve the Windows permission request if it appears.
  • Follow the guided installation.
  • Leave Run Arduino IDE selected when setup finishes.

Arduino IDE opens after setup with version 2.3.10 installed.

ⓧ Arduino IDE is not installed

Windows may request permission when the installer starts. Approving that request allows the guided installation to continue.

  • Double-click arduino-ide_2.3.10_Windows_64bit.exe in your Downloads folder.
  • Approve the Windows permission request if it appears.
  • Follow the guided installation.
  • Leave Run Arduino IDE selected when setup finishes.

Arduino IDE opens after setup with version 2.3.10 installed.

The IDE now needs the Nano board package. This package determines how your sketch is compiled for the selected hardware.

  • Click Tools in the Arduino IDE menu bar.
  • Hover over Board.
  • Click Boards Manager....
  • Search for Arduino Mbed OS Nano Boards.
  • Select version 4.6.0 from the package's version control.

The board package can take a few minutes to download. A quiet progress indicator during that time is expected.

  • Click Install on the Arduino Mbed OS Nano Boards package.

The package card should now report version 4.6.0 as installed.

Board package not installing?

  • Check that your PC still has an internet connection.
  • Close another Arduino IDE window if both windows are trying to update packages.
  • Restart Arduino IDE if the installation progress stops moving.

Help me diagnose why Arduino Mbed OS Nano Boards 4.6.0 will not install. Share the package-card state in the NextWork community if the issue continues.

Install the sensor libraries and upload Blink

The Rev2 board uses dedicated libraries for its pressure sensor. It also uses dedicated libraries for its environmental sensor plus its inertial sensor.

Why these exact libraries?

The onboard pressure sensor uses Arduino_LPS22HB. The onboard temperature plus humidity sensor uses Arduino_HS300x.

The Rev2 inertial sensor uses Arduino_BMI270_BMM150. These pinned releases match the APIs used by the payload sketch.

  • Click Tools in the menu bar.
  • Click Manage Libraries....
  • Search for Arduino_LPS22HB.
  • Select version 1.0.3.
  • Click Install.

The Arduino_LPS22HB entry should now report version 1.0.3 as installed.

  • Search for Arduino_HS300x.
  • Select version 1.0.1.
  • Click Install.

The Arduino_HS300x entry should now report version 1.0.1 as installed.

  • Search for Arduino_BMI270_BMM150.
  • Select version 1.2.4.
  • Click Install.

The Arduino_BMI270_BMM150 entry should now report version 1.2.4 as installed.

A sensor library is missing?

  • Check the spelling of the library name against the pinned names above.
  • Clear the Library Manager search before searching for the next library.
  • Confirm the installed version shown on each library entry.

Help me find or install one of the three pinned Arduino sensor libraries. Share the library name in the NextWork community if it still does not appear.

The software stack is ready. The final check proves that the cable can transfer a sketch to the physical board.

  • Connect the Micro-B plug to the Nano board.
  • Connect the other end of the cable to your Windows PC.

You should see the board's power indicator light up.

  • Click Tools in the menu bar.
  • Hover over Board.
  • Hover over Arduino Mbed OS Nano Boards.
  • Click Arduino Nano 33 BLE.
  • Click Tools in the menu bar.
  • Hover over Port.
  • Select the detected COM port associated with the Nano.

What do the board and port control?

The board selection tells Arduino IDE which hardware rules to use during compilation. The port selection identifies the physical Nano that receives the upload.

  • Click File in the menu bar.
  • Hover over Examples.
  • Hover over 01.Basics.
  • Click Blink.

Before you upload the example, what should the board do if the IDE version, board package, cable, board selection, and port selection are all working?

  • Click Upload in the Arduino IDE toolbar.

The IDE reports that the upload completed. You should see the Nano's built-in LED blink repeatedly.

Built-in LED not blinking?

  • Confirm that Arduino Nano 33 BLE remains selected under the board menu.
  • Confirm that the detected COM port remains selected.
  • Reconnect the board with the Micro-B USB data cable if no port appears.
  • Try a direct USB port on the PC if Windows does not detect the board.

Help me troubleshoot why Blink will not upload to my Arduino Nano 33 BLE Sense Rev2. Share the upload result in the NextWork community if the board still does not respond.

That blinking LED proves the complete upload path works. Your IDE can now program the physical Nano through its selected COM port.

Your payload workbench is ready from CAD licensing through board upload. Next, you will turn the Nano into a live environmental sensor.

Make the Payload Sense Its Environment

The blinking built-in LED proves your Arduino Nano 33 BLE Sense Rev2 accepts sketches from Windows. A payload still needs evidence that its environmental sensors respond.

In this step, you will use Arduino IDE to stream live environmental measurements from the board. The first live stream proves the hardware senses its surroundings.

The stream's format also matters. You will use the first output to judge whether readable console text is ready for engineering analysis.

In this step, get ready to:
  • Initialize the onboard pressure sensor.
  • Initialize the onboard HS300x sensor.
  • Evaluate labeled live readings as ground-station data.
Initialize the environmental sensors

The sketch must initialize each onboard sensor before requesting measurements. A failed initialization stops the program before it can present misleading data.

  • Switch back to Arduino IDE from earlier.
  • Create a new sketch in its editor.
  • Save the sketch as CanSatPayload.ino.
  • Replace the sketch contents with this sensor initialization code:
#include <Arduino_LPS22HB.h>
#include <Arduino_HS300x.h>

void setup() {
  Serial.begin(9600);
  delay(1000);

  if (!BARO.begin()) {
    Serial.println("Failed to initialize pressure sensor!");
    while (1) {
    }
  }

  if (!HS300x.begin()) {
    Serial.println("Failed to initialize humidity temperature sensor!");
    while (1) {
    }
  }
}

What does this code do?

  • The Arduino_LPS22HB.h import gives the sketch access to the onboard pressure sensor through BARO.
  • The Arduino_HS300x.h import gives the sketch access to the onboard temperature and humidity sensor through HS300x.
  • Serial.begin(9600) prepares the data connection used to display sensor readings.
  • BARO.begin() checks that the pressure sensor can start correctly.
  • HS300x.begin() checks that the temperature and humidity sensor can start correctly.
  • Save CanSatPayload.ino.
  • Upload this version by selecting Upload in the Arduino IDE toolbar.

Arduino IDE should complete the upload without a compilation failure. The Nano now runs both sensor initialization checks.

Upload not completing?

  • Confirm that the selected board remains Arduino Nano 33 BLE.
  • Confirm that the selected port remains the detected COM port.
  • Reconnect the Micro-B USB data cable if Arduino IDE loses the board during upload.

Help me diagnose the failed upload.

Stream labeled sensor readings

The loop() function turns initialized sensors into a repeating measurement stream. Each pass gathers one environmental sample before waiting one second.

  • Scroll to the closing brace of setup() in CanSatPayload.ino.
  • Paste this reading loop below setup():
void loop() {
  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPct = HS300x.readHumidity();

  Serial.print("Pressure (kPa): ");
  Serial.println(pressureKpa);
  Serial.print("Temperature (C): ");
  Serial.println(temperatureC);
  Serial.print("Humidity (%): ");
  Serial.println(humidityPct);
  Serial.println();

  delay(1000);
}

How does the reading loop work?

  • pressureKpa holds the latest pressure measurement in kilopascals.
  • temperatureC holds the latest temperature measurement in degrees Celsius.
  • humidityPct holds the latest relative humidity measurement.
  • Serial.print() places a readable label before each measurement.
  • delay(1000) creates an approximate one-second measurement cadence.

Before you upload this version, do you expect the readings to stay perfectly fixed while the board rests on your desk?

  • Save CanSatPayload.ino.
  • Upload the updated sketch by selecting Upload.
  • Open Serial Monitor in Arduino IDE.
  • Set Serial Monitor to 9600 baud.

You should see repeating groups of labeled measurements separated by blank lines. Each group should contain pressure, temperature, and humidity values.

Before you warm the board, which measurement do you expect your hand to affect first?

  • Hold your hand around the board for several seconds without touching its pins.
  • Watch the next several reading groups in Serial Monitor.

You should see at least one value shift while the output continues to refresh.

Great result. Your payload now converts a physical change into live sensor data.

Readings missing or unchanged?

  • Confirm that Serial Monitor remains set to 9600 baud if the output is unreadable.
  • Press the board's reset button once if no readings appear after the upload.
  • Check the installed sensor libraries if you see Failed to initialize pressure sensor! or Failed to initialize humidity temperature sensor!.

Help me troubleshoot the sensor stream.

✔️ Awesome, I've got everything!

Your CanSatPayload.ino file now contains the complete environmental-sensing sketch.

ⓧ I'd like to double check the full code

  • Compare your saved CanSatPayload.ino file with this reference:
#include <Arduino_LPS22HB.h>
#include <Arduino_HS300x.h>

void setup() {
  Serial.begin(9600);
  delay(1000);

  if (!BARO.begin()) {
    Serial.println("Failed to initialize pressure sensor!");
    while (1) {
    }
  }

  if (!HS300x.begin()) {
    Serial.println("Failed to initialize humidity temperature sensor!");
    while (1) {
    }
  }
}

void loop() {
  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPct = HS300x.readHumidity();

  Serial.print("Pressure (kPa): ");
  Serial.println(pressureKpa);
  Serial.print("Temperature (C): ");
  Serial.println(temperatureC);
  Serial.print("Humidity (%): ");
  Serial.println(humidityPct);
  Serial.println();

  delay(1000);
}

This reference combines sensor initialization with the repeating environmental readout.

Record the telemetry limitation

The test has exposed the intended limitation. Each sensor sample occupies several labeled lines.

Why is this hard to analyze?

  • Blank lines create empty records when the stream is imported into analysis software.
  • The stream has no timestamp for tracking elapsed test time.
  • The values do not share one CSV row for direct graphing or processing.

Your payload can sense its environment and prove that response live. Next, you will package those readings into analysis-ready telemetry.

Turn Readings into Telemetry Packets

Your Arduino Nano 33 BLE Sense Rev2 already reports three environmental measurements. The labeled stream proves that the sensors work.

The sketch in Arduino IDE now needs inertial readings from the onboard IMU. You will package every sample as a timestamped CSV row at a fixed one-second cadence.

In this step, get ready to:
  • Initialize the onboard IMU for three-axis acceleration.
  • Format each sensor sample as a timestamped CSV telemetry packet.
  • Collect ten rows that continue updating during a gentle tilt.
Add the IMU and telemetry header

Three-axis acceleration comes from the board's onboard IMU. The sketch must load its library before it can initialize the sensor.

  • In CanSatPayload.ino, find these two imports at the top of the file:
#include <Arduino_LPS22HB.h>
#include <Arduino_HS300x.h>

What is already imported?

These imports provide the pressure sensor through BARO. They also provide the temperature and humidity sensor through HS300x.

  • Replace those two lines with this three-line import group:
#include <Arduino_LPS22HB.h>
#include <Arduino_HS300x.h>
#include <Arduino_BMI270_BMM150.h>

What changed?

The third import gives the sketch access to IMU. This object provides the acceleration availability check plus the three-axis reading.

  • In setup(), find the HS300x initialization block.
  • Place your cursor after that block's closing brace.
  • Add the IMU check plus the CSV header by pasting this code:
  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1) {
    }
  }

  Serial.println("time_ms,pressure_kpa,temperature_c,humidity_pct,accel_x_g,accel_y_g,accel_z_g");

What does this code do?

  • The IMU.begin() check confirms that the inertial sensor is available before telemetry starts.
  • The loop inside the failure branch stops the sketch if initialization fails.
  • The final Serial.println() defines the order and units of every telemetry column.

Before you upload, where do you expect the new header to appear among the existing labeled readings?

  • Save CanSatPayload.ino.
  • Click Upload in the Arduino IDE toolbar.
  • Return to the Serial Monitor from earlier at 9600 baud.

You should see the CSV header once above the existing labeled readings. That header confirms the IMU initialized successfully.

Missing the telemetry header?

  • Confirm that the third import spells Arduino_BMI270_BMM150.h exactly.
  • Check that the IMU initialization block sits inside setup().
  • Look for Failed to initialize IMU! in Serial Monitor.

Help me diagnose why my Nano sketch does not print the telemetry header.

Format each telemetry packet

A telemetry packet keeps every measurement in a predictable position. A timestamp makes the sampling interval visible during later analysis.

  • In CanSatPayload.ino, select the entire existing loop() function.
  • Replace the selected function with this telemetry loop:
void loop() {
  unsigned long timeMs = millis();
  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPct = HS300x.readHumidity();

  float accelX = 0.0f;
  float accelY = 0.0f;
  float accelZ = 0.0f;

  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(accelX, accelY, accelZ);
  }

  Serial.print(timeMs);
  Serial.print(',');
  Serial.print(pressureKpa, 3);
  Serial.print(',');
  Serial.print(temperatureC, 2);
  Serial.print(',');
  Serial.print(humidityPct, 2);
  Serial.print(',');
  Serial.print(accelX, 3);
  Serial.print(',');
  Serial.print(accelY, 3);
  Serial.print(',');
  Serial.println(accelZ, 3);

  delay(1000);
}

How does the packet work?

  • The timeMs variable records elapsed time from millis().
  • The three acceleration variables start at 0.0f before the sketch checks for a fresh sample.
  • Each comma separates one field from the next field in the CSV row.
  • The final delay(1000) sets an interval of approximately one second between packets.

Before you upload, what repeated pattern do you expect to replace the labels and blank lines?

  • Save CanSatPayload.ino.
  • Click Upload in Arduino IDE.
  • Return to the Serial Monitor from earlier at 9600 baud.

You should see time_ms,pressure_kpa,temperature_c,humidity_pct,accel_x_g,accel_y_g,accel_z_g followed by comma-separated rows. Each row should contain seven values.

Seeing labels or incomplete rows?

  • Confirm that you replaced the entire old loop() function.
  • Check that every value except accelZ is followed by a comma print.
  • Confirm that Serial.println(accelZ, 3) ends each packet on a new line.

Help me fix malformed CSV rows in my CanSat telemetry sketch.

✔️ Awesome, I've got everything!

Your telemetry sketch now matches the complete version for this step.

ⓧ I'd like to double check the full code

#include <Arduino_LPS22HB.h>
#include <Arduino_HS300x.h>
#include <Arduino_BMI270_BMM150.h>

void setup() {
  Serial.begin(9600);
  delay(1000);

  if (!BARO.begin()) {
    Serial.println("Failed to initialize pressure sensor!");
    while (1) {
    }
  }

  if (!HS300x.begin()) {
    Serial.println("Failed to initialize humidity temperature sensor!");
    while (1) {
    }
  }

  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1) {
    }
  }

  Serial.println("time_ms,pressure_kpa,temperature_c,humidity_pct,accel_x_g,accel_y_g,accel_z_g");
}

void loop() {
  unsigned long timeMs = millis();
  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPct = HS300x.readHumidity();

  float accelX = 0.0f;
  float accelY = 0.0f;
  float accelZ = 0.0f;

  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(accelX, accelY, accelZ);
  }

  Serial.print(timeMs);
  Serial.print(',');
  Serial.print(pressureKpa, 3);
  Serial.print(',');
  Serial.print(temperatureC, 2);
  Serial.print(',');
  Serial.print(humidityPct, 2);
  Serial.print(',');
  Serial.print(accelX, 3);
  Serial.print(',');
  Serial.print(accelY, 3);
  Serial.print(',');
  Serial.println(accelZ, 3);

  delay(1000);
}
Verify the telemetry cadence

The completed stream must stay structured while the payload moves. Ten consecutive rows give you enough evidence to check the cadence plus the sensor response.

Before you tilt the board, which acceleration columns do you expect to change most?

  • Return to the Serial Monitor from earlier.
  • Let the stream run until at least ten telemetry rows appear.
  • Compare the timestamps in two adjacent rows.
  • Gently tilt the connected board by hand.
  • Watch the acceleration columns during the tilt.

You should see timestamps increase by approximately 1000 between rows. The acceleration values should respond while pressure, temperature, and humidity continue without interruption.

That is the data path proven: your payload now produces repeatable environmental and motion telemetry once per second.

Acceleration values staying unchanged?

  • Confirm that each telemetry row contains values for accelX, accelY, and accelZ.
  • Check that IMU.readAcceleration(accelX, accelY, accelZ) sits inside the acceleration availability check.
  • Use a slow tilt that changes the board's orientation relative to gravity.

Help me troubleshoot acceleration values that do not respond during the tilt test.

Your sensor readings now form a telemetry stream that is ready for analysis. Next, you will build the CanSat assembly and expose a deliberate packaging failure.

Make the Payload Fail a Fit Check

Your Arduino Nano 33 BLE Sense Rev2 now produces one structured telemetry packet every second. That proves the sensing subsystem works on the bench.

A functioning subsystem can still fail the vehicle envelope. In this step, you will use SOLIDWORKS to model the CanSat packaging space before testing a deliberately offset board placeholder with Interference Detection.

In this step, get ready to:
  • Model the CanSat envelope and payload deck.
  • Create a simplified Nano placeholder with a preliminary component height.
  • Build an assembly that produces a visible interference result.
Model the CanSat envelope and payload deck

The CanSat envelope defines the packaging boundary for every component. Its verified outside dimensions are 66 mm in diameter and 115 mm in height.

  • Switch back to SOLIDWORKS from earlier.
  • Create a new Part document for the envelope.

You should see a blank part document ready for the envelope geometry.

  • Model a solid cylinder with an outside diameter of 66 mm using your standard CSWA sketch workflow.
  • Set the cylinder height to 115 mm.

You should see a cylindrical body whose proportions match the required CanSat envelope.

  • Hollow the cylinder using a preliminary wall thickness that remains easy to see.
  • Make the envelope body transparent with Change Transparency in the Display Pane.

You should now see the inner packaging space through the cylindrical wall.

  • Save the part as CanSatEnvelope.SLDPRT in the same project location as MissionStatement.txt.

The document tab should now show CanSatEnvelope.SLDPRT.

  • Create another new Part document for the payload deck.
  • Sketch a centered circle with a diameter of 62 mm.

You should see a circular profile that is smaller than the envelope diameter.

  • Extrude the circle into a thin solid disc using a preliminary thickness suitable for the cardstock model.
  • Save the part as PayloadDeck.SLDPRT beside CanSatEnvelope.SLDPRT.

You now have separate envelope and deck parts ready for mechanical integration.

Why use simplified geometry?

This model focuses on packaging clearance. Manufacturing details would add geometry without improving this fit check.

The 4 mm diameter difference leaves 2 mm of radial clearance on each side. That project-defined margin makes the deck clearance visible.

Model the Nano placeholder

The placeholder needs accurate plan dimensions for a useful fit check. Its component height remains preliminary because your simplified model represents the board envelope.

  • Measure the Nano board's maximum overall height with your metric ruler.
  • Round the measured height upward to the next whole millimetre.

The rounded value gives the placeholder a conservative height for this preliminary integration model.

  • Record the rounded value here: your measured or conservative Nano height in mm.
  • Create a new Part document for the Nano placeholder.

Your physical measurement is now ready to drive the simplified CAD envelope.

  • Sketch a centered rectangular footprint measuring 43.16 mm by 17.76 mm.

You should see a narrow rectangular profile matching the official Nano plan dimensions.

  • Extrude the rectangular footprint to your measured or conservative Nano height in mm.
  • Add a visible model note that labels the component height as preliminary.

The placeholder should now show its official footprint plus a clearly identified preliminary height.

  • Save the part as NanoPlaceholder.SLDPRT beside the other CAD parts.

Your three simplified components are now ready to answer the integration question.

Build the failing assembly and capture evidence

The assembly turns separate part geometry into a packaging test. The deliberately offset placeholder represents a component placement that has not passed integration review.

  • Create a new Assembly document in SOLIDWORKS.
  • Insert CanSatEnvelope.SLDPRT as the first component with Insert Components.

The envelope should appear as the fixed reference component for the assembly.

  • Insert PayloadDeck.SLDPRT with Insert Components.
  • Insert NanoPlaceholder.SLDPRT with Insert Components.

You should see all three components in the FeatureManager design tree.

  • Position the payload deck completely inside the envelope using standard mates.
  • Drag the Nano placeholder sideways until part of it visibly crosses the envelope wall.

The transparent wall should make the Nano placeholder's bad radial placement visible.

  • Save the assembly as CanSatPayloadAssembly.SLDASM beside the three part files.

Before you calculate the check, do you expect the deliberately offset placeholder to appear in the interference results?

  • Open Interference Detection from the Evaluate toolbar.
  • Select Calculate in the Interference Detection PropertyManager.

You should see an entry under Results for the overlap between NanoPlaceholder.SLDPRT and CanSatEnvelope.SLDPRT.

  • Select the reported interference under Results.

SOLIDWORKS should highlight the overlapping volume in red. This failure is intentional evidence that the first placement violates the packaging boundary.

No interference result?

  • Confirm that the envelope wall uses solid geometry.
  • Move NanoPlaceholder.SLDPRT farther through the envelope wall.
  • Run Calculate again.

Get help checking the assembly geometry with this troubleshooting prompt.

The result can be a little fiddly to frame because the graphics area and Results panel both need to stay visible. Arrange them before capturing the evidence.

  • Keep the selected interference visible beside the open Results panel.

Your screen should now show the geometric crossing plus the calculated interference evidence.

  • Press Windows+Shift+S to open the Snipping Tool overlay.
  • Drag a rectangle around the assembly graphics area and the visible Results panel.

Windows copies the captured region into Snipping Tool and shows a notification.

  • Select the screenshot notification to open the capture.
  • Select Save as in Snipping Tool.

The Save As dialog lets you place the evidence beside the project artifacts.

  • Create a folder named evidence beside the CAD files.
  • Open the new evidence folder.

The Save As location should now end with the evidence folder.

  • Enter interference-failure.png as the file name.
  • Select PNG as the file type.

The dialog should now show the exact evidence filename and image format.

  • Select Save to create evidence/interference-failure.png.

That is the designed failure captured. Your CAD evidence now connects a packaging requirement to a visible integration problem.

You now have a documented integration failure. Next up, you will correct the placement before verifying the CAD model against the physical payload.

Fix the Integration and Run a Bench Test

The failed Interference Detection result from the previous step gave you a concrete integration problem. A functioning payload still needs corrected packaging before its data can count as system evidence.

Now you will correct the SOLIDWORKS assembly before translating the same envelope into cardstock. The tethered bench test then proves that the packaged sensor payload keeps streaming telemetry during controlled hand motion.

In this step, get ready to:
  • Produce a corrected CAD assembly with no unintended overlap.
  • Capture preliminary mass-property evidence for the simplified geometry.
  • Complete a safe ten-second bench test with the physical cardstock model.
Correct the CAD integration

A centered payload creates predictable radial clearance. Mates turn that intent into constraints that SOLIDWORKS can verify repeatedly.

  • Switch back to CanSatPayloadAssembly.SLDASM in SOLIDWORKS.
  • Select the Nano placeholder in the assembly graphics area.
  • Add a Coincident mate between the Nano placeholder's bottom face and the payload deck's top face.
  • Set a Distance mate from the deck's longitudinal center plane to one Nano end face at 21.58 mm.
  • Set a Distance mate from the deck's transverse center plane to one Nano side face at 8.88 mm.
  • Save CanSatPayloadAssembly.SLDASM.

Why Do These Distances Center the Nano?

The Nano placeholder length is 43.16 mm. Half of that length is 21.58 mm.

The width is 17.76 mm. Half of that width is 8.88 mm. Those two offsets align the placeholder's geometric center with the deck's center.

Before you rerun the check, do you expect the Nano placeholder to remain in the interference results now that both center distances match half its plan dimensions?

  • Rerun Interference Detection on the corrected assembly.

You should see no unintended overlap between the centered Nano placeholder and the CanSat envelope.

  • Capture the passing result as evidence/interference-pass.png.

That closes the packaging failure loop. Your assembly now carries visible evidence that the corrective placement works.

A clean interference result proves clearance. Mass Properties provides preliminary mass information plus a center of mass for the simplified geometry.

  • Open the Tools menu in SOLIDWORKS.
  • Select Evaluate.
  • Select Mass Properties.

You should see the calculated mass information in the dialog. The model view should also identify the calculated center-of-mass location.

  • Position the model so the center-of-mass marker is visible beside the Mass Properties dialog.
  • Capture an image that includes the dialog beside the center-of-mass view.

The captured image should preserve both the numerical result and its location in the assembly.

  • Add the caption PRELIMINARY - SIMPLIFIED GEOMETRY to the captured image.

You should see a clear warning that these values come from simplified placeholder geometry.

  • Save the labeled image as evidence/mass-properties.png.

Still Seeing an Unintended Overlap?

  • Inspect the two Distance mate directions if the placeholder moved away from the deck center.
  • Check that the Coincident mate uses the Nano bottom face against the deck top face.
  • Suppress any older mate that still holds the Nano in its deliberately offset position.

Help me diagnose the remaining interference in my corrected CanSat assembly.

Build the cardstock engineering model

The physical mock-up checks whether the envelope remains practical around real hardware. It also exposes cable-access problems that simplified CAD may miss.

Keep the Model on the Bench

The approved test article stays tethered by its Micro-B USB cable. The test uses controlled hand motion while the model remains securely in your hand.

Dropping or launching the model falls outside this bench test. The cable must retain enough slack to avoid pulling on the Nano connector.

  • Mark a center point on the cardstock.
  • Place four edge marks 31 mm from the center point.

Opposite edge marks should sit 62 mm apart. Those marks define the diameter of the payload deck.

  • Sketch a circle through the four edge marks.
  • Cut out the cardstock circle with the scissors.
  • Measure the finished deck across its widest point with the metric ruler.

You should measure a diameter of approximately 62 mm.

  • Mark a 115 mm by 217 mm rectangle on another piece of cardstock.
  • Cut out the marked rectangle with the scissors.
  • Measure the cut rectangle with the metric ruler.

The short side should measure 115 mm. The long side should measure approximately 217 mm.

Why Is the Sleeve 217 mm Wide?

A 66 mm diameter circle has a circumference of approximately 207 mm.

The remaining 10 mm creates an overlap for the taped seam. That overlap closes the sleeve without reducing the intended diameter.

  • Mark a 10 mm overlap line along one short edge of the rectangle.
  • Roll the cardstock until the opposite edge reaches the overlap line.

The rolled cardstock should now form a cylindrical sleeve with an open top and bottom.

  • Secure the sleeve seam with removable tape.
  • Measure the finished sleeve with the metric ruler.

You should measure a height of approximately 115 mm plus a diameter of approximately 66 mm.

  • Place the real Nano on the cardstock deck with its Micro-B connector facing the sleeve opening.
  • Secure the Nano to the deck with removable tape.
  • Tilt the loose deck gently to test the taped connection.

The Nano should remain fixed to the deck during the gentle tilt.

  • Guide the connected Micro-B cable through the sleeve opening.
  • Slide the payload deck into the sleeve.

You should still be able to reach the Micro-B connector without removing the deck.

  • Secure the payload deck inside the sleeve with removable tape.
  • Confirm the USB cable has enough slack for controlled hand motion.

Your CAD envelope now has a physical counterpart. The board stays secured while its programming connection remains accessible.

Does the Cardstock Model Feel Loose?

  • Increase the seam overlap slightly if the sleeve measures wider than 66 mm.
  • Reduce the seam overlap if the payload deck cannot enter the sleeve.
  • Replace the removable tape if the Nano shifts during the gentle tilt check.

Help me correct the fit of my cardstock CanSat model.

Run the tethered bench test

The final check combines packaging with live sensing. A successful test keeps the seven-column CSV stream continuous while the model experiences gentle tilt, hand warming, and a light shake.

Use Controlled Hand Motion

Keep the model tethered throughout the test. Every movement stays gentle enough for the cardstock sleeve, taped deck, and connected USB cable.

  • Hold the cardstock model securely in one hand.
  • Check that the Micro-B cable hangs with visible slack.

The cable should curve naturally between the model and your computer. It should not pull against the board connector.

  • Switch back to the Arduino IDE from earlier.
  • Return to Serial Monitor.

You should see the existing telemetry header followed by live comma-separated rows.

  • Confirm the baud selector shows 9600.
  • Wait for one complete telemetry row to arrive.

Before you start the ten-second test, do you expect every motion to appear without interrupting the environmental readings?

  • Hold the model steady for the first telemetry row.
  • Tilt the model gently during the next three rows.
  • Warm the sleeve with your hand during the following three rows.
  • Apply a light hand shake during the final three rows.

You should see at least ten uninterrupted rows beneath time_ms,pressure_kpa,temperature_c,humidity_pct,accel_x_g,accel_y_g,accel_z_g. The acceleration columns should respond during the tilt and shake while the environmental columns continue updating.

  • Photograph the tethered cardstock model after the test.
  • Save the photo as evidence/bench-test-photo.png.

You should now have a physical record showing the secured payload plus its accessible USB connection.

  • Select the telemetry header plus at least ten consecutive test rows in Serial Monitor.
  • Copy the selected telemetry.
  • Paste the copied telemetry into a plain-text file inside the existing evidence folder.

The pasted text should show the seven-column header followed by consecutive comma-separated rows.

  • Save the telemetry file as evidence/bench-test-telemetry.csv.
  • Check the adjacent time_ms values in the saved file.

You should see timestamp increases of approximately 1000 milliseconds with no missing test rows. The saved data should preserve the changing acceleration values plus uninterrupted pressure, temperature, and humidity readings.

You have now closed the engineering loop from a visible fit failure to corrected CAD evidence plus repeatable physical telemetry.

Secret mission

Add a High-Acceleration Event Flag

Your payload already records motion on three axes. Extend its telemetry with an onboard event flag that makes high-acceleration moments easy to find.

Clean Up Your Resources

Clean Up Your Resources

Your local project files, physical model, and disconnected hardware have no ongoing usage cost. An optional 3DEXPERIENCE SOLIDWORKS for Makers subscription continues to cost money while its monthly renewal remains active.

Cost warning

A monthly 3DEXPERIENCE SOLIDWORKS for Makers subscription costs $15 USD per month before tax.

The monthly subscription renews automatically unless canceled.

Resources you used:

  • Project source files: MissionStatement.txt, CanSatPayload.ino, CanSatEnvelope.SLDPRT, PayloadDeck.SLDPRT, NanoPlaceholder.SLDPRT, and CanSatPayloadAssembly.SLDASM.
  • Verification evidence: evidence/bench-test-photo.png, evidence/bench-test-telemetry.csv, evidence/high-acceleration-event-telemetry.csv, evidence/interference-failure.png, evidence/interference-pass.png, and evidence/mass-properties.png.
  • Physical engineering model: the cardstock sleeve contains the taped Arduino Nano 33 BLE Sense Rev2 on its cardstock payload deck.
  • Optional subscription: the monthly 3DEXPERIENCE SOLIDWORKS for Makers renewal if you subscribed for this project.

Keep everything running

No action is needed. Choose this if you are still collecting telemetry or improving the integration model.

  • Keep MissionStatement.txt, CanSatPayload.ino, and the four CAD files together.
  • Keep the evidence folder beside the project files.
  • Store the physical model where the Nano pins cannot bend or contact metal.
  • Continue using Arduino IDE with the uploaded Secret Mission sketch.
  • Keep the monthly Makers subscription active only while you need its CAD access.

Pause - I'll come back to this later

Shut down the live session to protect the hardware while keeping every project artifact available.

  • Close the Serial Monitor window.
  • Close Arduino IDE.
  • Close SOLIDWORKS.
  • Disconnect the Micro-B USB cable from the Nano board.
  • Store the assembled cardstock model where its pins cannot bend or short against metal.
  • Retain the project source files beside the evidence folder.

Your sketch remains uploaded to the Nano. The Makers monthly plan keeps renewing unless you cancel it.

Delete - I don't want to use this again

Deleting your local evidence is permanent. The Arduino board stays reusable after you dismantle the cardstock shell.

  • Copy any portfolio evidence you want to preserve to a safe location.
  • Disconnect the Micro-B USB cable from the Nano board.
  • Remove the Nano board from the removable tape.
  • Set the Nano board and Micro-B USB cable aside for reuse.
  • Recycle or discard the cardstock sleeve, cardstock deck, and used tape.
  • In File Explorer, return to the folder containing MissionStatement.txt.
  • Select MissionStatement.txt, CanSatPayload.ino, CanSatEnvelope.SLDPRT, PayloadDeck.SLDPRT, NanoPlaceholder.SLDPRT, CanSatPayloadAssembly.SLDASM, and the evidence folder.
  • Press the Delete key to move the selected artifacts to the Recycle Bin.

Your local project copies now sit in the Recycle Bin.

  • Empty the Recycle Bin to remove the local project artifacts permanently.
  • Sign in to My Account if you subscribed to 3DEXPERIENCE SOLIDWORKS for Makers.
  • Cancel the monthly renewal for the Makers subscription.
  • Confirm that the monthly renewal is no longer active.

Cleanup is complete. Your Nano remains ready for another sensor project.

Nice Work!

Nice Work!

Mission complete! Your bench-top CanSat engineering model now produces live sensor data inside a verified mechanical package.

What you learned:

  • Built a physical CanSat payload that reports pressure, temperature, humidity, and acceleration in one CSV telemetry row approximately every second.
  • Created a deliberate fit failure in SOLIDWORKS. Corrected the Nano placement until Interference Detection reported no unintended overlap. Captured preliminary mass-property and center-of-mass evidence for the simplified assembly.
  • Ran a safe tethered bench test with the assembled cardstock model. Saved a test photo plus uninterrupted telemetry as repeatable verification evidence.
  • Secret Mission: Added a high-acceleration event flag that compares acceleration magnitude squared with the project-defined threshold. Saved one normal row plus one flagged row as proof.

Ready to quiz yourself?