Tag: Academia – Python Prog

Well done everyone!

Students from BTE 1522 and DRE2213 presented their final projects, and the outcomes were impressive =).

What began at the start of the course as an introduction to beginner Python programming through a simple Pygame slider game (Pygame assignments) has now evolved into fully functional sensor-based systems using Raspberry Pi and the BME280 environmental sensor.

This transition from a purely digital game environment to a real-world, physically embedded system, was intentional =).

By first grounding students in Python fundamentals (variables, loops, conditionals, event handling, and logic flow) through game development, students were able to focus later on how their code interacts with the physical world.

BTE1522 – IMU Data Collection

Learning Python Through Motion, Data, and Innovation: BTE1522 Project Showcase

Students from BTE1522 – Innovation (Python) recently presented their final projects, and the results clearly demonstrated how hands-on, sensor-driven learning can elevate Python programming skills.

In this course, students worked with the MPU6050 motion sensor on the LilEx 5 platform, moving beyond basic scripting to build end-to-end data-driven systems involving sensing, storage, and visualization.

Project Focus

Each student group was tasked to:

1. 1. 1. Read motion data from the MPU6050 using Python

      2. Design and conduct structured data collection for different human movements

      3. Store the data in a database of their choice

      4. Build a dashboard to visualize and interpret the collected data

This workflow mirrors real-world IoT and data engineering pipelines.

Movement-Based Data Collection

Students collected sensor data based on well-defined criteria, including:

1. 1. 1. Standing

      2. Leaning left and right (roll)

      3. Bending forward and backward (pitch)

      4. Lying down

They carefully controlled parameters such as:

1. 1. 1. Sampling rate

      2. Timeframe per movement

      3. Sensor placement

      4. Calibration procedures

This encouraged students to think critically about data quality, consistency, and repeatability, not just code correctness.

From Raw Sensor Data to Insight

Using Python, students transformed raw accelerometer and gyroscope readings into structured datasets. They then explored different tools and platforms to:

1. 1. 1. Build databases

      2. Create dashboards for visualization and interpretation

Through this process, students learned that innovation is not only about building something new, but also about making data understandable and useful.

Physical Embodiment as a Learning Strategy

Similar to DRE2213, this course emphasized learning through physical embodiment. Students could directly observe how body movement affected sensor readings, reinforcing their understanding of:

1. 1. 1. 1. Coordinate axes

         2. Sensor fusion concepts

         3. Time-series data behavior

By linking physical motion to Python code and visual dashboards, abstract programming concepts became concrete and intuitive.

Overall, student performance was very satisfying. Good job everyone.

The projects demonstrated strong engagement, creativity, and a growing confidence in Python programming.

The project videos embedded below highlight how students applied Python not just as a programming language, but as a tool for sensing, data analysis, and innovation.

DRE2213 – BM280 Data Monitoring – SULAM

Project Highlights

In their final projects, DRE2213 students successfully demonstrated:

1. Closed-loop sensing systems
   Integrating the BME280 sensor with Raspberry Pi using Python, where sensor readings triggered real-time responses such as LEDs and buzzers.

2. Data logging and storage
   Students independently explored multiple database solutions:

   • • Firebase

     • Google Sheets / Spreadsheet-based logging
       This showed strong initiative and adaptability beyond what was explicitly taught.

3. Dashboard development and visualization
   A wide range of dashboard approaches were implemented, including:

   • • HTML-based dashboards

     • Adafruit IO

     • Flask web applications

     • Streamlit dashboards

Each solution reflected different design choices, yet all achieved the same goal: making sensor data meaningful, visible, and interactive.

https://youtube.com/shorts/KYIy1CRj6Nk?si=2cHH3TGO1eFjDp9y

https://www.youtube.com/shorts/KYIy1CRj6Nk

https://youtube.com/shorts/KYIy1CRj6Nk?si=2cHH3TGO1eFjDp9y

 

 

Learning Through Physical Embodiment

What stood out most was how BTE1522 and DRE2213 students connected abstract Python code to tangible outcomes. Seeing a buzzer activate, an LED respond, or a dashboard update in real time helped students understand what their code is doing, not just whether it runs.

