Build a PLA CanSat Payload

Build and print a PLA CanSat chassis with live Arduino sensor telemetry.

Introduction

30 Second Summary

Desk-tested electronics can work perfectly until the enclosure blocks a connector or collides with the board. A physical fit check catches those surprises before a more advanced build.

In this project, you will build a hand-held PLA CanSat payload model around dimensions you choose. The finished model combines live sensor data from an Arduino Nano 33 BLE Sense Rev2 with a SOLIDWORKS-verified printed chassis.

What You'll Build

Hold your finished payload inside its printed chassis while the live acceleration values respond to every rotation.

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

  • A live six-column CSV telemetry stream that reports the payload's environment plus its three-axis motion once per second.
  • A mechanical fit demonstration where you can show a deliberate SOLIDWORKS collision before presenting the corrected assembly.
  • A printed PLA chassis that carries the powered board while full telemetry continues over USB. You can support the final design with center-of-mass evidence.
  • Secret Mission: A learner-tuned high-acceleration field that switches from 0 to 1 when your payload exceeds a threshold you justify.

Are there any prerequisites?

You need basic SOLIDWORKS assembly experience plus access to an Arduino Nano 33 BLE Sense Rev2 with a data-capable Micro-B cable.

You also need an existing PLA printer profile in Flash Studio Desktop. No Arduino programming experience is required.

Before We Start

This first commitment keeps the project focused on a PLA-only CanSat fit model that demonstrates sensor behavior and mechanical fit. The result is a USB-powered bench model with no flight-ready systems or safety claims.

Set Up the Sensor Board

The payload plan is settled. The board still needs a reliable programming path through Windows.

Arduino IDE must recognize the Arduino Nano 33 BLE Sense Rev2 as the target hardware. The pinned board package plus sensor libraries create that agreement.

A live tilt test at the end proves that the full sensor toolchain works before you write the payload sketch.

In this step, get ready to:
  • Install Arduino IDE 2.3.10 plus Arduino Mbed OS Nano Boards 4.6.0.
  • Select the Arduino Nano 33 BLE target with its COM port.
  • Prove live acceleration by uploading SimpleAccelerometer and watching X, Y, and Z values in Serial Monitor.
Install Arduino IDE and board support

Arduino IDE compiles sketches for the selected board. Its active port tells Windows which connected device receives each upload.

  • Open Windows search by pressing the Windows key.
  • Type Arduino IDE into the search field.
  • Choose the not installed tab below if Windows shows no matching application.
  • Press Enter if Windows lists Arduino IDE.
  • Select Help from the menu bar.
  • Select About Arduino IDE.
  • Match the displayed version to one of the tabs below.

✔️ I see the pinned version

Your installed version matches 2.3.10. The editor is ready for the Nano board package.

  • Close the application information window.

ⓧ I see a different version

Installing the pinned release updates the desktop application. Your existing sketches stay in their current folder.

  • Close Arduino IDE.
  • Open the official Arduino Software page.
  • Download the Windows installer for Arduino IDE 2.3.10.
  • Run the downloaded installer.
  • Approve the Windows permission request if it appears.
  • Complete the installation using the default options.

You should see the installer report that setup is complete.

  • Open Windows search by pressing the Windows key.
  • Type Arduino IDE into the search field.
  • Press Enter.
  • Return to the application information window through the Help menu.
  • Confirm that the displayed version is 2.3.10.

ⓧ Arduino IDE is not installed

The official Windows installer adds the editor to your computer. Windows may request permission before installation begins.

  • Open the official Arduino Software page.
  • Download the Windows installer for Arduino IDE 2.3.10.
  • Run the downloaded installer.
  • Approve the Windows permission request if it appears.
  • Complete the installation using the default options.

You should see the installer report that setup is complete.

  • Open Windows search by pressing the Windows key.
  • Type Arduino IDE into the search field.
  • Press Enter.
  • Open the application information window through the Help menu.
  • Confirm that the displayed version is 2.3.10.

A power-only cable can light the board without creating a data connection. Your data-capable Micro-B USB cable gives Arduino IDE a port it can use for uploads.

  • Connect the Nano to your Windows PC with the data-capable Micro-B USB cable.

You should see a COM port become available in Arduino IDE.

  • Select the board icon in the left sidebar to open Boards Manager.
  • Search for Arduino Mbed OS Nano Boards.

You should see the Nano board package in the search results.

The package can take a few minutes to install, so a short pause here is normal.

  • Choose version 4.6.0 from the version menu.
  • Click INSTALL.

You should see INSTALLED beneath the package name with version 4.6.0.

What Does the Board Package Do?

The board package supplies the compiler settings plus upload rules for the Nano family. Arduino IDE uses those instructions to build a sketch for the selected target.

  • Open the board selector in the top toolbar.
  • Select Arduino Nano 33 BLE beside the detected COM port.
  • Select Tools from the menu bar.
  • Point to Port.
  • Select the COM entry associated with the Nano.

