Rhobincu la 16 martie 2026 17:07

2026-03-16T17:07:57Z

Rhobincu la 15 martie 2026 22:46

2026-03-15T22:46:16Z

Rhobincu la 15 martie 2026 22:43

2026-03-15T22:43:20Z

Rhobincu: Pagină nouă: = Lab 3: Build Systems - From GNU Make to Modern CMake = == Introduction == In Week 2, we solved the human collaboration problem using Git. Today, we solve the compilation scaling...

2026-03-15T22:37:31Z

Pagină nouă: = Lab 3: Build Systems - From GNU Make to Modern CMake = == Introduction == In Week 2, we solved the human collaboration problem using Git. Today, we solve the compilation scaling...

Pagină nouă

= Lab 3: Build Systems - From GNU Make to Modern CMake =

== Introduction ==
In Week 2, we solved the human collaboration problem using Git. Today, we solve the compilation scaling problem.

As embedded projects grow from a single file to hundreds of files with external dependencies (like cryptography or networking libraries), clicking a "Build" button in an IDE or typing <code>g++ main.cpp</code> in the terminal is no longer viable. By the end of this 2-hour lab, you will have:
# Written a scalable GNU Makefile using pattern rules and automatic variables.
# Solved the "Header Dependency Problem" using GCC's <code>-MMD</code> flags.
# Migrated the project to Modern CMake.
# Enforced clean "Out-of-Source" builds.
# Built a static hardware driver library and linked it to an executable.
# Automatically downloaded and linked a 3rd-party library directly from GitHub using CMake's <code>FetchContent</code>.

'''Requirement:''' You may work individually or with your partner from last week.

---

== Part 1: Project Setup and The GNU Make Baseline (30 Minutes) ==
First, we need some source code to compile. We will simulate an IoT sensor node.

=== 1. Create the Project Workspace ===
Open your terminal and create a new directory:
<pre>
mkdir sdpt-lab3-builds
cd sdpt-lab3-builds
mkdir src include
</pre>

=== 2. Create the Source Files ===
Create a header file <code>include/sensor.h</code>:
<pre>
#ifndef SENSOR_H
#define SENSOR_H

struct SensorData {
int temperature;
int humidity;
};

void init_sensor();
SensorData read_sensor();

#endif
</pre>

Create the implementation file <code>src/sensor.cpp</code>:
<pre>
#include <iostream>
#include "../include/sensor.h"

void init_sensor() {
std::cout << "[Hardware] I2C Sensor Initialized." << std::endl;
}

SensorData read_sensor() {
SensorData data;
data.temperature = 24;
data.humidity = 60;
return data;
}
</pre>

Create the main application <code>src/main.cpp</code>:
<pre>
#include <iostream>
#include "../include/sensor.h"

int main() {
std::cout << "Starting IoT Node..." << std::endl;
init_sensor();

SensorData current_data = read_sensor();
std::cout << "Temp: " << current_data.temperature << "C, Hum: " << current_data.humidity << "%" << std::endl;

return 0;
}
</pre>

=== 3. Write the Scalable Makefile ===
In the root directory (<code>sdpt-lab3-builds/</code>), create a file named exactly <code>Makefile</code>.
''Warning: You MUST use an actual TAB character for the indented lines, not spaces!''

<pre>
CXX = g++
CXXFLAGS = -Wall -Wextra -O2 -MMD -MP
TARGET = firmware.bin