This combination of:

1. 1. 1. Digital embodiment (game-based learning with Pygame), and

      2. Physical embodiment (real sensors, real data, real feedback)

proved to be a powerful approach in helping students grasp programming concepts more deeply and confidently.

Reflection

The quality of the projects and the variety of technical approaches exceeded expectations. Students demonstrated not only programming skills, but also problem-solving, system integration, and creativity.

The embedded project videos below showcase their work and reflect a learning journey that truly bridges Python programming and real-world applications.

 

Nurul Hazlina – Feb 4th

Explore Programming with the Slider Game

1. Learn basic Python via Slider game
2. Installation of Computer visual code (cvs) for advance application in image and data processing

Today students from BHE 25/26 I participated in a hands-on programming training session designed to make learning Python both engaging and intuitive. The session ran from 8:30 AM to 12:45 PM and combined game-based learning with practical tool setup for future advanced applications.

The training introduced students to core programming concepts through an interactive Slider Game, followed by the installation of Visual Studio Code (VS Code) to prepare them for more advanced work in image and data processing.

Session 1: Learning Python Basics Through the Slider Game

Time: 8:30 AM – 12:30 PM

Instead of starting with abstract syntax and long code examples, students learned Python fundamentals by building and modifying a simple Slider Game. This approach allowed concepts to emerge naturally through interaction and experimentation.

Through guided activities, students progressively explored:

1. 1. 1. Variables – storing and updating player positions, scores, and timers

      2. Mathematical operations – controlling movement speed, scoring, and boundaries

      3. Control structures (loops & conditionals) – managing enemy movement, collisions, and game flow

      4. Event handling – responding to keyboard inputs for real-time player control

      5. Data structures – using lists to manage multiple enemies and game objects

      6. Functions – organizing code for clarity and reusability

      7. Debugging and logical thinking – testing, observing outcomes, and refining logic

By the end of the session, students were not just reading code—they were seeing their code come alive on the screen.

Learning by Seeing and Doing: Digital & Physical Embodiment

A key strength of the Slider Game approach is embodied learning. As students interacted with the game—moving the player, triggering collisions, or adjusting timing—they could immediately visualize the effect of each programming concept.

This form of digital embodiment supports deeper understanding:

1. 1. 1. Students test hypotheses by changing values and logic

      2. Immediate visual feedback reinforces correct reasoning

      3. Errors become learning opportunities rather than frustrations

By observing how their code directly influences game behavior, students developed stronger intuition about how programming logic works in real systems.

Session 2: Preparing for Advanced Applications

Time: 12:30 PM – 12:45 PM

In the final segment, students were guided through the installation and setup of Visual Studio Code (VS Code)—a widely used development environment for professional and academic programming. This is as part of their preparation for their upcoming flying professor’s class in March 2026.

This step prepares students for:

1. 1. 1. Advanced Python development

      2. Image processing and computer vision

      3. Data analysis and visualization

      4. Future projects involving AI and intelligent systems

Introducing VS Code early helps students transition smoothly from learning concepts to building more complex, real-world applications.

 

Looking Ahead

This training demonstrated that game-based and embodied learning can significantly enhance how students grasp programming fundamentals. By combining interaction, visualization, and hands-on practice, students build confidence, curiosity, and problem-solving skills—key foundations for future work in computing and engineering.

Moving forward, similar sessions will continue to explore how interactive digital environments and intelligent scaffolding can further support meaningful learning in programming education.

Further UMPSA STEM Lab work on Slider Game and Digital Embodiment can be accessed here.

 

Bringing Python, IoT, and Physical Computing Together =)..

Today’s class marked an important milestone for DRE2213 – Programming and Data Structure, as students presented their final projects developed using Raspberry Pi and Python, with a strong focus on environmental sensing using the BME280 sensor. The SULAM session showcased not only technical competence, but also how far the students have progressed in applying programming concepts to real-world systems – in Perpustakaan UMPSA Pekan Monitoring System.

I am truly impressed by the level of achievement demonstrated by the students. Each group successfully implemented a complete IoT-based system, covering three essential components of modern embedded and data-driven applications.

1. Closed-Loop Sensor Integration