You should see the board name in bold beside its selected port. That pairing confirms that uploads have a destination.

No COM Port Listed?

Reconnect the Micro-B cable at both ends. Confirm that the cable supports data transfer.

Try another USB port on the Windows PC if the board still does not appear.

If the target is not identified automatically, use Select other board and port from the board selector.

Help me diagnose why Arduino IDE cannot see my Nano.

Why Use the Onboard Sensors?

The Rev2 includes an onboard IMU for motion sensing. It also includes onboard pressure plus temperature and humidity sensors.

These devices remove external breakout wiring from the payload. Your effort stays focused on telemetry plus physical integration.

Install the three sensor libraries

The board package prepares the compiler for the Nano. Sensor libraries expose the functions that read each onboard device.

Each library installation can take up to a minute, so a short wait between results is expected.

  • Select Library Manager from the left sidebar.
  • Search for Arduino_BMI270_BMM150.

You should see the official motion sensor library in the search results.

  • Choose version 1.2.4 from the version menu.
  • Click INSTALL.

You should see INSTALLED beside Arduino_BMI270_BMM150.

  • Search for Arduino_HS300x.

You should see the temperature and humidity sensor library in the search results.

  • Choose version 1.0.1 from the version menu.
  • Click INSTALL.

You should see INSTALLED beside Arduino_HS300x.

  • Search for Arduino_LPS22HB.

You should see the pressure sensor library in the search results.

  • Choose version 1.0.3 from the version menu.
  • Click INSTALL.

You should see INSTALLED beside Arduino_LPS22HB. All three onboard sensor interfaces are now available.

What Do These Libraries Provide?

  • Arduino_BMI270_BMM150 provides access to the onboard acceleration sensor.
  • Arduino_HS300x provides temperature plus humidity readings.
  • Arduino_LPS22HB provides barometric pressure readings.

Library Version Missing?

Clear the Library Manager search field. Search again using the complete library name.

Check your internet connection if the library list does not load.

Help me install the pinned Arduino sensor libraries.

Upload the acceleration example

An example sketch gives you a known working sensor test. Its live readings separate hardware setup problems from code you write later.

  • Select File from the menu bar.
  • Select Examples.
  • Find Arduino_BMI270_BMM150 in the installed library examples.
  • Select SimpleAccelerometer.

You should see the example sketch open in a new editor window.

  • Click Verify in the top toolbar.

You should see the console finish compiling without reporting an error.

  • Click Upload in the top toolbar.

You should see the upload finish successfully. That is the toolchain connected from the editor to the physical Nano.

  • Click Serial Monitor in the top-right corner of Arduino IDE.
  • Set the Serial Monitor baud rate to 9600.

You should see live X, Y, and Z acceleration readings updating in the monitor.

Before you move the board, which acceleration values do you expect to respond when its orientation changes?

  • Hold the Nano still on a stable surface.
  • Tilt the Nano slowly in different directions.

You should see the X, Y, and Z values change as the board tilts. Your Nano is now reading motion through the complete Arduino setup.

No Live Acceleration Readings?

Confirm that Serial Monitor is using 9600 baud. Confirm that the selected COM port belongs to the connected Nano.

Upload SimpleAccelerometer again if the monitor remains blank.

Help me restore the live acceleration readings.

Your sensor board now responds to physical movement through a verified toolchain. Next, you will turn those live values into a clean CSV telemetry stream.

Produce the First CSV Telemetry

Your Arduino Nano 33 BLE Sense Rev2 now reports live acceleration readings. Tilting the board proves that its motion sensor responds to the physical world.

The example's descriptive output works well for a person reading the screen. A clean CSV stream gives every acceleration value a consistent position that another tool can parse.

In this step, get ready to:
  • Create a telemetry sketch that initializes the motion sensor.
  • Read three-axis acceleration into comma-separated rows.
  • Set the telemetry stream to one row per second.
Create the telemetry sketch

A telemetry stream needs a fixed column order before it starts producing measurements. The header establishes that order for every row that follows.

  • Use the top menu in Arduino IDE from earlier to create a new sketch.
  • Save the new sketch as CanSatPayload.ino.
  • Replace the generated sketch contents with this first runnable version:
#include <Arduino_BMI270_BMM150.h>

float x = 0.0f;
float y = 0.0f;
float z = 0.0f;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }

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

  Serial.println("accel_x_g,accel_y_g,accel_z_g");
}

void loop() {
}

What Does This Code Do?

  • The Arduino_BMI270_BMM150.h header gives the sketch access to the onboard motion sensor.
  • The x, y, and z variables hold acceleration readings measured in g.
  • The setup() function starts serial communication before initializing the motion sensor.
  • The final line prints the three-column CSV header once whenever the board restarts.
  • Save CanSatPayload.ino.
  • Click Verify in the Arduino IDE toolbar.
  • Click Upload in the Arduino IDE toolbar.
  • Return to the Serial Monitor from earlier.

You'll see accel_x_g,accel_y_g,accel_z_g printed as the header. Good progress. Your payload now identifies the meaning of each telemetry column.

