Airport Baggage System

Overview

This engineering project combined Python data processing with the design of a physical mechanism for moving baggage between levels.

The software read passenger and fleet information and determined outcomes such as boarded, oversold, bumped, overweight, delayed, and layovers. In parallel, the team had to build and test a real baggage-transfer concept.

Software

The first challenge was converting input text files into consistent internal structures. From there the program could apply the project rules and record each passenger's outcome in a traceable way.

load passenger_data.txt
load fleet_data.txt

parse -> validate -> classify -> assign

outputs:
  boarded
  oversold / bumped
  overweight
  delayed
  layovers

Figure 1 - Simplified software data flow.

Programming focus

Data handling

Parsing, conditions, data structures, validation, and repeatable outputs.

Engineering focus

Traceable decisions

Make it clear why each passenger receives an outcome rather than reporting only final counts.

Mechanism

An early rotary concept used string to move the baggage platform, but slack and alignment made the motion difficult to control reliably. The later design used a linear-actuator bridge with a hinge, slider rails, and side walls to constrain the bag more predictably.

Rotary / string concept. Simple in theory, but the string introduced slack, inconsistent motion, and alignment problems.
Linear-actuator bridge. A more constrained mechanism made the motion easier to predict and integrate.
Rails and side walls. Mechanical guidance reduced the number of ways the baggage could leave the intended path.

Documentation

The strongest version of this page should connect the software and hardware visually rather than presenting them as separate assignments.

▣

Split visual: program output + mechanism

Put a terminal/output screenshot beside a prototype photo, CAD sketch, or mechanism diagram.

Figure 2 - Pairing software evidence with hardware evidence makes the project easy to understand.

Lessons

Constrained motion reduces failure modes in physical prototypes.
Software is easier to debug when parsing, decision logic, and output are separated.
Testing an early idea quickly is more valuable than polishing a mechanism that is fundamentally unreliable.
Good documentation explains why the final design differs from the first sketch.

Next steps

Today I would structure the Python portion around clearer data models and unit tests, model the mechanism in CAD before fabrication, and record throughput, repeatability, and failure-rate measurements so the final concept could be compared quantitatively with the earlier one.

Hero build photo / video