Students demonstrated their ability to build closed-loop systems by interfacing the BME280 temperature, humidity, and pressure sensor with the Raspberry Pi. Based on predefined threshold values, the system was able to trigger actuators such as LEDs and buzzers, reinforcing key concepts in sensor reading, decision-making logic, and control flow in Python.

2. Data Logging and Management

Another highlight was the diversity in data management approaches. Some groups opted for cloud-based databases such as Firebase, while others used Google Sheets or local storage solutions. This exposed students to different data structures, data persistence methods, and practical considerations in handling sensor data over time.

3. Dashboard Development and Visualization

Students also demonstrated creativity and flexibility in building dashboards to visualize sensor data. A wide range of tools were used, including:

• HTML-based dashboards

• Adafruit IO

• Flask web applications

• Streamlit dashboards

This variety reflects students’ growing confidence in selecting appropriate tools and frameworks to communicate data effectively.

From Games to Physical Systems – A Meaningful Learning Journey

At the beginning of this course, students were introduced to Python programming through a slider game developed using Pygame. This approach allowed them to grasp fundamental programming concepts—such as variables, loops, conditionals, and functions—within a digital and interactive environment.

As the course progressed, students transitioned from digital game development to physical computing projects, applying the same programming principles to real hardware and sensors. This combination of digital embodiment (game development) and physical embodiment (IoT systems) provided a strong foundation for understanding how software interacts with the real world.

Learning programming in an interactive and hands-on manner enables students to truly understand what their code is doing. Instead of writing abstract programs, they can see, hear, and measure the outcomes of their code—whether it is a game reacting to user input or a sensor triggering a buzzer based on environmental conditions.

Closing Reflections

Today’s presentations clearly demonstrated that interactive, project-based learning is an effective way to teach programming and data structures. By engaging with both digital and physical systems, students developed not only technical skills but also problem-solving confidence and design thinking.

Well done to all DRE2213 students on your excellent work. Your projects reflect strong effort, creativity, and meaningful learning. Keep building, keep experimenting, and keep pushing the boundaries of what you can create with Python and Raspberry Pi.

 

 

 

 

• Title 1

• Title 2

• TItle 3

• Title 5

• Title 7

• Title 8

• Title 9

Good

• Title 10

• Title 12

• Title 13

• Title 14

• Title 17

Good =)

• Title 18

• Title 19

• Title 20

This week, Week 11, we reached an important milestone in the IoT learning journey. Building upon the foundations established in Weeks 9 and 10, this week’s activity focused on visualising sensor data through dashboards, using two different approaches:

1. 1. 1. A cloud-hosted dashboard using Adafruit IO

      2. A self-hosted dashboard using HTML served directly from the Raspberry Pi Pico W (LilEx3)

By the end of this session, you no longer just reading sensors — but you’ve design a complete IoT data pipelines, from sensing to networking to visualisation.

This week is we transit our attention from collecting data to presenting data.

Using the BME280 environmental sensor, you are able to work with:

1. 1. 1. 1. Temperature

         2. Humidity

         3. Atmospheric pressure

The same sensor data was then visualised using two different dashboard approaches, highlighting important design choices in IoT systems.

Approach 1: Cloud Dashboard Using Adafruit IO – Refer to Act 7 in TINTA and Google Classsroom 

This method introduces students to cloud-based IoT platforms, a common industry practice.

Key concepts:

1. 1. 1. 1. WiFi connectivity

         2. MQTT protocol

         3. Publishing data to a third-party server

         4. Remote access and visualisation

Code Explanation (Adafruit IO Method)

• • • Imports modules for hardware control, networking, MQTT communication, and the BME280 sensor.

• • • Initializes the I2C bus and the BME280 sensor.

• • • Connects the Pico W to a WiFi network.

• • • Configures the MQTT client for communication with Adafruit IO.

• • • Reads sensor values and publishes temperature data to the cloud dashboard.

This approach shows how sensor data can be accessed anywhere in the world, but depends on external services and internet connectivity.

Approach 2: Self-Hosted HTML Dashboard on Pico W

This method shifts learning toward edge computing and embedded web servers.

Key concepts:

1. 1. 1. 1. HTTP client–server model

         2. Serving HTML from a microcontroller

         3. JSON data exchange

         4. JavaScript-based live updates

         5. Local network dashboards

 

Code Explanation (HTML Dashboard Method)

• • • Enables the Pico W to act as a web server.

• • • Stores the dashboard webpage directly in Python memory.

• • • Starts an HTTP server on port 80.

• • • Distinguishes between:

      • Page requests (/)

      • Data requests (/data)

• • • Reads temperature, humidity, and pressure in real time.

• • • JavaScript on the webpage periodically requests new sensor data and updates the display without refreshing the page.

This approach emphasizes system integration, where the device itself becomes the dashboard — similar to ground stations and embedded monitoring panels.

Comparing Both Dashboard Approaches

Both approaches are valuable, and understanding when to use each is an important engineering skill.

Bringing It All Together

By connecting:

1. 1. Weeks 9 & 10 (MPU6050 motion sensing & data logging)

   2. Week 11 (IoT dashboards and networking)

you are now capable of:

1. 1. 1. Interfacing multiple sensors

      2. Logging and processing data

      3. Transmitting data over networks

      4. Designing dashboards (cloud and local)

      5. Building complete IoT systems

At this stage, you are no longer following isolated tutorials, but are now ready to design and execute their own IoT projects.

Dear DRE and BTE-ian,

notes on serial data communication |  notes on reading MPU6050 data.

This week, you’ve gone thru to one of the most exciting aspects of embedded systems and sensor-based computing: collecting, processing, and logging motion data using the MPU6050 sensor. Working with the LilEx3 – our in-house Raspberry Pi Pico–based picosatellite simulator, you explored how real satellites interpret motion, orientation, and attitude information through microcontrollers and built-in algorithms.

This activity was designed not only to strengthen understanding of Python programming on microcontrollers, but also to demonstrate how sensor data can be captured, logged, and interpreted, a fundamental skill in IoT, robotics, aerospace, and scientific computing.

1. Introducing the MPU6050 Sensor

The MPU6050 combines a 3-axis accelerometer and 3-axis gyroscope, allowing us to detect:

1. 1. 1. 1. Linear acceleration (AX, AY, AZ)

         2. Angular velocity (GX, GY, GZ)

         3. Motion patterns

         4. Orientation of a device in space

In satellite engineering, this type of sensor is crucial for:

1. 1. 1. 1. Attitude determination

         2. Stabilisation

         3. Orientation control

         4. Deployment sequence monitoring

For our LiLex3 picosatellite simulator, this data helps you to understand how satellites “sense” their position and respond to environmental changes.

2. Python Programming on the Raspberry Pi Pico

Acomplishing the task, you wrote MicroPython code to:

1. 1. 1. Initialise the I2C communication bus

      2. Read real-time sensor values

      3. Display values on the Thonny console

      4. Log data into a .txt file for later analysis

This hands-on exercise strengthened key Python concepts:

1. Variables & Data Types
   • You handled multiple numeric readings and stored them in variables such as ax, ay, az.
2. Functions & Modular Code
   • They used functions like mpu.values() and learned how functions return multiple sensor readings at once.
3. Loops
   • A continuous while True: loop was used to collect real-time data every second.
4. File Handling
   • One of the most important skills today was learning how to open, write, and save data to a file—essential for logging experiments.
5. Example snippet:
   • file = open("data.txt", "a")
file.write(f"{count},{ax},{ay},{az},{gx},{gy},{gz}\n")
file.flush()

   • This allowed the Pico to create a growing dataset, which you can later open in Excel for plotting or further analysis.
6. Printing to Console
   • The real-time values were also displayed in the Thonny console, helping you can visualize live changes as they physically moved the LiLex3 module.

3. Experiencing Motion: Determining Roll, Pitch, and Yaw

Rather than reading just “raw numbers,” you were tasked to interpret meaning behind the MPU6050 readings.

Through controlled physical movement of the LiLex3:

• • • 1. Pitch changed when tilting forward/backward

      2. Roll changed when tilting left/right

      3. Yaw changed when rotating horizontally (similar to turning a compass)