Header Missing from Serial Monitor?

  • Confirm that the connected board target from the previous step remains selected.
  • Confirm that the correct COM port from the previous step remains selected.
  • Press the board's reset button once if the serial connection did not restart after the upload.

Ask for help if the header is still missing by using help me troubleshoot why my Arduino sketch uploads but its CSV header does not appear in Serial Monitor.

Stream acceleration as CSV

The header defines the table structure. The loop now needs to fill that structure with a fresh sensor reading whenever acceleration data is available.

  • Find the empty loop() function near the bottom of CanSatPayload.ino.
  • Replace the entire empty function with this telemetry loop:
void loop() {
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    Serial.print(x);
    Serial.print(',');
    Serial.print(y);
    Serial.print(',');
    Serial.println(z);
  }
}

How Does the Telemetry Loop Work?

  • The IMU.accelerationAvailable() check allows the loop to read only when the sensor has a measurement ready.
  • The IMU.readAcceleration(x, y, z) call stores the three axis readings in their matching variables.
  • Each Serial.print() call writes one value or separator without ending the row.
  • The final Serial.println() call writes the Z value before starting a new row.
  • Save CanSatPayload.ino.
  • Click Verify in the Arduino IDE toolbar.
  • Click Upload in the Arduino IDE toolbar.
  • Return to the Serial Monitor from earlier.
  • Tilt the connected board gently.

You'll see comma-separated rows update rapidly. The three values change as you alter the board's orientation.

Rows Missing or Stuck?

  • Compare the variable names in IMU.readAcceleration(x, y, z) with the declarations above setup().
  • Check every Serial.print() line for matching parentheses.
  • Reconnect the data-capable Micro-B USB cable if the board loses power during movement.

Use help me debug missing or unchanged acceleration rows in my CSV stream.

Set a one-second update rate

The sensor can provide readings faster than this early payload needs. A one-second pause keeps the first telemetry stream readable while preserving a consistent update rhythm.

  • Find the current loop() function in CanSatPayload.ino.
  • Replace the entire function with this final version:
void loop() {
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    Serial.print(x);
    Serial.print(',');
    Serial.print(y);
    Serial.print(',');
    Serial.println(z);
  }

  delay(1000);
}

What Does the Delay Control?

The delay(1000) call pauses the loop for one thousand milliseconds after each pass. This limits the sketch to approximately one telemetry row per second.

  • Save CanSatPayload.ino.
  • Click Verify in the Arduino IDE toolbar.

Before you upload, what rhythm do you expect the rows to follow? Keep your prediction in mind.

  • Click Upload in the Arduino IDE toolbar.
  • Return to the Serial Monitor from earlier.
  • Tilt the connected board gently in several directions.

You'll see accel_x_g,accel_y_g,accel_z_g followed by one comma-separated row per second. The acceleration values change when you tilt the board.

That's your first payload data stream working. The Nano now turns physical movement into a clean three-column CSV table.

Rows Still Updating Too Quickly?

  • Confirm that delay(1000); sits inside loop().
  • Confirm that the delay line appears after the acceleration block.
  • Upload the saved sketch again if Serial Monitor still shows the previous behavior.

Use help me troubleshoot why my Arduino CSV rows are not updating once per second.

✔️ Awesome, I've got everything!

Your sketch is saved. Serial Monitor now shows a three-column acceleration row approximately once per second.

ⓧ I'd like to double check the full code

Compare your complete CanSatPayload.ino sketch with this reference.

#include <Arduino_BMI270_BMM150.h>

float x = 0.0f;
float y = 0.0f;
float z = 0.0f;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }

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

  Serial.println("accel_x_g,accel_y_g,accel_z_g");
}

void loop() {
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    Serial.print(x);
    Serial.print(',');
    Serial.print(y);
    Serial.print(',');
    Serial.println(z);
  }

  delay(1000);
}

Your payload now produces structured motion telemetry over USB. Next, you'll expand the same stream with pressure, temperature, and humidity readings.

Add the Environmental Sensors

Your three-column CSV stream already proves that the Arduino Nano 33 BLE Sense Rev2 can report motion. The payload now needs environmental context.

This step expands the stream with pressure, temperature, and humidity. The finished sketch produces the six-field telemetry promised by the project.

In this step, get ready to:
  • Connect the pressure plus temperature and humidity libraries to the sketch.
  • Initialize every onboard sensor with a shared failure handler.
  • Produce one six-field telemetry row per second.
Connect the environmental libraries

Each sensor library gives your sketch access to one part of the onboard hardware. Adding their headers first confirms that your existing installation can resolve all three libraries.

  • Return to the CanSatPayload.ino tab in Arduino IDE.
  • Find this line:
#include <Arduino_BMI270_BMM150.h>

What does this line do?

The Arduino_BMI270_BMM150.h header provides the IMU object used by your working acceleration stream.

  • Replace that line with these three library headers:
#include <Arduino_BMI270_BMM150.h>
#include <Arduino_HS300x.h>
#include <Arduino_LPS22HB.h>

What do these headers provide?

  • Arduino_BMI270_BMM150.h provides the IMU acceleration interface.
  • Arduino_HS300x.h provides temperature and humidity readings through HS300x.
  • Arduino_LPS22HB.h provides pressure readings through BARO.
  • Save CanSatPayload.ino.
  • Click Verify in the Arduino IDE toolbar.

Good progress. The sketch should compile with all three headers, which confirms that Arduino IDE can resolve every sensor library.

Does a library fail to compile?

Check each header for matching capitalization. Confirm that the installed library names correspond to the three headers in the sketch.

Ask for help with the sensor library compilation error.

Build the six-sensor telemetry

Sensor initialization acts as a startup gate. The shared stopWithMessage() helper prints the specific failed sensor before stopping the sketch.

The loop then samples pressure, temperature, humidity, and acceleration. Each row follows the same order as the expanded CSV header.

  • Select the declarations from float x = 0.0f; through the closing brace of setup().
  • Replace that selection with this sensor setup code:
float accelXG = 0.0f;
float accelYG = 0.0f;
float accelZG = 0.0f;

void stopWithMessage(const char* message) {
  Serial.println(message);
  while (true) {
  }
}

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }

  if (!IMU.begin()) {
    stopWithMessage("Failed to initialize IMU");
  }

  if (!HS300x.begin()) {
    stopWithMessage("Failed to initialize temperature and humidity sensor");
  }

  if (!BARO.begin()) {
    stopWithMessage("Failed to initialize pressure sensor");
  }

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

What does this setup code do?

  • accelXG, accelYG, and accelZG hold the most recent acceleration readings in g.
  • stopWithMessage() prints a sensor-specific message before halting the sketch.
  • IMU.begin(), HS300x.begin(), and BARO.begin() confirm that each onboard sensor is ready.
  • Serial.println() defines the exact order of the six telemetry fields.
  • Select the existing loop() function.
  • Replace the selection with this six-sensor loop:
void loop() {
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(accelXG, accelYG, accelZG);
  }

  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPercent = HS300x.readHumidity();

  Serial.print(pressureKpa);
  Serial.print(',');
  Serial.print(temperatureC);
  Serial.print(',');
  Serial.print(humidityPercent);
  Serial.print(',');
  Serial.print(accelXG);
  Serial.print(',');
  Serial.print(accelYG);
  Serial.print(',');
  Serial.println(accelZG);

  delay(1000);
}

What does this loop do?

  • IMU.accelerationAvailable() checks whether a fresh acceleration sample is ready.
  • BARO.readPressure(KILOPASCAL) reads pressure in kilopascals.
  • HS300x.readTemperature(CELSIUS) reads temperature in degrees Celsius.
  • HS300x.readHumidity() reads relative humidity.
  • Serial.print() writes each reading in the same order as the CSV header.
  • delay(1000) keeps the stream at one row per second.

Before you upload, consider which columns you expect to react first when you tilt the board.

  • Save CanSatPayload.ino.
  • Click Verify in the Arduino IDE toolbar.
  • Click Upload after verification succeeds.
  • Return to Serial Monitor after the upload completes.

You should see pressure_kpa,temperature_c,humidity_percent,accel_x_g,accel_y_g,accel_z_g followed by six comma-separated values. A new row should arrive once per second.

Does the stream stop during startup?

A failure message means one onboard sensor did not initialize. The sketch stops at that point to prevent incomplete telemetry rows.

  • Disconnect the Micro-B USB cable.
  • Reconnect the Micro-B USB cable.
  • Upload CanSatPayload.ino again.

Ask for help identifying the sensor that failed to initialize.

✔️ Awesome, I've got everything!

Your saved sketch now matches the completed six-sensor telemetry program.

ⓧ I'd like to double check the full code

Compare your complete CanSatPayload.ino file with this reference.

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

float accelXG = 0.0f;
float accelYG = 0.0f;
float accelZG = 0.0f;

void stopWithMessage(const char* message) {
  Serial.println(message);
  while (true) {
  }
}

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }

  if (!IMU.begin()) {
    stopWithMessage("Failed to initialize IMU");
  }

  if (!HS300x.begin()) {
    stopWithMessage("Failed to initialize temperature and humidity sensor");
  }

  if (!BARO.begin()) {
    stopWithMessage("Failed to initialize pressure sensor");
  }

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

void loop() {
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(accelXG, accelYG, accelZG);
  }

  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPercent = HS300x.readHumidity();

  Serial.print(pressureKpa);
  Serial.print(',');
  Serial.print(temperatureC);
  Serial.print(',');
  Serial.print(humidityPercent);
  Serial.print(',');
  Serial.print(accelXG);
  Serial.print(',');
  Serial.print(accelYG);
  Serial.print(',');
  Serial.println(accelZG);

  delay(1000);
}
Verify the six-field stream