# Dynamically find all .cpp files in the src/ directory
SRCS = $(wildcard src/*.cpp)

# String substitution: convert .cpp list to .o list
OBJS = $(SRCS:.cpp=.o)

# Create a list of .d (dependency) files
DEPS = $(OBJS:.o=.d)

# Default rule
all: $(TARGET)

# Linker rule using automatic variables ($^ = all dependencies, $@ = target)
$(TARGET): $(OBJS)
$(CXX) $^ -o $@

# Pattern rule to compile any .cpp into a .o file ($< = first dependency)
%.o: %.cpp
$(CXX) $(CXXFLAGS) -c $< -o $@

# Clean rule to remove binaries
clean:
rm -f $(OBJS) $(DEPS) $(TARGET)

# Include the auto-generated GCC dependencies
-include $(DEPS)
</pre>

=== 4. Test and Inspect the Build ===
Run the build:
<pre>
make
./firmware.bin
</pre>
Now, look inside your <code>src/</code> folder. Run <code>ls src/</code>.
Notice the <code>.d</code> files? Open <code>src/main.d</code> in a text editor. You will see that GCC automatically wrote a Makefile rule proving that <code>main.o</code> depends on <code>sensor.h</code>. This is how Make knows to recompile <code>main.cpp</code> if you only change the header file!

---

== Part 2: Migrating to Modern CMake (30 Minutes) ==
Makefiles are great, but they leave <code>.o</code> and <code>.d</code> files scattered all over our source code, and they are not cross-platform. Let's upgrade.

=== 1. Clean up the Make artifacts ===
Run the clean rule to delete all the generated binaries from Part 1.
<pre>
make clean
</pre>

=== 2. Write the CMakeLists.txt ===
In the root directory, create a file named <code>CMakeLists.txt</code>:

<pre>
cmake_minimum_required(VERSION 3.10)
project(IoTNode CXX)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Define the executable and its source files
add_executable(firmware src/main.cpp src/sensor.cpp)

# Tell CMake where to look for header files
target_include_directories(firmware PRIVATE include/)
</pre>

=== 3. The Out-of-Source Build ===
We will never compile in the root directory again.
<pre>
mkdir build
cd build

# Tell CMake to read the parent directory and generate the build system
cmake ..

# Execute the build
make
</pre>
Run your program: <code>./firmware</code>. Notice that your <code>src/</code> directory is completely clean. All binaries are safely isolated inside the <code>build/</code> folder.

---

== Part 3: Modular Architecture (Static Libraries) (30 Minutes) ==
In professional embedded development, we don't dump all source files into the executable. We build independent, reusable Static Libraries (<code>.a</code> files) for hardware drivers.

=== 1. Refactor CMakeLists.txt ===
Go back to your root directory and open <code>CMakeLists.txt</code>. Rewrite it to decouple the sensor driver from the main application:

<pre>
cmake_minimum_required(VERSION 3.10)
project(IoTNode CXX)

set(CMAKE_CXX_STANDARD 14)

# 1. Build the sensor driver as a STATIC library
add_library(sensor_lib STATIC src/sensor.cpp)

# 2. Attach the include directory to the library (PUBLIC means anyone who links this library gets the headers too)
target_include_directories(sensor_lib PUBLIC include/)

# 3. Build the main executable (Notice we removed sensor.cpp!)
add_executable(firmware src/main.cpp)

# 4. Link the library to the executable
target_link_libraries(firmware PRIVATE sensor_lib)
</pre>

=== 2. Rebuild and Verify ===
Go into your <code>build/</code> directory and just run <code>make</code> (CMake automatically detects the changes to CMakeLists.txt and regenerates everything).

<pre>
cd build
make
</pre>

Look at the terminal output. You should see it building <code>libsensor_lib.a</code> first, and then linking it to <code>firmware</code>. Run <code>ls -l</code> to verify the <code>.a</code> archive exists.

---

== Part 4: Remote 3rd-Party Dependencies (30 Minutes) ==
Our IoT node generates data, but we need to format it as JSON to send it over the network. Writing a JSON parser in C++ from scratch is a terrible idea. We will use a popular 3rd-party library (Nlohmann JSON) and import it directly from GitHub using CMake's <code>FetchContent</code>.

=== 1. Fetching the Library ===
Open your <code>CMakeLists.txt</code> and add the FetchContent block ''before'' your executable definition:

<pre>
cmake_minimum_required(VERSION 3.14) # Note: Upgraded to 3.14 for FetchContent
project(IoTNode CXX)

set(CMAKE_CXX_STANDARD 14)

# --- Define local library ---
add_library(sensor_lib STATIC src/sensor.cpp)
target_include_directories(sensor_lib PUBLIC include/)

# --- Fetch 3rd Party Library from GitHub ---
include(FetchContent)
FetchContent_Declare(
json
GIT_REPOSITORY https://github.com/nlohmann/json.git
GIT_TAG v3.11.2
)
FetchContent_MakeAvailable(json)

# --- Define Executable ---
add_executable(firmware src/main.cpp)

# Link BOTH our local hardware library AND the remote JSON library
# (The remote library exposes a target named 'nlohmann_json::nlohmann_json')
target_link_libraries(firmware PRIVATE sensor_lib nlohmann_json::nlohmann_json)
</pre>

=== 2. Use the JSON Library in Code ===
Open <code>src/main.cpp</code> and update it to serialize our sensor data:

<pre>
#include <iostream>
#include "../include/sensor.h"
#include <nlohmann/json.hpp> // Included from the fetched library!

using json = nlohmann::json;

int main() {
std::cout << "Starting IoT Node..." << std::endl;
init_sensor();

SensorData current_data = read_sensor();

// Create a JSON object and pack our data into it
json payload;
payload["device_id"] = "RPI_NODE_01";
payload["status"] = "active";
payload["data"]["temperature"] = current_data.temperature;
payload["data"]["humidity"] = current_data.humidity;

// Serialize and print the JSON string
std::string network_message = payload.dump(4); // 4 spaces of indentation
std::cout << "\n--- Transmission Payload ---\n" << network_message << std::endl;

return 0;
}
</pre>

=== 3. The Final Build ===
Go to your <code>build/</code> directory. Run <code>make</code>.
''Note: This build will take slightly longer because CMake is reaching out to GitHub, downloading the library, and configuring it on the fly.''

Run <code>./firmware</code>. You should see a perfectly formatted JSON payload printed to your terminal!

---

== Lab Deliverable ==
To receive full credit for this week's lab, demonstrate the following to your professor or TA:
# Run <code>./firmware</code> to show the successful JSON serialization.
# Show your <code>CMakeLists.txt</code> file demonstrating the <code>FetchContent</code> block and <code>target_link_libraries</code>.
# Navigate to <code>build/_deps/json-src</code> in your terminal to prove that CMake successfully downloaded the external repository into the out-of-source build tree.
# Explain the difference between the <code>PUBLIC</code> and <code>PRIVATE</code> keywords in your CMake link step.

@@ Linia 183: / Linia 183: @@
 == Lab Evaluation ==
-To receive full credit, call the professor/TA to your workstation and demonstrate:
+To receive full credit, submit the following elements on Moodle:
-# The GCC dependency tracking working in Challenge 1 (changing a header triggers a recompile).
+# Final version of the Makefile.
-# The clean root directory, proving an Out-of-Source build.
+# Final version of the CMakeLists.txt.
-# The <code>libsensor_driver.a</code> static library file inside your build directory.
+# Screenshot of the console output of your executable printing the JSON payload.

@@ Linia 11: / Linia 11: @@
 * Master Modern CMake: out-of-source builds, targets, and static libraries.
 * Integrate remote third-party libraries using CMake <code>FetchContent</code>.
 == Part 1: Theoretical Reference ==
@@ Linia 87: / Linia 85: @@
 * [https://www.gnu.org/software/make/manual/make.html GNU Make Manual]
 * [https://cmake.org/cmake/help/latest/ CMake Official Documentation]
 == Part 2: The Challenges ==
@@ Linia 138: / Linia 134: @@
 </syntaxhighlight>
 === Challenge 1: The Scalable Makefile (Estimated time: 25 mins) ===
@@ Linia 152: / Linia 147: @@
 # Open <code>include/sensor.h</code> and add a dummy integer to the <code>SensorData</code> struct. Run <code>make</code> again. It MUST recompile both <code>.cpp</code> files automatically. If it doesn't, your dependency tracking is broken.
 === Challenge 2: Migrating to CMake (Estimated time: 20 mins) ===
@@ Linia 164: / Linia 158: @@
 '''Verification:'''
 Your root directory should contain only your source files and the <code>CMakeLists.txt</code>. Inside the <code>build/</code> directory, running <code>make</code> should yield the executable.
 === Challenge 3: Modular Architecture (Estimated time: 25 mins) ===
@@ Linia 177: / Linia 169: @@
 '''Verification:'''
 Run <code>make</code> inside the build folder. You must see it compile <code>libsensor_driver.a</code> first, and then link it to the main executable.
 === Challenge 4: Third-Party Git Dependencies (Estimated time: 30 mins) ===
@@ Linia 191: / Linia 181: @@
 '''Verification:'''
 Running your executable should print a perfectly formatted, multi-line JSON string representing your sensor data. Check <code>build/_deps/</code> to see the downloaded source code.
 == Lab Evaluation ==

SDPT Lab 3 - Revizia istoricului

Rhobincu la 16 martie 2026 17:07

Rhobincu la 15 martie 2026 22:46

Rhobincu la 15 martie 2026 22:43

Rhobincu: Pagină nouă: = Lab 3: Build Systems - From GNU Make to Modern CMake = == Introduction == In Week 2, we solved the human collaboration problem using Git. Today, we solve the compilation scaling...