DEV Community: Masoud Rahimi

Build and Debug C++ Application with VSCode and MSVC

Masoud Rahimi — Tue, 15 Sep 2020 13:40:13 +0000

Using VSCode as your main development IDE is quite interesting as it offers many features with the support of most programming languages.
To develop C/C++ applications you need to have a separate compiler installed, you can either use MinGW or Microsoft Visual C++ compiler. In this tutorial, I'm giving you a brief tutorial about using VSCode to develop C/C++ applications with MSVC on Windows.

There is an official tutorial about setting the environment but it may be unclear in some parts (e.g. it force you to use Development Command Prompt each time you open up VSCode). So I'm adding an alternative for those parts and create a custom build configuration.

Prerequisites

Download and install VSCode from the official website.
Install Microsoft Visual C++ toolset. You can use Visual Studio Installer and select C++ build tools. To verify the installation open up Developer Command Prompt from the Start menu and check the cl.exe command.
Install C/C++ extension for VSCode from here.

Setup instructions

Create a directory for your project and put the required files in it. Then open the directory with VSCode. You can either use the command code . in terminal or right-click inside the folder and choose open with Code.

Create a simple hello world C++ file called main.cpp in the root of the project.

#include <iostream>
using namespace std;

int main()
{
    cout << "It Works!" << endl;
    cin.get();
}

Press F1 or Ctrl+Shift+P to open Command Palette and choose C/C++ Edit Configurations UI. This will open up the configuration windows. Choose the Win32 for configuration name and set a proper compiler path. It should automatically set the path for cl.exe e.g C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Tools/MSVC/14.21.27702/bin/Hostx64/x64/cl.exe. You can set other options like IntelliSense mode, Include path and etc.
Create an empty settings.json file in .vscode directory and add the two parameters for cl.exe path and build directory path (if the file already exists just add these two values). In this configuration, we are creating a build directory called build to store the binaries. Also, we create a custom build command called buildCommand to execute cl.exe from the VS Command Prompt.
```
{
    "buildDir": "${workspaceRoot}\\build",
    "buildCommand": "C:\\Program^ Files^ ^(x86^)\\Microsoft^ Visual^ Studio\\2019\\Enterprise\\Common7\\Tools\\VsDevCmd.bat && cl"
}
```
We would be able to use these variables in other config files with ${config:<ConfigName>} syntax.

Next, We are going to create a tasks.json file and create a task for our build. Create the tasks.json inside .vscode directory and fill it like below:

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "shell",
            "label": "Set dependencies for build",
            "command": "if not exist ${config:buildDir} mkdir ${config:buildDir}"
        },
        {
            "type": "shell",
            "label": "C/C++: cl.exe build active file",
            "command": "${config:buildCommand}",
            "args": [
                "/Zi",
                "/EHsc",
                "/Fe:",
                "${config:buildDir}\\${fileBasenameNoExtension}.exe",
                "/Fo${config:buildDir}\\",
                "/Fd${config:buildDir}\\",
                "${file}"
            ],
            "options": {
                "cwd": "${workspaceFolder}"
            },
            "problemMatcher": [
                "$msCompile"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "dependsOn": [
                "Set dependencies for build"
            ]
        }
    ]
}

The arguments for cl.exe are quite standard but if you want to add more options you can add them in the args section.

To verify the installation run the build task with Ctrl+Shift+B. This will create the build directory and put the output.

To debug your application create a launch.json file in .vscode a directory like below:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "cl.exe - Build and debug active file",
            "type": "cppvsdbg",
            "request": "launch",
            "program": "${config:buildDir}\\${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${env:buildDir}",
            "environment": [],
            "externalConsole": false,
            "preLaunchTask": "C/C++: cl.exe build active file"
        }
    ]
}

This is a default configuration and I already change the program path. I also add a preLaunchTask to rebuild the project before launching the debug session.

After creating the debug configuration you can put your breakpoints and launch the debug session with F5.

Resources

All resource files can be accessed from my GitHub repository.