A useful telemetry stream keeps every row in the same field order. Stable environmental values provide context while the acceleration values reveal movement.

  • Place the connected board on a stable surface.
  • Observe several rows in Serial Monitor.

The pressure, temperature, and humidity fields should remain plausible and fairly stable. Each row should still contain six values.

Before you move the payload, consider which fields should respond to motion.

  • Tilt the connected board slowly.
  • Watch the next several rows in Serial Monitor.

The three acceleration columns should change as you tilt the board. The environmental columns should continue updating once per second.

Your payload now combines motion with environmental telemetry in one clean stream. Next, you will use SOLIDWORKS to test whether the electronics fit inside your PLA chassis design.

Make the Mechanical Layout Fail

Your six-field CSV stream proves the electronics work. A payload can still fail when the board collides with its chassis.

In SOLIDWORKS, you will create a learner-dimensioned assembly around the physical board. You will deliberately introduce an interference so the fit problem becomes visible evidence.

In this step, get ready to:
  • Create an open PLA chassis from dimensions you select.
  • Build a constrained assembly from the chassis and a measured board envelope.
  • Capture a reported interference from a deliberate chassis-to-envelope collision.
Create the open PLA chassis

An open chassis keeps the structure visible during fit checks. Your own design intent determines every overall dimension.

  • Press the Windows key to open Windows search.
  • Type SOLIDWORKS into the search field.
  • Press Enter to open SOLIDWORKS.
  • Create a blank part through the SOLIDWORKS new-part workflow.

You should see an empty part document ready for the chassis geometry.

  • Save the part as CanSatChassis.SLDPRT through the SOLIDWORKS Save As workflow.
  • Sketch the overall chassis footprint using dimensions chosen for your payload concept.
  • Inspect the fully defined footprint before creating solid geometry.

The footprint should reflect your intended payload proportions. Its dimensions remain your engineering choice.

  • Build an open base with walls that match your selected wall choices.
  • Add mounting geometry that reflects how you intend to retain the board.
  • Rotate the model to inspect the open interior from several angles.

You should see a lightweight chassis with accessible board space. The electronics area remains visible for the coming fit check.

  • Add one structural feature inside the area where the board envelope will be tested.
  • Save CanSatChassis.SLDPRT.
  • Inspect the completed chassis to confirm the feature is a solid body.

Your first mechanical artifact is complete. The open chassis now gives you a concrete structure for testing board fit.

Why use an open chassis?

An open structure uses less material during the later physical test. It also keeps mounting geometry visible during assembly checks.

This design keeps the project focused on structural fit. Your printed model stays a powered bench payload.

Model and assemble the board envelope

The Arduino Nano 33 BLE Sense Rev2 envelope is a simplified solid based on your own measurements. It represents the board's occupied space without recreating every component.

  • Disconnect the Micro-B cable from the board before measuring it.
  • Place the board on a stable nonconductive surface.
  • Measure the board's overall length in millimetres.
  • Record the measured length here: your board length in mm.
  • Measure the board's overall width in millimetres.
  • Record the measured width here: your board width in mm.
  • Measure the board's maximum occupied height in millimetres.
  • Record the measured height here: your board height in mm.

These three measurements define the minimum occupied volume of your simplified board model. They also make your fit check traceable to the hardware in your hand.

  • Reconnect the Micro-B cable to the Arduino board.
  • Return to Serial Monitor in the Arduino IDE from earlier.
  • Move the board gently to test the live stream.

You should see the six-field CSV rows continue once per second. The acceleration values should respond to the movement.

Your live payload is back online. Its measured envelope is ready for the assembly.

  • Switch back to the open SOLIDWORKS window.
  • Create another blank part through the new-part workflow.

You should now have a separate empty part document for the simplified board envelope.

  • Sketch a rectangular footprint for the board envelope.
  • Dimension the footprint with your board length in mm by your board width in mm.
  • Inspect the footprint to confirm both measured dimensions are applied.

The rectangular footprint should now match the board measurements you recorded.

  • Extrude the footprint to your board height in mm.
  • Save the part as ArduinoEnvelope.SLDPRT.

You should see one simple solid that represents the measured board volume. Detailed electronic components are outside this fit model's scope.

  • Start a new assembly through the SOLIDWORKS assembly workflow.
  • Insert CanSatChassis.SLDPRT into the assembly.

You should see the open chassis as the first assembly component.

  • Insert ArduinoEnvelope.SLDPRT into the same assembly.
  • Fix CanSatChassis.SLDPRT as the assembly reference.
  • Rotate the assembly to confirm both components are visible.

The assembly should contain the chassis plus one rectangular board envelope.

  • Constrain ArduinoEnvelope.SLDPRT inside the chassis using your intended mounting orientation.
  • Save the assembly as CanSatAssembly.SLDASM.
  • Rotate the constrained assembly to inspect the board envelope inside the open structure.

You should see the measured envelope held inside the learner-dimensioned chassis. The assembly now represents your proposed physical layout.

Force and capture the interference