By observing accelerometer and gyroscope patterns, you began to understand how flight controllers, drones, and satellites estimate their orientation in space.

This experience reinforces why MPU data is vital in aerospace applications:

1. 1. 1. CubeSat attitude determination

      2. Drone flight stabilization

      3. Rocket telemetry

      4. Robotics navigation

      5. VR/AR motion tracking

Then you were encouraged to mark down the sensor readings corresponding to specific movements and attempt simple calculations for roll/pitch/yaw using standard trigonometric formulas (e.g., atan2).

4. Data Logging: Building a Dataset for Analysis

One of the biggest takeaways was the importance of data logging.

By saving values into a .txt file, you learned how to:

1. 1. 1. 1. Record experimental data
         2. Align timestamps and readings
         3.  Import the file into Excel
         4. Plot sensor graphs (AX vs. time, pitch changes, etc.)
         5. Observe patterns corresponding to movement

This introduces to real scientific data workflows used in:

1. 1. 1. 1. Research experiments

         2. IoT sensor monitoring

         3. Engineering testing

         4. Satellite mission data collection

The logged dataset becomes the “flight log” for their miniature picosatellite simulator.

5. Conclusion: Why Today’s Activity Matters

Today’s class was not just about wiring a sensor and reading numbers. It was about understanding how real systems sense, interpret, and record the world around them.

You learned:

1. 1. 1. 1. Embedded Python programming

         2. Real-time sensor acquisition

         3. Data logging techniques

         4. Interpreting physical motion through numerical patterns

         5. Satellite-style orientation measurement

By the end of the session, every student had generated their own dataset and gained insight into how satellites determine roll, pitch, and yaw—all through hands-on experimentation with the LiLex3 and MPU6050.

This activity bridges classroom concepts with real aerospace and IoT engineering, preparing you for more advanced missions involving filtering (Kalman), attitude determination, and flight-control algorithms.

 

 

All the best in your test everyone!

Dear DRE-BTE-ians,

This week we move forward to explored how data structures and programming concepts come to life through the Raspberry Pi Pico. We completed Activity 1 (Digital Output), Activity 2 (Traffic Light), and Activity 3 (Digital Input), each introducing a new layer of understanding in Python programming and physical computing.

Activity 1 – Digital Output: Lighting Up with Variables

We began with the most fundamental task, turning an LED ON and OFF.
Through this, students learned:

• 1. How to define and use variables to store pin numbers and LED states

  2. How data types like integers and booleans control hardware behavior

  3. How to send output signals using the Pin() function and .on()/.off() commands

This activity established the foundation for understanding how code interacts with physical devices. Also, we make use of Wokwi online simulator, which is good especially in learning the basic concepts.

Activity 2 – Traffic Light Simulation: Learning Data Structures

Next, we built a traffic light simulation using three LEDs (Red, Yellow, Green).
Here, students experimented with different data structures to organize and control multiple outputs:

1. 1. 1. Lists ([]) to store LED pins in a sequence

      2. Tuples (()) for fixed sets of pins

      3. Dictionaries ({}) to label LEDs for clarity ("R": 14, "Y": 13, "G": 12)

They also explored how to simplify code using loops and sleep statements to manage timing:

This hands-on activity demonstrated how data organization directly impacts code simplicity and readability.

Activity 3 – Digital Input: Reading from Buttons and Switches

The third activity introduced digital input, connecting push buttons and slider switches to the Raspberry Pi Pico.
Students learned to:

1. 1. 1. Read input values (0 or 1)

      2. Use conditional statements (if/else) to make the LED respond to user actions

      3. Understand Boolean logic and how it drives interactivity in real-world systems

This activity tied together input → process → output, emphasizing the logic flow that underpins all embedded systems.

Through these activities, you’ve not only focued on the essential coding techniques but also explored core data structures that make programs efficient and scalable. Understanding how lists, tuples, and dictionaries manage data sets the stage for more complex IoT and sensor-based applications in upcoming sessions.

Next week, we’re having Midterm Test =).

We’ll continue building upon these concepts as we move toward conditional programming and sensor integration, after the midterm break. Great work everyone — keep experimenting, debugging, and learning by doing!