Setup Docker with Windows Terminal and Oh My ZSH

Masoud Rahimi — Thu, 02 Jul 2020 21:05:13 +0000

As you might know, playing with Docker in Windows is quite interesting as it gives you the ability to play with both Linux and Windows containers.
For newcomers to Docker, it may become frustrating to play with the Docker command line because of using Windows Command Prompt or PowerShell as both have not a quite user-friendly terminal and they don't support autocompletion of Docker commands.
I'm giving a brief tutorial to set up Docker to use the new Windows terminal and your favorite Linux distribution to create a nice terminal environment for play with Docker Desktop. I also added the Zsh shell for making it more functional and handy.

Prerequisites

Windows 10 with the latest build 2004.
Install WSL2 and a Linux Distribution (I've used Ubuntu 20.04 LTS) You can follow the official docs for installation. Don't forget to execute wsl --set-version <distribution name> 2 to set WSL 2 for your Linux distribution.
Install Windows Terminal (Not the preview version) from Microsoft Store.

Installation

Install Powerline font for Windows along with Cascadia Code monospaced font to support Unicode symbols of Oh my ZSH.
- Grab the Cascadia Code font from its Github release page and install it like regular fonts.
Open the Windows Terminal and choose settings. Then it will pop up the settings.json file in your default IDE. I recommend you to use VSCode as it gives you the autocompletion of settings parameters. In the list section you will see each terminal configuration. We will use the Linux Distro (Ubuntu-20.04 for me) to apply the specific settings. You may also add your custom parameters to the defaults section to apply to all existing terminals.

Grab your favorite Windows Terminal theme for here and it will copy the json configuration to your clipboard. Then paste it into the schemes of the configuration file. Finally add "colorScheme": "<YourThemeName>" to the terminal profile section.
You can also add your favorite background image to the background of the terminal. Just copy your image (either jpg, png, or gif) to this path %LOCALAPPDATA%\Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState then add below settings to the configuration. You can find more info about these parameters in here.

    "backgroundImage" : "ms-appdata:///local/<YourImageName>",
    "backgroundImageOpacity" : 0.6,
    "backgroundImageStretchMode" : "fill"

Your final configuration file would look something like this:

{
    "$schema": "https://aka.ms/terminal-profiles-schema",
    "defaultProfile": "{SomeGUID}",
    "copyOnSelect": false,
    "copyFormatting": false,

    "profiles":
    {
        "defaults":
        {
            "cursorShape": "vintage",
            "fontFace": "Cascadia Code PL"
        },
        "list":
        [
            {
                "guid": "{SomeGUID}",
                "hidden": false,
                "name": "Ubuntu-20.04",
                "source": "Windows.Terminal.Wsl",
                "backgroundImage" : "ms-appdata:///local/background.jpg",
                "backgroundImageOpacity" : 0.6,
                "backgroundImageStretchMode" : "fill",
                "colorScheme": "3024 Day"
            },
            //...
        ]
    },

    "schemes": [
        {
        "name": "3024 Day",
        "black": "#090300",
        //...
        }
    ],
    //...
}

Open your Linux distro IDE in Windows Terminal and install Docker as usual. You can follow the official docs. During the installation it may ask about installing GRUB you can just skip it. You may see an error after installing Docker, this is because Docker can't run on a separate daemon so open your Docker Desktop settings, navigate to Resources > WSL INTEGRATION and enable the integration for your Linux distro.
Install Zsh and Oh my Zsh.

sudo apt update && sudo apt install -y git fonts-powerline zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
After installation, the wizard would ask you to set zsh as your default shell, so accept it.
Edit the ~/.zshrc file and set the proper theme for your zsh.

    ZSH_THEME="agnoster"

Restart the terminal and you should see the new shell applied. Remember that the Docker on your Linux distro will use your Docker host daemon so the data like images, containers, and volumes would save on your host.

Contribution

The project source code can be found in my GitHub repository.

Create embedded Linux images with Docker from scratch

Masoud Rahimi — Fri, 10 Apr 2020 08:03:48 +0000

Embedded Linux systems are so common these days and they can be found in set-top boxes, smart TVs, network devices (like routers, 3G/4G USB modems), etc. For the developers, a major concern with these systems is to create their own custom Linux distribution based on their needs. This includes creating the image for the development or the final product. Making the image usually consists of compiling the Linux kernel, device tree binaries, compiling bootloader, and customizing the Linux file system. These steps may become frustrating if you want to test something or trying to rebuild the image over and over. On the other side creating the environment for cross-compiling is a little complicated as you need to set a special environment for the ARM toolchain.

There are many automated tools to achieve this like Buildroot and Yocto Project. They usually give you a minimal version of the Linux image and are a good choice for the final image that intended to use in the production environment, but for the development environment, they are not always the best choice because of lacking package manager or external tools.
Another choice is to create your own custom Linux image by compiling the kernel, bootloader, file system, and finally bring them all together and put it into the device SD card or flash storage. With the Docker, you can do this very straight forward and you don't need to mess around with your host. Moreover, it can be used even on Mac or Windows machines.

I created a simple Docker project to achieve this. It can be customized to use with any embedded Linux board and can be developed easily. I've tested it with BeagleBone Black but with a little change can be used on other educational development boards like Raspberry Pi, Nano Pi, etc. You can also use it on your own customized embedded Linux board but you need to provide your configuration file for the kernel or bootloader.
All you need to do is to provide the resource binaries for Linux kernel, Bootloader, and filesystem then start the build with a single command docker-compose up. The output is a standard image file that can be written on the SD card easily. Also, it uses Linaro toolchain for cross-compilation so it is fast and reliable.

Although the use of the project is quite easy and straight forward I've made a step by step guide. So let's go into details and how to set it up.

To use this project there is no need to set up any special environment or meet any special requirements.
I've used BeagleBone Black as the target system with Ubuntu 18.04 and Ti's Linux Kernel 4.19.94.

Features

Based on Docker so can be run on any machine without any requirements.
Build Kernel, DTS, modules, and headers from scratch.
Build Bootloader (u-boot) from the source.
Can be combined with any Linux distro filesystem.
Create image file (.img) as output file for easy writing to SD card.
High-speed build with help of using Linaro toolchain and Docker engine.
Can be used with any Embedded Linux system with little configuration change.

Requirements

Docker and Docker Compose
Download resource files and put them in resources directory:
- Linaro cross compile toolchain.
- You can get the binaries from here.
- Linux Kernel source for your board.
- For BeagleBone Black you can use the official kernel
- u-boot source code).
- A base rootfs Linux distro.
- You can grab Ubuntu or Debian distro from here.
- Ubuntu 18.04.3 used in this project.
- As the compile process may take longer, you need to increase the Docker engine resources:
- Windows
- Mac

How to use

Make sure that you meet the requirements and put the necessary files into the resources directory:

For example:

  project
  └───resources
  │   │   armhf-rootfs-ubuntu-bionic.tar
  │   │   gcc-linaro-7.5.0-2019.12-x86_64_arm-linux-gnueabihf.tar
  │   │   linux-4.19.94-ti-rt-r41.tar.gz
  │   │   u-boot-2020.04-rc3.tar.gz

Make sure that you decompress the Linux rootfs to get the right compressed file. The files that contain all the Linux rootfs inside its root directory (e.g. armhf-rootfs-ubuntu-bionic.tar).
Set the Dockerfile parameters in docker-compose.yml:
- kernel_version: kernel version in X.Y.Z format
- kernel_filename: kernel source file path
- kernel_defconfig: kernel configuration file
- uboot_filename: u-boot source file path
- uboot_defconfig: u-boot configuration file
- rootfs_filename: Linux Root file system path
- linaro_filename: Linaro toolchain file path
Bring up the console and navigate to project root directory and execute docker-compose up --build.
If the process complete successfully you should get the image file sd_image.img in the output directory.

Contribution

Project source code can be found here. Reporting any bugs or suggestions for improvement would be appreciated.