SOLIDWORKS Interference Detection checks whether solid assembly components occupy the same space. A highlighted overlap turns a suspected fit problem into visible evidence.

  • Reposition ArduinoEnvelope.SLDPRT so it deliberately intersects the structural feature you created.
  • Update the envelope constraint to preserve that overlapping position.
  • Rotate the assembly to inspect the collision area.

The envelope and the chassis feature should visibly occupy the same region. Keep that deliberate collision in place for the analysis.

  • Save CanSatAssembly.SLDASM with the deliberate overlap.

Before you run the check, which chassis feature do you expect SOLIDWORKS to identify as overlapping the envelope?

  • Open Command Search in SOLIDWORKS.
  • Enter Interference Detection in Command Search.
  • Select the matching command from the search results.
  • Run the analysis from the Interference Detection panel.

You should see at least one interference reported. SOLIDWORKS should highlight the overlapping board envelope and chassis geometry.

That reported failure is the intended result. You now have proof that the current board position cannot work as modeled.

No interference reported?

Confirm that both components are solid bodies. Surface contact without shared volume does not create the intended overlap.

Move the envelope farther into the structural feature. Run Interference Detection again after rebuilding the assembly.

Ask for help with finding why SOLIDWORKS does not report the deliberate overlap.

  • Keep the reported interference highlighted in SOLIDWORKS.
  • Press Windows+Shift+S to start a Windows screen capture.
  • Drag over the SOLIDWORKS window to capture the highlighted geometry plus the reported result.
  • Save the capture with your project evidence.
  • Save CanSatAssembly.SLDASM again.

✔️ Awesome, I've got everything!

Your three SOLIDWORKS files are saved. Your interference evidence shows the highlighted unwanted overlap.

ⓧ I'd like to double check the assembly state

Compare your project with this end-of-step checkpoint.

  • The CanSatChassis.SLDPRT file contains an open chassis with your overall dimensions. It includes your wall choices. It includes your mounting geometry. It includes your clearances. It also contains the structural feature used for the collision.
  • The ArduinoEnvelope.SLDPRT file represents your measured Arduino board dimensions as a simplified solid.
  • The CanSatAssembly.SLDASM file contains both parts. Its constraints place the envelope through the chassis structural feature.
  • Your saved interference evidence shows at least one highlighted chassis-to-envelope overlap.
  • The uploaded CanSatPayload.ino sketch remains unchanged. Serial Monitor continues to show its six-field CSV telemetry.

You have captured a specific mechanical defect without disturbing the live telemetry sketch. Next, you will use that evidence to correct the layout before printing the chassis.

Correct, Print, and Integrate the Chassis

Your deliberate collision exposed the structural feature that blocks the board. A working sensor still fails as a payload if the chassis cannot hold it.

This step turns that SOLIDWORKS failure into a corrected assembly with preliminary balance evidence.

The final proof is physical. Your printed PLA chassis must carry the live board while the six-field CSV stream keeps updating.

In this step, get ready to:
  • Validate the corrected assembly.
  • Prepare a time-budgeted chassis print.
  • Demonstrate telemetry from the integrated payload.
Prove the corrected assembly

The highlighted interference gives you a precise defect to correct. Your own measurements still control the correction.

  • Return to CanSatAssembly.SLDASM from the previous step.
  • Use the highlighted overlap as your correction target.
  • Keep the dimensions in ArduinoEnvelope.SLDPRT matched to your measured board.
  • Choose whether to adjust the Arduino envelope position or the chassis geometry.
  • Adjust the chosen feature to create your intended clearance.
  • Return to CanSatAssembly.SLDASM after making the correction.
  • Save every modified SOLIDWORKS file.

Before you rerun the check, predict whether the corrected assembly will still report an unwanted overlap.

  • Enter Interference Detection in Command Search.
  • Run Interference Detection on the corrected assembly.

You should see no unwanted interference between the constrained Arduino envelope and the chassis.

Still seeing unwanted interference?

  • Inspect the highlighted volume to locate the remaining conflict.
  • Confirm that the corrected part is active in CanSatAssembly.SLDASM.
  • Repeat the correction until Interference Detection reports no unwanted overlap.

Ask for help with the remaining collision by selecting help me interpret the highlighted SOLIDWORKS interference.

The corrected fit check establishes clearance. The next check estimates where the assembly balances.

  • Enter Mass Properties in Command Search.
  • Run Mass Properties on CanSatAssembly.SLDASM.

You should see preliminary center-of-mass information for the corrected assembly.

  • Save a screenshot of the displayed center-of-mass information.
  • Keep the initial interference evidence from the previous step.

Why is the center of mass preliminary?

The result uses your simplified board envelope and the properties assigned in the model. It provides useful design evidence for this bench payload.

That is the digital defect closed. Your corrected assembly now has fit evidence plus a preliminary balance result.

Prepare the chassis for printing

An STL file carries the corrected chassis surface into Flash Studio Desktop. The layer preview exposes how that surface becomes printable layers.

The displayed printing time acts as your scope gate.

  • Switch back to CanSatChassis.SLDPRT.
  • Open the File menu.
  • Select Save As.
  • Choose .stl as the file type.
  • Enter CanSatChassis.STL as the file name.
  • Save the exported file.
  • Confirm that CanSatChassis.STL appears beside your SOLIDWORKS files.

Your corrected chassis now exists in a format the slicer can read.

  • Press the Windows key to open Windows search.
  • Type Flash Studio Desktop and press Enter to open it.
  • Import CanSatChassis.STL onto the build plate.

You should see the corrected open chassis positioned on the virtual build plate.

  • Select your existing printer preset under Printer.
  • Select your existing PLA preset under Filament.

The selected printer and filament fields should now show the presets you already use with this machine.

  • Select your existing slicing preset under Process.
  • Click Slice plate.

You should see a layer preview with displayed filament usage and printing time.

  • Inspect the layer preview for a complete chassis shape.
  • Compare the displayed printing time with the time remaining in the 60-minute project budget.

Keep the print inside the budget

If the estimate pushes the full project past 60 minutes, simplify only nonfunctional geometry.

  • Return to CanSatChassis.SLDPRT.
  • Remove only nonfunctional geometry.
  • Preserve every mounting surface.
  • Preserve every required clearance.
  • Rerun Interference Detection on the revised assembly.
  • Export the revised part as CanSatChassis.STL.
  • Slice the revised file again.
  • Repeat this loop until the displayed estimate fits the project budget.

Once the estimate fits, your corrected chassis is ready to become a physical part.

Can't see a usable layer preview?

  • Confirm that you imported the latest CanSatChassis.STL export.
  • Confirm that the selected printer preset matches your existing machine.
  • Confirm that your usual PLA preset is selected under Filament.

Ask for help with the sliced model by selecting help me troubleshoot my missing or incomplete layer preview.

Integrate the live payload

Digital clearance cannot reveal every real-world fit detail. The Arduino Nano 33 BLE Sense Rev2 now becomes the final gauge.

Printing brings hot surfaces plus moving hardware into the workflow. Follow the safety routine you already use with this printer.

Expect this stage to take the exact duration shown by Flash Studio Desktop. That displayed estimate is your guide while the printer works.

  • Click Print plate to send the sliced job through your existing printer workflow.

You should see the print enter your printer's normal job workflow.

  • Monitor the print using your normal printer routine.
  • Wait for the printer to report that the job is complete.
  • Remove the chassis with your usual safe removal process.
  • Inspect the chassis for incomplete functional features.

The longest hands-on stage is complete. You now have the physical chassis that your digital checks prepared.

  • Disconnect the Micro-B cable from the Arduino board.
  • Seat the board in the printed chassis without forcing it.

The board should sit in your intended mounting area without bending the chassis or the board.

  • Confirm that the Micro-B port remains accessible.
  • Reconnect the same data-capable Micro-B cable.
  • Return to Arduino IDE from earlier.
  • Click Upload to upload CanSatPayload.ino.

Arduino IDE should confirm that the upload completed successfully.

  • Return to Serial Monitor after the upload completes.

You should see pressure_kpa,temperature_c,humidity_percent,accel_x_g,accel_y_g,accel_z_g followed by one six-field row per second.

Before you rotate the payload, predict which three columns will respond most clearly.

  • Rotate the assembled payload slowly in your hand.

You should see the three acceleration values change while the complete six-field stream continues. Your printed chassis now carries a powered telemetry payload.

Fit tight or telemetry missing?

  • Remove the board if the chassis presses against any component.
  • Compare the printed fit with ArduinoEnvelope.SLDPRT before revising the chassis.
  • Confirm that Arduino Nano 33 BLE remains selected in the board selector.
  • Confirm that the correct COM port remains selected.
  • Upload CanSatPayload.ino again after correcting the connection.

Ask for integration help by selecting help me troubleshoot the physical fit or missing telemetry.

✔️ Awesome, I've got everything!

Your printed chassis holds the board while the complete six-field telemetry stream continues.

ⓧ I'd like to double check the full code

  • Compare CanSatPayload.ino with the unchanged reference below:
#include <Arduino_BMI270_BMM150.h>
#include <Arduino_HS300x.h>
#include <Arduino_LPS22HB.h>

float accelXG = 0.0f;
float accelYG = 0.0f;
float accelZG = 0.0f;

void stopWithMessage(const char* message) {
  Serial.println(message);
  while (true) {
  }
}

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }

  if (!IMU.begin()) {
    stopWithMessage("Failed to initialize IMU");
  }

  if (!HS300x.begin()) {
    stopWithMessage("Failed to initialize temperature and humidity sensor");
  }

  if (!BARO.begin()) {
    stopWithMessage("Failed to initialize pressure sensor");
  }

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

void loop() {
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(accelXG, accelYG, accelZG);
  }

  float pressureKpa = BARO.readPressure(KILOPASCAL);
  float temperatureC = HS300x.readTemperature(CELSIUS);
  float humidityPercent = HS300x.readHumidity();

  Serial.print(pressureKpa);
  Serial.print(',');
  Serial.print(temperatureC);
  Serial.print(',');
  Serial.print(humidityPercent);
  Serial.print(',');
  Serial.print(accelXG);
  Serial.print(',');
  Serial.print(accelYG);
  Serial.print(',');
  Serial.println(accelZG);

  delay(1000);
}

What should this sketch preserve?

The header contains the six promised telemetry fields. Each loop prints pressure, temperature, humidity, and three-axis acceleration once per second.

You have closed the engineering loop from a visible CAD defect to a working PLA payload. The fitted board still produces live telemetry.

Secret mission

Flag High-Acceleration Events

Your payload already records how it moves. This challenge turns those readings into a decision by adding a high-acceleration event field that changes when controlled movement crosses your chosen threshold.

Clean Up Your Resources

Clean Up Your Resources

All project resources are local, so there are no recurring cloud charges. Choose whether to keep your work ready for demonstrations, pause it for another session, or remove the project-specific artifacts.

Resources you used:

  • Local Arduino sketch CanSatPayload.ino.
  • Local SOLIDWORKS files CanSatChassis.SLDPRT, ArduinoEnvelope.SLDPRT, and CanSatAssembly.SLDASM.
  • Exported chassis file CanSatChassis.STL.
  • Saved interference evidence from the deliberate chassis-to-board overlap.
  • Saved center-of-mass evidence for the corrected assembly.
  • Printed PLA chassis containing the fitted Arduino Nano 33 BLE Sense Rev2.

Keep everything running

No action is needed. Choose this option if you are still testing the payload or preparing to demonstrate it.

  • Keep Serial Monitor open while you continue observing the seven-column CSV telemetry.
  • Store CanSatPayload.ino, the three SOLIDWORKS files, and CanSatChassis.STL together.
  • Store the interference evidence beside the corrected assembly files.
  • Store the center-of-mass evidence beside the corrected assembly files.
  • Keep the printed PLA chassis assembled with the Arduino board for demonstrations.
  • Leave Arduino IDE, SOLIDWORKS, and Flash Studio Desktop installed for future engineering projects.

Pause - I'll come back to this later

Shut down the local equipment while keeping every project artifact ready for your next session.

  • Close Serial Monitor in Arduino IDE.
  • Disconnect the Micro-B USB cable from the Arduino Nano 33 BLE Sense Rev2.
  • Power down the PLA printer using its normal shutdown process.
  • Unload the PLA filament if that matches your normal printer care.
  • Keep CanSatPayload.ino, the SOLIDWORKS files, CanSatChassis.STL, both evidence records, and the printed chassis for your return.

Delete - I don't want to use this again

Deleting project-specific artifacts is permanent. Your hardware and installed software stay available for future builds.

  • Close Serial Monitor in Arduino IDE.
  • Disconnect the Micro-B USB cable from the Arduino Nano 33 BLE Sense Rev2.
  • Power down the PLA printer using its normal shutdown process.
  • Delete CanSatPayload.ino from its saved location in File Explorer.
  • Delete CanSatChassis.SLDPRT from its saved location in File Explorer.
  • Delete ArduinoEnvelope.SLDPRT from its saved location in File Explorer.
  • Delete CanSatAssembly.SLDASM from its saved location in File Explorer.
  • Delete CanSatChassis.STL from its saved location in File Explorer.
  • Delete the saved interference evidence from its saved location in File Explorer.
  • Delete the saved center-of-mass evidence from its saved location in File Explorer.
  • Review the Recycle Bin to confirm it contains only the project artifacts you intend to remove.
  • Permanently delete the selected project artifacts from the Recycle Bin.

The printed PLA chassis is the final project-specific artifact.

  • Remove the Arduino Nano 33 BLE Sense Rev2 from the printed PLA chassis.
  • Handle the unwanted printed PLA chassis through the recycling or disposal options available in your area.

Nice Work!

Nice Work!

You did it! Your printed PLA CanSat bench model now carries the Arduino Nano 33 BLE Sense Rev2 while streaming live sensor telemetry over USB.

You've learned how to:

  • Programmed the Arduino Nano 33 BLE Sense Rev2 to read its onboard motion sensors plus environmental sensors. Produced a live CSV telemetry stream over USB.
  • Used SOLIDWORKS Interference Detection to expose a deliberate overlap. Corrected the assembly until no unwanted interference remained. Captured preliminary center-of-mass evidence with Mass Properties.
  • Turned learner-selected dimensions into a printed open PLA chassis. Prepared the exported STL for printing with Flash Studio Desktop. Fitted the board into the finished chassis while keeping telemetry live.
  • Completed the optional Secret Mission by tuning HIGH_ACCELERATION_THRESHOLD_G from controlled observations. The stream now flags high-acceleration events with 0 or 1.

Ready to quiz yourself?